    001    /* Generated By:JavaCC: Do not edit this line. ParseException.java Version 5.0 */
    002    /* JavaCCOptions:KEEP_LINE_COL=null */
    003    package org.apache.commons.jexl2.parser;
    004
    005    /**
    006     * This exception is thrown when parse errors are encountered.
    007     * You can explicitly create objects of this exception type by
    008     * calling the method generateParseException in the generated
    009     * parser.
    010     *
    011     * You can modify this class to customize your error reporting
    012     * mechanisms so long as you retain the public fields.
    013     */
    014    public class ParseException extends Exception {
    015
    016      /**
    017       * The version identifier for this Serializable class.
    018       * Increment only if the <i>serialized</i> form of the
    019       * class changes.
    020       */
    021      private static final long serialVersionUID = 1L;
    022
    023      /**
    024       * This constructor is used by the method "generateParseException"
    025       * in the generated parser.  Calling this constructor generates
    026       * a new object of this type with the fields "currentToken",
    027       * "expectedTokenSequences", and "tokenImage" set.
    028       */
    029      public ParseException(Token currentTokenVal,
    030                            int[][] expectedTokenSequencesVal,
    031                            String[] tokenImageVal
    032                           )
    033      {
    034        super(initialise(currentTokenVal, expectedTokenSequencesVal, tokenImageVal));
    035        currentToken = currentTokenVal;
    036        expectedTokenSequences = expectedTokenSequencesVal;
    037        tokenImage = tokenImageVal;
    038      }
    039
    040      /**
    041       * The following constructors are for use by you for whatever
    042       * purpose you can think of.  Constructing the exception in this
    043       * manner makes the exception behave in the normal way - i.e., as
    044       * documented in the class "Throwable".  The fields "errorToken",
    045       * "expectedTokenSequences", and "tokenImage" do not contain
    046       * relevant information.  The JavaCC generated code does not use
    047       * these constructors.
    048       */
    049
    050      public ParseException() {
    051        super();
    052      }
    053
    054      /** Constructor with message. */
    055      public ParseException(String message) {
    056        super(message);
    057      }
    058
    059
    060      /**
    061       * This is the last token that has been consumed successfully.  If
    062       * this object has been created due to a parse error, the token
    063       * followng this token will (therefore) be the first error token.
    064       */
    065      public Token currentToken;
    066
    067      /**
    068       * Each entry in this array is an array of integers.  Each array
    069       * of integers represents a sequence of tokens (by their ordinal
    070       * values) that is expected at this point of the parse.
    071       */
    072      public int[][] expectedTokenSequences;
    073
    074      /**
    075       * This is a reference to the "tokenImage" array of the generated
    076       * parser within which the parse error occurred.  This array is
    077       * defined in the generated ...Constants interface.
    078       */
    079      public String[] tokenImage;
    080
    081      /**
    082       * It uses "currentToken" and "expectedTokenSequences" to generate a parse
    083       * error message and returns it.  If this object has been created
    084       * due to a parse error, and you do not catch it (it gets thrown
    085       * from the parser) the correct error message
    086       * gets displayed.
    087       */
    088      private static String initialise(Token currentToken,
    089                               int[][] expectedTokenSequences,
    090                               String[] tokenImage) {
    091        String eol = System.getProperty("line.separator", "\n");
    092        StringBuffer expected = new StringBuffer();
    093        int maxSize = 0;
    094        for (int i = 0; i < expectedTokenSequences.length; i++) {
    095          if (maxSize < expectedTokenSequences[i].length) {
    096            maxSize = expectedTokenSequences[i].length;
    097          }
    098          for (int j = 0; j < expectedTokenSequences[i].length; j++) {
    099            expected.append(tokenImage[expectedTokenSequences[i][j]]).append(' ');
    100          }
    101          if (expectedTokenSequences[i][expectedTokenSequences[i].length - 1] != 0) {
    102            expected.append("...");
    103          }
    104          expected.append(eol).append("    ");
    105        }
    106        String retval = "Encountered \"";
    107        Token tok = currentToken.next;
    108        for (int i = 0; i < maxSize; i++) {
    109          if (i != 0) retval += " ";
    110          if (tok.kind == 0) {
    111            retval += tokenImage[0];
    112            break;
    113          }
    114          retval += " " + tokenImage[tok.kind];
    115          retval += " \"";
    116          retval += add_escapes(tok.image);
    117          retval += " \"";
    118          tok = tok.next;
    119        }
    120        retval += "\" at line " + currentToken.next.beginLine + ", column " + currentToken.next.beginColumn;
    121        retval += "." + eol;
    122        if (expectedTokenSequences.length == 1) {
    123          retval += "Was expecting:" + eol + "    ";
    124        } else {
    125          retval += "Was expecting one of:" + eol + "    ";
    126        }
    127        retval += expected.toString();
    128        return retval;
    129      }
    130
    131      /**
    132       * The end of line string for this machine.
    133       */
    134      protected String eol = System.getProperty("line.separator", "\n");
    135
    136      /**
    137       * Used to convert raw characters to their escaped version
    138       * when these raw version cannot be used as part of an ASCII
    139       * string literal.
    140       */
    141      static String add_escapes(String str) {
    142          StringBuffer retval = new StringBuffer();
    143          char ch;
    144          for (int i = 0; i < str.length(); i++) {
    145            switch (str.charAt(i))
    146            {
    147               case 0 :
    148                  continue;
    149               case '\b':
    150                  retval.append("\\b");
    151                  continue;
    152               case '\t':
    153                  retval.append("\\t");
    154                  continue;
    155               case '\n':
    156                  retval.append("\\n");
    157                  continue;
    158               case '\f':
    159                  retval.append("\\f");
    160                  continue;
    161               case '\r':
    162                  retval.append("\\r");
    163                  continue;
    164               case '\"':
    165                  retval.append("\\\"");
    166                  continue;
    167               case '\'':
    168                  retval.append("\\\'");
    169                  continue;
    170               case '\\':
    171                  retval.append("\\\\");
    172                  continue;
    173               default:
    174                  if ((ch = str.charAt(i)) < 0x20 || ch > 0x7e) {
    175                     String s = "0000" + Integer.toString(ch, 16);
    176                     retval.append("\\u" + s.substring(s.length() - 4, s.length()));
    177                  } else {
    178                     retval.append(ch);
    179                  }
    180                  continue;
    181            }
    182          }
    183          return retval.toString();
    184       }
    185
    186    }
    187    /* JavaCC - OriginalChecksum=92b2e3e81ac3afc0fe75143915b4ce67 (do not edit this line) */