1 /* Generated By:JavaCC: Do not edit this line. ParseException.java Version 5.0 */

     2 /* JavaCCOptions:KEEP_LINE_COL=null */

     3 package jdk.internal.management.remote.rest.json.parser;

     4 

     5 /**

     6  * This exception is thrown when parse errors are encountered.

     7  * You can explicitly create objects of this exception type by

     8  * calling the method generateParseException in the generated

     9  * parser.

    10  *

    11  * You can modify this class to customize your error reporting

    12  * mechanisms so long as you retain the public fields.

    13  */

    14 public class ParseException extends Exception {

    15 

    16   /**

    17    * The version identifier for this Serializable class.

    18    * Increment only if the <i>serialized</i> form of the

    19    * class changes.

    20    */

    21   private static final long serialVersionUID = 1L;

    22 

    23   /**

    24    * This constructor is used by the method "generateParseException"

    25    * in the generated parser.  Calling this constructor generates

    26    * a new object of this type with the fields "currentToken",

    27    * "expectedTokenSequences", and "tokenImage" set.

    28    */

    29   public ParseException(Token currentTokenVal,

    30                         int[][] expectedTokenSequencesVal,

    31                         String[] tokenImageVal

    32                        )

    33   {

    34     super(initialise(currentTokenVal, expectedTokenSequencesVal, tokenImageVal));

    35     currentToken = currentTokenVal;

    36     expectedTokenSequences = expectedTokenSequencesVal;

    37     tokenImage = tokenImageVal;

    38   }

    39 

    40   /**

    41    * The following constructors are for use by you for whatever

    42    * purpose you can think of.  Constructing the exception in this

    43    * manner makes the exception behave in the normal way - i.e., as

    44    * documented in the class "Throwable".  The fields "errorToken",

    45    * "expectedTokenSequences", and "tokenImage" do not contain

    46    * relevant information.  The JavaCC generated code does not use

    47    * these constructors.

    48    */

    49 

    50   public ParseException() {

    51     super();

    52   }

    53 

    54   /** Constructor with message. */

    55   public ParseException(String message) {

    56     super(message);

    57   }

    58 

    59 

    60   /**

    61    * This is the last token that has been consumed successfully.  If

    62    * this object has been created due to a parse error, the token

    63    * followng this token will (therefore) be the first error token.

    64    */

    65   public Token currentToken;

    66 

    67   /**

    68    * Each entry in this array is an array of integers.  Each array

    69    * of integers represents a sequence of tokens (by their ordinal

    70    * values) that is expected at this point of the parse.

    71    */

    72   public int[][] expectedTokenSequences;

    73 

    74   /**

    75    * This is a reference to the "tokenImage" array of the generated

    76    * parser within which the parse error occurred.  This array is

    77    * defined in the generated ...Constants interface.

    78    */

    79   public String[] tokenImage;

    80 

    81   /**

    82    * It uses "currentToken" and "expectedTokenSequences" to generate a parse

    83    * error message and returns it.  If this object has been created

    84    * due to a parse error, and you do not catch it (it gets thrown

    85    * from the parser) the correct error message

    86    * gets displayed.

    87    */

    88   private static String initialise(Token currentToken,

    89                            int[][] expectedTokenSequences,

    90                            String[] tokenImage) {

    91     String eol = System.getProperty("line.separator", "\n");

    92     StringBuffer expected = new StringBuffer();

    93     int maxSize = 0;

    94     for (int i = 0; i < expectedTokenSequences.length; i++) {

    95       if (maxSize < expectedTokenSequences[i].length) {

    96         maxSize = expectedTokenSequences[i].length;

    97       }

    98       for (int j = 0; j < expectedTokenSequences[i].length; j++) {

    99         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=676ade0685adcc4f6efc95fc903deb31 (do not edit this line) */