Coverage Report - org.apache.commons.configuration.plist.ParseException
 
Classes in this File Line Coverage Branch Coverage Complexity
ParseException
48%
32/66
31%
10/32
5
 
 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.configuration.plist;
 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  1
     super(initialise(currentTokenVal, expectedTokenSequencesVal, tokenImageVal));
 35  1
     currentToken = currentTokenVal;
 36  1
     expectedTokenSequences = expectedTokenSequencesVal;
 37  1
     tokenImage = tokenImageVal;
 38  1
   }
 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  0
     super();
 52  0
   }
 53  
 
 54  
   /** Constructor with message. */
 55  
   public ParseException(String message) {
 56  4
     super(message);
 57  4
   }
 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  1
     String eol = System.getProperty("line.separator", "\n");
 92  1
     StringBuffer expected = new StringBuffer();
 93  1
     int maxSize = 0;
 94  2
     for (int i = 0; i < expectedTokenSequences.length; i++) {
 95  1
       if (maxSize < expectedTokenSequences[i].length) {
 96  1
         maxSize = expectedTokenSequences[i].length;
 97  
       }
 98  2
       for (int j = 0; j < expectedTokenSequences[i].length; j++) {
 99  1
         expected.append(tokenImage[expectedTokenSequences[i][j]]).append(' ');
 100  
       }
 101  1
       if (expectedTokenSequences[i][expectedTokenSequences[i].length - 1] != 0) {
 102  1
         expected.append("...");
 103  
       }
 104  1
       expected.append(eol).append("    ");
 105  
     }
 106  1
     String retval = "Encountered \"";
 107  1
     Token tok = currentToken.next;
 108  1
     for (int i = 0; i < maxSize; i++) {
 109  1
       if (i != 0) retval += " ";
 110  1
       if (tok.kind == 0) {
 111  1
         retval += tokenImage[0];
 112  1
         break;
 113  
       }
 114  0
       retval += " " + tokenImage[tok.kind];
 115  0
       retval += " \"";
 116  0
       retval += add_escapes(tok.image);
 117  0
       retval += " \"";
 118  0
       tok = tok.next;
 119  
     }
 120  1
     retval += "\" at line " + currentToken.next.beginLine + ", column " + currentToken.next.beginColumn;
 121  1
     retval += "." + eol;
 122  1
     if (expectedTokenSequences.length == 1) {
 123  1
       retval += "Was expecting:" + eol + "    ";
 124  
     } else {
 125  0
       retval += "Was expecting one of:" + eol + "    ";
 126  
     }
 127  1
     retval += expected.toString();
 128  1
     return retval;
 129  
   }
 130  
 
 131  
   /**
 132  
    * The end of line string for this machine.
 133  
    */
 134  5
   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  0
       StringBuffer retval = new StringBuffer();
 143  
       char ch;
 144  0
       for (int i = 0; i < str.length(); i++) {
 145  0
         switch (str.charAt(i))
 146  
         {
 147  
            case 0 :
 148  0
               continue;
 149  
            case '\b':
 150  0
               retval.append("\\b");
 151  0
               continue;
 152  
            case '\t':
 153  0
               retval.append("\\t");
 154  0
               continue;
 155  
            case '\n':
 156  0
               retval.append("\\n");
 157  0
               continue;
 158  
            case '\f':
 159  0
               retval.append("\\f");
 160  0
               continue;
 161  
            case '\r':
 162  0
               retval.append("\\r");
 163  0
               continue;
 164  
            case '\"':
 165  0
               retval.append("\\\"");
 166  0
               continue;
 167  
            case '\'':
 168  0
               retval.append("\\\'");
 169  0
               continue;
 170  
            case '\\':
 171  0
               retval.append("\\\\");
 172  0
               continue;
 173  
            default:
 174  0
               if ((ch = str.charAt(i)) < 0x20 || ch > 0x7e) {
 175  0
                  String s = "0000" + Integer.toString(ch, 16);
 176  0
                  retval.append("\\u" + s.substring(s.length() - 4, s.length()));
 177  0
               } else {
 178  0
                  retval.append(ch);
 179  
               }
 180  
               continue;
 181  
         }
 182  
       }
 183  0
       return retval.toString();
 184  
    }
 185  
 
 186  
 }
 187  
 /* JavaCC - OriginalChecksum=becc552d27f8b55ef0ef4f8e004ca688 (do not edit this line) */