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