ParseException.java

  1. /* Generated By:JavaCC: Do not edit this line. ParseException.java Version 5.0 */
  2. /* JavaCCOptions:KEEP_LINE_COL=null */
  3. package org.apache.commons.configuration2.plist;

  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 {

  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;

  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.   }

  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.    */

  50.   public ParseException() {
  51.     super();
  52.   }

  54.   /** Constructor with message. */
  55.   public ParseException(String message) {
  56.     super(message);
  57.   }


  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;

  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;

  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;

  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.   }

  131.   /**
  132.    * The end of line string for this machine.
  133.    */
  134.   protected String eol = System.getProperty("line.separator", "\n");

  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.    }

  186. }
  187. /* JavaCC - OriginalChecksum=511e60e8dc5275c2349a384d892ee0da (do not edit this line) */
Created with JaCoCo 0.8.12.202403310830