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