View Javadoc

1   /* Generated By:JJTree&JavaCC: Do not edit this line. ParserTokenManager.java */
2   package org.apache.velocity.runtime.parser;
3   import java.io.*;
4   import java.util.*;
5   import org.apache.velocity.runtime.RuntimeServices;
6   import org.apache.velocity.runtime.parser.node.*;
7   import org.apache.velocity.runtime.directive.Directive;
8   import org.apache.velocity.runtime.directive.Macro;
9   import org.apache.velocity.runtime.directive.MacroParseException;
10  import org.apache.velocity.util.StringUtils;
11  
12  public class ParserTokenManager implements ParserConstants
13  {
14      private int fileDepth = 0;
15  
16      private int lparen = 0;
17      private int rparen = 0;
18  
19      Stack stateStack = new Stack();
20      public boolean debugPrint = false;
21  
22      private boolean inReference;
23      public boolean inDirective;
24      private boolean inComment;
25      public  boolean inSet;
26  
27      /**
28       *  pushes the current state onto the 'state stack',
29       *  and maintains the parens counts
30       *  public because we need it in PD & VM handling
31       *
32       *  @return boolean : success.  It can fail if the state machine
33       *     gets messed up (do don't mess it up :)
34       */
35      public boolean stateStackPop()
36      {
37          Hashtable h;
38  
39          try
40          {
41              h = (Hashtable) stateStack.pop();
42          }
43          catch( EmptyStackException e)
44          {
45              lparen=0;
46              SwitchTo(DEFAULT);
47              return false;
48          }
49  
50          if( debugPrint )
51              System.out.println(
52                  " stack pop (" + stateStack.size() + ") : lparen=" +
53                      ( (Integer) h.get("lparen")).intValue() +
54                          " newstate=" + ( (Integer) h.get("lexstate")).intValue() );
55  
56          lparen = ( (Integer) h.get("lparen")).intValue();
57          rparen = ( (Integer) h.get("rparen")).intValue();
58  
59          SwitchTo( ( (Integer) h.get("lexstate")).intValue() );
60  
61          return true;
62      }
63  
64      /**
65       *  pops a state off the stack, and restores paren counts
66       *
67       *  @return boolean : success of operation
68       */
69      public boolean stateStackPush()
70      {
71          if( debugPrint )
72              System.out.println(" (" + stateStack.size() + ") pushing cur state : " +
73                  curLexState );
74  
75          Hashtable h = new Hashtable();
76  
77          h.put("lexstate", new Integer( curLexState ) );
78          h.put("lparen", new Integer( lparen ));
79          h.put("rparen", new Integer( rparen ));
80  
81          lparen = 0;
82  
83          stateStack.push( h );
84  
85          return true;
86      }
87  
88      /**
89       *  Clears all state variables, resets to
90       *  start values, clears stateStack.  Call
91       *  before parsing.
92       *  @return void
93       */
94      public void clearStateVars()
95      {
96          stateStack.clear();
97  
98          lparen = 0;
99          rparen = 0;
100         inReference = false;
101         inDirective = false;
102         inComment = false;
103         inSet = false;
104 
105         return;
106     }
107 
108     /**
109      *  handles the dropdown logic when encountering a RPAREN
110      */
111     private void RPARENHandler()
112     {
113         /*
114          *  Ultimately, we want to drop down to the state below
115          *  the one that has an open (if we hit bottom (DEFAULT),
116          *  that's fine. It's just text schmoo.
117          */
118 
119         boolean closed = false;
120 
121         if (inComment)
122             closed = true;
123 
124         while( !closed )
125         {
126             /*
127              * look at current state.  If we haven't seen a lparen
128              * in this state then we drop a state, because this
129              * lparen clearly closes our state
130              */
131 
132             if( lparen > 0)
133             {
134                 /*
135                  *  if rparen + 1 == lparen, then this state is closed.
136                  * Otherwise, increment and keep parsing
137                  */
138 
139                  if( lparen == rparen + 1)
140                  {
141                        stateStackPop();
142                  }
143                 else
144                 {
145                     rparen++;
146                 }
147 
148                  closed = true;
149             }
150             else
151             {
152                 /*
153                  * now, drop a state
154                  */
155 
156                 if(!stateStackPop())
157                     break;
158             }
159         }
160     }
161   public  java.io.PrintStream debugStream = System.out;
162   public  void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
163 private final int jjStopStringLiteralDfa_0(int pos, long active0)
164 {
165    switch (pos)
166    {
167       case 0:
168          if ((active0 & 0x10L) != 0L)
169             return 58;
170          if ((active0 & 0x80000000L) != 0L)
171             return 101;
172          if ((active0 & 0x40L) != 0L)
173             return 65;
174          if ((active0 & 0x30000000L) != 0L)
175          {
176             jjmatchedKind = 57;
177             return 63;
178          }
179          if ((active0 & 0x200000000000L) != 0L)
180             return 50;
181          if ((active0 & 0x70000L) != 0L)
182             return 7;
183          return -1;
184       case 1:
185          if ((active0 & 0x10000L) != 0L)
186             return 5;
187          if ((active0 & 0x30000000L) != 0L)
188          {
189             jjmatchedKind = 57;
190             jjmatchedPos = 1;
191             return 63;
192          }
193          return -1;
194       case 2:
195          if ((active0 & 0x30000000L) != 0L)
196          {
197             jjmatchedKind = 57;
198             jjmatchedPos = 2;
199             return 63;
200          }
201          return -1;
202       case 3:
203          if ((active0 & 0x10000000L) != 0L)
204             return 63;
205          if ((active0 & 0x20000000L) != 0L)
206          {
207             jjmatchedKind = 57;
208             jjmatchedPos = 3;
209             return 63;
210          }
211          return -1;
212       default :
213          return -1;
214    }
215 }
216 private final int jjStartNfa_0(int pos, long active0)
217 {
218    return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1);
219 }
220 private final int jjStopAtPos(int pos, int kind)
221 {
222    jjmatchedKind = kind;
223    jjmatchedPos = pos;
224    return pos + 1;
225 }
226 private final int jjStartNfaWithStates_0(int pos, int kind, int state)
227 {
228    jjmatchedKind = kind;
229    jjmatchedPos = pos;
230    try { curChar = input_stream.readChar(); }
231    catch(java.io.IOException e) { return pos + 1; }
232    return jjMoveNfa_0(state, pos + 1);
233 }
234 private final int jjMoveStringLiteralDfa0_0()
235 {
236    switch(curChar)
237    {
238       case 35:
239          jjmatchedKind = 17;
240          return jjMoveStringLiteralDfa1_0(0x50000L);
241       case 37:
242          return jjStopAtPos(0, 35);
243       case 40:
244          return jjStopAtPos(0, 8);
245       case 42:
246          return jjStopAtPos(0, 33);
247       case 43:
248          return jjStopAtPos(0, 32);
249       case 44:
250          return jjStopAtPos(0, 3);
251       case 45:
252          return jjStartNfaWithStates_0(0, 31, 101);
253       case 46:
254          return jjMoveStringLiteralDfa1_0(0x10L);
255       case 47:
256          return jjStopAtPos(0, 34);
257       case 58:
258          return jjStopAtPos(0, 5);
259       case 61:
260          return jjStartNfaWithStates_0(0, 45, 50);
261       case 91:
262          return jjStopAtPos(0, 1);
263       case 93:
264          return jjStopAtPos(0, 2);
265       case 102:
266          return jjMoveStringLiteralDfa1_0(0x20000000L);
267       case 116:
268          return jjMoveStringLiteralDfa1_0(0x10000000L);
269       case 123:
270          return jjStartNfaWithStates_0(0, 6, 65);
271       case 125:
272          return jjStopAtPos(0, 7);
273       default :
274          return jjMoveNfa_0(0, 0);
275    }
276 }
277 private final int jjMoveStringLiteralDfa1_0(long active0)
278 {
279    try { curChar = input_stream.readChar(); }
280    catch(java.io.IOException e) {
281       jjStopStringLiteralDfa_0(0, active0);
282       return 1;
283    }
284    switch(curChar)
285    {
286       case 35:
287          if ((active0 & 0x40000L) != 0L)
288             return jjStopAtPos(1, 18);
289          break;
290       case 42:
291          if ((active0 & 0x10000L) != 0L)
292             return jjStartNfaWithStates_0(1, 16, 5);
293          break;
294       case 46:
295          if ((active0 & 0x10L) != 0L)
296             return jjStopAtPos(1, 4);
297          break;
298       case 97:
299          return jjMoveStringLiteralDfa2_0(active0, 0x20000000L);
300       case 114:
301          return jjMoveStringLiteralDfa2_0(active0, 0x10000000L);
302       default :
303          break;
304    }
305    return jjStartNfa_0(0, active0);
306 }
307 private final int jjMoveStringLiteralDfa2_0(long old0, long active0)
308 {
309    if (((active0 &= old0)) == 0L)
310       return jjStartNfa_0(0, old0); 
311    try { curChar = input_stream.readChar(); }
312    catch(java.io.IOException e) {
313       jjStopStringLiteralDfa_0(1, active0);
314       return 2;
315    }
316    switch(curChar)
317    {
318       case 108:
319          return jjMoveStringLiteralDfa3_0(active0, 0x20000000L);
320       case 117:
321          return jjMoveStringLiteralDfa3_0(active0, 0x10000000L);
322       default :
323          break;
324    }
325    return jjStartNfa_0(1, active0);
326 }
327 private final int jjMoveStringLiteralDfa3_0(long old0, long active0)
328 {
329    if (((active0 &= old0)) == 0L)
330       return jjStartNfa_0(1, old0); 
331    try { curChar = input_stream.readChar(); }
332    catch(java.io.IOException e) {
333       jjStopStringLiteralDfa_0(2, active0);
334       return 3;
335    }
336    switch(curChar)
337    {
338       case 101:
339          if ((active0 & 0x10000000L) != 0L)
340             return jjStartNfaWithStates_0(3, 28, 63);
341          break;
342       case 115:
343          return jjMoveStringLiteralDfa4_0(active0, 0x20000000L);
344       default :
345          break;
346    }
347    return jjStartNfa_0(2, active0);
348 }
349 private final int jjMoveStringLiteralDfa4_0(long old0, long active0)
350 {
351    if (((active0 &= old0)) == 0L)
352       return jjStartNfa_0(2, old0); 
353    try { curChar = input_stream.readChar(); }
354    catch(java.io.IOException e) {
355       jjStopStringLiteralDfa_0(3, active0);
356       return 4;
357    }
358    switch(curChar)
359    {
360       case 101:
361          if ((active0 & 0x20000000L) != 0L)
362             return jjStartNfaWithStates_0(4, 29, 63);
363          break;
364       default :
365          break;
366    }
367    return jjStartNfa_0(3, active0);
368 }
369 private final void jjCheckNAdd(int state)
370 {
371    if (jjrounds[state] != jjround)
372    {
373       jjstateSet[jjnewStateCnt++] = state;
374       jjrounds[state] = jjround;
375    }
376 }
377 private final void jjAddStates(int start, int end)
378 {
379    do {
380       jjstateSet[jjnewStateCnt++] = jjnextStates[start];
381    } while (start++ != end);
382 }
383 private final void jjCheckNAddTwoStates(int state1, int state2)
384 {
385    jjCheckNAdd(state1);
386    jjCheckNAdd(state2);
387 }
388 private final void jjCheckNAddStates(int start, int end)
389 {
390    do {
391       jjCheckNAdd(jjnextStates[start]);
392    } while (start++ != end);
393 }
394 private final void jjCheckNAddStates(int start)
395 {
396    jjCheckNAdd(jjnextStates[start]);
397    jjCheckNAdd(jjnextStates[start + 1]);
398 }
399 static final long[] jjbitVec0 = {
400    0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
401 };
402 static final long[] jjbitVec2 = {
403    0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
404 };
405 private final int jjMoveNfa_0(int startState, int curPos)
406 {
407    int[] nextStates;
408    int startsAt = 0;
409    jjnewStateCnt = 101;
410    int i = 1;
411    jjstateSet[0] = startState;
412    int j, kind = 0x7fffffff;
413    for (;;)
414    {
415       if (++jjround == 0x7fffffff)
416          ReInitRounds();
417       if (curChar < 64)
418       {
419          long l = 1L << curChar;
420          MatchLoop: do
421          {
422             switch(jjstateSet[--i])
423             {
424                case 0:
425                   if ((0x3ff000000000000L & l) != 0L)
426                   {
427                      if (kind > 52)
428                         kind = 52;
429                      jjCheckNAddStates(0, 5);
430                   }
431                   else if ((0x100002600L & l) != 0L)
432                   {
433                      if (kind > 26)
434                         kind = 26;
435                      jjCheckNAdd(9);
436                   }
437                   else if (curChar == 45)
438                      jjCheckNAddStates(6, 9);
439                   else if (curChar == 36)
440                   {
441                      if (kind > 13)
442                         kind = 13;
443                      jjCheckNAddTwoStates(73, 74);
444                   }
445                   else if (curChar == 46)
446                      jjCheckNAdd(58);
447                   else if (curChar == 33)
448                   {
449                      if (kind > 44)
450                         kind = 44;
451                   }
452                   else if (curChar == 61)
453                      jjstateSet[jjnewStateCnt++] = 50;
454                   else if (curChar == 62)
455                      jjstateSet[jjnewStateCnt++] = 48;
456                   else if (curChar == 60)
457                      jjstateSet[jjnewStateCnt++] = 45;
458                   else if (curChar == 38)
459                      jjstateSet[jjnewStateCnt++] = 35;
460                   else if (curChar == 39)
461                      jjCheckNAddStates(10, 12);
462                   else if (curChar == 34)
463                      jjCheckNAddStates(13, 15);
464                   else if (curChar == 35)
465                      jjstateSet[jjnewStateCnt++] = 7;
466                   else if (curChar == 41)
467                   {
468                      if (kind > 9)
469                         kind = 9;
470                      jjCheckNAddStates(16, 18);
471                   }
472                   if ((0x2400L & l) != 0L)
473                   {
474                      if (kind > 30)
475                         kind = 30;
476                   }
477                   else if (curChar == 33)
478                      jjstateSet[jjnewStateCnt++] = 54;
479                   else if (curChar == 62)
480                   {
481                      if (kind > 40)
482                         kind = 40;
483                   }
484                   else if (curChar == 60)
485                   {
486                      if (kind > 38)
487                         kind = 38;
488                   }
489                   if (curChar == 13)
490                      jjstateSet[jjnewStateCnt++] = 33;
491                   break;
492                case 101:
493                   if ((0x3ff000000000000L & l) != 0L)
494                      jjCheckNAddTwoStates(96, 97);
495                   else if (curChar == 46)
496                      jjCheckNAdd(58);
497                   if ((0x3ff000000000000L & l) != 0L)
498                      jjCheckNAddTwoStates(90, 91);
499                   if ((0x3ff000000000000L & l) != 0L)
500                   {
501                      if (kind > 52)
502                         kind = 52;
503                      jjCheckNAddTwoStates(87, 89);
504                   }
505                   break;
506                case 1:
507                   if ((0x100000200L & l) != 0L)
508                      jjCheckNAddStates(16, 18);
509                   break;
510                case 2:
511                   if ((0x2400L & l) != 0L && kind > 9)
512                      kind = 9;
513                   break;
514                case 3:
515                   if (curChar == 10 && kind > 9)
516                      kind = 9;
517                   break;
518                case 4:
519                   if (curChar == 13)
520                      jjstateSet[jjnewStateCnt++] = 3;
521                   break;
522                case 5:
523                   if (curChar == 42)
524                      jjstateSet[jjnewStateCnt++] = 6;
525                   break;
526                case 6:
527                   if ((0xfffffff7ffffffffL & l) != 0L && kind > 15)
528                      kind = 15;
529                   break;
530                case 7:
531                   if (curChar == 42)
532                      jjstateSet[jjnewStateCnt++] = 5;
533                   break;
534                case 8:
535                   if (curChar == 35)
536                      jjstateSet[jjnewStateCnt++] = 7;
537                   break;
538                case 9:
539                   if ((0x100002600L & l) == 0L)
540                      break;
541                   if (kind > 26)
542                      kind = 26;
543                   jjCheckNAdd(9);
544                   break;
545                case 10:
546                   if (curChar == 34)
547                      jjCheckNAddStates(13, 15);
548                   break;
549                case 11:
550                   if ((0xfffffffbffffffffL & l) != 0L)
551                      jjCheckNAddStates(13, 15);
552                   break;
553                case 12:
554                   if (curChar == 34 && kind > 27)
555                      kind = 27;
556                   break;
557                case 14:
558                   if ((0x8400000000L & l) != 0L)
559                      jjCheckNAddStates(13, 15);
560                   break;
561                case 15:
562                   if ((0xff000000000000L & l) != 0L)
563                      jjCheckNAddStates(19, 22);
564                   break;
565                case 16:
566                   if ((0xff000000000000L & l) != 0L)
567                      jjCheckNAddStates(13, 15);
568                   break;
569                case 17:
570                   if ((0xf000000000000L & l) != 0L)
571                      jjstateSet[jjnewStateCnt++] = 18;
572                   break;
573                case 18:
574                   if ((0xff000000000000L & l) != 0L)
575                      jjCheckNAdd(16);
576                   break;
577                case 20:
578                   if ((0x3ff000000000000L & l) != 0L)
579                      jjstateSet[jjnewStateCnt++] = 21;
580                   break;
581                case 21:
582                   if ((0x3ff000000000000L & l) != 0L)
583                      jjstateSet[jjnewStateCnt++] = 22;
584                   break;
585                case 22:
586                   if ((0x3ff000000000000L & l) != 0L)
587                      jjstateSet[jjnewStateCnt++] = 23;
588                   break;
589                case 23:
590                   if ((0x3ff000000000000L & l) != 0L)
591                      jjCheckNAddStates(13, 15);
592                   break;
593                case 24:
594                   if (curChar == 32)
595                      jjAddStates(23, 24);
596                   break;
597                case 25:
598                   if (curChar == 10)
599                      jjCheckNAddStates(13, 15);
600                   break;
601                case 26:
602                   if (curChar == 39)
603                      jjCheckNAddStates(10, 12);
604                   break;
605                case 27:
606                   if ((0xffffff7fffffffffL & l) != 0L)
607                      jjCheckNAddStates(10, 12);
608                   break;
609                case 29:
610                   if (curChar == 32)
611                      jjAddStates(25, 26);
612                   break;
613                case 30:
614                   if (curChar == 10)
615                      jjCheckNAddStates(10, 12);
616                   break;
617                case 31:
618                   if (curChar == 39 && kind > 27)
619                      kind = 27;
620                   break;
621                case 32:
622                   if ((0x2400L & l) != 0L && kind > 30)
623                      kind = 30;
624                   break;
625                case 33:
626                   if (curChar == 10 && kind > 30)
627                      kind = 30;
628                   break;
629                case 34:
630                   if (curChar == 13)
631                      jjstateSet[jjnewStateCnt++] = 33;
632                   break;
633                case 35:
634                   if (curChar == 38 && kind > 36)
635                      kind = 36;
636                   break;
637                case 36:
638                   if (curChar == 38)
639                      jjstateSet[jjnewStateCnt++] = 35;
640                   break;
641                case 44:
642                   if (curChar == 60 && kind > 38)
643                      kind = 38;
644                   break;
645                case 45:
646                   if (curChar == 61 && kind > 39)
647                      kind = 39;
648                   break;
649                case 46:
650                   if (curChar == 60)
651                      jjstateSet[jjnewStateCnt++] = 45;
652                   break;
653                case 47:
654                   if (curChar == 62 && kind > 40)
655                      kind = 40;
656                   break;
657                case 48:
658                   if (curChar == 61 && kind > 41)
659                      kind = 41;
660                   break;
661                case 49:
662                   if (curChar == 62)
663                      jjstateSet[jjnewStateCnt++] = 48;
664                   break;
665                case 50:
666                   if (curChar == 61 && kind > 42)
667                      kind = 42;
668                   break;
669                case 51:
670                   if (curChar == 61)
671                      jjstateSet[jjnewStateCnt++] = 50;
672                   break;
673                case 54:
674                   if (curChar == 61 && kind > 43)
675                      kind = 43;
676                   break;
677                case 55:
678                   if (curChar == 33)
679                      jjstateSet[jjnewStateCnt++] = 54;
680                   break;
681                case 56:
682                   if (curChar == 33 && kind > 44)
683                      kind = 44;
684                   break;
685                case 57:
686                   if (curChar == 46)
687                      jjCheckNAdd(58);
688                   break;
689                case 58:
690                   if ((0x3ff000000000000L & l) == 0L)
691                      break;
692                   if (kind > 53)
693                      kind = 53;
694                   jjCheckNAddTwoStates(58, 59);
695                   break;
696                case 60:
697                   if ((0x280000000000L & l) != 0L)
698                      jjCheckNAdd(61);
699                   break;
700                case 61:
701                   if ((0x3ff000000000000L & l) == 0L)
702                      break;
703                   if (kind > 53)
704                      kind = 53;
705                   jjCheckNAdd(61);
706                   break;
707                case 63:
708                   if ((0x3ff000000000000L & l) == 0L)
709                      break;
710                   if (kind > 57)
711                      kind = 57;
712                   jjstateSet[jjnewStateCnt++] = 63;
713                   break;
714                case 66:
715                   if ((0x3ff000000000000L & l) != 0L)
716                      jjAddStates(27, 28);
717                   break;
718                case 70:
719                   if (curChar == 36 && kind > 13)
720                      kind = 13;
721                   break;
722                case 72:
723                   if (curChar == 36)
724                      jjCheckNAddTwoStates(73, 74);
725                   break;
726                case 74:
727                   if (curChar == 33 && kind > 14)
728                      kind = 14;
729                   break;
730                case 75:
731                   if (curChar != 36)
732                      break;
733                   if (kind > 13)
734                      kind = 13;
735                   jjCheckNAddTwoStates(73, 74);
736                   break;
737                case 86:
738                   if (curChar == 45)
739                      jjCheckNAddStates(6, 9);
740                   break;
741                case 87:
742                   if ((0x3ff000000000000L & l) == 0L)
743                      break;
744                   if (kind > 52)
745                      kind = 52;
746                   jjCheckNAddTwoStates(87, 89);
747                   break;
748                case 88:
749                   if (curChar == 46 && kind > 52)
750                      kind = 52;
751                   break;
752                case 89:
753                   if (curChar == 46)
754                      jjstateSet[jjnewStateCnt++] = 88;
755                   break;
756                case 90:
757                   if ((0x3ff000000000000L & l) != 0L)
758                      jjCheckNAddTwoStates(90, 91);
759                   break;
760                case 91:
761                   if (curChar != 46)
762                      break;
763                   if (kind > 53)
764                      kind = 53;
765                   jjCheckNAddTwoStates(92, 93);
766                   break;
767                case 92:
768                   if ((0x3ff000000000000L & l) == 0L)
769                      break;
770                   if (kind > 53)
771                      kind = 53;
772                   jjCheckNAddTwoStates(92, 93);
773                   break;
774                case 94:
775                   if ((0x280000000000L & l) != 0L)
776                      jjCheckNAdd(95);
777                   break;
778                case 95:
779                   if ((0x3ff000000000000L & l) == 0L)
780                      break;
781                   if (kind > 53)
782                      kind = 53;
783                   jjCheckNAdd(95);
784                   break;
785                case 96:
786                   if ((0x3ff000000000000L & l) != 0L)
787                      jjCheckNAddTwoStates(96, 97);
788                   break;
789                case 98:
790                   if ((0x280000000000L & l) != 0L)
791                      jjCheckNAdd(99);
792                   break;
793                case 99:
794                   if ((0x3ff000000000000L & l) == 0L)
795                      break;
796                   if (kind > 53)
797                      kind = 53;
798                   jjCheckNAdd(99);
799                   break;
800                case 100:
801                   if ((0x3ff000000000000L & l) == 0L)
802                      break;
803                   if (kind > 52)
804                      kind = 52;
805                   jjCheckNAddStates(0, 5);
806                   break;
807                default : break;
808             }
809          } while(i != startsAt);
810       }
811       else if (curChar < 128)
812       {
813          long l = 1L << (curChar & 077);
814          MatchLoop: do
815          {
816             switch(jjstateSet[--i])
817             {
818                case 0:
819                   if ((0x7fffffe87fffffeL & l) != 0L)
820                   {
821                      if (kind > 57)
822                         kind = 57;
823                      jjCheckNAdd(63);
824                   }
825                   else if (curChar == 92)
826                      jjCheckNAddStates(29, 32);
827                   else if (curChar == 123)
828                      jjstateSet[jjnewStateCnt++] = 65;
829                   else if (curChar == 124)
830                      jjstateSet[jjnewStateCnt++] = 40;
831                   if (curChar == 110)
832                      jjAddStates(33, 34);
833                   else if (curChar == 103)
834                      jjAddStates(35, 36);
835                   else if (curChar == 108)
836                      jjAddStates(37, 38);
837                   else if (curChar == 101)
838                      jjstateSet[jjnewStateCnt++] = 52;
839                   else if (curChar == 111)
840                      jjstateSet[jjnewStateCnt++] = 42;
841                   else if (curChar == 97)
842                      jjstateSet[jjnewStateCnt++] = 38;
843                   break;
844                case 6:
845                   if (kind > 15)
846                      kind = 15;
847                   break;
848                case 11:
849                   if ((0xffffffffefffffffL & l) != 0L)
850                      jjCheckNAddStates(13, 15);
851                   break;
852                case 13:
853                   if (curChar == 92)
854                      jjAddStates(39, 44);
855                   break;
856                case 14:
857                   if ((0x14404410000000L & l) != 0L)
858                      jjCheckNAddStates(13, 15);
859                   break;
860                case 19:
861                   if (curChar == 117)
862                      jjstateSet[jjnewStateCnt++] = 20;
863                   break;
864                case 20:
865                   if ((0x7e0000007eL & l) != 0L)
866                      jjstateSet[jjnewStateCnt++] = 21;
867                   break;
868                case 21:
869                   if ((0x7e0000007eL & l) != 0L)
870                      jjstateSet[jjnewStateCnt++] = 22;
871                   break;
872                case 22:
873                   if ((0x7e0000007eL & l) != 0L)
874                      jjstateSet[jjnewStateCnt++] = 23;
875                   break;
876                case 23:
877                   if ((0x7e0000007eL & l) != 0L)
878                      jjCheckNAddStates(13, 15);
879                   break;
880                case 27:
881                   jjAddStates(10, 12);
882                   break;
883                case 28:
884                   if (curChar == 92)
885                      jjAddStates(25, 26);
886                   break;
887                case 37:
888                   if (curChar == 100 && kind > 36)
889                      kind = 36;
890                   break;
891                case 38:
892                   if (curChar == 110)
893                      jjstateSet[jjnewStateCnt++] = 37;
894                   break;
895                case 39:
896                   if (curChar == 97)
897                      jjstateSet[jjnewStateCnt++] = 38;
898                   break;
899                case 40:
900                   if (curChar == 124 && kind > 37)
901                      kind = 37;
902                   break;
903                case 41:
904                   if (curChar == 124)
905                      jjstateSet[jjnewStateCnt++] = 40;
906                   break;
907                case 42:
908                   if (curChar == 114 && kind > 37)
909                      kind = 37;
910                   break;
911                case 43:
912                   if (curChar == 111)
913                      jjstateSet[jjnewStateCnt++] = 42;
914                   break;
915                case 52:
916                   if (curChar == 113 && kind > 42)
917                      kind = 42;
918                   break;
919                case 53:
920                   if (curChar == 101)
921                      jjstateSet[jjnewStateCnt++] = 52;
922                   break;
923                case 59:
924                   if ((0x2000000020L & l) != 0L)
925                      jjAddStates(45, 46);
926                   break;
927                case 62:
928                case 63:
929                   if ((0x7fffffe87fffffeL & l) == 0L)
930                      break;
931                   if (kind > 57)
932                      kind = 57;
933                   jjCheckNAdd(63);
934                   break;
935                case 64:
936                   if (curChar == 123)
937                      jjstateSet[jjnewStateCnt++] = 65;
938                   break;
939                case 65:
940                case 66:
941                   if ((0x7fffffe87fffffeL & l) != 0L)
942                      jjCheckNAddTwoStates(66, 67);
943                   break;
944                case 67:
945                   if (curChar == 125 && kind > 58)
946                      kind = 58;
947                   break;
948                case 68:
949                   if (curChar == 92)
950                      jjCheckNAddStates(29, 32);
951                   break;
952                case 69:
953                   if (curChar == 92)
954                      jjCheckNAddTwoStates(69, 70);
955                   break;
956                case 71:
957                   if (curChar == 92)
958                      jjCheckNAddTwoStates(71, 72);
959                   break;
960                case 73:
961                   if (curChar == 92)
962                      jjAddStates(47, 48);
963                   break;
964                case 76:
965                   if (curChar == 108)
966                      jjAddStates(37, 38);
967                   break;
968                case 77:
969                   if (curChar == 116 && kind > 38)
970                      kind = 38;
971                   break;
972                case 78:
973                   if (curChar == 101 && kind > 39)
974                      kind = 39;
975                   break;
976                case 79:
977                   if (curChar == 103)
978                      jjAddStates(35, 36);
979                   break;
980                case 80:
981                   if (curChar == 116 && kind > 40)
982                      kind = 40;
983                   break;
984                case 81:
985                   if (curChar == 101 && kind > 41)
986                      kind = 41;
987                   break;
988                case 82:
989                   if (curChar == 110)
990                      jjAddStates(33, 34);
991                   break;
992                case 83:
993                   if (curChar == 101 && kind > 43)
994                      kind = 43;
995                   break;
996                case 84:
997                   if (curChar == 116 && kind > 44)
998                      kind = 44;
999                   break;
1000                case 85:
1001                   if (curChar == 111)
1002                      jjstateSet[jjnewStateCnt++] = 84;
1003                   break;
1004                case 93:
1005                   if ((0x2000000020L & l) != 0L)
1006                      jjAddStates(49, 50);
1007                   break;
1008                case 97:
1009                   if ((0x2000000020L & l) != 0L)
1010                      jjAddStates(51, 52);
1011                   break;
1012                default : break;
1013             }
1014          } while(i != startsAt);
1015       }
1016       else
1017       {
1018          int hiByte = (int)(curChar >> 8);
1019          int i1 = hiByte >> 6;
1020          long l1 = 1L << (hiByte & 077);
1021          int i2 = (curChar & 0xff) >> 6;
1022          long l2 = 1L << (curChar & 077);
1023          MatchLoop: do
1024          {
1025             switch(jjstateSet[--i])
1026             {
1027                case 6:
1028                   if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 15)
1029                      kind = 15;
1030                   break;
1031                case 11:
1032                   if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1033                      jjAddStates(13, 15);
1034                   break;
1035                case 27:
1036                   if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1037                      jjAddStates(10, 12);
1038                   break;
1039                default : break;
1040             }
1041          } while(i != startsAt);
1042       }
1043       if (kind != 0x7fffffff)
1044       {
1045          jjmatchedKind = kind;
1046          jjmatchedPos = curPos;
1047          kind = 0x7fffffff;
1048       }
1049       ++curPos;
1050       if ((i = jjnewStateCnt) == (startsAt = 101 - (jjnewStateCnt = startsAt)))
1051          return curPos;
1052       try { curChar = input_stream.readChar(); }
1053       catch(java.io.IOException e) { return curPos; }
1054    }
1055 }
1056 private final int jjStopStringLiteralDfa_6(int pos, long active0)
1057 {
1058    switch (pos)
1059    {
1060       case 0:
1061          if ((active0 & 0x70000L) != 0L)
1062             return 2;
1063          return -1;
1064       default :
1065          return -1;
1066    }
1067 }
1068 private final int jjStartNfa_6(int pos, long active0)
1069 {
1070    return jjMoveNfa_6(jjStopStringLiteralDfa_6(pos, active0), pos + 1);
1071 }
1072 private final int jjStartNfaWithStates_6(int pos, int kind, int state)
1073 {
1074    jjmatchedKind = kind;
1075    jjmatchedPos = pos;
1076    try { curChar = input_stream.readChar(); }
1077    catch(java.io.IOException e) { return pos + 1; }
1078    return jjMoveNfa_6(state, pos + 1);
1079 }
1080 private final int jjMoveStringLiteralDfa0_6()
1081 {
1082    switch(curChar)
1083    {
1084       case 35:
1085          jjmatchedKind = 17;
1086          return jjMoveStringLiteralDfa1_6(0x50000L);
1087       case 42:
1088          return jjMoveStringLiteralDfa1_6(0x1000000L);
1089       default :
1090          return jjMoveNfa_6(3, 0);
1091    }
1092 }
1093 private final int jjMoveStringLiteralDfa1_6(long active0)
1094 {
1095    try { curChar = input_stream.readChar(); }
1096    catch(java.io.IOException e) {
1097       jjStopStringLiteralDfa_6(0, active0);
1098       return 1;
1099    }
1100    switch(curChar)
1101    {
1102       case 35:
1103          if ((active0 & 0x40000L) != 0L)
1104             return jjStopAtPos(1, 18);
1105          else if ((active0 & 0x1000000L) != 0L)
1106             return jjStopAtPos(1, 24);
1107          break;
1108       case 42:
1109          if ((active0 & 0x10000L) != 0L)
1110             return jjStartNfaWithStates_6(1, 16, 0);
1111          break;
1112       default :
1113          break;
1114    }
1115    return jjStartNfa_6(0, active0);
1116 }
1117 private final int jjMoveNfa_6(int startState, int curPos)
1118 {
1119    int[] nextStates;
1120    int startsAt = 0;
1121    jjnewStateCnt = 12;
1122    int i = 1;
1123    jjstateSet[0] = startState;
1124    int j, kind = 0x7fffffff;
1125    for (;;)
1126    {
1127       if (++jjround == 0x7fffffff)
1128          ReInitRounds();
1129       if (curChar < 64)
1130       {
1131          long l = 1L << curChar;
1132          MatchLoop: do
1133          {
1134             switch(jjstateSet[--i])
1135             {
1136                case 3:
1137                   if (curChar == 36)
1138                   {
1139                      if (kind > 13)
1140                         kind = 13;
1141                      jjCheckNAddTwoStates(9, 10);
1142                   }
1143                   else if (curChar == 35)
1144                      jjstateSet[jjnewStateCnt++] = 2;
1145                   break;
1146                case 0:
1147                   if (curChar == 42)
1148                      jjstateSet[jjnewStateCnt++] = 1;
1149                   break;
1150                case 1:
1151                   if ((0xfffffff7ffffffffL & l) != 0L && kind > 15)
1152                      kind = 15;
1153                   break;
1154                case 2:
1155                   if (curChar == 42)
1156                      jjstateSet[jjnewStateCnt++] = 0;
1157                   break;
1158                case 6:
1159                   if (curChar == 36 && kind > 13)
1160                      kind = 13;
1161                   break;
1162                case 8:
1163                   if (curChar == 36)
1164                      jjCheckNAddTwoStates(9, 10);
1165                   break;
1166                case 10:
1167                   if (curChar == 33 && kind > 14)
1168                      kind = 14;
1169                   break;
1170                case 11:
1171                   if (curChar != 36)
1172                      break;
1173                   if (kind > 13)
1174                      kind = 13;
1175                   jjCheckNAddTwoStates(9, 10);
1176                   break;
1177                default : break;
1178             }
1179          } while(i != startsAt);
1180       }
1181       else if (curChar < 128)
1182       {
1183          long l = 1L << (curChar & 077);
1184          MatchLoop: do
1185          {
1186             switch(jjstateSet[--i])
1187             {
1188                case 3:
1189                   if (curChar == 92)
1190                      jjCheckNAddStates(53, 56);
1191                   break;
1192                case 1:
1193                   if (kind > 15)
1194                      kind = 15;
1195                   break;
1196                case 5:
1197                   if (curChar == 92)
1198                      jjCheckNAddTwoStates(5, 6);
1199                   break;
1200                case 7:
1201                   if (curChar == 92)
1202                      jjCheckNAddTwoStates(7, 8);
1203                   break;
1204                case 9:
1205                   if (curChar == 92)
1206                      jjAddStates(57, 58);
1207                   break;
1208                default : break;
1209             }
1210          } while(i != startsAt);
1211       }
1212       else
1213       {
1214          int hiByte = (int)(curChar >> 8);
1215          int i1 = hiByte >> 6;
1216          long l1 = 1L << (hiByte & 077);
1217          int i2 = (curChar & 0xff) >> 6;
1218          long l2 = 1L << (curChar & 077);
1219          MatchLoop: do
1220          {
1221             switch(jjstateSet[--i])
1222             {
1223                case 1:
1224                   if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 15)
1225                      kind = 15;
1226                   break;
1227                default : break;
1228             }
1229          } while(i != startsAt);
1230       }
1231       if (kind != 0x7fffffff)
1232       {
1233          jjmatchedKind = kind;
1234          jjmatchedPos = curPos;
1235          kind = 0x7fffffff;
1236       }
1237       ++curPos;
1238       if ((i = jjnewStateCnt) == (startsAt = 12 - (jjnewStateCnt = startsAt)))
1239          return curPos;
1240       try { curChar = input_stream.readChar(); }
1241       catch(java.io.IOException e) { return curPos; }
1242    }
1243 }
1244 private final int jjStopStringLiteralDfa_4(int pos, long active0)
1245 {
1246    switch (pos)
1247    {
1248       case 0:
1249          if ((active0 & 0x70000L) != 0L)
1250             return 2;
1251          return -1;
1252       default :
1253          return -1;
1254    }
1255 }
1256 private final int jjStartNfa_4(int pos, long active0)
1257 {
1258    return jjMoveNfa_4(jjStopStringLiteralDfa_4(pos, active0), pos + 1);
1259 }
1260 private final int jjStartNfaWithStates_4(int pos, int kind, int state)
1261 {
1262    jjmatchedKind = kind;
1263    jjmatchedPos = pos;
1264    try { curChar = input_stream.readChar(); }
1265    catch(java.io.IOException e) { return pos + 1; }
1266    return jjMoveNfa_4(state, pos + 1);
1267 }
1268 private final int jjMoveStringLiteralDfa0_4()
1269 {
1270    switch(curChar)
1271    {
1272       case 35:
1273          jjmatchedKind = 17;
1274          return jjMoveStringLiteralDfa1_4(0x50000L);
1275       default :
1276          return jjMoveNfa_4(3, 0);
1277    }
1278 }
1279 private final int jjMoveStringLiteralDfa1_4(long active0)
1280 {
1281    try { curChar = input_stream.readChar(); }
1282    catch(java.io.IOException e) {
1283       jjStopStringLiteralDfa_4(0, active0);
1284       return 1;
1285    }
1286    switch(curChar)
1287    {
1288       case 35:
1289          if ((active0 & 0x40000L) != 0L)
1290             return jjStopAtPos(1, 18);
1291          break;
1292       case 42:
1293          if ((active0 & 0x10000L) != 0L)
1294             return jjStartNfaWithStates_4(1, 16, 0);
1295          break;
1296       default :
1297          break;
1298    }
1299    return jjStartNfa_4(0, active0);
1300 }
1301 private final int jjMoveNfa_4(int startState, int curPos)
1302 {
1303    int[] nextStates;
1304    int startsAt = 0;
1305    jjnewStateCnt = 92;
1306    int i = 1;
1307    jjstateSet[0] = startState;
1308    int j, kind = 0x7fffffff;
1309    for (;;)
1310    {
1311       if (++jjround == 0x7fffffff)
1312          ReInitRounds();
1313       if (curChar < 64)
1314       {
1315          long l = 1L << curChar;
1316          MatchLoop: do
1317          {
1318             switch(jjstateSet[--i])
1319             {
1320                case 3:
1321                   if ((0x3ff000000000000L & l) != 0L)
1322                   {
1323                      if (kind > 52)
1324                         kind = 52;
1325                      jjCheckNAddStates(59, 64);
1326                   }
1327                   else if (curChar == 45)
1328                      jjCheckNAddStates(65, 68);
1329                   else if (curChar == 36)
1330                   {
1331                      if (kind > 13)
1332                         kind = 13;
1333                      jjCheckNAddTwoStates(26, 27);
1334                   }
1335                   else if (curChar == 46)
1336                      jjCheckNAdd(11);
1337                   else if (curChar == 35)
1338                      jjstateSet[jjnewStateCnt++] = 2;
1339                   break;
1340                case 0:
1341                   if (curChar == 42)
1342                      jjstateSet[jjnewStateCnt++] = 1;
1343                   break;
1344                case 1:
1345                   if ((0xfffffff7ffffffffL & l) != 0L && kind > 15)
1346                      kind = 15;
1347                   break;
1348                case 2:
1349                   if (curChar == 42)
1350                      jjstateSet[jjnewStateCnt++] = 0;
1351                   break;
1352                case 10:
1353                   if (curChar == 46)
1354                      jjCheckNAdd(11);
1355                   break;
1356                case 11:
1357                   if ((0x3ff000000000000L & l) == 0L)
1358                      break;
1359                   if (kind > 53)
1360                      kind = 53;
1361                   jjCheckNAddTwoStates(11, 12);
1362                   break;
1363                case 13:
1364                   if ((0x280000000000L & l) != 0L)
1365                      jjCheckNAdd(14);
1366                   break;
1367                case 14:
1368                   if ((0x3ff000000000000L & l) == 0L)
1369                      break;
1370                   if (kind > 53)
1371                      kind = 53;
1372                   jjCheckNAdd(14);
1373                   break;
1374                case 16:
1375                   if ((0x3ff000000000000L & l) == 0L)
1376                      break;
1377                   if (kind > 57)
1378                      kind = 57;
1379                   jjstateSet[jjnewStateCnt++] = 16;
1380                   break;
1381                case 19:
1382                   if ((0x3ff000000000000L & l) != 0L)
1383                      jjAddStates(69, 70);
1384                   break;
1385                case 23:
1386                   if (curChar == 36 && kind > 13)
1387                      kind = 13;
1388                   break;
1389                case 25:
1390                   if (curChar == 36)
1391                      jjCheckNAddTwoStates(26, 27);
1392                   break;
1393                case 27:
1394                   if (curChar == 33 && kind > 14)
1395                      kind = 14;
1396                   break;
1397                case 28:
1398                   if (curChar != 36)
1399                      break;
1400                   if (kind > 13)
1401                      kind = 13;
1402                   jjCheckNAddTwoStates(26, 27);
1403                   break;
1404                case 31:
1405                   if ((0x100000200L & l) != 0L)
1406                      jjCheckNAddStates(71, 73);
1407                   break;
1408                case 32:
1409                   if ((0x2400L & l) != 0L && kind > 46)
1410                      kind = 46;
1411                   break;
1412                case 33:
1413                   if (curChar == 10 && kind > 46)
1414                      kind = 46;
1415                   break;
1416                case 34:
1417                case 51:
1418                   if (curChar == 13)
1419                      jjCheckNAdd(33);
1420                   break;
1421                case 42:
1422                   if ((0x100000200L & l) != 0L)
1423                      jjCheckNAddStates(74, 76);
1424                   break;
1425                case 43:
1426                   if ((0x2400L & l) != 0L && kind > 49)
1427                      kind = 49;
1428                   break;
1429                case 44:
1430                   if (curChar == 10 && kind > 49)
1431                      kind = 49;
1432                   break;
1433                case 45:
1434                case 67:
1435                   if (curChar == 13)
1436                      jjCheckNAdd(44);
1437                   break;
1438                case 50:
1439                   if ((0x100000200L & l) != 0L)
1440                      jjCheckNAddStates(77, 79);
1441                   break;
1442                case 66:
1443                   if ((0x100000200L & l) != 0L)
1444                      jjCheckNAddStates(80, 82);
1445                   break;
1446                case 77:
1447                   if (curChar == 45)
1448                      jjCheckNAddStates(65, 68);
1449                   break;
1450                case 78:
1451                   if ((0x3ff000000000000L & l) == 0L)
1452                      break;
1453                   if (kind > 52)
1454                      kind = 52;
1455                   jjCheckNAddTwoStates(78, 80);
1456                   break;
1457                case 79:
1458                   if (curChar == 46 && kind > 52)
1459                      kind = 52;
1460                   break;
1461                case 80:
1462                   if (curChar == 46)
1463                      jjstateSet[jjnewStateCnt++] = 79;
1464                   break;
1465                case 81:
1466                   if ((0x3ff000000000000L & l) != 0L)
1467                      jjCheckNAddTwoStates(81, 82);
1468                   break;
1469                case 82:
1470                   if (curChar != 46)
1471                      break;
1472                   if (kind > 53)
1473                      kind = 53;
1474                   jjCheckNAddTwoStates(83, 84);
1475                   break;
1476                case 83:
1477                   if ((0x3ff000000000000L & l) == 0L)
1478                      break;
1479                   if (kind > 53)
1480                      kind = 53;
1481                   jjCheckNAddTwoStates(83, 84);
1482                   break;
1483                case 85:
1484                   if ((0x280000000000L & l) != 0L)
1485                      jjCheckNAdd(86);
1486                   break;
1487                case 86:
1488                   if ((0x3ff000000000000L & l) == 0L)
1489                      break;
1490                   if (kind > 53)
1491                      kind = 53;
1492                   jjCheckNAdd(86);
1493                   break;
1494                case 87:
1495                   if ((0x3ff000000000000L & l) != 0L)
1496                      jjCheckNAddTwoStates(87, 88);
1497                   break;
1498                case 89:
1499                   if ((0x280000000000L & l) != 0L)
1500                      jjCheckNAdd(90);
1501                   break;
1502                case 90:
1503                   if ((0x3ff000000000000L & l) == 0L)
1504                      break;
1505                   if (kind > 53)
1506                      kind = 53;
1507                   jjCheckNAdd(90);
1508                   break;
1509                case 91:
1510                   if ((0x3ff000000000000L & l) == 0L)
1511                      break;
1512                   if (kind > 52)
1513                      kind = 52;
1514                   jjCheckNAddStates(59, 64);
1515                   break;
1516                default : break;
1517             }
1518          } while(i != startsAt);
1519       }
1520       else if (curChar < 128)
1521       {
1522          long l = 1L << (curChar & 077);
1523          MatchLoop: do
1524          {
1525             switch(jjstateSet[--i])
1526             {
1527                case 3:
1528                   if ((0x7fffffe87fffffeL & l) != 0L)
1529                   {
1530                      if (kind > 57)
1531                         kind = 57;
1532                      jjCheckNAdd(16);
1533                   }
1534                   else if (curChar == 123)
1535                      jjAddStates(83, 87);
1536                   else if (curChar == 92)
1537                      jjCheckNAddStates(88, 91);
1538                   if (curChar == 101)
1539                      jjAddStates(92, 94);
1540                   else if (curChar == 123)
1541                      jjstateSet[jjnewStateCnt++] = 18;
1542                   else if (curChar == 115)
1543                      jjstateSet[jjnewStateCnt++] = 8;
1544                   else if (curChar == 105)
1545                      jjstateSet[jjnewStateCnt++] = 4;
1546                   break;
1547                case 1:
1548                   if (kind > 15)
1549                      kind = 15;
1550                   break;
1551                case 4:
1552                   if (curChar == 102 && kind > 47)
1553                      kind = 47;
1554                   break;
1555                case 5:
1556                   if (curChar == 105)
1557                      jjstateSet[jjnewStateCnt++] = 4;
1558                   break;
1559                case 6:
1560                   if (curChar == 112 && kind > 50)
1561                      kind = 50;
1562                   break;
1563                case 7:
1564                   if (curChar == 111)
1565                      jjstateSet[jjnewStateCnt++] = 6;
1566                   break;
1567                case 8:
1568                   if (curChar == 116)
1569                      jjstateSet[jjnewStateCnt++] = 7;
1570                   break;
1571                case 9:
1572                   if (curChar == 115)
1573                      jjstateSet[jjnewStateCnt++] = 8;
1574                   break;
1575                case 12:
1576                   if ((0x2000000020L & l) != 0L)
1577                      jjAddStates(95, 96);
1578                   break;
1579                case 15:
1580                case 16:
1581                   if ((0x7fffffe87fffffeL & l) == 0L)
1582                      break;
1583                   if (kind > 57)
1584                      kind = 57;
1585                   jjCheckNAdd(16);
1586                   break;
1587                case 17:
1588                   if (curChar == 123)
1589                      jjstateSet[jjnewStateCnt++] = 18;
1590                   break;
1591                case 18:
1592                case 19:
1593                   if ((0x7fffffe87fffffeL & l) != 0L)
1594                      jjCheckNAddTwoStates(19, 20);
1595                   break;
1596                case 20:
1597                   if (curChar == 125 && kind > 58)
1598                      kind = 58;
1599                   break;
1600                case 21:
1601                   if (curChar == 92)
1602                      jjCheckNAddStates(88, 91);
1603                   break;
1604                case 22:
1605                   if (curChar == 92)
1606                      jjCheckNAddTwoStates(22, 23);
1607                   break;
1608                case 24:
1609                   if (curChar == 92)
1610                      jjCheckNAddTwoStates(24, 25);
1611                   break;
1612                case 26:
1613                   if (curChar == 92)
1614                      jjAddStates(97, 98);
1615                   break;
1616                case 29:
1617                   if (curChar == 101)
1618                      jjAddStates(92, 94);
1619                   break;
1620                case 30:
1621                   if (curChar != 100)
1622                      break;
1623                   if (kind > 46)
1624                      kind = 46;
1625                   jjCheckNAddStates(71, 73);
1626                   break;
1627                case 35:
1628                   if (curChar == 110)
1629                      jjstateSet[jjnewStateCnt++] = 30;
1630                   break;
1631                case 36:
1632                   if (curChar == 102 && kind > 48)
1633                      kind = 48;
1634                   break;
1635                case 37:
1636                   if (curChar == 105)
1637                      jjstateSet[jjnewStateCnt++] = 36;
1638                   break;
1639                case 38:
1640                   if (curChar == 101)
1641                      jjstateSet[jjnewStateCnt++] = 37;
1642                   break;
1643                case 39:
1644                   if (curChar == 115)
1645                      jjstateSet[jjnewStateCnt++] = 38;
1646                   break;
1647                case 40:
1648                   if (curChar == 108)
1649                      jjstateSet[jjnewStateCnt++] = 39;
1650                   break;
1651                case 41:
1652                   if (curChar != 101)
1653                      break;
1654                   if (kind > 49)
1655                      kind = 49;
1656                   jjCheckNAddStates(74, 76);
1657                   break;
1658                case 46:
1659                   if (curChar == 115)
1660                      jjstateSet[jjnewStateCnt++] = 41;
1661                   break;
1662                case 47:
1663                   if (curChar == 108)
1664                      jjstateSet[jjnewStateCnt++] = 46;
1665                   break;
1666                case 48:
1667                   if (curChar == 123)
1668                      jjAddStates(83, 87);
1669                   break;
1670                case 49:
1671                   if (curChar != 125)
1672                      break;
1673                   if (kind > 46)
1674                      kind = 46;
1675                   jjCheckNAddStates(77, 79);
1676                   break;
1677                case 52:
1678                   if (curChar == 100)
1679                      jjstateSet[jjnewStateCnt++] = 49;
1680                   break;
1681                case 53:
1682                   if (curChar == 110)
1683                      jjstateSet[jjnewStateCnt++] = 52;
1684                   break;
1685                case 54:
1686                   if (curChar == 101)
1687                      jjstateSet[jjnewStateCnt++] = 53;
1688                   break;
1689                case 55:
1690                   if (curChar == 125 && kind > 47)
1691                      kind = 47;
1692                   break;
1693                case 56:
1694                   if (curChar == 102)
1695                      jjstateSet[jjnewStateCnt++] = 55;
1696                   break;
1697                case 57:
1698                   if (curChar == 105)
1699                      jjstateSet[jjnewStateCnt++] = 56;
1700                   break;
1701                case 58:
1702                   if (curChar == 125 && kind > 48)
1703                      kind = 48;
1704                   break;
1705                case 59:
1706                   if (curChar == 102)
1707                      jjstateSet[jjnewStateCnt++] = 58;
1708                   break;
1709                case 60:
1710                   if (curChar == 105)
1711                      jjstateSet[jjnewStateCnt++] = 59;
1712                   break;
1713                case 61:
1714                   if (curChar == 101)
1715                      jjstateSet[jjnewStateCnt++] = 60;
1716                   break;
1717                case 62:
1718                   if (curChar == 115)
1719                      jjstateSet[jjnewStateCnt++] = 61;
1720                   break;
1721                case 63:
1722                   if (curChar == 108)
1723                      jjstateSet[jjnewStateCnt++] = 62;
1724                   break;
1725                case 64:
1726                   if (curChar == 101)
1727                      jjstateSet[jjnewStateCnt++] = 63;
1728                   break;
1729                case 65:
1730                   if (curChar != 125)
1731                      break;
1732                   if (kind > 49)
1733                      kind = 49;
1734                   jjCheckNAddStates(80, 82);
1735                   break;
1736                case 68:
1737                   if (curChar == 101)
1738                      jjstateSet[jjnewStateCnt++] = 65;
1739                   break;
1740                case 69:
1741                   if (curChar == 115)
1742                      jjstateSet[jjnewStateCnt++] = 68;
1743                   break;
1744                case 70:
1745                   if (curChar == 108)
1746                      jjstateSet[jjnewStateCnt++] = 69;
1747                   break;
1748                case 71:
1749                   if (curChar == 101)
1750                      jjstateSet[jjnewStateCnt++] = 70;
1751                   break;
1752                case 72:
1753                   if (curChar == 125 && kind > 50)
1754                      kind = 50;
1755                   break;
1756                case 73:
1757                   if (curChar == 112)
1758                      jjstateSet[jjnewStateCnt++] = 72;
1759                   break;
1760                case 74:
1761                   if (curChar == 111)
1762                      jjstateSet[jjnewStateCnt++] = 73;
1763                   break;
1764                case 75:
1765                   if (curChar == 116)
1766                      jjstateSet[jjnewStateCnt++] = 74;
1767                   break;
1768                case 76:
1769                   if (curChar == 115)
1770                      jjstateSet[jjnewStateCnt++] = 75;
1771                   break;
1772                case 84:
1773                   if ((0x2000000020L & l) != 0L)
1774                      jjAddStates(99, 100);
1775                   break;
1776                case 88:
1777                   if ((0x2000000020L & l) != 0L)
1778                      jjAddStates(101, 102);
1779                   break;
1780                default : break;
1781             }
1782          } while(i != startsAt);
1783       }
1784       else
1785       {
1786          int hiByte = (int)(curChar >> 8);
1787          int i1 = hiByte >> 6;
1788          long l1 = 1L << (hiByte & 077);
1789          int i2 = (curChar & 0xff) >> 6;
1790          long l2 = 1L << (curChar & 077);
1791          MatchLoop: do
1792          {
1793             switch(jjstateSet[--i])
1794             {
1795                case 1:
1796                   if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 15)
1797                      kind = 15;
1798                   break;
1799                default : break;
1800             }
1801          } while(i != startsAt);
1802       }
1803       if (kind != 0x7fffffff)
1804       {
1805          jjmatchedKind = kind;
1806          jjmatchedPos = curPos;
1807          kind = 0x7fffffff;
1808       }
1809       ++curPos;
1810       if ((i = jjnewStateCnt) == (startsAt = 92 - (jjnewStateCnt = startsAt)))
1811          return curPos;
1812       try { curChar = input_stream.readChar(); }
1813       catch(java.io.IOException e) { return curPos; }
1814    }
1815 }
1816 private final int jjStopStringLiteralDfa_3(int pos, long active0)
1817 {
1818    switch (pos)
1819    {
1820       case 0:
1821          if ((active0 & 0x180000L) != 0L)
1822             return 14;
1823          if ((active0 & 0x70000L) != 0L)
1824             return 29;
1825          return -1;
1826       default :
1827          return -1;
1828    }
1829 }
1830 private final int jjStartNfa_3(int pos, long active0)
1831 {
1832    return jjMoveNfa_3(jjStopStringLiteralDfa_3(pos, active0), pos + 1);
1833 }
1834 private final int jjStartNfaWithStates_3(int pos, int kind, int state)
1835 {
1836    jjmatchedKind = kind;
1837    jjmatchedPos = pos;
1838    try { curChar = input_stream.readChar(); }
1839    catch(java.io.IOException e) { return pos + 1; }
1840    return jjMoveNfa_3(state, pos + 1);
1841 }
1842 private final int jjMoveStringLiteralDfa0_3()
1843 {
1844    switch(curChar)
1845    {
1846       case 35:
1847          jjmatchedKind = 17;
1848          return jjMoveStringLiteralDfa1_3(0x50000L);
1849       case 92:
1850          jjmatchedKind = 20;
1851          return jjMoveStringLiteralDfa1_3(0x80000L);
1852       default :
1853          return jjMoveNfa_3(18, 0);
1854    }
1855 }
1856 private final int jjMoveStringLiteralDfa1_3(long active0)
1857 {
1858    try { curChar = input_stream.readChar(); }
1859    catch(java.io.IOException e) {
1860       jjStopStringLiteralDfa_3(0, active0);
1861       return 1;
1862    }
1863    switch(curChar)
1864    {
1865       case 35:
1866          if ((active0 & 0x40000L) != 0L)
1867             return jjStopAtPos(1, 18);
1868          break;
1869       case 42:
1870          if ((active0 & 0x10000L) != 0L)
1871             return jjStartNfaWithStates_3(1, 16, 27);
1872          break;
1873       case 92:
1874          if ((active0 & 0x80000L) != 0L)
1875             return jjStartNfaWithStates_3(1, 19, 30);
1876          break;
1877       default :
1878          break;
1879    }
1880    return jjStartNfa_3(0, active0);
1881 }
1882 private final int jjMoveNfa_3(int startState, int curPos)
1883 {
1884    int[] nextStates;
1885    int startsAt = 0;
1886    jjnewStateCnt = 30;
1887    int i = 1;
1888    jjstateSet[0] = startState;
1889    int j, kind = 0x7fffffff;
1890    for (;;)
1891    {
1892       if (++jjround == 0x7fffffff)
1893          ReInitRounds();
1894       if (curChar < 64)
1895       {
1896          long l = 1L << curChar;
1897          MatchLoop: do
1898          {
1899             switch(jjstateSet[--i])
1900             {
1901                case 29:
1902                   if (curChar == 42)
1903                      jjstateSet[jjnewStateCnt++] = 27;
1904                   break;
1905                case 18:
1906                   if ((0xffffffe7ffffffffL & l) != 0L)
1907                   {
1908                      if (kind > 21)
1909                         kind = 21;
1910                      jjCheckNAdd(12);
1911                   }
1912                   else if (curChar == 35)
1913                      jjCheckNAddStates(103, 105);
1914                   else if (curChar == 36)
1915                   {
1916                      if (kind > 13)
1917                         kind = 13;
1918                      jjCheckNAddTwoStates(23, 24);
1919                   }
1920                   if ((0x100000200L & l) != 0L)
1921                      jjCheckNAddTwoStates(0, 1);
1922                   break;
1923                case 30:
1924                   if (curChar == 36)
1925                      jjCheckNAddTwoStates(23, 24);
1926                   if (curChar == 36)
1927                   {
1928                      if (kind > 13)
1929                         kind = 13;
1930                   }
1931                   break;
1932                case 14:
1933                   if (curChar == 36)
1934                      jjCheckNAddTwoStates(23, 24);
1935                   else if (curChar == 35)
1936                      jjstateSet[jjnewStateCnt++] = 16;
1937                   if (curChar == 36)
1938                   {
1939                      if (kind > 13)
1940                         kind = 13;
1941                   }
1942                   break;
1943                case 0:
1944                   if ((0x100000200L & l) != 0L)
1945                      jjCheckNAddTwoStates(0, 1);
1946                   break;
1947                case 1:
1948                   if (curChar == 35)
1949                      jjCheckNAddTwoStates(6, 11);
1950                   break;
1951                case 3:
1952                   if (curChar == 32)
1953                      jjAddStates(106, 107);
1954                   break;
1955                case 4:
1956                   if (curChar == 40 && kind > 12)
1957                      kind = 12;
1958                   break;
1959                case 12:
1960                   if ((0xffffffe7ffffffffL & l) == 0L)
1961                      break;
1962                   if (kind > 21)
1963                      kind = 21;
1964                   jjCheckNAdd(12);
1965                   break;
1966                case 15:
1967                   if (curChar == 35)
1968                      jjstateSet[jjnewStateCnt++] = 16;
1969                   break;
1970                case 17:
1971                   if ((0x3ff000000000000L & l) == 0L)
1972                      break;
1973                   if (kind > 11)
1974                      kind = 11;
1975                   jjstateSet[jjnewStateCnt++] = 17;
1976                   break;
1977                case 20:
1978                   if (curChar == 36 && kind > 13)
1979                      kind = 13;
1980                   break;
1981                case 22:
1982                   if (curChar == 36)
1983                      jjCheckNAddTwoStates(23, 24);
1984                   break;
1985                case 24:
1986                   if (curChar == 33 && kind > 14)
1987                      kind = 14;
1988                   break;
1989                case 25:
1990                   if (curChar != 36)
1991                      break;
1992                   if (kind > 13)
1993                      kind = 13;
1994                   jjCheckNAddTwoStates(23, 24);
1995                   break;
1996                case 26:
1997                   if (curChar == 35)
1998                      jjCheckNAddStates(103, 105);
1999                   break;
2000                case 27:
2001                   if (curChar == 42)
2002                      jjstateSet[jjnewStateCnt++] = 28;
2003                   break;
2004                case 28:
2005                   if ((0xfffffff7ffffffffL & l) != 0L && kind > 15)
2006                      kind = 15;
2007                   break;
2008                default : break;
2009             }
2010          } while(i != startsAt);
2011       }
2012       else if (curChar < 128)
2013       {
2014          long l = 1L << (curChar & 077);
2015          MatchLoop: do
2016          {
2017             switch(jjstateSet[--i])
2018             {
2019                case 29:
2020                   if (curChar == 123)
2021                      jjstateSet[jjnewStateCnt++] = 10;
2022                   else if (curChar == 115)
2023                      jjstateSet[jjnewStateCnt++] = 5;
2024                   break;
2025                case 18:
2026                   if ((0xffffffffefffffffL & l) != 0L)
2027                   {
2028                      if (kind > 21)
2029                         kind = 21;
2030                      jjCheckNAdd(12);
2031                   }
2032                   else if (curChar == 92)
2033                      jjCheckNAddStates(108, 111);
2034                   if (curChar == 92)
2035                      jjAddStates(112, 113);
2036                   break;
2037                case 30:
2038                   if (curChar == 92)
2039                      jjAddStates(112, 113);
2040                   if (curChar == 92)
2041                      jjCheckNAddTwoStates(21, 22);
2042                   if (curChar == 92)
2043                      jjCheckNAddTwoStates(19, 20);
2044                   break;
2045                case 14:
2046                   if (curChar == 92)
2047                      jjCheckNAddTwoStates(21, 22);
2048                   if (curChar == 92)
2049                      jjCheckNAddTwoStates(19, 20);
2050                   if (curChar == 92)
2051                      jjstateSet[jjnewStateCnt++] = 13;
2052                   break;
2053                case 2:
2054                   if (curChar == 116)
2055                      jjCheckNAddTwoStates(3, 4);
2056                   break;
2057                case 5:
2058                   if (curChar == 101)
2059                      jjstateSet[jjnewStateCnt++] = 2;
2060                   break;
2061                case 6:
2062                   if (curChar == 115)
2063                      jjstateSet[jjnewStateCnt++] = 5;
2064                   break;
2065                case 7:
2066                   if (curChar == 125)
2067                      jjCheckNAddTwoStates(3, 4);
2068                   break;
2069                case 8:
2070                   if (curChar == 116)
2071                      jjstateSet[jjnewStateCnt++] = 7;
2072                   break;
2073                case 9:
2074                   if (curChar == 101)
2075                      jjstateSet[jjnewStateCnt++] = 8;
2076                   break;
2077                case 10:
2078                   if (curChar == 115)
2079                      jjstateSet[jjnewStateCnt++] = 9;
2080                   break;
2081                case 11:
2082                   if (curChar == 123)
2083                      jjstateSet[jjnewStateCnt++] = 10;
2084                   break;
2085                case 12:
2086                   if ((0xffffffffefffffffL & l) == 0L)
2087                      break;
2088                   if (kind > 21)
2089                      kind = 21;
2090                   jjCheckNAdd(12);
2091                   break;
2092                case 13:
2093                   if (curChar == 92)
2094                      jjAddStates(112, 113);
2095                   break;
2096                case 16:
2097                case 17:
2098                   if ((0x7fffffe87fffffeL & l) == 0L)
2099                      break;
2100                   if (kind > 11)
2101                      kind = 11;
2102                   jjCheckNAdd(17);
2103                   break;
2104                case 19:
2105                   if (curChar == 92)
2106                      jjCheckNAddTwoStates(19, 20);
2107                   break;
2108                case 21:
2109                   if (curChar == 92)
2110                      jjCheckNAddTwoStates(21, 22);
2111                   break;
2112                case 23:
2113                   if (curChar == 92)
2114                      jjAddStates(114, 115);
2115                   break;
2116                case 28:
2117                   if (kind > 15)
2118                      kind = 15;
2119                   break;
2120                default : break;
2121             }
2122          } while(i != startsAt);
2123       }
2124       else
2125       {
2126          int hiByte = (int)(curChar >> 8);
2127          int i1 = hiByte >> 6;
2128          long l1 = 1L << (hiByte & 077);
2129          int i2 = (curChar & 0xff) >> 6;
2130          long l2 = 1L << (curChar & 077);
2131          MatchLoop: do
2132          {
2133             switch(jjstateSet[--i])
2134             {
2135                case 18:
2136                case 12:
2137                   if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
2138                      break;
2139                   if (kind > 21)
2140                      kind = 21;
2141                   jjCheckNAdd(12);
2142                   break;
2143                case 28:
2144                   if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 15)
2145                      kind = 15;
2146                   break;
2147                default : break;
2148             }
2149          } while(i != startsAt);
2150       }
2151       if (kind != 0x7fffffff)
2152       {
2153          jjmatchedKind = kind;
2154          jjmatchedPos = curPos;
2155          kind = 0x7fffffff;
2156       }
2157       ++curPos;
2158       if ((i = jjnewStateCnt) == (startsAt = 30 - (jjnewStateCnt = startsAt)))
2159          return curPos;
2160       try { curChar = input_stream.readChar(); }
2161       catch(java.io.IOException e) { return curPos; }
2162    }
2163 }
2164 private final int jjStopStringLiteralDfa_7(int pos, long active0)
2165 {
2166    switch (pos)
2167    {
2168       case 0:
2169          if ((active0 & 0x70000L) != 0L)
2170             return 2;
2171          return -1;
2172       default :
2173          return -1;
2174    }
2175 }
2176 private final int jjStartNfa_7(int pos, long active0)
2177 {
2178    return jjMoveNfa_7(jjStopStringLiteralDfa_7(pos, active0), pos + 1);
2179 }
2180 private final int jjStartNfaWithStates_7(int pos, int kind, int state)
2181 {
2182    jjmatchedKind = kind;
2183    jjmatchedPos = pos;
2184    try { curChar = input_stream.readChar(); }
2185    catch(java.io.IOException e) { return pos + 1; }
2186    return jjMoveNfa_7(state, pos + 1);
2187 }
2188 private final int jjMoveStringLiteralDfa0_7()
2189 {
2190    switch(curChar)
2191    {
2192       case 35:
2193          jjmatchedKind = 17;
2194          return jjMoveStringLiteralDfa1_7(0x50000L);
2195       case 42:
2196          return jjMoveStringLiteralDfa1_7(0x800000L);
2197       default :
2198          return jjMoveNfa_7(3, 0);
2199    }
2200 }
2201 private final int jjMoveStringLiteralDfa1_7(long active0)
2202 {
2203    try { curChar = input_stream.readChar(); }
2204    catch(java.io.IOException e) {
2205       jjStopStringLiteralDfa_7(0, active0);
2206       return 1;
2207    }
2208    switch(curChar)
2209    {
2210       case 35:
2211          if ((active0 & 0x40000L) != 0L)
2212             return jjStopAtPos(1, 18);
2213          else if ((active0 & 0x800000L) != 0L)
2214             return jjStopAtPos(1, 23);
2215          break;
2216       case 42:
2217          if ((active0 & 0x10000L) != 0L)
2218             return jjStartNfaWithStates_7(1, 16, 0);
2219          break;
2220       default :
2221          break;
2222    }
2223    return jjStartNfa_7(0, active0);
2224 }
2225 private final int jjMoveNfa_7(int startState, int curPos)
2226 {
2227    int[] nextStates;
2228    int startsAt = 0;
2229    jjnewStateCnt = 12;
2230    int i = 1;
2231    jjstateSet[0] = startState;
2232    int j, kind = 0x7fffffff;
2233    for (;;)
2234    {
2235       if (++jjround == 0x7fffffff)
2236          ReInitRounds();
2237       if (curChar < 64)
2238       {
2239          long l = 1L << curChar;
2240          MatchLoop: do
2241          {
2242             switch(jjstateSet[--i])
2243             {
2244                case 3:
2245                   if (curChar == 36)
2246                   {
2247                      if (kind > 13)
2248                         kind = 13;
2249                      jjCheckNAddTwoStates(9, 10);
2250                   }
2251                   else if (curChar == 35)
2252                      jjstateSet[jjnewStateCnt++] = 2;
2253                   break;
2254                case 0:
2255                   if (curChar == 42)
2256                      jjstateSet[jjnewStateCnt++] = 1;
2257                   break;
2258                case 1:
2259                   if ((0xfffffff7ffffffffL & l) != 0L && kind > 15)
2260                      kind = 15;
2261                   break;
2262                case 2:
2263                   if (curChar == 42)
2264                      jjstateSet[jjnewStateCnt++] = 0;
2265                   break;
2266                case 6:
2267                   if (curChar == 36 && kind > 13)
2268                      kind = 13;
2269                   break;
2270                case 8:
2271                   if (curChar == 36)
2272                      jjCheckNAddTwoStates(9, 10);
2273                   break;
2274                case 10:
2275                   if (curChar == 33 && kind > 14)
2276                      kind = 14;
2277                   break;
2278                case 11:
2279                   if (curChar != 36)
2280                      break;
2281                   if (kind > 13)
2282                      kind = 13;
2283                   jjCheckNAddTwoStates(9, 10);
2284                   break;
2285                default : break;
2286             }
2287          } while(i != startsAt);
2288       }
2289       else if (curChar < 128)
2290       {
2291          long l = 1L << (curChar & 077);
2292          MatchLoop: do
2293          {
2294             switch(jjstateSet[--i])
2295             {
2296                case 3:
2297                   if (curChar == 92)
2298                      jjCheckNAddStates(53, 56);
2299                   break;
2300                case 1:
2301                   if (kind > 15)
2302                      kind = 15;
2303                   break;
2304                case 5:
2305                   if (curChar == 92)
2306                      jjCheckNAddTwoStates(5, 6);
2307                   break;
2308                case 7:
2309                   if (curChar == 92)
2310                      jjCheckNAddTwoStates(7, 8);
2311                   break;
2312                case 9:
2313                   if (curChar == 92)
2314                      jjAddStates(57, 58);
2315                   break;
2316                default : break;
2317             }
2318          } while(i != startsAt);
2319       }
2320       else
2321       {
2322          int hiByte = (int)(curChar >> 8);
2323          int i1 = hiByte >> 6;
2324          long l1 = 1L << (hiByte & 077);
2325          int i2 = (curChar & 0xff) >> 6;
2326          long l2 = 1L << (curChar & 077);
2327          MatchLoop: do
2328          {
2329             switch(jjstateSet[--i])
2330             {
2331                case 1:
2332                   if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 15)
2333                      kind = 15;
2334                   break;
2335                default : break;
2336             }
2337          } while(i != startsAt);
2338       }
2339       if (kind != 0x7fffffff)
2340       {
2341          jjmatchedKind = kind;
2342          jjmatchedPos = curPos;
2343          kind = 0x7fffffff;
2344       }
2345       ++curPos;
2346       if ((i = jjnewStateCnt) == (startsAt = 12 - (jjnewStateCnt = startsAt)))
2347          return curPos;
2348       try { curChar = input_stream.readChar(); }
2349       catch(java.io.IOException e) { return curPos; }
2350    }
2351 }
2352 private final int jjStopStringLiteralDfa_8(int pos, long active0)
2353 {
2354    switch (pos)
2355    {
2356       case 0:
2357          if ((active0 & 0x70000L) != 0L)
2358             return 2;
2359          return -1;
2360       default :
2361          return -1;
2362    }
2363 }
2364 private final int jjStartNfa_8(int pos, long active0)
2365 {
2366    return jjMoveNfa_8(jjStopStringLiteralDfa_8(pos, active0), pos + 1);
2367 }
2368 private final int jjStartNfaWithStates_8(int pos, int kind, int state)
2369 {
2370    jjmatchedKind = kind;
2371    jjmatchedPos = pos;
2372    try { curChar = input_stream.readChar(); }
2373    catch(java.io.IOException e) { return pos + 1; }
2374    return jjMoveNfa_8(state, pos + 1);
2375 }
2376 private final int jjMoveStringLiteralDfa0_8()
2377 {
2378    switch(curChar)
2379    {
2380       case 35:
2381          jjmatchedKind = 17;
2382          return jjMoveStringLiteralDfa1_8(0x50000L);
2383       default :
2384          return jjMoveNfa_8(3, 0);
2385    }
2386 }
2387 private final int jjMoveStringLiteralDfa1_8(long active0)
2388 {
2389    try { curChar = input_stream.readChar(); }
2390    catch(java.io.IOException e) {
2391       jjStopStringLiteralDfa_8(0, active0);
2392       return 1;
2393    }
2394    switch(curChar)
2395    {
2396       case 35:
2397          if ((active0 & 0x40000L) != 0L)
2398             return jjStopAtPos(1, 18);
2399          break;
2400       case 42:
2401          if ((active0 & 0x10000L) != 0L)
2402             return jjStartNfaWithStates_8(1, 16, 0);
2403          break;
2404       default :
2405          break;
2406    }
2407    return jjStartNfa_8(0, active0);
2408 }
2409 private final int jjMoveNfa_8(int startState, int curPos)
2410 {
2411    int[] nextStates;
2412    int startsAt = 0;
2413    jjnewStateCnt = 15;
2414    int i = 1;
2415    jjstateSet[0] = startState;
2416    int j, kind = 0x7fffffff;
2417    for (;;)
2418    {
2419       if (++jjround == 0x7fffffff)
2420          ReInitRounds();
2421       if (curChar < 64)
2422       {
2423          long l = 1L << curChar;
2424          MatchLoop: do
2425          {
2426             switch(jjstateSet[--i])
2427             {
2428                case 3:
2429                   if ((0x2400L & l) != 0L)
2430                   {
2431                      if (kind > 22)
2432                         kind = 22;
2433                   }
2434                   else if (curChar == 36)
2435                   {
2436                      if (kind > 13)
2437                         kind = 13;
2438                      jjCheckNAddTwoStates(12, 13);
2439                   }
2440                   else if (curChar == 35)
2441                      jjstateSet[jjnewStateCnt++] = 2;
2442                   if (curChar == 13)
2443                      jjstateSet[jjnewStateCnt++] = 5;
2444                   break;
2445                case 0:
2446                   if (curChar == 42)
2447                      jjstateSet[jjnewStateCnt++] = 1;
2448                   break;
2449                case 1:
2450                   if ((0xfffffff7ffffffffL & l) != 0L && kind > 15)
2451                      kind = 15;
2452                   break;
2453                case 2:
2454                   if (curChar == 42)
2455                      jjstateSet[jjnewStateCnt++] = 0;
2456                   break;
2457                case 4:
2458                   if ((0x2400L & l) != 0L && kind > 22)
2459                      kind = 22;
2460                   break;
2461                case 5:
2462                   if (curChar == 10 && kind > 22)
2463                      kind = 22;
2464                   break;
2465                case 6:
2466                   if (curChar == 13)
2467                      jjstateSet[jjnewStateCnt++] = 5;
2468                   break;
2469                case 9:
2470                   if (curChar == 36 && kind > 13)
2471                      kind = 13;
2472                   break;
2473                case 11:
2474                   if (curChar == 36)
2475                      jjCheckNAddTwoStates(12, 13);
2476                   break;
2477                case 13:
2478                   if (curChar == 33 && kind > 14)
2479                      kind = 14;
2480                   break;
2481                case 14:
2482                   if (curChar != 36)
2483                      break;
2484                   if (kind > 13)
2485                      kind = 13;
2486                   jjCheckNAddTwoStates(12, 13);
2487                   break;
2488                default : break;
2489             }
2490          } while(i != startsAt);
2491       }
2492       else if (curChar < 128)
2493       {
2494          long l = 1L << (curChar & 077);
2495          MatchLoop: do
2496          {
2497             switch(jjstateSet[--i])
2498             {
2499                case 3:
2500                   if (curChar == 92)
2501                      jjCheckNAddStates(116, 119);
2502                   break;
2503                case 1:
2504                   if (kind > 15)
2505                      kind = 15;
2506                   break;
2507                case 8:
2508                   if (curChar == 92)
2509                      jjCheckNAddTwoStates(8, 9);
2510                   break;
2511                case 10:
2512                   if (curChar == 92)
2513                      jjCheckNAddTwoStates(10, 11);
2514                   break;
2515                case 12:
2516                   if (curChar == 92)
2517                      jjAddStates(120, 121);
2518                   break;
2519                default : break;
2520             }
2521          } while(i != startsAt);
2522       }
2523       else
2524       {
2525          int hiByte = (int)(curChar >> 8);
2526          int i1 = hiByte >> 6;
2527          long l1 = 1L << (hiByte & 077);
2528          int i2 = (curChar & 0xff) >> 6;
2529          long l2 = 1L << (curChar & 077);
2530          MatchLoop: do
2531          {
2532             switch(jjstateSet[--i])
2533             {
2534                case 1:
2535                   if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 15)
2536                      kind = 15;
2537                   break;
2538                default : break;
2539             }
2540          } while(i != startsAt);
2541       }
2542       if (kind != 0x7fffffff)
2543       {
2544          jjmatchedKind = kind;
2545          jjmatchedPos = curPos;
2546          kind = 0x7fffffff;
2547       }
2548       ++curPos;
2549       if ((i = jjnewStateCnt) == (startsAt = 15 - (jjnewStateCnt = startsAt)))
2550          return curPos;
2551       try { curChar = input_stream.readChar(); }
2552       catch(java.io.IOException e) { return curPos; }
2553    }
2554 }
2555 private final int jjStopStringLiteralDfa_5(int pos, long active0, long active1)
2556 {
2557    switch (pos)
2558    {
2559       case 0:
2560          if ((active0 & 0x70000L) != 0L)
2561             return 2;
2562          if ((active0 & 0x30000000L) != 0L)
2563          {
2564             jjmatchedKind = 62;
2565             return 5;
2566          }
2567          return -1;
2568       case 1:
2569          if ((active0 & 0x10000L) != 0L)
2570             return 0;
2571          if ((active0 & 0x30000000L) != 0L)
2572          {
2573             jjmatchedKind = 62;
2574             jjmatchedPos = 1;
2575             return 5;
2576          }
2577          return -1;
2578       case 2:
2579          if ((active0 & 0x30000000L) != 0L)
2580          {
2581             jjmatchedKind = 62;
2582             jjmatchedPos = 2;
2583             return 5;
2584          }
2585          return -1;
2586       case 3:
2587          if ((active0 & 0x20000000L) != 0L)
2588          {
2589             jjmatchedKind = 62;
2590             jjmatchedPos = 3;
2591             return 5;
2592          }
2593          if ((active0 & 0x10000000L) != 0L)
2594             return 5;
2595          return -1;
2596       default :
2597          return -1;
2598    }
2599 }
2600 private final int jjStartNfa_5(int pos, long active0, long active1)
2601 {
2602    return jjMoveNfa_5(jjStopStringLiteralDfa_5(pos, active0, active1), pos + 1);
2603 }
2604 private final int jjStartNfaWithStates_5(int pos, int kind, int state)
2605 {
2606    jjmatchedKind = kind;
2607    jjmatchedPos = pos;
2608    try { curChar = input_stream.readChar(); }
2609    catch(java.io.IOException e) { return pos + 1; }
2610    return jjMoveNfa_5(state, pos + 1);
2611 }
2612 private final int jjMoveStringLiteralDfa0_5()
2613 {
2614    switch(curChar)
2615    {
2616       case 35:
2617          jjmatchedKind = 17;
2618          return jjMoveStringLiteralDfa1_5(0x50000L);
2619       case 102:
2620          return jjMoveStringLiteralDfa1_5(0x20000000L);
2621       case 116:
2622          return jjMoveStringLiteralDfa1_5(0x10000000L);
2623       case 123:
2624          return jjStopAtPos(0, 64);
2625       case 125:
2626          return jjStopAtPos(0, 65);
2627       default :
2628          return jjMoveNfa_5(3, 0);
2629    }
2630 }
2631 private final int jjMoveStringLiteralDfa1_5(long active0)
2632 {
2633    try { curChar = input_stream.readChar(); }
2634    catch(java.io.IOException e) {
2635       jjStopStringLiteralDfa_5(0, active0, 0L);
2636       return 1;
2637    }
2638    switch(curChar)
2639    {
2640       case 35:
2641          if ((active0 & 0x40000L) != 0L)
2642             return jjStopAtPos(1, 18);
2643          break;
2644       case 42:
2645          if ((active0 & 0x10000L) != 0L)
2646             return jjStartNfaWithStates_5(1, 16, 0);
2647          break;
2648       case 97:
2649          return jjMoveStringLiteralDfa2_5(active0, 0x20000000L);
2650       case 114:
2651          return jjMoveStringLiteralDfa2_5(active0, 0x10000000L);
2652       default :
2653          break;
2654    }
2655    return jjStartNfa_5(0, active0, 0L);
2656 }
2657 private final int jjMoveStringLiteralDfa2_5(long old0, long active0)
2658 {
2659    if (((active0 &= old0)) == 0L)
2660       return jjStartNfa_5(0, old0, 0L);
2661    try { curChar = input_stream.readChar(); }
2662    catch(java.io.IOException e) {
2663       jjStopStringLiteralDfa_5(1, active0, 0L);
2664       return 2;
2665    }
2666    switch(curChar)
2667    {
2668       case 108:
2669          return jjMoveStringLiteralDfa3_5(active0, 0x20000000L);
2670       case 117:
2671          return jjMoveStringLiteralDfa3_5(active0, 0x10000000L);
2672       default :
2673          break;
2674    }
2675    return jjStartNfa_5(1, active0, 0L);
2676 }
2677 private final int jjMoveStringLiteralDfa3_5(long old0, long active0)
2678 {
2679    if (((active0 &= old0)) == 0L)
2680       return jjStartNfa_5(1, old0, 0L);
2681    try { curChar = input_stream.readChar(); }
2682    catch(java.io.IOException e) {
2683       jjStopStringLiteralDfa_5(2, active0, 0L);
2684       return 3;
2685    }
2686    switch(curChar)
2687    {
2688       case 101:
2689          if ((active0 & 0x10000000L) != 0L)
2690             return jjStartNfaWithStates_5(3, 28, 5);
2691          break;
2692       case 115:
2693          return jjMoveStringLiteralDfa4_5(active0, 0x20000000L);
2694       default :
2695          break;
2696    }
2697    return jjStartNfa_5(2, active0, 0L);
2698 }
2699 private final int jjMoveStringLiteralDfa4_5(long old0, long active0)
2700 {
2701    if (((active0 &= old0)) == 0L)
2702       return jjStartNfa_5(2, old0, 0L);
2703    try { curChar = input_stream.readChar(); }
2704    catch(java.io.IOException e) {
2705       jjStopStringLiteralDfa_5(3, active0, 0L);
2706       return 4;
2707    }
2708    switch(curChar)
2709    {
2710       case 101:
2711          if ((active0 & 0x20000000L) != 0L)
2712             return jjStartNfaWithStates_5(4, 29, 5);
2713          break;
2714       default :
2715          break;
2716    }
2717    return jjStartNfa_5(3, active0, 0L);
2718 }
2719 private final int jjMoveNfa_5(int startState, int curPos)
2720 {
2721    int[] nextStates;
2722    int startsAt = 0;
2723    jjnewStateCnt = 16;
2724    int i = 1;
2725    jjstateSet[0] = startState;
2726    int j, kind = 0x7fffffff;
2727    for (;;)
2728    {
2729       if (++jjround == 0x7fffffff)
2730          ReInitRounds();
2731       if (curChar < 64)
2732       {
2733          long l = 1L << curChar;
2734          MatchLoop: do
2735          {
2736             switch(jjstateSet[--i])
2737             {
2738                case 3:
2739                   if (curChar == 36)
2740                   {
2741                      if (kind > 13)
2742                         kind = 13;
2743                      jjCheckNAddTwoStates(13, 14);
2744                   }
2745                   else if (curChar == 46)
2746                      jjstateSet[jjnewStateCnt++] = 7;
2747                   else if (curChar == 35)
2748                      jjstateSet[jjnewStateCnt++] = 2;
2749                   break;
2750                case 0:
2751                   if (curChar == 42)
2752                      jjstateSet[jjnewStateCnt++] = 1;
2753                   break;
2754                case 1:
2755                   if ((0xfffffff7ffffffffL & l) != 0L && kind > 15)
2756                      kind = 15;
2757                   break;
2758                case 2:
2759                   if (curChar == 42)
2760                      jjstateSet[jjnewStateCnt++] = 0;
2761                   break;
2762                case 5:
2763                   if ((0x3ff000000000000L & l) == 0L)
2764                      break;
2765                   if (kind > 62)
2766                      kind = 62;
2767                   jjstateSet[jjnewStateCnt++] = 5;
2768                   break;
2769                case 6:
2770                   if (curChar == 46)
2771                      jjstateSet[jjnewStateCnt++] = 7;
2772                   break;
2773                case 10:
2774                   if (curChar == 36 && kind > 13)
2775                      kind = 13;
2776                   break;
2777                case 12:
2778                   if (curChar == 36)
2779                      jjCheckNAddTwoStates(13, 14);
2780                   break;
2781                case 14:
2782                   if (curChar == 33 && kind > 14)
2783                      kind = 14;
2784                   break;
2785                case 15:
2786                   if (curChar != 36)
2787                      break;
2788                   if (kind > 13)
2789                      kind = 13;
2790                   jjCheckNAddTwoStates(13, 14);
2791                   break;
2792                default : break;
2793             }
2794          } while(i != startsAt);
2795       }
2796       else if (curChar < 128)
2797       {
2798          long l = 1L << (curChar & 077);
2799          MatchLoop: do
2800          {
2801             switch(jjstateSet[--i])
2802             {
2803                case 3:
2804                   if ((0x7fffffe87fffffeL & l) != 0L)
2805                   {
2806                      if (kind > 62)
2807                         kind = 62;
2808                      jjCheckNAdd(5);
2809                   }
2810                   else if (curChar == 92)
2811                      jjCheckNAddStates(122, 125);
2812                   break;
2813                case 1:
2814                   if (kind > 15)
2815                      kind = 15;
2816                   break;
2817                case 4:
2818                case 5:
2819                   if ((0x7fffffe87fffffeL & l) == 0L)
2820                      break;
2821                   if (kind > 62)
2822                      kind = 62;
2823                   jjCheckNAdd(5);
2824                   break;
2825                case 7:
2826                   if ((0x7fffffe07fffffeL & l) != 0L && kind > 63)
2827                      kind = 63;
2828                   break;
2829                case 8:
2830                   if (curChar == 92)
2831                      jjCheckNAddStates(122, 125);
2832                   break;
2833                case 9:
2834                   if (curChar == 92)
2835                      jjCheckNAddTwoStates(9, 10);
2836                   break;
2837                case 11:
2838                   if (curChar == 92)
2839                      jjCheckNAddTwoStates(11, 12);
2840                   break;
2841                case 13:
2842                   if (curChar == 92)
2843                      jjAddStates(95, 96);
2844                   break;
2845                default : break;
2846             }
2847          } while(i != startsAt);
2848       }
2849       else
2850       {
2851          int hiByte = (int)(curChar >> 8);
2852          int i1 = hiByte >> 6;
2853          long l1 = 1L << (hiByte & 077);
2854          int i2 = (curChar & 0xff) >> 6;
2855          long l2 = 1L << (curChar & 077);
2856          MatchLoop: do
2857          {
2858             switch(jjstateSet[--i])
2859             {
2860                case 1:
2861                   if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 15)
2862                      kind = 15;
2863                   break;
2864                default : break;
2865             }
2866          } while(i != startsAt);
2867       }
2868       if (kind != 0x7fffffff)
2869       {
2870          jjmatchedKind = kind;
2871          jjmatchedPos = curPos;
2872          kind = 0x7fffffff;
2873       }
2874       ++curPos;
2875       if ((i = jjnewStateCnt) == (startsAt = 16 - (jjnewStateCnt = startsAt)))
2876          return curPos;
2877       try { curChar = input_stream.readChar(); }
2878       catch(java.io.IOException e) { return curPos; }
2879    }
2880 }
2881 private final int jjStopStringLiteralDfa_1(int pos, long active0)
2882 {
2883    switch (pos)
2884    {
2885       case 0:
2886          if ((active0 & 0x70000L) != 0L)
2887             return 2;
2888          if ((active0 & 0x30000000L) != 0L)
2889          {
2890             jjmatchedKind = 62;
2891             return 28;
2892          }
2893          if ((active0 & 0x10L) != 0L)
2894             return 58;
2895          return -1;
2896       case 1:
2897          if ((active0 & 0x10000L) != 0L)
2898             return 0;
2899          if ((active0 & 0x30000000L) != 0L)
2900          {
2901             jjmatchedKind = 62;
2902             jjmatchedPos = 1;
2903             return 28;
2904          }
2905          return -1;
2906       case 2:
2907          if ((active0 & 0x30000000L) != 0L)
2908          {
2909             jjmatchedKind = 62;
2910             jjmatchedPos = 2;
2911             return 28;
2912          }
2913          return -1;
2914       case 3:
2915          if ((active0 & 0x10000000L) != 0L)
2916             return 28;
2917          if ((active0 & 0x20000000L) != 0L)
2918          {
2919             jjmatchedKind = 62;
2920             jjmatchedPos = 3;
2921             return 28;
2922          }
2923          return -1;
2924       default :
2925          return -1;
2926    }
2927 }
2928 private final int jjStartNfa_1(int pos, long active0)
2929 {
2930    return jjMoveNfa_1(jjStopStringLiteralDfa_1(pos, active0), pos + 1);
2931 }
2932 private final int jjStartNfaWithStates_1(int pos, int kind, int state)
2933 {
2934    jjmatchedKind = kind;
2935    jjmatchedPos = pos;
2936    try { curChar = input_stream.readChar(); }
2937    catch(java.io.IOException e) { return pos + 1; }
2938    return jjMoveNfa_1(state, pos + 1);
2939 }
2940 private final int jjMoveStringLiteralDfa0_1()
2941 {
2942    switch(curChar)
2943    {
2944       case 35:
2945          jjmatchedKind = 17;
2946          return jjMoveStringLiteralDfa1_1(0x50000L);
2947       case 41:
2948          return jjStopAtPos(0, 10);
2949       case 44:
2950          return jjStopAtPos(0, 3);
2951       case 46:
2952          return jjMoveStringLiteralDfa1_1(0x10L);
2953       case 58:
2954          return jjStopAtPos(0, 5);
2955       case 91:
2956          return jjStopAtPos(0, 1);
2957       case 93:
2958          return jjStopAtPos(0, 2);
2959       case 102:
2960          return jjMoveStringLiteralDfa1_1(0x20000000L);
2961       case 116:
2962          return jjMoveStringLiteralDfa1_1(0x10000000L);
2963       case 123:
2964          return jjStopAtPos(0, 6);
2965       case 125:
2966          return jjStopAtPos(0, 7);
2967       default :
2968          return jjMoveNfa_1(3, 0);
2969    }
2970 }
2971 private final int jjMoveStringLiteralDfa1_1(long active0)
2972 {
2973    try { curChar = input_stream.readChar(); }
2974    catch(java.io.IOException e) {
2975       jjStopStringLiteralDfa_1(0, active0);
2976       return 1;
2977    }
2978    switch(curChar)
2979    {
2980       case 35:
2981          if ((active0 & 0x40000L) != 0L)
2982             return jjStopAtPos(1, 18);
2983          break;
2984       case 42:
2985          if ((active0 & 0x10000L) != 0L)
2986             return jjStartNfaWithStates_1(1, 16, 0);
2987          break;
2988       case 46:
2989          if ((active0 & 0x10L) != 0L)
2990             return jjStopAtPos(1, 4);
2991          break;
2992       case 97:
2993          return jjMoveStringLiteralDfa2_1(active0, 0x20000000L);
2994       case 114:
2995          return jjMoveStringLiteralDfa2_1(active0, 0x10000000L);
2996       default :
2997          break;
2998    }
2999    return jjStartNfa_1(0, active0);
3000 }
3001 private final int jjMoveStringLiteralDfa2_1(long old0, long active0)
3002 {
3003    if (((active0 &= old0)) == 0L)
3004       return jjStartNfa_1(0, old0); 
3005    try { curChar = input_stream.readChar(); }
3006    catch(java.io.IOException e) {
3007       jjStopStringLiteralDfa_1(1, active0);
3008       return 2;
3009    }
3010    switch(curChar)
3011    {
3012       case 108:
3013          return jjMoveStringLiteralDfa3_1(active0, 0x20000000L);
3014       case 117:
3015          return jjMoveStringLiteralDfa3_1(active0, 0x10000000L);
3016       default :
3017          break;
3018    }
3019    return jjStartNfa_1(1, active0);
3020 }
3021 private final int jjMoveStringLiteralDfa3_1(long old0, long active0)
3022 {
3023    if (((active0 &= old0)) == 0L)
3024       return jjStartNfa_1(1, old0); 
3025    try { curChar = input_stream.readChar(); }
3026    catch(java.io.IOException e) {
3027       jjStopStringLiteralDfa_1(2, active0);
3028       return 3;
3029    }
3030    switch(curChar)
3031    {
3032       case 101:
3033          if ((active0 & 0x10000000L) != 0L)
3034             return jjStartNfaWithStates_1(3, 28, 28);
3035          break;
3036       case 115:
3037          return jjMoveStringLiteralDfa4_1(active0, 0x20000000L);
3038       default :
3039          break;
3040    }
3041    return jjStartNfa_1(2, active0);
3042 }
3043 private final int jjMoveStringLiteralDfa4_1(long old0, long active0)
3044 {
3045    if (((active0 &= old0)) == 0L)
3046       return jjStartNfa_1(2, old0); 
3047    try { curChar = input_stream.readChar(); }
3048    catch(java.io.IOException e) {
3049       jjStopStringLiteralDfa_1(3, active0);
3050       return 4;
3051    }
3052    switch(curChar)
3053    {
3054       case 101:
3055          if ((active0 & 0x20000000L) != 0L)
3056             return jjStartNfaWithStates_1(4, 29, 28);
3057          break;
3058       default :
3059          break;
3060    }
3061    return jjStartNfa_1(3, active0);
3062 }
3063 private final int jjMoveNfa_1(int startState, int curPos)
3064 {
3065    int[] nextStates;
3066    int startsAt = 0;
3067    jjnewStateCnt = 59;
3068    int i = 1;
3069    jjstateSet[0] = startState;
3070    int j, kind = 0x7fffffff;
3071    for (;;)
3072    {
3073       if (++jjround == 0x7fffffff)
3074          ReInitRounds();
3075       if (curChar < 64)
3076       {
3077          long l = 1L << curChar;
3078          MatchLoop: do
3079          {
3080             switch(jjstateSet[--i])
3081             {
3082                case 3:
3083                   if ((0x3ff000000000000L & l) != 0L)
3084                   {
3085                      if (kind > 52)
3086                         kind = 52;
3087                      jjCheckNAddStates(126, 131);
3088                   }
3089                   else if ((0x100002600L & l) != 0L)
3090                   {
3091                      if (kind > 26)
3092                         kind = 26;
3093                      jjCheckNAdd(4);
3094                   }
3095                   else if (curChar == 46)
3096                      jjCheckNAddTwoStates(48, 58);
3097                   else if (curChar == 45)
3098                      jjCheckNAddStates(132, 135);
3099                   else if (curChar == 36)
3100                   {
3101                      if (kind > 13)
3102                         kind = 13;
3103                      jjCheckNAddTwoStates(34, 35);
3104                   }
3105                   else if (curChar == 39)
3106                      jjCheckNAddStates(136, 138);
3107                   else if (curChar == 34)
3108                      jjCheckNAddStates(139, 141);
3109                   else if (curChar == 35)
3110                      jjstateSet[jjnewStateCnt++] = 2;
3111                   break;
3112                case 58:
3113                case 48:
3114                   if ((0x3ff000000000000L & l) == 0L)
3115                      break;
3116                   if (kind > 53)
3117                      kind = 53;
3118                   jjCheckNAddTwoStates(48, 49);
3119                   break;
3120                case 0:
3121                   if (curChar == 42)
3122                      jjstateSet[jjnewStateCnt++] = 1;
3123                   break;
3124                case 1:
3125                   if ((0xfffffff7ffffffffL & l) != 0L && kind > 15)
3126                      kind = 15;
3127                   break;
3128                case 2:
3129                   if (curChar == 42)
3130                      jjstateSet[jjnewStateCnt++] = 0;
3131                   break;
3132                case 4:
3133                   if ((0x100002600L & l) == 0L)
3134                      break;
3135                   if (kind > 26)
3136                      kind = 26;
3137                   jjCheckNAdd(4);
3138                   break;
3139                case 5:
3140                   if (curChar == 34)
3141                      jjCheckNAddStates(139, 141);
3142                   break;
3143                case 6:
3144                   if ((0xfffffffbffffffffL & l) != 0L)
3145                      jjCheckNAddStates(139, 141);
3146                   break;
3147                case 7:
3148                   if (curChar == 34 && kind > 27)
3149                      kind = 27;
3150                   break;
3151                case 9:
3152                   if ((0x8400000000L & l) != 0L)
3153                      jjCheckNAddStates(139, 141);
3154                   break;
3155                case 10:
3156                   if ((0xff000000000000L & l) != 0L)
3157                      jjCheckNAddStates(142, 145);
3158                   break;
3159                case 11:
3160                   if ((0xff000000000000L & l) != 0L)
3161                      jjCheckNAddStates(139, 141);
3162                   break;
3163                case 12:
3164                   if ((0xf000000000000L & l) != 0L)
3165                      jjstateSet[jjnewStateCnt++] = 13;
3166                   break;
3167                case 13:
3168                   if ((0xff000000000000L & l) != 0L)
3169                      jjCheckNAdd(11);
3170                   break;
3171                case 15:
3172                   if ((0x3ff000000000000L & l) != 0L)
3173                      jjstateSet[jjnewStateCnt++] = 16;
3174                   break;
3175                case 16:
3176                   if ((0x3ff000000000000L & l) != 0L)
3177                      jjstateSet[jjnewStateCnt++] = 17;
3178                   break;
3179                case 17:
3180                   if ((0x3ff000000000000L & l) != 0L)
3181                      jjstateSet[jjnewStateCnt++] = 18;
3182                   break;
3183                case 18:
3184                   if ((0x3ff000000000000L & l) != 0L)
3185                      jjCheckNAddStates(139, 141);
3186                   break;
3187                case 19:
3188                   if (curChar == 32)
3189                      jjAddStates(69, 70);
3190                   break;
3191                case 20:
3192                   if (curChar == 10)
3193                      jjCheckNAddStates(139, 141);
3194                   break;
3195                case 21:
3196                   if (curChar == 39)
3197                      jjCheckNAddStates(136, 138);
3198                   break;
3199                case 22:
3200                   if ((0xffffff7fffffffffL & l) != 0L)
3201                      jjCheckNAddStates(136, 138);
3202                   break;
3203                case 24:
3204                   if (curChar == 32)
3205                      jjAddStates(23, 24);
3206                   break;
3207                case 25:
3208                   if (curChar == 10)
3209                      jjCheckNAddStates(136, 138);
3210                   break;
3211                case 26:
3212                   if (curChar == 39 && kind > 27)
3213                      kind = 27;
3214                   break;
3215                case 28:
3216                   if ((0x3ff000000000000L & l) == 0L)
3217                      break;
3218                   if (kind > 62)
3219                      kind = 62;
3220                   jjstateSet[jjnewStateCnt++] = 28;
3221                   break;
3222                case 31:
3223                   if (curChar == 36 && kind > 13)
3224                      kind = 13;
3225                   break;
3226                case 33:
3227                   if (curChar == 36)
3228                      jjCheckNAddTwoStates(34, 35);
3229                   break;
3230                case 35:
3231                   if (curChar == 33 && kind > 14)
3232                      kind = 14;
3233                   break;
3234                case 36:
3235                   if (curChar != 36)
3236                      break;
3237                   if (kind > 13)
3238                      kind = 13;
3239                   jjCheckNAddTwoStates(34, 35);
3240                   break;
3241                case 37:
3242                   if (curChar == 45)
3243                      jjCheckNAddStates(132, 135);
3244                   break;
3245                case 38:
3246                   if ((0x3ff000000000000L & l) == 0L)
3247                      break;
3248                   if (kind > 52)
3249                      kind = 52;
3250                   jjCheckNAddTwoStates(38, 40);
3251                   break;
3252                case 39:
3253                   if (curChar == 46 && kind > 52)
3254                      kind = 52;
3255                   break;
3256                case 40:
3257                   if (curChar == 46)
3258                      jjstateSet[jjnewStateCnt++] = 39;
3259                   break;
3260                case 41:
3261                   if ((0x3ff000000000000L & l) != 0L)
3262                      jjCheckNAddTwoStates(41, 42);
3263                   break;
3264                case 42:
3265                   if (curChar != 46)
3266                      break;
3267                   if (kind > 53)
3268                      kind = 53;
3269                   jjCheckNAddTwoStates(43, 44);
3270                   break;
3271                case 43:
3272                   if ((0x3ff000000000000L & l) == 0L)
3273                      break;
3274                   if (kind > 53)
3275                      kind = 53;
3276                   jjCheckNAddTwoStates(43, 44);
3277                   break;
3278                case 45:
3279                   if ((0x280000000000L & l) != 0L)
3280                      jjCheckNAdd(46);
3281                   break;
3282                case 46:
3283                   if ((0x3ff000000000000L & l) == 0L)
3284                      break;
3285                   if (kind > 53)
3286                      kind = 53;
3287                   jjCheckNAdd(46);
3288                   break;
3289                case 47:
3290                   if (curChar == 46)
3291                      jjCheckNAdd(48);
3292                   break;
3293                case 50:
3294                   if ((0x280000000000L & l) != 0L)
3295                      jjCheckNAdd(51);
3296                   break;
3297                case 51:
3298                   if ((0x3ff000000000000L & l) == 0L)
3299                      break;
3300                   if (kind > 53)
3301                      kind = 53;
3302                   jjCheckNAdd(51);
3303                   break;
3304                case 52:
3305                   if ((0x3ff000000000000L & l) != 0L)
3306                      jjCheckNAddTwoStates(52, 53);
3307                   break;
3308                case 54:
3309                   if ((0x280000000000L & l) != 0L)
3310                      jjCheckNAdd(55);
3311                   break;
3312                case 55:
3313                   if ((0x3ff000000000000L & l) == 0L)
3314                      break;
3315                   if (kind > 53)
3316                      kind = 53;
3317                   jjCheckNAdd(55);
3318                   break;
3319                case 56:
3320                   if ((0x3ff000000000000L & l) == 0L)
3321                      break;
3322                   if (kind > 52)
3323                      kind = 52;
3324                   jjCheckNAddStates(126, 131);
3325                   break;
3326                case 57:
3327                   if (curChar == 46)
3328                      jjCheckNAddTwoStates(48, 58);
3329                   break;
3330                default : break;
3331             }
3332          } while(i != startsAt);
3333       }
3334       else if (curChar < 128)
3335       {
3336          long l = 1L << (curChar & 077);
3337          MatchLoop: do
3338          {
3339             switch(jjstateSet[--i])
3340             {
3341                case 3:
3342                   if ((0x7fffffe87fffffeL & l) != 0L)
3343                   {
3344                      if (kind > 62)
3345                         kind = 62;
3346                      jjCheckNAdd(28);
3347                   }
3348                   else if (curChar == 92)
3349                      jjCheckNAddStates(146, 149);
3350                   break;
3351                case 58:
3352                   if ((0x7fffffe07fffffeL & l) != 0L && kind > 63)
3353                      kind = 63;
3354                   break;
3355                case 1:
3356                   if (kind > 15)
3357                      kind = 15;
3358                   break;
3359                case 6:
3360                   if ((0xffffffffefffffffL & l) != 0L)
3361                      jjCheckNAddStates(139, 141);
3362                   break;
3363                case 8:
3364                   if (curChar == 92)
3365                      jjAddStates(150, 155);
3366                   break;
3367                case 9:
3368                   if ((0x14404410000000L & l) != 0L)
3369                      jjCheckNAddStates(139, 141);
3370                   break;
3371                case 14:
3372                   if (curChar == 117)
3373                      jjstateSet[jjnewStateCnt++] = 15;
3374                   break;
3375                case 15:
3376                   if ((0x7e0000007eL & l) != 0L)
3377                      jjstateSet[jjnewStateCnt++] = 16;
3378                   break;
3379                case 16:
3380                   if ((0x7e0000007eL & l) != 0L)
3381                      jjstateSet[jjnewStateCnt++] = 17;
3382                   break;
3383                case 17:
3384                   if ((0x7e0000007eL & l) != 0L)
3385                      jjstateSet[jjnewStateCnt++] = 18;
3386                   break;
3387                case 18:
3388                   if ((0x7e0000007eL & l) != 0L)
3389                      jjCheckNAddStates(139, 141);
3390                   break;
3391                case 22:
3392                   jjAddStates(136, 138);
3393                   break;
3394                case 23:
3395                   if (curChar == 92)
3396                      jjAddStates(23, 24);
3397                   break;
3398                case 27:
3399                case 28:
3400                   if ((0x7fffffe87fffffeL & l) == 0L)
3401                      break;
3402                   if (kind > 62)
3403                      kind = 62;
3404                   jjCheckNAdd(28);
3405                   break;
3406                case 29:
3407                   if (curChar == 92)
3408                      jjCheckNAddStates(146, 149);
3409                   break;
3410                case 30:
3411                   if (curChar == 92)
3412                      jjCheckNAddTwoStates(30, 31);
3413                   break;
3414                case 32:
3415                   if (curChar == 92)
3416                      jjCheckNAddTwoStates(32, 33);
3417                   break;
3418                case 34:
3419                   if (curChar == 92)
3420                      jjAddStates(156, 157);
3421                   break;
3422                case 44:
3423                   if ((0x2000000020L & l) != 0L)
3424                      jjAddStates(158, 159);
3425                   break;
3426                case 49:
3427                   if ((0x2000000020L & l) != 0L)
3428                      jjAddStates(160, 161);
3429                   break;
3430                case 53:
3431                   if ((0x2000000020L & l) != 0L)
3432                      jjAddStates(162, 163);
3433                   break;
3434                default : break;
3435             }
3436          } while(i != startsAt);
3437       }
3438       else
3439       {
3440          int hiByte = (int)(curChar >> 8);
3441          int i1 = hiByte >> 6;
3442          long l1 = 1L << (hiByte & 077);
3443          int i2 = (curChar & 0xff) >> 6;
3444          long l2 = 1L << (curChar & 077);
3445          MatchLoop: do
3446          {
3447             switch(jjstateSet[--i])
3448             {
3449                case 1:
3450                   if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 15)
3451                      kind = 15;
3452                   break;
3453                case 6:
3454                   if (jjCanMove_0(hiByte, i1, i2, l1, l2))
3455                      jjAddStates(139, 141);
3456                   break;
3457                case 22:
3458                   if (jjCanMove_0(hiByte, i1, i2, l1, l2))
3459                      jjAddStates(136, 138);
3460                   break;
3461                default : break;
3462             }
3463          } while(i != startsAt);
3464       }
3465       if (kind != 0x7fffffff)
3466       {
3467          jjmatchedKind = kind;
3468          jjmatchedPos = curPos;
3469          kind = 0x7fffffff;
3470       }
3471       ++curPos;
3472       if ((i = jjnewStateCnt) == (startsAt = 59 - (jjnewStateCnt = startsAt)))
3473          return curPos;
3474       try { curChar = input_stream.readChar(); }
3475       catch(java.io.IOException e) { return curPos; }
3476    }
3477 }
3478 private final int jjStopStringLiteralDfa_2(int pos, long active0, long active1)
3479 {
3480    switch (pos)
3481    {
3482       case 0:
3483          if ((active0 & 0x70000L) != 0L)
3484             return 2;
3485          if ((active0 & 0x30000000L) != 0L)
3486          {
3487             jjmatchedKind = 62;
3488             return 5;
3489          }
3490          return -1;
3491       case 1:
3492          if ((active0 & 0x10000L) != 0L)
3493             return 0;
3494          if ((active0 & 0x30000000L) != 0L)
3495          {
3496             jjmatchedKind = 62;
3497             jjmatchedPos = 1;
3498             return 5;
3499          }
3500          return -1;
3501       case 2:
3502          if ((active0 & 0x30000000L) != 0L)
3503          {
3504             jjmatchedKind = 62;
3505             jjmatchedPos = 2;
3506             return 5;
3507          }
3508          return -1;
3509       case 3:
3510          if ((active0 & 0x20000000L) != 0L)
3511          {
3512             jjmatchedKind = 62;
3513             jjmatchedPos = 3;
3514             return 5;
3515          }
3516          if ((active0 & 0x10000000L) != 0L)
3517             return 5;
3518          return -1;
3519       default :
3520          return -1;
3521    }
3522 }
3523 private final int jjStartNfa_2(int pos, long active0, long active1)
3524 {
3525    return jjMoveNfa_2(jjStopStringLiteralDfa_2(pos, active0, active1), pos + 1);
3526 }
3527 private final int jjStartNfaWithStates_2(int pos, int kind, int state)
3528 {
3529    jjmatchedKind = kind;
3530    jjmatchedPos = pos;
3531    try { curChar = input_stream.readChar(); }
3532    catch(java.io.IOException e) { return pos + 1; }
3533    return jjMoveNfa_2(state, pos + 1);
3534 }
3535 private final int jjMoveStringLiteralDfa0_2()
3536 {
3537    switch(curChar)
3538    {
3539       case 35:
3540          jjmatchedKind = 17;
3541          return jjMoveStringLiteralDfa1_2(0x50000L);
3542       case 40:
3543          return jjStopAtPos(0, 8);
3544       case 102:
3545          return jjMoveStringLiteralDfa1_2(0x20000000L);
3546       case 116:
3547          return jjMoveStringLiteralDfa1_2(0x10000000L);
3548       case 123:
3549          return jjStopAtPos(0, 64);
3550       case 125:
3551          return jjStopAtPos(0, 65);
3552       default :
3553          return jjMoveNfa_2(3, 0);
3554    }
3555 }
3556 private final int jjMoveStringLiteralDfa1_2(long active0)
3557 {
3558    try { curChar = input_stream.readChar(); }
3559    catch(java.io.IOException e) {
3560       jjStopStringLiteralDfa_2(0, active0, 0L);
3561       return 1;
3562    }
3563    switch(curChar)
3564    {
3565       case 35:
3566          if ((active0 & 0x40000L) != 0L)
3567             return jjStopAtPos(1, 18);
3568          break;
3569       case 42:
3570          if ((active0 & 0x10000L) != 0L)
3571             return jjStartNfaWithStates_2(1, 16, 0);
3572          break;
3573       case 97:
3574          return jjMoveStringLiteralDfa2_2(active0, 0x20000000L);
3575       case 114:
3576          return jjMoveStringLiteralDfa2_2(active0, 0x10000000L);
3577       default :
3578          break;
3579    }
3580    return jjStartNfa_2(0, active0, 0L);
3581 }
3582 private final int jjMoveStringLiteralDfa2_2(long old0, long active0)
3583 {
3584    if (((active0 &= old0)) == 0L)
3585       return jjStartNfa_2(0, old0, 0L);
3586    try { curChar = input_stream.readChar(); }
3587    catch(java.io.IOException e) {
3588       jjStopStringLiteralDfa_2(1, active0, 0L);
3589       return 2;
3590    }
3591    switch(curChar)
3592    {
3593       case 108:
3594          return jjMoveStringLiteralDfa3_2(active0, 0x20000000L);
3595       case 117:
3596          return jjMoveStringLiteralDfa3_2(active0, 0x10000000L);
3597       default :
3598          break;
3599    }
3600    return jjStartNfa_2(1, active0, 0L);
3601 }
3602 private final int jjMoveStringLiteralDfa3_2(long old0, long active0)
3603 {
3604    if (((active0 &= old0)) == 0L)
3605       return jjStartNfa_2(1, old0, 0L);
3606    try { curChar = input_stream.readChar(); }
3607    catch(java.io.IOException e) {
3608       jjStopStringLiteralDfa_2(2, active0, 0L);
3609       return 3;
3610    }
3611    switch(curChar)
3612    {
3613       case 101:
3614          if ((active0 & 0x10000000L) != 0L)
3615             return jjStartNfaWithStates_2(3, 28, 5);
3616          break;
3617       case 115:
3618          return jjMoveStringLiteralDfa4_2(active0, 0x20000000L);
3619       default :
3620          break;
3621    }
3622    return jjStartNfa_2(2, active0, 0L);
3623 }
3624 private final int jjMoveStringLiteralDfa4_2(long old0, long active0)
3625 {
3626    if (((active0 &= old0)) == 0L)
3627       return jjStartNfa_2(2, old0, 0L);
3628    try { curChar = input_stream.readChar(); }
3629    catch(java.io.IOException e) {
3630       jjStopStringLiteralDfa_2(3, active0, 0L);
3631       return 4;
3632    }
3633    switch(curChar)
3634    {
3635       case 101:
3636          if ((active0 & 0x20000000L) != 0L)
3637             return jjStartNfaWithStates_2(4, 29, 5);
3638          break;
3639       default :
3640          break;
3641    }
3642    return jjStartNfa_2(3, active0, 0L);
3643 }
3644 private final int jjMoveNfa_2(int startState, int curPos)
3645 {
3646    int[] nextStates;
3647    int startsAt = 0;
3648    jjnewStateCnt = 16;
3649    int i = 1;
3650    jjstateSet[0] = startState;
3651    int j, kind = 0x7fffffff;
3652    for (;;)
3653    {
3654       if (++jjround == 0x7fffffff)
3655          ReInitRounds();
3656       if (curChar < 64)
3657       {
3658          long l = 1L << curChar;
3659          MatchLoop: do
3660          {
3661             switch(jjstateSet[--i])
3662             {
3663                case 3:
3664                   if (curChar == 36)
3665                   {
3666                      if (kind > 13)
3667                         kind = 13;
3668                      jjCheckNAddTwoStates(13, 14);
3669                   }
3670                   else if (curChar == 46)
3671                      jjstateSet[jjnewStateCnt++] = 7;
3672                   else if (curChar == 35)
3673                      jjstateSet[jjnewStateCnt++] = 2;
3674                   break;
3675                case 0:
3676                   if (curChar == 42)
3677                      jjstateSet[jjnewStateCnt++] = 1;
3678                   break;
3679                case 1:
3680                   if ((0xfffffff7ffffffffL & l) != 0L && kind > 15)
3681                      kind = 15;
3682                   break;
3683                case 2:
3684                   if (curChar == 42)
3685                      jjstateSet[jjnewStateCnt++] = 0;
3686                   break;
3687                case 5:
3688                   if ((0x3ff000000000000L & l) == 0L)
3689                      break;
3690                   if (kind > 62)
3691                      kind = 62;
3692                   jjstateSet[jjnewStateCnt++] = 5;
3693                   break;
3694                case 6:
3695                   if (curChar == 46)
3696                      jjstateSet[jjnewStateCnt++] = 7;
3697                   break;
3698                case 10:
3699                   if (curChar == 36 && kind > 13)
3700                      kind = 13;
3701                   break;
3702                case 12:
3703                   if (curChar == 36)
3704                      jjCheckNAddTwoStates(13, 14);
3705                   break;
3706                case 14:
3707                   if (curChar == 33 && kind > 14)
3708                      kind = 14;
3709                   break;
3710                case 15:
3711                   if (curChar != 36)
3712                      break;
3713                   if (kind > 13)
3714                      kind = 13;
3715                   jjCheckNAddTwoStates(13, 14);
3716                   break;
3717                default : break;
3718             }
3719          } while(i != startsAt);
3720       }
3721       else if (curChar < 128)
3722       {
3723          long l = 1L << (curChar & 077);
3724          MatchLoop: do
3725          {
3726             switch(jjstateSet[--i])
3727             {
3728                case 3:
3729                   if ((0x7fffffe87fffffeL & l) != 0L)
3730                   {
3731                      if (kind > 62)
3732                         kind = 62;
3733                      jjCheckNAdd(5);
3734                   }
3735                   else if (curChar == 92)
3736                      jjCheckNAddStates(122, 125);
3737                   break;
3738                case 1:
3739                   if (kind > 15)
3740                      kind = 15;
3741                   break;
3742                case 4:
3743                case 5:
3744                   if ((0x7fffffe87fffffeL & l) == 0L)
3745                      break;
3746                   if (kind > 62)
3747                      kind = 62;
3748                   jjCheckNAdd(5);
3749                   break;
3750                case 7:
3751                   if ((0x7fffffe07fffffeL & l) != 0L && kind > 63)
3752                      kind = 63;
3753                   break;
3754                case 8:
3755                   if (curChar == 92)
3756                      jjCheckNAddStates(122, 125);
3757                   break;
3758                case 9:
3759                   if (curChar == 92)
3760                      jjCheckNAddTwoStates(9, 10);
3761                   break;
3762                case 11:
3763                   if (curChar == 92)
3764                      jjCheckNAddTwoStates(11, 12);
3765                   break;
3766                case 13:
3767                   if (curChar == 92)
3768                      jjAddStates(95, 96);
3769                   break;
3770                default : break;
3771             }
3772          } while(i != startsAt);
3773       }
3774       else
3775       {
3776          int hiByte = (int)(curChar >> 8);
3777          int i1 = hiByte >> 6;
3778          long l1 = 1L << (hiByte & 077);
3779          int i2 = (curChar & 0xff) >> 6;
3780          long l2 = 1L << (curChar & 077);
3781          MatchLoop: do
3782          {
3783             switch(jjstateSet[--i])
3784             {
3785                case 1:
3786                   if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 15)
3787                      kind = 15;
3788                   break;
3789                default : break;
3790             }
3791          } while(i != startsAt);
3792       }
3793       if (kind != 0x7fffffff)
3794       {
3795          jjmatchedKind = kind;
3796          jjmatchedPos = curPos;
3797          kind = 0x7fffffff;
3798       }
3799       ++curPos;
3800       if ((i = jjnewStateCnt) == (startsAt = 16 - (jjnewStateCnt = startsAt)))
3801          return curPos;
3802       try { curChar = input_stream.readChar(); }
3803       catch(java.io.IOException e) { return curPos; }
3804    }
3805 }
3806 static final int[] jjnextStates = {
3807    87, 89, 90, 91, 96, 97, 87, 90, 57, 96, 27, 28, 31, 11, 12, 13, 
3808    1, 2, 4, 11, 16, 12, 13, 24, 25, 29, 30, 66, 67, 69, 70, 71, 
3809    72, 83, 85, 80, 81, 77, 78, 14, 15, 17, 19, 24, 25, 60, 61, 73, 
3810    74, 94, 95, 98, 99, 5, 6, 7, 8, 9, 10, 78, 80, 81, 82, 87, 
3811    88, 78, 81, 10, 87, 19, 20, 31, 32, 34, 42, 43, 45, 50, 32, 51, 
3812    66, 43, 67, 54, 57, 64, 71, 76, 22, 23, 24, 25, 35, 40, 47, 13, 
3813    14, 26, 27, 85, 86, 89, 90, 6, 11, 29, 3, 4, 19, 20, 21, 22, 
3814    14, 15, 23, 24, 8, 9, 10, 11, 12, 13, 9, 10, 11, 12, 38, 40, 
3815    41, 42, 52, 53, 38, 41, 47, 52, 22, 23, 26, 6, 7, 8, 6, 11, 
3816    7, 8, 30, 31, 32, 33, 9, 10, 12, 14, 19, 20, 34, 35, 45, 46, 
3817    50, 51, 54, 55, 
3818 };
3819 private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2)
3820 {
3821    switch(hiByte)
3822    {
3823       case 0:
3824          return ((jjbitVec2[i2] & l2) != 0L);
3825       default : 
3826          if ((jjbitVec0[i1] & l1) != 0L)
3827             return true;
3828          return false;
3829    }
3830 }
3831 public static final String[] jjstrLiteralImages = {
3832 null, null, null, null, null, null, null, null, null, null, null, null, null, 
3833 null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
3834 null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
3835 null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
3836 null, null, null, null, null, null, null, null, null, null, null, null, null, };
3837 public static final String[] lexStateNames = {
3838    "DIRECTIVE", 
3839    "REFMOD2", 
3840    "REFMODIFIER", 
3841    "DEFAULT", 
3842    "PRE_DIRECTIVE", 
3843    "REFERENCE", 
3844    "IN_MULTI_LINE_COMMENT", 
3845    "IN_FORMAL_COMMENT", 
3846    "IN_SINGLE_LINE_COMMENT", 
3847 };
3848 public static final int[] jjnewLexState = {
3849    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
3850    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
3851    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
3852 };
3853 static final long[] jjtoToken = {
3854    0xc637fffffdfc1fffL, 0x3L, 
3855 };
3856 static final long[] jjtoSkip = {
3857    0x2000000L, 0xcL, 
3858 };
3859 static final long[] jjtoSpecial = {
3860    0x0L, 0xcL, 
3861 };
3862 static final long[] jjtoMore = {
3863    0x3e000L, 0x0L, 
3864 };
3865 protected CharStream input_stream;
3866 private final int[] jjrounds = new int[101];
3867 private final int[] jjstateSet = new int[202];
3868 StringBuffer image;
3869 int jjimageLen;
3870 int lengthOfMatch;
3871 protected char curChar;
3872 public ParserTokenManager(CharStream stream){
3873    input_stream = stream;
3874 }
3875 public ParserTokenManager(CharStream stream, int lexState){
3876    this(stream);
3877    SwitchTo(lexState);
3878 }
3879 public void ReInit(CharStream stream)
3880 {
3881    jjmatchedPos = jjnewStateCnt = 0;
3882    curLexState = defaultLexState;
3883    input_stream = stream;
3884    ReInitRounds();
3885 }
3886 private final void ReInitRounds()
3887 {
3888    int i;
3889    jjround = 0x80000001;
3890    for (i = 101; i-- > 0;)
3891       jjrounds[i] = 0x80000000;
3892 }
3893 public void ReInit(CharStream stream, int lexState)
3894 {
3895    ReInit(stream);
3896    SwitchTo(lexState);
3897 }
3898 public void SwitchTo(int lexState)
3899 {
3900    if (lexState >= 9 || lexState < 0)
3901       throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
3902    else
3903       curLexState = lexState;
3904 }
3905 
3906 protected Token jjFillToken()
3907 {
3908    Token t = Token.newToken(jjmatchedKind);
3909    t.kind = jjmatchedKind;
3910    String im = jjstrLiteralImages[jjmatchedKind];
3911    t.image = (im == null) ? input_stream.GetImage() : im;
3912    t.beginLine = input_stream.getBeginLine();
3913    t.beginColumn = input_stream.getBeginColumn();
3914    t.endLine = input_stream.getEndLine();
3915    t.endColumn = input_stream.getEndColumn();
3916    return t;
3917 }
3918 
3919 int curLexState = 3;
3920 int defaultLexState = 3;
3921 int jjnewStateCnt;
3922 int jjround;
3923 int jjmatchedPos;
3924 int jjmatchedKind;
3925 
3926 public Token getNextToken() 
3927 {
3928   int kind;
3929   Token specialToken = null;
3930   Token matchedToken;
3931   int curPos = 0;
3932 
3933   EOFLoop :
3934   for (;;)
3935   {   
3936    try   
3937    {     
3938       curChar = input_stream.BeginToken();
3939    }     
3940    catch(java.io.IOException e)
3941    {        
3942       jjmatchedKind = 0;
3943       matchedToken = jjFillToken();
3944       matchedToken.specialToken = specialToken;
3945       return matchedToken;
3946    }
3947    image = null;
3948    jjimageLen = 0;
3949 
3950    for (;;)
3951    {
3952      switch(curLexState)
3953      {
3954        case 0:
3955          jjmatchedKind = 0x7fffffff;
3956          jjmatchedPos = 0;
3957          curPos = jjMoveStringLiteralDfa0_0();
3958          break;
3959        case 1:
3960          jjmatchedKind = 0x7fffffff;
3961          jjmatchedPos = 0;
3962          curPos = jjMoveStringLiteralDfa0_1();
3963          if (jjmatchedPos == 0 && jjmatchedKind > 66)
3964          {
3965             jjmatchedKind = 66;
3966          }
3967          break;
3968        case 2:
3969          jjmatchedKind = 0x7fffffff;
3970          jjmatchedPos = 0;
3971          curPos = jjMoveStringLiteralDfa0_2();
3972          if (jjmatchedPos == 0 && jjmatchedKind > 66)
3973          {
3974             jjmatchedKind = 66;
3975          }
3976          break;
3977        case 3:
3978          jjmatchedKind = 0x7fffffff;
3979          jjmatchedPos = 0;
3980          curPos = jjMoveStringLiteralDfa0_3();
3981          break;
3982        case 4:
3983          jjmatchedKind = 0x7fffffff;
3984          jjmatchedPos = 0;
3985          curPos = jjMoveStringLiteralDfa0_4();
3986          if (jjmatchedPos == 0 && jjmatchedKind > 67)
3987          {
3988             jjmatchedKind = 67;
3989          }
3990          break;
3991        case 5:
3992          jjmatchedKind = 0x7fffffff;
3993          jjmatchedPos = 0;
3994          curPos = jjMoveStringLiteralDfa0_5();
3995          if (jjmatchedPos == 0 && jjmatchedKind > 66)
3996          {
3997             jjmatchedKind = 66;
3998          }
3999          break;
4000        case 6:
4001          jjmatchedKind = 0x7fffffff;
4002          jjmatchedPos = 0;
4003          curPos = jjMoveStringLiteralDfa0_6();
4004          if (jjmatchedPos == 0 && jjmatchedKind > 25)
4005          {
4006             jjmatchedKind = 25;
4007          }
4008          break;
4009        case 7:
4010          jjmatchedKind = 0x7fffffff;
4011          jjmatchedPos = 0;
4012          curPos = jjMoveStringLiteralDfa0_7();
4013          if (jjmatchedPos == 0 && jjmatchedKind > 25)
4014          {
4015             jjmatchedKind = 25;
4016          }
4017          break;
4018        case 8:
4019          jjmatchedKind = 0x7fffffff;
4020          jjmatchedPos = 0;
4021          curPos = jjMoveStringLiteralDfa0_8();
4022          if (jjmatchedPos == 0 && jjmatchedKind > 25)
4023          {
4024             jjmatchedKind = 25;
4025          }
4026          break;
4027      }
4028      if (jjmatchedKind != 0x7fffffff)
4029      {
4030         if (jjmatchedPos + 1 < curPos)
4031            input_stream.backup(curPos - jjmatchedPos - 1);
4032         if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
4033         {
4034            matchedToken = jjFillToken();
4035            matchedToken.specialToken = specialToken;
4036            TokenLexicalActions(matchedToken);
4037        if (jjnewLexState[jjmatchedKind] != -1)
4038          curLexState = jjnewLexState[jjmatchedKind];
4039            return matchedToken;
4040         }
4041         else if ((jjtoSkip[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
4042         {
4043            if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
4044            {
4045               matchedToken = jjFillToken();
4046               if (specialToken == null)
4047                  specialToken = matchedToken;
4048               else
4049               {
4050                  matchedToken.specialToken = specialToken;
4051                  specialToken = (specialToken.next = matchedToken);
4052               }
4053               SkipLexicalActions(matchedToken);
4054            }
4055            else 
4056               SkipLexicalActions(null);
4057          if (jjnewLexState[jjmatchedKind] != -1)
4058            curLexState = jjnewLexState[jjmatchedKind];
4059            continue EOFLoop;
4060         }
4061         MoreLexicalActions();
4062       if (jjnewLexState[jjmatchedKind] != -1)
4063         curLexState = jjnewLexState[jjmatchedKind];
4064         curPos = 0;
4065         jjmatchedKind = 0x7fffffff;
4066         try {
4067            curChar = input_stream.readChar();
4068            continue;
4069         }
4070         catch (java.io.IOException e1) { }
4071      }
4072      int error_line = input_stream.getEndLine();
4073      int error_column = input_stream.getEndColumn();
4074      String error_after = null;
4075      boolean EOFSeen = false;
4076      try { input_stream.readChar(); input_stream.backup(1); }
4077      catch (java.io.IOException e1) {
4078         EOFSeen = true;
4079         error_after = curPos <= 1 ? "" : input_stream.GetImage();
4080         if (curChar == '\n' || curChar == '\r') {
4081            error_line++;
4082            error_column = 0;
4083         }
4084         else
4085            error_column++;
4086      }
4087      if (!EOFSeen) {
4088         input_stream.backup(1);
4089         error_after = curPos <= 1 ? "" : input_stream.GetImage();
4090      }
4091      throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
4092    }
4093   }
4094 }
4095 
4096 void SkipLexicalActions(Token matchedToken)
4097 {
4098    switch(jjmatchedKind)
4099    {
4100       case 66 :
4101          if (image == null)
4102             image = new StringBuffer();
4103          image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
4104         /*
4105          * push every terminator character back into the stream
4106          */
4107 
4108         input_stream.backup(1);
4109 
4110         inReference = false;
4111 
4112         if ( debugPrint )
4113             System.out.print("REF_TERM :");
4114 
4115         stateStackPop();
4116          break;
4117       case 67 :
4118          if (image == null)
4119             image = new StringBuffer();
4120          image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
4121         if ( debugPrint )
4122             System.out.print("DIRECTIVE_TERM :");
4123 
4124         input_stream.backup(1);
4125         inDirective = false;
4126         stateStackPop();
4127          break;
4128       default :
4129          break;
4130    }
4131 }
4132 void MoreLexicalActions()
4133 {
4134    jjimageLen += (lengthOfMatch = jjmatchedPos + 1);
4135    switch(jjmatchedKind)
4136    {
4137       case 13 :
4138          if (image == null)
4139             image = new StringBuffer();
4140          image.append(input_stream.GetSuffix(jjimageLen));
4141          jjimageLen = 0;
4142         if (! inComment)
4143         {
4144             /*
4145              * if we find ourselves in REFERENCE, we need to pop down
4146              * to end the previous ref
4147              */
4148 
4149             if (curLexState == REFERENCE)
4150             {
4151                 inReference = false;
4152                 stateStackPop();
4153             }
4154 
4155             inReference = true;
4156 
4157             if ( debugPrint )
4158                 System.out.print( "$  : going to " + REFERENCE );
4159 
4160             stateStackPush();
4161             SwitchTo(REFERENCE);
4162         }
4163          break;
4164       case 14 :
4165          if (image == null)
4166             image = new StringBuffer();
4167          image.append(input_stream.GetSuffix(jjimageLen));
4168          jjimageLen = 0;
4169         if (! inComment)
4170         {
4171             /*
4172              * if we find ourselves in REFERENCE, we need to pop down
4173              * to end the previous ref
4174              */
4175 
4176             if (curLexState == REFERENCE)
4177             {
4178                 inReference = false;
4179                 stateStackPop();
4180             }
4181 
4182             inReference = true;
4183 
4184             if ( debugPrint )
4185                 System.out.print( "$!  : going to " + REFERENCE );
4186 
4187             stateStackPush();
4188             SwitchTo(REFERENCE);
4189         }
4190          break;
4191       case 15 :
4192          if (image == null)
4193             image = new StringBuffer();
4194          image.append(input_stream.GetSuffix(jjimageLen));
4195          jjimageLen = 0;
4196         input_stream.backup(1);
4197         inComment = true;
4198         stateStackPush();
4199         SwitchTo( IN_FORMAL_COMMENT);
4200          break;
4201       case 16 :
4202          if (image == null)
4203             image = new StringBuffer();
4204          image.append(input_stream.GetSuffix(jjimageLen));
4205          jjimageLen = 0;
4206         inComment=true;
4207         stateStackPush();
4208         SwitchTo( IN_MULTI_LINE_COMMENT );
4209          break;
4210       case 17 :
4211          if (image == null)
4212             image = new StringBuffer();
4213          image.append(input_stream.GetSuffix(jjimageLen));
4214          jjimageLen = 0;
4215         if (! inComment)
4216         {
4217             /*
4218              * We can have the situation where #if($foo)$foo#end.
4219              * We need to transition out of REFERENCE before going to DIRECTIVE.
4220              * I don't really like this, but I can't think of a legal way
4221              * you are going into DIRECTIVE while in REFERENCE.  -gmj
4222              */
4223 
4224             if (curLexState == REFERENCE || curLexState == REFMODIFIER )
4225             {
4226                 inReference = false;
4227                 stateStackPop();
4228             }
4229 
4230             inDirective = true;
4231 
4232             if ( debugPrint )
4233                 System.out.print("# :  going to " + DIRECTIVE );
4234 
4235             stateStackPush();
4236             SwitchTo(PRE_DIRECTIVE);
4237         }
4238          break;
4239       default : 
4240          break;
4241    }
4242 }
4243 void TokenLexicalActions(Token matchedToken)
4244 {
4245    switch(jjmatchedKind)
4246    {
4247       case 8 :
4248         if (image == null)
4249             image = new StringBuffer();
4250             image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
4251         if (!inComment)
4252             lparen++;
4253 
4254         /*
4255          * If in REFERENCE and we have seen the dot, then move
4256          * to REFMOD2 -> Modifier()
4257          */
4258 
4259         if (curLexState == REFMODIFIER )
4260             SwitchTo( REFMOD2 );
4261          break;
4262       case 9 :
4263         if (image == null)
4264             image = new StringBuffer();
4265             image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
4266        RPARENHandler();
4267          break;
4268       case 10 :
4269         if (image == null)
4270             image = new StringBuffer();
4271             image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
4272         /*
4273          * need to simply switch back to REFERENCE, not drop down the stack
4274          * because we can (infinitely) chain, ala
4275          * $foo.bar().blargh().woogie().doogie()
4276          */
4277 
4278         SwitchTo( REFERENCE );
4279          break;
4280       case 12 :
4281         if (image == null)
4282             image = new StringBuffer();
4283             image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
4284         if (! inComment)
4285         {
4286             inDirective = true;
4287 
4288             if ( debugPrint )
4289                 System.out.print("#set :  going to " + DIRECTIVE );
4290 
4291             stateStackPush();
4292             inSet = true;
4293             SwitchTo(DIRECTIVE);
4294         }
4295 
4296         /*
4297          *  need the LPAREN action
4298          */
4299 
4300         if (!inComment)
4301         {
4302             lparen++;
4303 
4304             /*
4305              * If in REFERENCE and we have seen the dot, then move
4306              * to REFMOD2 -> Modifier()
4307              */
4308 
4309             if (curLexState == REFMODIFIER )
4310                 SwitchTo( REFMOD2 );
4311         }
4312          break;
4313       case 18 :
4314         if (image == null)
4315             image = new StringBuffer();
4316             image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
4317         if (!inComment)
4318         {
4319             if (curLexState == REFERENCE)
4320             {
4321                 inReference = false;
4322                 stateStackPop();
4323             }
4324 
4325             inComment = true;
4326             stateStackPush();
4327             SwitchTo(IN_SINGLE_LINE_COMMENT);
4328         }
4329          break;
4330       case 22 :
4331         if (image == null)
4332             image = new StringBuffer();
4333             image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
4334      inComment = false;
4335      stateStackPop();
4336          break;
4337       case 23 :
4338         if (image == null)
4339             image = new StringBuffer();
4340             image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
4341     inComment = false;
4342     stateStackPop();
4343          break;
4344       case 24 :
4345         if (image == null)
4346             image = new StringBuffer();
4347             image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
4348     inComment = false;
4349     stateStackPop();
4350          break;
4351       case 27 :
4352         if (image == null)
4353             image = new StringBuffer();
4354             image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
4355         /*
4356          *  - if we are in DIRECTIVE and haven't seen ( yet, then also drop out.
4357          *      don't forget to account for the beloved yet wierd #set
4358          *  - finally, if we are in REFMOD2 (remember : $foo.bar( ) then " is ok!
4359          */
4360 
4361          if( curLexState == DIRECTIVE && !inSet && lparen == 0)
4362             stateStackPop();
4363          break;
4364       case 30 :
4365         if (image == null)
4366             image = new StringBuffer();
4367             image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
4368         if ( debugPrint )
4369             System.out.println(" NEWLINE :");
4370 
4371         stateStackPop();
4372 
4373         if (inSet)
4374             inSet = false;
4375 
4376         if (inDirective)
4377             inDirective = false;
4378          break;
4379       case 46 :
4380         if (image == null)
4381             image = new StringBuffer();
4382             image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
4383         inDirective = false;
4384         stateStackPop();
4385          break;
4386       case 47 :
4387         if (image == null)
4388             image = new StringBuffer();
4389             image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
4390         SwitchTo(DIRECTIVE);
4391          break;
4392       case 48 :
4393         if (image == null)
4394             image = new StringBuffer();
4395             image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
4396         SwitchTo(DIRECTIVE);
4397          break;
4398       case 49 :
4399         if (image == null)
4400             image = new StringBuffer();
4401             image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
4402         inDirective = false;
4403         stateStackPop();
4404          break;
4405       case 50 :
4406         if (image == null)
4407             image = new StringBuffer();
4408             image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
4409         inDirective = false;
4410         stateStackPop();
4411          break;
4412       case 52 :
4413         if (image == null)
4414             image = new StringBuffer();
4415             image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
4416         /*
4417          * Remove the double period if it is there
4418          */
4419         if (matchedToken.image.endsWith("..")) {
4420             input_stream.backup(2);
4421             matchedToken.image = matchedToken.image.substring(0,matchedToken.image.length()-2);
4422         }
4423 
4424         /*
4425          * check to see if we are in set
4426          *    ex.  #set $foo = $foo + 3
4427          *  because we want to handle the \n after
4428          */
4429 
4430         if ( lparen == 0 && !inSet && curLexState != REFMOD2)
4431         {
4432             stateStackPop();
4433         }
4434          break;
4435       case 53 :
4436         if (image == null)
4437             image = new StringBuffer();
4438             image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
4439         /*
4440          * check to see if we are in set
4441          *    ex.  #set $foo = $foo + 3
4442          *  because we want to handle the \n after
4443          */
4444 
4445         if ( lparen == 0 && !inSet && curLexState != REFMOD2)
4446         {
4447             stateStackPop();
4448     }
4449          break;
4450       case 63 :
4451         if (image == null)
4452             image = new StringBuffer();
4453             image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
4454         /*
4455          * push the alpha char back into the stream so the following identifier
4456          * is complete
4457          */
4458 
4459         input_stream.backup(1);
4460 
4461         /*
4462          * and munge the <DOT> so we just get a . when we have normal text that
4463          * looks like a ref.ident
4464          */
4465 
4466         matchedToken.image = ".";
4467 
4468         if ( debugPrint )
4469             System.out.print("DOT : switching to " + REFMODIFIER);
4470         SwitchTo(REFMODIFIER);
4471          break;
4472       case 65 :
4473         if (image == null)
4474             image = new StringBuffer();
4475             image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
4476         stateStackPop();
4477          break;
4478       default : 
4479          break;
4480    }
4481 }
4482 }