1   /* JavaCCParserTokenManager.java */
2   /* Generated By:JavaCC: Do not edit this line. JavaCCParserTokenManager.java */
3   package jminusminus;
4   import java.util.ArrayList;
5   
6   /** Token Manager. */
7   @SuppressWarnings ("unused")
8   public class JavaCCParserTokenManager implements JavaCCParserConstants {
9   
10    /** Debug output. */
11    public  java.io.PrintStream debugStream = System.out;
12    /** Set debug output. */
13    public  void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
14  private final int jjStopStringLiteralDfa_0(int pos, long active0){
15     switch (pos)
16     {
17        case 0:
18           if ((active0 & 0x1fffffe00L) != 0L)
19           {
20              jjmatchedKind = 54;
21              return 1;
22           }
23           return -1;
24        case 1:
25           if ((active0 & 0x10000L) != 0L)
26              return 1;
27           if ((active0 & 0x1fffefe00L) != 0L)
28           {
29              jjmatchedKind = 54;
30              jjmatchedPos = 1;
31              return 1;
32           }
33           return -1;
34        case 2:
35           if ((active0 & 0x180000L) != 0L)
36              return 1;
37           if ((active0 & 0x1ffe6fe00L) != 0L)
38           {
39              jjmatchedKind = 54;
40              jjmatchedPos = 2;
41              return 1;
42           }
43           return -1;
44        case 3:
45           if ((active0 & 0xe0202800L) != 0L)
46              return 1;
47           if ((active0 & 0x11fc6d600L) != 0L)
48           {
49              jjmatchedKind = 54;
50              jjmatchedPos = 3;
51              return 1;
52           }
53           return -1;
54        case 4:
55           if ((active0 & 0x110009000L) != 0L)
56              return 1;
57           if ((active0 & 0xfc64600L) != 0L)
58           {
59              jjmatchedKind = 54;
60              jjmatchedPos = 4;
61              return 1;
62           }
63           return -1;
64        case 5:
65           if ((active0 & 0xe020000L) != 0L)
66              return 1;
67           if ((active0 & 0x1c44600L) != 0L)
68           {
69              jjmatchedKind = 54;
70              jjmatchedPos = 5;
71              return 1;
72           }
73           return -1;
74        case 6:
75           if ((active0 & 0xc04400L) != 0L)
76              return 1;
77           if ((active0 & 0x1040200L) != 0L)
78           {
79              jjmatchedKind = 54;
80              jjmatchedPos = 6;
81              return 1;
82           }
83           return -1;
84        case 7:
85           if ((active0 & 0x1040000L) != 0L)
86           {
87              jjmatchedKind = 54;
88              jjmatchedPos = 7;
89              return 1;
90           }
91           if ((active0 & 0x200L) != 0L)
92              return 1;
93           return -1;
94        case 8:
95           if ((active0 & 0x40000L) != 0L)
96           {
97              jjmatchedKind = 54;
98              jjmatchedPos = 8;
99              return 1;
100          }
101          if ((active0 & 0x1000000L) != 0L)
102             return 1;
103          return -1;
104       default :
105          return -1;
106    }
107 }
108 private final int jjStartNfa_0(int pos, long active0){
109    return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1);
110 }
111 private int jjStopAtPos(int pos, int kind)
112 {
113    jjmatchedKind = kind;
114    jjmatchedPos = pos;
115    return pos + 1;
116 }
117 private int jjMoveStringLiteralDfa0_0(){
118    switch(curChar)
119    {
120       case 33:
121          return jjStopAtPos(0, 49);
122       case 38:
123          return jjMoveStringLiteralDfa1_0(0x800000000000L);
124       case 40:
125          return jjStopAtPos(0, 37);
126       case 41:
127          return jjStopAtPos(0, 38);
128       case 42:
129          return jjStopAtPos(0, 53);
130       case 43:
131          jjmatchedKind = 51;
132          return jjMoveStringLiteralDfa1_0(0x10400000000000L);
133       case 44:
134          return jjStopAtPos(0, 33);
135       case 45:
136          jjmatchedKind = 50;
137          return jjMoveStringLiteralDfa1_0(0x80000000000L);
138       case 46:
139          return jjStopAtPos(0, 34);
140       case 47:
141          return jjMoveStringLiteralDfa1_0(0x40L);
142       case 59:
143          return jjStopAtPos(0, 41);
144       case 60:
145          return jjMoveStringLiteralDfa1_0(0x1000000000000L);
146       case 61:
147          jjmatchedKind = 42;
148          return jjMoveStringLiteralDfa1_0(0x100000000000L);
149       case 62:
150          return jjStopAtPos(0, 45);
151       case 91:
152          return jjStopAtPos(0, 35);
153       case 93:
154          return jjStopAtPos(0, 39);
155       case 97:
156          return jjMoveStringLiteralDfa1_0(0x200L);
157       case 98:
158          return jjMoveStringLiteralDfa1_0(0x400L);
159       case 99:
160          return jjMoveStringLiteralDfa1_0(0x1800L);
161       case 101:
162          return jjMoveStringLiteralDfa1_0(0x6000L);
163       case 102:
164          return jjMoveStringLiteralDfa1_0(0x8000L);
165       case 105:
166          return jjMoveStringLiteralDfa1_0(0xf0000L);
167       case 110:
168          return jjMoveStringLiteralDfa1_0(0x300000L);
169       case 112:
170          return jjMoveStringLiteralDfa1_0(0x3c00000L);
171       case 114:
172          return jjMoveStringLiteralDfa1_0(0x4000000L);
173       case 115:
174          return jjMoveStringLiteralDfa1_0(0x18000000L);
175       case 116:
176          return jjMoveStringLiteralDfa1_0(0x60000000L);
177       case 118:
178          return jjMoveStringLiteralDfa1_0(0x80000000L);
179       case 119:
180          return jjMoveStringLiteralDfa1_0(0x100000000L);
181       case 123:
182          return jjStopAtPos(0, 36);
183       case 125:
184          return jjStopAtPos(0, 40);
185       default :
186          return jjMoveNfa_0(0, 0);
187    }
188 }
189 private int jjMoveStringLiteralDfa1_0(long active0){
190    try { curChar = input_stream.readChar(); }
191    catch(java.io.IOException e) {
192       jjStopStringLiteralDfa_0(0, active0);
193       return 1;
194    }
195    switch(curChar)
196    {
197       case 38:
198          if ((active0 & 0x800000000000L) != 0L)
199             return jjStopAtPos(1, 47);
200          break;
201       case 43:
202          if ((active0 & 0x400000000000L) != 0L)
203             return jjStopAtPos(1, 46);
204          break;
205       case 45:
206          if ((active0 & 0x80000000000L) != 0L)
207             return jjStopAtPos(1, 43);
208          break;
209       case 47:
210          if ((active0 & 0x40L) != 0L)
211             return jjStopAtPos(1, 6);
212          break;
213       case 61:
214          if ((active0 & 0x100000000000L) != 0L)
215             return jjStopAtPos(1, 44);
216          else if ((active0 & 0x1000000000000L) != 0L)
217             return jjStopAtPos(1, 48);
218          else if ((active0 & 0x10000000000000L) != 0L)
219             return jjStopAtPos(1, 52);
220          break;
221       case 97:
222          return jjMoveStringLiteralDfa2_0(active0, 0x408000L);
223       case 98:
224          return jjMoveStringLiteralDfa2_0(active0, 0x200L);
225       case 101:
226          return jjMoveStringLiteralDfa2_0(active0, 0x4100000L);
227       case 102:
228          if ((active0 & 0x10000L) != 0L)
229             return jjStartNfaWithStates_0(1, 16, 1);
230          break;
231       case 104:
232          return jjMoveStringLiteralDfa2_0(active0, 0x120000800L);
233       case 108:
234          return jjMoveStringLiteralDfa2_0(active0, 0x3000L);
235       case 109:
236          return jjMoveStringLiteralDfa2_0(active0, 0x20000L);
237       case 110:
238          return jjMoveStringLiteralDfa2_0(active0, 0xc0000L);
239       case 111:
240          return jjMoveStringLiteralDfa2_0(active0, 0x80000400L);
241       case 114:
242          return jjMoveStringLiteralDfa2_0(active0, 0x41800000L);
243       case 116:
244          return jjMoveStringLiteralDfa2_0(active0, 0x8000000L);
245       case 117:
246          return jjMoveStringLiteralDfa2_0(active0, 0x12200000L);
247       case 120:
248          return jjMoveStringLiteralDfa2_0(active0, 0x4000L);
249       default :
250          break;
251    }
252    return jjStartNfa_0(0, active0);
253 }
254 private int jjMoveStringLiteralDfa2_0(long old0, long active0){
255    if (((active0 &= old0)) == 0L)
256       return jjStartNfa_0(0, old0);
257    try { curChar = input_stream.readChar(); }
258    catch(java.io.IOException e) {
259       jjStopStringLiteralDfa_0(1, active0);
260       return 2;
261    }
262    switch(curChar)
263    {
264       case 97:
265          return jjMoveStringLiteralDfa3_0(active0, 0x8001800L);
266       case 98:
267          return jjMoveStringLiteralDfa3_0(active0, 0x2000000L);
268       case 99:
269          return jjMoveStringLiteralDfa3_0(active0, 0x400000L);
270       case 105:
271          return jjMoveStringLiteralDfa3_0(active0, 0x1a0800000L);
272       case 108:
273          return jjMoveStringLiteralDfa3_0(active0, 0x208000L);
274       case 111:
275          return jjMoveStringLiteralDfa3_0(active0, 0x1000400L);
276       case 112:
277          return jjMoveStringLiteralDfa3_0(active0, 0x10020000L);
278       case 115:
279          return jjMoveStringLiteralDfa3_0(active0, 0x42200L);
280       case 116:
281          if ((active0 & 0x80000L) != 0L)
282             return jjStartNfaWithStates_0(2, 19, 1);
283          return jjMoveStringLiteralDfa3_0(active0, 0x4004000L);
284       case 117:
285          return jjMoveStringLiteralDfa3_0(active0, 0x40000000L);
286       case 119:
287          if ((active0 & 0x100000L) != 0L)
288             return jjStartNfaWithStates_0(2, 20, 1);
289          break;
290       default :
291          break;
292    }
293    return jjStartNfa_0(1, active0);
294 }
295 private int jjMoveStringLiteralDfa3_0(long old0, long active0){
296    if (((active0 &= old0)) == 0L)
297       return jjStartNfa_0(1, old0);
298    try { curChar = input_stream.readChar(); }
299    catch(java.io.IOException e) {
300       jjStopStringLiteralDfa_0(2, active0);
301       return 3;
302    }
303    switch(curChar)
304    {
305       case 100:
306          if ((active0 & 0x80000000L) != 0L)
307             return jjStartNfaWithStates_0(3, 31, 1);
308          break;
309       case 101:
310          if ((active0 & 0x2000L) != 0L)
311             return jjStartNfaWithStates_0(3, 13, 1);
312          else if ((active0 & 0x40000000L) != 0L)
313             return jjStartNfaWithStates_0(3, 30, 1);
314          return jjMoveStringLiteralDfa4_0(active0, 0x10004000L);
315       case 107:
316          return jjMoveStringLiteralDfa4_0(active0, 0x400000L);
317       case 108:
318          if ((active0 & 0x200000L) != 0L)
319             return jjStartNfaWithStates_0(3, 21, 1);
320          return jjMoveStringLiteralDfa4_0(active0, 0x102000400L);
321       case 111:
322          return jjMoveStringLiteralDfa4_0(active0, 0x20000L);
323       case 114:
324          if ((active0 & 0x800L) != 0L)
325             return jjStartNfaWithStates_0(3, 11, 1);
326          break;
327       case 115:
328          if ((active0 & 0x20000000L) != 0L)
329             return jjStartNfaWithStates_0(3, 29, 1);
330          return jjMoveStringLiteralDfa4_0(active0, 0x9000L);
331       case 116:
332          return jjMoveStringLiteralDfa4_0(active0, 0x9040200L);
333       case 117:
334          return jjMoveStringLiteralDfa4_0(active0, 0x4000000L);
335       case 118:
336          return jjMoveStringLiteralDfa4_0(active0, 0x800000L);
337       default :
338          break;
339    }
340    return jjStartNfa_0(2, active0);
341 }
342 private int jjMoveStringLiteralDfa4_0(long old0, long active0){
343    if (((active0 &= old0)) == 0L)
344       return jjStartNfa_0(2, old0);
345    try { curChar = input_stream.readChar(); }
346    catch(java.io.IOException e) {
347       jjStopStringLiteralDfa_0(3, active0);
348       return 4;
349    }
350    switch(curChar)
351    {
352       case 97:
353          return jjMoveStringLiteralDfa5_0(active0, 0xc40000L);
354       case 101:
355          if ((active0 & 0x8000L) != 0L)
356             return jjStartNfaWithStates_0(4, 15, 1);
357          else if ((active0 & 0x100000000L) != 0L)
358             return jjStartNfaWithStates_0(4, 32, 1);
359          return jjMoveStringLiteralDfa5_0(active0, 0x1000400L);
360       case 105:
361          return jjMoveStringLiteralDfa5_0(active0, 0xa000000L);
362       case 110:
363          return jjMoveStringLiteralDfa5_0(active0, 0x4000L);
364       case 114:
365          if ((active0 & 0x10000000L) != 0L)
366             return jjStartNfaWithStates_0(4, 28, 1);
367          return jjMoveStringLiteralDfa5_0(active0, 0x4020200L);
368       case 115:
369          if ((active0 & 0x1000L) != 0L)
370             return jjStartNfaWithStates_0(4, 12, 1);
371          break;
372       default :
373          break;
374    }
375    return jjStartNfa_0(3, active0);
376 }
377 private int jjMoveStringLiteralDfa5_0(long old0, long active0){
378    if (((active0 &= old0)) == 0L)
379       return jjStartNfa_0(3, old0);
380    try { curChar = input_stream.readChar(); }
381    catch(java.io.IOException e) {
382       jjStopStringLiteralDfa_0(4, active0);
383       return 5;
384    }
385    switch(curChar)
386    {
387       case 97:
388          return jjMoveStringLiteralDfa6_0(active0, 0x600L);
389       case 99:
390          if ((active0 & 0x2000000L) != 0L)
391             return jjStartNfaWithStates_0(5, 25, 1);
392          else if ((active0 & 0x8000000L) != 0L)
393             return jjStartNfaWithStates_0(5, 27, 1);
394          return jjMoveStringLiteralDfa6_0(active0, 0x1000000L);
395       case 100:
396          return jjMoveStringLiteralDfa6_0(active0, 0x4000L);
397       case 103:
398          return jjMoveStringLiteralDfa6_0(active0, 0x400000L);
399       case 110:
400          if ((active0 & 0x4000000L) != 0L)
401             return jjStartNfaWithStates_0(5, 26, 1);
402          return jjMoveStringLiteralDfa6_0(active0, 0x40000L);
403       case 116:
404          if ((active0 & 0x20000L) != 0L)
405             return jjStartNfaWithStates_0(5, 17, 1);
406          return jjMoveStringLiteralDfa6_0(active0, 0x800000L);
407       default :
408          break;
409    }
410    return jjStartNfa_0(4, active0);
411 }
412 private int jjMoveStringLiteralDfa6_0(long old0, long active0){
413    if (((active0 &= old0)) == 0L)
414       return jjStartNfa_0(4, old0);
415    try { curChar = input_stream.readChar(); }
416    catch(java.io.IOException e) {
417       jjStopStringLiteralDfa_0(5, active0);
418       return 6;
419    }
420    switch(curChar)
421    {
422       case 99:
423          return jjMoveStringLiteralDfa7_0(active0, 0x40200L);
424       case 101:
425          if ((active0 & 0x400000L) != 0L)
426             return jjStartNfaWithStates_0(6, 22, 1);
427          else if ((active0 & 0x800000L) != 0L)
428             return jjStartNfaWithStates_0(6, 23, 1);
429          break;
430       case 110:
431          if ((active0 & 0x400L) != 0L)
432             return jjStartNfaWithStates_0(6, 10, 1);
433          break;
434       case 115:
435          if ((active0 & 0x4000L) != 0L)
436             return jjStartNfaWithStates_0(6, 14, 1);
437          break;
438       case 116:
439          return jjMoveStringLiteralDfa7_0(active0, 0x1000000L);
440       default :
441          break;
442    }
443    return jjStartNfa_0(5, active0);
444 }
445 private int jjMoveStringLiteralDfa7_0(long old0, long active0){
446    if (((active0 &= old0)) == 0L)
447       return jjStartNfa_0(5, old0);
448    try { curChar = input_stream.readChar(); }
449    catch(java.io.IOException e) {
450       jjStopStringLiteralDfa_0(6, active0);
451       return 7;
452    }
453    switch(curChar)
454    {
455       case 101:
456          return jjMoveStringLiteralDfa8_0(active0, 0x1040000L);
457       case 116:
458          if ((active0 & 0x200L) != 0L)
459             return jjStartNfaWithStates_0(7, 9, 1);
460          break;
461       default :
462          break;
463    }
464    return jjStartNfa_0(6, active0);
465 }
466 private int jjMoveStringLiteralDfa8_0(long old0, long active0){
467    if (((active0 &= old0)) == 0L)
468       return jjStartNfa_0(6, old0);
469    try { curChar = input_stream.readChar(); }
470    catch(java.io.IOException e) {
471       jjStopStringLiteralDfa_0(7, active0);
472       return 8;
473    }
474    switch(curChar)
475    {
476       case 100:
477          if ((active0 & 0x1000000L) != 0L)
478             return jjStartNfaWithStates_0(8, 24, 1);
479          break;
480       case 111:
481          return jjMoveStringLiteralDfa9_0(active0, 0x40000L);
482       default :
483          break;
484    }
485    return jjStartNfa_0(7, active0);
486 }
487 private int jjMoveStringLiteralDfa9_0(long old0, long active0){
488    if (((active0 &= old0)) == 0L)
489       return jjStartNfa_0(7, old0);
490    try { curChar = input_stream.readChar(); }
491    catch(java.io.IOException e) {
492       jjStopStringLiteralDfa_0(8, active0);
493       return 9;
494    }
495    switch(curChar)
496    {
497       case 102:
498          if ((active0 & 0x40000L) != 0L)
499             return jjStartNfaWithStates_0(9, 18, 1);
500          break;
501       default :
502          break;
503    }
504    return jjStartNfa_0(8, active0);
505 }
506 private int jjStartNfaWithStates_0(int pos, int kind, int state)
507 {
508    jjmatchedKind = kind;
509    jjmatchedPos = pos;
510    try { curChar = input_stream.readChar(); }
511    catch(java.io.IOException e) { return pos + 1; }
512    return jjMoveNfa_0(state, pos + 1);
513 }
514 static final long[] jjbitVec0 = {
515    0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
516 };
517 private int jjMoveNfa_0(int startState, int curPos)
518 {
519    int startsAt = 0;
520    jjnewStateCnt = 13;
521    int i = 1;
522    jjstateSet[0] = startState;
523    int kind = 0x7fffffff;
524    for (;;)
525    {
526       if (++jjround == 0x7fffffff)
527          ReInitRounds();
528       if (curChar < 64)
529       {
530          long l = 1L << curChar;
531          do
532          {
533             switch(jjstateSet[--i])
534             {
535                case 0:
536                   if ((0x3ff000000000000L & l) != 0L)
537                   {
538                      if (kind > 57)
539                         kind = 57;
540                      { jjCheckNAdd(2); }
541                   }
542                   else if (curChar == 34)
543                      { jjCheckNAddStates(0, 2); }
544                   else if (curChar == 39)
545                      { jjAddStates(3, 4); }
546                   else if (curChar == 36)
547                   {
548                      if (kind > 54)
549                         kind = 54;
550                      { jjCheckNAdd(1); }
551                   }
552                   break;
553                case 1:
554                   if ((0x3ff001000000000L & l) == 0L)
555                      break;
556                   if (kind > 54)
557                      kind = 54;
558                   { jjCheckNAdd(1); }
559                   break;
560                case 2:
561                   if ((0x3ff000000000000L & l) == 0L)
562                      break;
563                   if (kind > 57)
564                      kind = 57;
565                   { jjCheckNAdd(2); }
566                   break;
567                case 3:
568                   if (curChar == 39)
569                      { jjAddStates(3, 4); }
570                   break;
571                case 5:
572                   if ((0x8400000000L & l) != 0L)
573                      { jjCheckNAdd(6); }
574                   break;
575                case 6:
576                   if (curChar == 39 && kind > 58)
577                      kind = 58;
578                   break;
579                case 7:
580                   if ((0xffffff7fffffffffL & l) != 0L)
581                      { jjCheckNAdd(6); }
582                   break;
583                case 8:
584                   if (curChar == 34)
585                      { jjCheckNAddStates(0, 2); }
586                   break;
587                case 10:
588                   if ((0x8400000000L & l) != 0L)
589                      { jjCheckNAddStates(0, 2); }
590                   break;
591                case 11:
592                   if ((0xfffffffbffffffffL & l) != 0L)
593                      { jjCheckNAddStates(0, 2); }
594                   break;
595                case 12:
596                   if (curChar == 34 && kind > 59)
597                      kind = 59;
598                   break;
599                default : break;
600             }
601          } while(i != startsAt);
602       }
603       else if (curChar < 128)
604       {
605          long l = 1L << (curChar & 077);
606          do
607          {
608             switch(jjstateSet[--i])
609             {
610                case 0:
611                case 1:
612                   if ((0x7fffffe87fffffeL & l) == 0L)
613                      break;
614                   if (kind > 54)
615                      kind = 54;
616                   { jjCheckNAdd(1); }
617                   break;
618                case 4:
619                   if (curChar == 92)
620                      jjstateSet[jjnewStateCnt++] = 5;
621                   break;
622                case 5:
623                   if ((0x14404410000000L & l) != 0L)
624                      { jjCheckNAdd(6); }
625                   break;
626                case 7:
627                   if ((0xffffffffefffffffL & l) != 0L)
628                      { jjCheckNAdd(6); }
629                   break;
630                case 9:
631                   if (curChar == 92)
632                      jjstateSet[jjnewStateCnt++] = 10;
633                   break;
634                case 10:
635                   if ((0x14404410000000L & l) != 0L)
636                      { jjCheckNAddStates(0, 2); }
637                   break;
638                case 11:
639                   if ((0xffffffffefffffffL & l) != 0L)
640                      { jjCheckNAddStates(0, 2); }
641                   break;
642                default : break;
643             }
644          } while(i != startsAt);
645       }
646       else
647       {
648          int i2 = (curChar & 0xff) >> 6;
649          long l2 = 1L << (curChar & 077);
650          do
651          {
652             switch(jjstateSet[--i])
653             {
654                case 7:
655                   if ((jjbitVec0[i2] & l2) != 0L)
656                      jjstateSet[jjnewStateCnt++] = 6;
657                   break;
658                case 11:
659                   if ((jjbitVec0[i2] & l2) != 0L)
660                      { jjAddStates(0, 2); }
661                   break;
662                default : break;
663             }
664          } while(i != startsAt);
665       }
666       if (kind != 0x7fffffff)
667       {
668          jjmatchedKind = kind;
669          jjmatchedPos = curPos;
670          kind = 0x7fffffff;
671       }
672       ++curPos;
673       if ((i = jjnewStateCnt) == (startsAt = 13 - (jjnewStateCnt = startsAt)))
674          return curPos;
675       try { curChar = input_stream.readChar(); }
676       catch(java.io.IOException e) { return curPos; }
677    }
678 }
679 private int jjMoveStringLiteralDfa0_1()
680 {
681    return jjMoveNfa_1(0, 0);
682 }
683 private int jjMoveNfa_1(int startState, int curPos)
684 {
685    int startsAt = 0;
686    jjnewStateCnt = 3;
687    int i = 1;
688    jjstateSet[0] = startState;
689    int kind = 0x7fffffff;
690    for (;;)
691    {
692       if (++jjround == 0x7fffffff)
693          ReInitRounds();
694       if (curChar < 64)
695       {
696          long l = 1L << curChar;
697          do
698          {
699             switch(jjstateSet[--i])
700             {
701                case 0:
702                   if ((0x2400L & l) != 0L)
703                   {
704                      if (kind > 7)
705                         kind = 7;
706                   }
707                   if (curChar == 13)
708                      jjstateSet[jjnewStateCnt++] = 1;
709                   break;
710                case 1:
711                   if (curChar == 10 && kind > 7)
712                      kind = 7;
713                   break;
714                case 2:
715                   if (curChar == 13)
716                      jjstateSet[jjnewStateCnt++] = 1;
717                   break;
718                default : break;
719             }
720          } while(i != startsAt);
721       }
722       else if (curChar < 128)
723       {
724          long l = 1L << (curChar & 077);
725          do
726          {
727             switch(jjstateSet[--i])
728             {
729                default : break;
730             }
731          } while(i != startsAt);
732       }
733       else
734       {
735          int i2 = (curChar & 0xff) >> 6;
736          long l2 = 1L << (curChar & 077);
737          do
738          {
739             switch(jjstateSet[--i])
740             {
741                default : break;
742             }
743          } while(i != startsAt);
744       }
745       if (kind != 0x7fffffff)
746       {
747          jjmatchedKind = kind;
748          jjmatchedPos = curPos;
749          kind = 0x7fffffff;
750       }
751       ++curPos;
752       if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
753          return curPos;
754       try { curChar = input_stream.readChar(); }
755       catch(java.io.IOException e) { return curPos; }
756    }
757 }
758 
759 /** Token literal values. */
760 public static final String[] jjstrLiteralImages = {
761 "", null, null, null, null, null, null, null, null, 
762 "\141\142\163\164\162\141\143\164", "\142\157\157\154\145\141\156", "\143\150\141\162", "\143\154\141\163\163", 
763 "\145\154\163\145", "\145\170\164\145\156\144\163", "\146\141\154\163\145", "\151\146", 
764 "\151\155\160\157\162\164", "\151\156\163\164\141\156\143\145\157\146", "\151\156\164", "\156\145\167", 
765 "\156\165\154\154", "\160\141\143\153\141\147\145", "\160\162\151\166\141\164\145", 
766 "\160\162\157\164\145\143\164\145\144", "\160\165\142\154\151\143", "\162\145\164\165\162\156", 
767 "\163\164\141\164\151\143", "\163\165\160\145\162", "\164\150\151\163", "\164\162\165\145", 
768 "\166\157\151\144", "\167\150\151\154\145", "\54", "\56", "\133", "\173", "\50", "\51", "\135", 
769 "\175", "\73", "\75", "\55\55", "\75\75", "\76", "\53\53", "\46\46", "\74\75", "\41", 
770 "\55", "\53", "\53\75", "\52", null, null, null, null, null, null, null, null, };
771 protected Token jjFillToken()
772 {
773    final Token t;
774    final String curTokenImage;
775    final int beginLine;
776    final int endLine;
777    final int beginColumn;
778    final int endColumn;
779    String im = jjstrLiteralImages[jjmatchedKind];
780    curTokenImage = (im == null) ? input_stream.GetImage() : im;
781    beginLine = input_stream.getBeginLine();
782    beginColumn = input_stream.getBeginColumn();
783    endLine = input_stream.getEndLine();
784    endColumn = input_stream.getEndColumn();
785    t = Token.newToken(jjmatchedKind);
786    t.kind = jjmatchedKind;
787    t.image = curTokenImage;
788 
789    t.beginLine = beginLine;
790    t.endLine = endLine;
791    t.beginColumn = beginColumn;
792    t.endColumn = endColumn;
793 
794    return t;
795 }
796 static final int[] jjnextStates = {
797    9, 11, 12, 4, 7, 
798 };
799 
800 int curLexState = 0;
801 int defaultLexState = 0;
802 int jjnewStateCnt;
803 int jjround;
804 int jjmatchedPos;
805 int jjmatchedKind;
806 
807 /** Get the next Token. */
808 public Token getNextToken() 
809 {
810   Token matchedToken;
811   int curPos = 0;
812 
813   EOFLoop :
814   for (;;)
815   {
816    try
817    {
818       curChar = input_stream.BeginToken();
819    }
820    catch(Exception e)
821    {
822       jjmatchedKind = 0;
823       jjmatchedPos = -1;
824       matchedToken = jjFillToken();
825       return matchedToken;
826    }
827 
828    switch(curLexState)
829    {
830      case 0:
831        try { input_stream.backup(0);
832           while (curChar <= 32 && (0x100003600L & (1L << curChar)) != 0L)
833              curChar = input_stream.BeginToken();
834        }
835        catch (java.io.IOException e1) { continue EOFLoop; }
836        jjmatchedKind = 0x7fffffff;
837        jjmatchedPos = 0;
838        curPos = jjMoveStringLiteralDfa0_0();
839        if (jjmatchedPos == 0 && jjmatchedKind > 61)
840        {
841           jjmatchedKind = 61;
842        }
843        break;
844      case 1:
845        jjmatchedKind = 0x7fffffff;
846        jjmatchedPos = 0;
847        curPos = jjMoveStringLiteralDfa0_1();
848        if (jjmatchedPos == 0 && jjmatchedKind > 8)
849        {
850           jjmatchedKind = 8;
851        }
852        break;
853    }
854      if (jjmatchedKind != 0x7fffffff)
855      {
856         if (jjmatchedPos + 1 < curPos)
857            input_stream.backup(curPos - jjmatchedPos - 1);
858         if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
859         {
860            matchedToken = jjFillToken();
861        if (jjnewLexState[jjmatchedKind] != -1)
862          curLexState = jjnewLexState[jjmatchedKind];
863            return matchedToken;
864         }
865         else
866         {
867          if (jjnewLexState[jjmatchedKind] != -1)
868            curLexState = jjnewLexState[jjmatchedKind];
869            continue EOFLoop;
870         }
871      }
872      int error_line = input_stream.getEndLine();
873      int error_column = input_stream.getEndColumn();
874      String error_after = null;
875      boolean EOFSeen = false;
876      try { input_stream.readChar(); input_stream.backup(1); }
877      catch (java.io.IOException e1) {
878         EOFSeen = true;
879         error_after = curPos <= 1 ? "" : input_stream.GetImage();
880         if (curChar == '\n' || curChar == '\r') {
881            error_line++;
882            error_column = 0;
883         }
884         else
885            error_column++;
886      }
887      if (!EOFSeen) {
888         input_stream.backup(1);
889         error_after = curPos <= 1 ? "" : input_stream.GetImage();
890      }
891      throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
892   }
893 }
894 
895 void SkipLexicalActions(Token matchedToken)
896 {
897    switch(jjmatchedKind)
898    {
899       default :
900          break;
901    }
902 }
903 void MoreLexicalActions()
904 {
905    jjimageLen += (lengthOfMatch = jjmatchedPos + 1);
906    switch(jjmatchedKind)
907    {
908       default :
909          break;
910    }
911 }
912 void TokenLexicalActions(Token matchedToken)
913 {
914    switch(jjmatchedKind)
915    {
916       default :
917          break;
918    }
919 }
920 private void jjCheckNAdd(int state)
921 {
922    if (jjrounds[state] != jjround)
923    {
924       jjstateSet[jjnewStateCnt++] = state;
925       jjrounds[state] = jjround;
926    }
927 }
928 private void jjAddStates(int start, int end)
929 {
930    do {
931       jjstateSet[jjnewStateCnt++] = jjnextStates[start];
932    } while (start++ != end);
933 }
934 private void jjCheckNAddTwoStates(int state1, int state2)
935 {
936    jjCheckNAdd(state1);
937    jjCheckNAdd(state2);
938 }
939 
940 private void jjCheckNAddStates(int start, int end)
941 {
942    do {
943       jjCheckNAdd(jjnextStates[start]);
944    } while (start++ != end);
945 }
946 
947     /** Constructor. */
948     public JavaCCParserTokenManager(SimpleCharStream stream){
949 
950       if (SimpleCharStream.staticFlag)
951             throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
952 
953     input_stream = stream;
954   }
955 
956   /** Constructor. */
957   public JavaCCParserTokenManager (SimpleCharStream stream, int lexState){
958     ReInit(stream);
959     SwitchTo(lexState);
960   }
961 
962   /** Reinitialise parser. */
963   
964   public void ReInit(SimpleCharStream stream)
965   {
966 
967 
968     jjmatchedPos =
969     jjnewStateCnt =
970     0;
971     curLexState = defaultLexState;
972     input_stream = stream;
973     ReInitRounds();
974   }
975 
976   private void ReInitRounds()
977   {
978     int i;
979     jjround = 0x80000001;
980     for (i = 13; i-- > 0;)
981       jjrounds[i] = 0x80000000;
982   }
983 
984   /** Reinitialise parser. */
985   public void ReInit(SimpleCharStream stream, int lexState)
986   
987   {
988     ReInit(stream);
989     SwitchTo(lexState);
990   }
991 
992   /** Switch to specified lex state. */
993   public void SwitchTo(int lexState)
994   {
995     if (lexState >= 2 || lexState < 0)
996       throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
997     else
998       curLexState = lexState;
999   }
1000
1001
1002/** Lexer state names. */
1003public static final String[] lexStateNames = {
1004   "DEFAULT",
1005   "IN_SINGLE_LINE_COMMENT",
1006};
1007
1008/** Lex State array. */
1009public static final int[] jjnewLexState = {
1010   -1, -1, -1, -1, -1, -1, 1, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
1011   -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, 
1012   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
1013};
1014static final long[] jjtoToken = {
1015   0x2e7ffffffffffe01L, 
1016};
1017static final long[] jjtoSkip = {
1018   0x1feL, 
1019};
1020static final long[] jjtoSpecial = {
1021   0x0L, 
1022};
1023static final long[] jjtoMore = {
1024   0x0L, 
1025};
1026    protected SimpleCharStream  input_stream;
1027
1028    private final int[] jjrounds = new int[13];
1029    private final int[] jjstateSet = new int[2 * 13];
1030    private final StringBuilder jjimage = new StringBuilder();
1031    private StringBuilder image = jjimage;
1032    private int jjimageLen;
1033    private int lengthOfMatch;
1034    protected int curChar;
1035}
1036