src/org/json/simple/parser/Yylex.java

   1 /* The following code was generated by JFlex 1.4.2 */
   2
   3 package org.json.simple.parser;
   4
   5 class Yylex {
   6
   7   /** This character denotes the end of file */
   8   public static final int YYEOF = -1;
   9
  10   /** initial size of the lookahead buffer */
  11   private static final int ZZ_BUFFERSIZE = 16384;
  12
  13   /** lexical states */
  14   public static final int YYINITIAL = 0;
  15   public static final int STRING_BEGIN = 2;
  16
  17   /**
  18    * ZZ_LEXSTATE[l] is the state in the DFA for the lexical state l
  19    * ZZ_LEXSTATE[l+1] is the state in the DFA for the lexical state l
  20    *                  at the beginning of a line
  21    * l is of the form l = 2*k, k a non negative integer
  22    */
  23   private static final int ZZ_LEXSTATE[] = {
  24      0,  0,  1, 1
  25   };
  26
  27   /**
  28    * Translates characters to character classes
  29    */
  30   private static final String ZZ_CMAP_PACKED =
  31     "\11\0\1\7\1\7\2\0\1\7\22\0\1\7\1\0\1\11\10\0"+
  32     "\1\6\1\31\1\2\1\4\1\12\12\3\1\32\6\0\4\1\1\5"+
  33     "\1\1\24\0\1\27\1\10\1\30\3\0\1\22\1\13\2\1\1\21"+
  34     "\1\14\5\0\1\23\1\0\1\15\3\0\1\16\1\24\1\17\1\20"+
  35     "\5\0\1\25\1\0\1\26\uff82\0";
  36
  37   /**
  38    * Translates characters to character classes
  39    */
  40   private static final char [] ZZ_CMAP = zzUnpackCMap(ZZ_CMAP_PACKED);
  41
  42   /**
  43    * Translates DFA states to action switch labels.
  44    */
  45   private static final int [] ZZ_ACTION = zzUnpackAction();
  46
  47   private static final String ZZ_ACTION_PACKED_0 =
  48     "\2\0\2\1\1\2\1\3\1\4\3\1\1\5\1\6"+
  49     "\1\7\1\10\1\11\1\12\1\13\1\14\1\15\5\0"+
  50     "\1\14\1\16\1\17\1\20\1\21\1\22\1\23\1\24"+
  51     "\1\0\1\25\1\0\1\25\4\0\1\26\1\27\2\0"+
  52     "\1\30";
  53
  54   private static int [] zzUnpackAction() {
  55     int [] result = new int[45];
  56     int offset = 0;
  57     offset = zzUnpackAction(ZZ_ACTION_PACKED_0, offset, result);
  58     return result;
  59   }
  60
  61   private static int zzUnpackAction(String packed, int offset, int [] result) {
  62     int i = 0;       /* index in packed string  */
  63     int j = offset;  /* index in unpacked array */
  64     int l = packed.length();
  65     while (i < l) {
  66       int count = packed.charAt(i++);
  67       int value = packed.charAt(i++);
  68       do result[j++] = value; while (--count > 0);
  69     }
  70     return j;
  71   }
  72
  73
  74   /**
  75    * Translates a state to a row index in the transition table
  76    */
  77   private static final int [] ZZ_ROWMAP = zzUnpackRowMap();
  78
  79   private static final String ZZ_ROWMAP_PACKED_0 =
  80     "\0\0\0\33\0\66\0\121\0\154\0\207\0\66\0\242"+
  81     "\0\275\0\330\0\66\0\66\0\66\0\66\0\66\0\66"+
  82     "\0\363\0\u010e\0\66\0\u0129\0\u0144\0\u015f\0\u017a\0\u0195"+
  83     "\0\66\0\66\0\66\0\66\0\66\0\66\0\66\0\66"+
  84     "\0\u01b0\0\u01cb\0\u01e6\0\u01e6\0\u0201\0\u021c\0\u0237\0\u0252"+
  85     "\0\66\0\66\0\u026d\0\u0288\0\66";
  86
  87   private static int [] zzUnpackRowMap() {
  88     int [] result = new int[45];
  89     int offset = 0;
  90     offset = zzUnpackRowMap(ZZ_ROWMAP_PACKED_0, offset, result);
  91     return result;
  92   }
  93
  94   private static int zzUnpackRowMap(String packed, int offset, int [] result) {
  95     int i = 0;  /* index in packed string  */
  96     int j = offset;  /* index in unpacked array */
  97     int l = packed.length();
  98     while (i < l) {
  99       int high = packed.codePointAt(i++) << 16;
 100       result[j++] = high | packed.codePointAt(i++);
 101     }
 102     return j;
 103   }
 104
 105   /**
 106    * The transition table of the DFA
 107    */
 108   private static final int ZZ_TRANS [] = {
 109     2, 2, 3, 4, 2, 2, 2, 5, 2, 6,
 110     2, 2, 7, 8, 2, 9, 2, 2, 2, 2,
 111     2, 10, 11, 12, 13, 14, 15, 16, 16, 16,
 112     16, 16, 16, 16, 16, 17, 18, 16, 16, 16,
 113     16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
 114     16, 16, 16, 16, -1, -1, -1, -1, -1, -1,
 115     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
 116     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
 117     -1, -1, -1, -1, 4, -1, -1, -1, -1, -1,
 118     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
 119     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
 120     -1, 4, 19, 20, -1, -1, -1, -1, -1, -1,
 121     -1, -1, -1, -1, -1, 20, -1, -1, -1, -1,
 122     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
 123     -1, -1, 5, -1, -1, -1, -1, -1, -1, -1,
 124     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
 125     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
 126     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
 127     21, -1, -1, -1, -1, -1, -1, -1, -1, -1,
 128     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
 129     -1, -1, -1, -1, -1, 22, -1, -1, -1, -1,
 130     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
 131     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
 132     23, -1, -1, -1, -1, -1, -1, -1, -1, -1,
 133     -1, -1, -1, 16, 16, 16, 16, 16, 16, 16,
 134     16, -1, -1, 16, 16, 16, 16, 16, 16, 16,
 135     16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
 136     -1, -1, -1, -1, -1, -1, -1, -1, 24, 25,
 137     26, 27, 28, 29, 30, 31, 32, -1, -1, -1,
 138     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
 139     33, -1, -1, -1, -1, -1, -1, -1, -1, -1,
 140     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
 141     -1, -1, -1, -1, -1, -1, 34, 35, -1, -1,
 142     34, -1, -1, -1, -1, -1, -1, -1, -1, -1,
 143     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
 144     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
 145     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
 146     36, -1, -1, -1, -1, -1, -1, -1, -1, -1,
 147     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
 148     -1, -1, -1, -1, -1, -1, -1, 37, -1, -1,
 149     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
 150     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
 151     -1, 38, -1, -1, -1, -1, -1, -1, -1, -1,
 152     -1, -1, -1, 39, -1, 39, -1, 39, -1, -1,
 153     -1, -1, -1, 39, 39, -1, -1, -1, -1, 39,
 154     39, -1, -1, -1, -1, -1, -1, -1, -1, -1,
 155     -1, -1, 33, -1, 20, -1, -1, -1, -1, -1,
 156     -1, -1, -1, -1, -1, -1, 20, -1, -1, -1,
 157     -1, -1, -1, -1, -1, -1, -1, -1, -1, 35,
 158     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
 159     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
 160     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
 161     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
 162     -1, -1, -1, 38, -1, -1, -1, -1, -1, -1,
 163     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
 164     -1, -1, -1, -1, -1, -1, -1, -1, -1, 40,
 165     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
 166     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
 167     -1, -1, -1, -1, 41, -1, -1, -1, -1, -1,
 168     -1, -1, -1, -1, -1, 42, -1, 42, -1, 42,
 169     -1, -1, -1, -1, -1, 42, 42, -1, -1, -1,
 170     -1, 42, 42, -1, -1, -1, -1, -1, -1, -1,
 171     -1, -1, 43, -1, 43, -1, 43, -1, -1, -1,
 172     -1, -1, 43, 43, -1, -1, -1, -1, 43, 43,
 173     -1, -1, -1, -1, -1, -1, -1, -1, -1, 44,
 174     -1, 44, -1, 44, -1, -1, -1, -1, -1, 44,
 175     44, -1, -1, -1, -1, 44, 44, -1, -1, -1,
 176     -1, -1, -1, -1, -1,
 177   };
 178
 179   /* error codes */
 180   private static final int ZZ_UNKNOWN_ERROR = 0;
 181   private static final int ZZ_NO_MATCH = 1;
 182   private static final int ZZ_PUSHBACK_2BIG = 2;
 183
 184   /* error messages for the codes above */
 185   private static final String ZZ_ERROR_MSG[] = {
 186     "Unkown internal scanner error",
 187     "Error: could not match input",
 188     "Error: pushback value was too large"
 189   };
 190
 191   /**
 192    * ZZ_ATTRIBUTE[aState] contains the attributes of state <code>aState</code>
 193    */
 194   private static final int [] ZZ_ATTRIBUTE = zzUnpackAttribute();
 195
 196   private static final String ZZ_ATTRIBUTE_PACKED_0 =
 197     "\2\0\1\11\3\1\1\11\3\1\6\11\2\1\1\11"+
 198     "\5\0\10\11\1\0\1\1\1\0\1\1\4\0\2\11"+
 199     "\2\0\1\11";
 200
 201   private static int [] zzUnpackAttribute() {
 202     int [] result = new int[45];
 203     int offset = 0;
 204     offset = zzUnpackAttribute(ZZ_ATTRIBUTE_PACKED_0, offset, result);
 205     return result;
 206   }
 207
 208   private static int zzUnpackAttribute(String packed, int offset, int [] result) {
 209     int i = 0;       /* index in packed string  */
 210     int j = offset;  /* index in unpacked array */
 211     int l = packed.length();
 212     while (i < l) {
 213       int count = packed.charAt(i++);
 214       int value = packed.charAt(i++);
 215       do result[j++] = value; while (--count > 0);
 216     }
 217     return j;
 218   }
 219
 220   /** the input device */
 221   private java.io.Reader zzReader;
 222
 223   /** the current state of the DFA */
 224   private int zzState;
 225
 226   /** the current lexical state */
 227   private int zzLexicalState = YYINITIAL;
 228
 229   /** this buffer contains the current text to be matched and is
 230       the source of the yytext() string */
 231   private char zzBuffer[] = new char[ZZ_BUFFERSIZE];
 232
 233   /** the textposition at the last accepting state */
 234   private int zzMarkedPos;
 235
 236   /** the current text position in the buffer */
 237   private int zzCurrentPos;
 238
 239   /** startRead marks the beginning of the yytext() string in the buffer */
 240   private int zzStartRead;
 241
 242   /** endRead marks the last character in the buffer, that has been read
 243       from input */
 244   private int zzEndRead;
 245
 246   /** number of newlines encountered up to the start of the matched text */
 247   private int yyline;
 248
 249   /** the number of characters up to the start of the matched text */
 250   private int yychar;
 251
 252   /**
 253    * the number of characters from the last newline up to the start of the
 254    * matched text
 255    */
 256   private int yycolumn;
 257
 258   /**
 259    * zzAtBOL == true <=> the scanner is currently at the beginning of a line
 260    */
 261   private boolean zzAtBOL = true;
 262
 263   /** zzAtEOF == true <=> the scanner is at the EOF */
 264   private boolean zzAtEOF;
 265
 266   /* user code: */
 267 private StringBuffer sb=new StringBuffer();
 268
 269 int getPosition(){
 270         return yychar;
 271 }
 272
 273
 274
 275   /**
 276    * Creates a new scanner
 277    * There is also a java.io.InputStream version of this constructor.
 278    *
 279    * @param   in  the java.io.Reader to read input from.
 280    */
 281   Yylex(java.io.Reader in) {
 282     this.zzReader = in;
 283   }
 284
 285   /**
 286    * Creates a new scanner.
 287    * There is also java.io.Reader version of this constructor.
 288    *
 289    * @param   in  the java.io.Inputstream to read input from.
 290    */
 291   Yylex(java.io.InputStream in) {
 292     this(new java.io.InputStreamReader(in));
 293   }
 294
 295   /**
 296    * Unpacks the compressed character translation table.
 297    *
 298    * @param packed   the packed character translation table
 299    * @return         the unpacked character translation table
 300    */
 301   private static char [] zzUnpackCMap(String packed) {
 302     char [] map = new char[0x10000];
 303     int i = 0;  /* index in packed string  */
 304     int j = 0;  /* index in unpacked array */
 305     while (i < 90) {
 306       int  count = packed.charAt(i++);
 307       char value = packed.charAt(i++);
 308       do map[j++] = value; while (--count > 0);
 309     }
 310     return map;
 311   }
 312
 313
 314   /**
 315    * Refills the input buffer.
 316    *
 317    * @return      <code>false</code>, iff there was new input.
 318    *
 319    * @exception   java.io.IOException  if any I/O-Error occurs
 320    */
 321   private boolean zzRefill() throws java.io.IOException {
 322
 323     /* first: make room (if you can) */
 324     if (zzStartRead > 0) {
 325       System.arraycopy(zzBuffer, zzStartRead,
 326                        zzBuffer, 0,
 327                        zzEndRead-zzStartRead);
 328
 329       /* translate stored positions */
 330       zzEndRead-= zzStartRead;
 331       zzCurrentPos-= zzStartRead;
 332       zzMarkedPos-= zzStartRead;
 333       zzStartRead = 0;
 334     }
 335
 336     /* is the buffer big enough? */
 337     if (zzCurrentPos >= zzBuffer.length) {
 338       /* if not: blow it up */
 339       char newBuffer[] = new char[zzCurrentPos*2];
 340       System.arraycopy(zzBuffer, 0, newBuffer, 0, zzBuffer.length);
 341       zzBuffer = newBuffer;
 342     }
 343
 344     /* finally: fill the buffer with new input */
 345     int numRead = zzReader.read(zzBuffer, zzEndRead,
 346                                             zzBuffer.length-zzEndRead);
 347
 348     if (numRead > 0) {
 349       zzEndRead+= numRead;
 350       return false;
 351     }
 352     // unlikely but not impossible: read 0 characters, but not at end of stream
 353     if (numRead == 0) {
 354       int c = zzReader.read();
 355       if (c == -1) {
 356         return true;
 357       } else {
 358         zzBuffer[zzEndRead++] = (char) c;
 359         return false;
 360       }
 361     }
 362
 363         // numRead < 0
 364     return true;
 365   }
 366
 367
 368   /**
 369    * Closes the input stream.
 370    */
 371   public final void yyclose() throws java.io.IOException {
 372     zzAtEOF = true;            /* indicate end of file */
 373     zzEndRead = zzStartRead;  /* invalidate buffer    */
 374
 375     if (zzReader != null)
 376       zzReader.close();
 377   }
 378
 379
 380   /**
 381    * Resets the scanner to read from a new input stream.
 382    * Does not close the old reader.
 383    *
 384    * All internal variables are reset, the old input stream
 385    * <b>cannot</b> be reused (internal buffer is discarded and lost).
 386    * Lexical state is set to <tt>ZZ_INITIAL</tt>.
 387    *
 388    * @param reader   the new input stream
 389    */
 390   public final void yyreset(java.io.Reader reader) {
 391     zzReader = reader;
 392     zzAtBOL  = true;
 393     zzAtEOF  = false;
 394     zzEndRead = zzStartRead = 0;
 395     zzCurrentPos = zzMarkedPos = 0;
 396     yyline = yychar = yycolumn = 0;
 397     zzLexicalState = YYINITIAL;
 398   }
 399
 400
 401   /**
 402    * Returns the current lexical state.
 403    */
 404   public final int yystate() {
 405     return zzLexicalState;
 406   }
 407
 408
 409   /**
 410    * Enters a new lexical state
 411    *
 412    * @param newState the new lexical state
 413    */
 414   public final void yybegin(int newState) {
 415     zzLexicalState = newState;
 416   }
 417
 418
 419   /**
 420    * Returns the text matched by the current regular expression.
 421    */
 422   public final String yytext() {
 423     return new String( zzBuffer, zzStartRead, zzMarkedPos-zzStartRead );
 424   }
 425
 426
 427   /**
 428    * Returns the character at position <tt>pos</tt> from the
 429    * matched text.
 430    *
 431    * It is equivalent to yytext().charAt(pos), but faster
 432    *
 433    * @param pos the position of the character to fetch.
 434    *            A value from 0 to yylength()-1.
 435    *
 436    * @return the character at position pos
 437    */
 438   public final char yycharat(int pos) {
 439     return zzBuffer[zzStartRead+pos];
 440   }
 441
 442
 443   /**
 444    * Returns the length of the matched text region.
 445    */
 446   public final int yylength() {
 447     return zzMarkedPos-zzStartRead;
 448   }
 449
 450
 451   /**
 452    * Reports an error that occured while scanning.
 453    *
 454    * In a wellformed scanner (no or only correct usage of
 455    * yypushback(int) and a match-all fallback rule) this method
 456    * will only be called with things that "Can't Possibly Happen".
 457    * If this method is called, something is seriously wrong
 458    * (e.g. a JFlex bug producing a faulty scanner etc.).
 459    *
 460    * Usual syntax/scanner level error handling should be done
 461    * in error fallback rules.
 462    *
 463    * @param   errorCode  the code of the errormessage to display
 464    */
 465   private void zzScanError(int errorCode) {
 466     String message;
 467     try {
 468       message = ZZ_ERROR_MSG[errorCode];
 469     }
 470     catch (ArrayIndexOutOfBoundsException e) {
 471       message = ZZ_ERROR_MSG[ZZ_UNKNOWN_ERROR];
 472     }
 473
 474     throw new Error(message);
 475   }
 476
 477
 478   /**
 479    * Pushes the specified amount of characters back into the input stream.
 480    *
 481    * They will be read again by then next call of the scanning method
 482    *
 483    * @param number  the number of characters to be read again.
 484    *                This number must not be greater than yylength()!
 485    */
 486   public void yypushback(int number)  {
 487     if ( number > yylength() )
 488       zzScanError(ZZ_PUSHBACK_2BIG);
 489
 490     zzMarkedPos -= number;
 491   }
 492
 493
 494   /**
 495    * Resumes scanning until the next regular expression is matched, the end of
 496    * input is encountered or an I/O-Error occurs.
 497    *
 498    * @return the next token
 499    * @exception java.io.IOException
 500    *              if any I/O-Error occurs
 501    */
 502   public Yytoken yylex() throws java.io.IOException, ParseException
 503   {
 504     int zzInput;
 505     int zzAction;
 506
 507     // cached fields:
 508     int zzCurrentPosL;
 509     int zzMarkedPosL;
 510     int zzEndReadL = zzEndRead;
 511     char[] zzBufferL = zzBuffer;
 512     char[] zzCMapL = ZZ_CMAP;
 513
 514     int[] zzTransL = ZZ_TRANS;
 515     int[] zzRowMapL = ZZ_ROWMAP;
 516     int[] zzAttrL = ZZ_ATTRIBUTE;
 517
 518     while (true)
 519     {
 520       zzMarkedPosL = zzMarkedPos;
 521
 522       yychar += zzMarkedPosL - zzStartRead;
 523
 524       zzAction = -1;
 525
 526       zzCurrentPosL = zzCurrentPos = zzStartRead = zzMarkedPosL;
 527
 528       zzState = ZZ_LEXSTATE[zzLexicalState];
 529
 530       zzForAction:
 531       {
 532         while (true)
 533         {
 534
 535           if (zzCurrentPosL < zzEndReadL)
 536             zzInput = zzBufferL[zzCurrentPosL++];
 537           else if (zzAtEOF)
 538           {
 539             zzInput = YYEOF;
 540             break zzForAction;
 541           }
 542           else
 543           {
 544             // store back cached positions
 545             zzCurrentPos = zzCurrentPosL;
 546             zzMarkedPos = zzMarkedPosL;
 547             boolean eof = zzRefill();
 548             // get translated positions and possibly new buffer
 549             zzCurrentPosL = zzCurrentPos;
 550             zzMarkedPosL = zzMarkedPos;
 551             zzBufferL = zzBuffer;
 552             zzEndReadL = zzEndRead;
 553             if (eof)
 554             {
 555               zzInput = YYEOF;
 556               break zzForAction;
 557             }
 558             else
 559             {
 560               zzInput = zzBufferL[zzCurrentPosL++];
 561             }
 562           }
 563           int zzNext = zzTransL[zzRowMapL[zzState] + zzCMapL[zzInput]];
 564           if (zzNext == -1)
 565             break zzForAction;
 566           zzState = zzNext;
 567
 568           int zzAttributes = zzAttrL[zzState];
 569           if ((zzAttributes & 1) == 1)
 570           {
 571             zzAction = zzState;
 572             zzMarkedPosL = zzCurrentPosL;
 573             if ((zzAttributes & 8) == 8)
 574               break zzForAction;
 575           }
 576
 577         }
 578       }
 579
 580       // store back cached position
 581       zzMarkedPos = zzMarkedPosL;
 582       switch (zzAction < 0 ? zzAction : ZZ_ACTION[zzAction])
 583       {
 584       case 11:
 585       {
 586         sb.append(yytext());
 587       }
 588       case 25:
 589         break;
 590       case 4:
 591       {
 592         sb = null;
 593         sb = new StringBuffer();
 594         yybegin(STRING_BEGIN);
 595       }
 596       case 26:
 597         break;
 598       case 16:
 599       {
 600         sb.append('\b');
 601       }
 602       case 27:
 603         break;
 604       case 6:
 605       {
 606         return new Yytoken(Yytoken.TYPE_RIGHT_BRACE, null);
 607       }
 608       case 28:
 609         break;
 610       case 23:
 611       {
 612         Boolean val = Boolean.valueOf(yytext());
 613         return new Yytoken(Yytoken.TYPE_VALUE, val);
 614       }
 615       case 29:
 616         break;
 617       case 22:
 618       {
 619         return new Yytoken(Yytoken.TYPE_VALUE, null);
 620       }
 621       case 30:
 622         break;
 623       case 13:
 624       {
 625         yybegin(YYINITIAL);
 626         return new Yytoken(Yytoken.TYPE_VALUE, sb.toString());
 627       }
 628       case 31:
 629         break;
 630       case 12:
 631       {
 632         sb.append('\\');
 633       }
 634       case 32:
 635         break;
 636       case 21:
 637       {
 638         Double val = Double.valueOf(yytext());
 639         return new Yytoken(Yytoken.TYPE_VALUE, val);
 640       }
 641       case 33:
 642         break;
 643       case 1:
 644       {
 645         throw new ParseException(yychar,
 646                 ParseException.ERROR_UNEXPECTED_CHAR,
 647                 new Character(yycharat(0)));
 648       }
 649       case 34:
 650         break;
 651       case 8:
 652       {
 653         return new Yytoken(Yytoken.TYPE_RIGHT_SQUARE, null);
 654       }
 655       case 35:
 656         break;
 657       case 19:
 658       {
 659         sb.append('\r');
 660       }
 661       case 36:
 662         break;
 663       case 15:
 664       {
 665         sb.append('/');
 666       }
 667       case 37:
 668         break;
 669       case 10:
 670       {
 671         return new Yytoken(Yytoken.TYPE_COLON, null);
 672       }
 673       case 38:
 674         break;
 675       case 14:
 676       {
 677         sb.append('"');
 678       }
 679       case 39:
 680         break;
 681       case 5:
 682       {
 683         return new Yytoken(Yytoken.TYPE_LEFT_BRACE, null);
 684       }
 685       case 40:
 686         break;
 687       case 17:
 688       {
 689         sb.append('\f');
 690       }
 691       case 41:
 692         break;
 693       case 24:
 694       {
 695         try
 696         {
 697           int ch = Integer.parseInt(yytext().substring(2), 16);
 698           sb.append((char) ch);
 699         } catch (Exception e)
 700         {
 701           throw new ParseException(yychar,
 702                   ParseException.ERROR_UNEXPECTED_EXCEPTION, e);
 703         }
 704       }
 705       case 42:
 706         break;
 707       case 20:
 708       {
 709         sb.append('\t');
 710       }
 711       case 43:
 712         break;
 713       case 7:
 714       {
 715         return new Yytoken(Yytoken.TYPE_LEFT_SQUARE, null);
 716       }
 717       case 44:
 718         break;
 719       case 2:
 720       {
 721         Long val = Long.valueOf(yytext());
 722         return new Yytoken(Yytoken.TYPE_VALUE, val);
 723       }
 724       case 45:
 725         break;
 726       case 18:
 727       {
 728         sb.append('\n');
 729       }
 730       case 46:
 731         break;
 732       case 9:
 733       {
 734         return new Yytoken(Yytoken.TYPE_COMMA, null);
 735       }
 736       case 47:
 737         break;
 738       case 3:
 739       {
 740       }
 741       case 48:
 742         break;
 743       default:
 744         if (zzInput == YYEOF && zzStartRead == zzCurrentPos)
 745         {
 746           zzAtEOF = true;
 747           return null;
 748         }
 749         else
 750         {
 751           zzScanError(ZZ_NO_MATCH);
 752         }
 753       }
 754     }
 755   }
 756
 757
 758 }