View Javadoc

1   /* Generated By:JJTree&JavaCC: Do not edit this line. JavaParserTokenManager.java */
2   package net.sourceforge.pmd.ast;
3   
4   public class JavaParserTokenManager implements JavaParserConstants
5   {
6     public  java.io.PrintStream debugStream = System.out;
7     public  void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
8   private final int jjStopStringLiteralDfa_0(int pos, long active0, long active1)
9   {
10     switch (pos)
11     {
12        case 0:
13           if ((active1 & 0x40000L) != 0L)
14              return 4;
15           if ((active0 & 0x7ffffffffffff000L) != 0L)
16           {
17              jjmatchedKind = 71;
18              return 28;
19           }
20           if ((active0 & 0x100L) != 0L || (active1 & 0x1002000000000L) != 0L)
21              return 49;
22           return -1;
23        case 1:
24           if ((active0 & 0x201800000L) != 0L)
25              return 28;
26           if ((active0 & 0x7ffffffdfe7ff000L) != 0L)
27           {
28              if (jjmatchedPos != 1)
29              {
30                 jjmatchedKind = 71;
31                 jjmatchedPos = 1;
32              }
33              return 28;
34           }
35           if ((active0 & 0x100L) != 0L)
36              return 54;
37           return -1;
38        case 2:
39           if ((active0 & 0x400026080000000L) != 0L)
40              return 28;
41           if ((active0 & 0x7bfffd9d7f7ff000L) != 0L)
42           {
43              if (jjmatchedPos != 2)
44              {
45                 jjmatchedKind = 71;
46                 jjmatchedPos = 2;
47              }
48              return 28;
49           }
50           return -1;
51        case 3:
52           if ((active0 & 0xa20048102058000L) != 0L)
53              return 28;
54           if ((active0 & 0x71dff95c7d7a7000L) != 0L)
55           {
56              jjmatchedKind = 71;
57              jjmatchedPos = 3;
58              return 28;
59           }
60           return -1;
61        case 4:
62           if ((active0 & 0x20c50000781a4000L) != 0L)
63              return 28;
64           if ((active0 & 0x511af95c05603000L) != 0L)
65           {
66              if (jjmatchedPos != 4)
67              {
68                 jjmatchedKind = 71;
69                 jjmatchedPos = 4;
70              }
71              return 28;
72           }
73           return -1;
74        case 5:
75           if ((active0 & 0x8ac10801000000L) != 0L)
76              return 28;
77           if ((active0 & 0x5110385424603000L) != 0L)
78           {
79              jjmatchedKind = 71;
80              jjmatchedPos = 5;
81              return 28;
82           }
83           return -1;
84        case 6:
85           if ((active0 & 0x5110205400201000L) != 0L)
86           {
87              jjmatchedKind = 71;
88              jjmatchedPos = 6;
89              return 28;
90           }
91           if ((active0 & 0x180024402000L) != 0L)
92              return 28;
93           return -1;
94        case 7:
95           if ((active0 & 0x5000000000201000L) != 0L)
96              return 28;
97           if ((active0 & 0x110205400000000L) != 0L)
98           {
99              jjmatchedKind = 71;
100             jjmatchedPos = 7;
101             return 28;
102          }
103          return -1;
104       case 8:
105          if ((active0 & 0x100204000000000L) != 0L)
106             return 28;
107          if ((active0 & 0x10001400000000L) != 0L)
108          {
109             jjmatchedKind = 71;
110             jjmatchedPos = 8;
111             return 28;
112          }
113          return -1;
114       case 9:
115          if ((active0 & 0x10000000000000L) != 0L)
116          {
117             jjmatchedKind = 71;
118             jjmatchedPos = 9;
119             return 28;
120          }
121          if ((active0 & 0x1400000000L) != 0L)
122             return 28;
123          return -1;
124       case 10:
125          if ((active0 & 0x10000000000000L) != 0L)
126          {
127             jjmatchedKind = 71;
128             jjmatchedPos = 10;
129             return 28;
130          }
131          return -1;
132       default :
133          return -1;
134    }
135 }
136 private final int jjStartNfa_0(int pos, long active0, long active1)
137 {
138    return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0, active1), pos + 1);
139 }
140 private final int jjStopAtPos(int pos, int kind)
141 {
142    jjmatchedKind = kind;
143    jjmatchedPos = pos;
144    return pos + 1;
145 }
146 private final int jjStartNfaWithStates_0(int pos, int kind, int state)
147 {
148    jjmatchedKind = kind;
149    jjmatchedPos = pos;
150    try { curChar = input_stream.readChar(); }
151    catch(java.io.IOException e) { return pos + 1; }
152    return jjMoveNfa_0(state, pos + 1);
153 }
154 private final int jjMoveStringLiteralDfa0_0()
155 {
156    switch(curChar)
157    {
158       case 9:
159          return jjStopAtPos(0, 2);
160       case 10:
161          return jjStopAtPos(0, 3);
162       case 12:
163          return jjStopAtPos(0, 5);
164       case 13:
165          return jjStopAtPos(0, 4);
166       case 26:
167          return jjStopAtPos(0, 120);
168       case 32:
169          return jjStopAtPos(0, 1);
170       case 33:
171          jjmatchedKind = 86;
172          return jjMoveStringLiteralDfa1_0(0x0L, 0x20000000L);
173       case 37:
174          jjmatchedKind = 105;
175          return jjMoveStringLiteralDfa1_0(0x0L, 0x10000000000000L);
176       case 38:
177          jjmatchedKind = 102;
178          return jjMoveStringLiteralDfa1_0(0x0L, 0x2000080000000L);
179       case 40:
180          return jjStopAtPos(0, 74);
181       case 41:
182          return jjStopAtPos(0, 75);
183       case 42:
184          jjmatchedKind = 100;
185          return jjMoveStringLiteralDfa1_0(0x0L, 0x800000000000L);
186       case 43:
187          jjmatchedKind = 98;
188          return jjMoveStringLiteralDfa1_0(0x0L, 0x200100000000L);
189       case 44:
190          return jjStopAtPos(0, 81);
191       case 45:
192          jjmatchedKind = 99;
193          return jjMoveStringLiteralDfa1_0(0x0L, 0x400200000000L);
194       case 46:
195          return jjStartNfaWithStates_0(0, 82, 4);
196       case 47:
197          jjmatchedKind = 101;
198          return jjMoveStringLiteralDfa1_0(0x100L, 0x1000000000000L);
199       case 58:
200          return jjStopAtPos(0, 89);
201       case 59:
202          return jjStopAtPos(0, 80);
203       case 60:
204          jjmatchedKind = 85;
205          return jjMoveStringLiteralDfa1_0(0x0L, 0x20040008000000L);
206       case 61:
207          jjmatchedKind = 83;
208          return jjMoveStringLiteralDfa1_0(0x0L, 0x4000000L);
209       case 62:
210          jjmatchedKind = 84;
211          return jjMoveStringLiteralDfa1_0(0x0L, 0xc0180010000000L);
212       case 63:
213          return jjStopAtPos(0, 88);
214       case 91:
215          return jjStopAtPos(0, 78);
216       case 93:
217          return jjStopAtPos(0, 79);
218       case 94:
219          jjmatchedKind = 104;
220          return jjMoveStringLiteralDfa1_0(0x0L, 0x8000000000000L);
221       case 97:
222          return jjMoveStringLiteralDfa1_0(0x1000L, 0x0L);
223       case 98:
224          return jjMoveStringLiteralDfa1_0(0xe000L, 0x0L);
225       case 99:
226          return jjMoveStringLiteralDfa1_0(0x3f0000L, 0x0L);
227       case 100:
228          return jjMoveStringLiteralDfa1_0(0x1c00000L, 0x0L);
229       case 101:
230          return jjMoveStringLiteralDfa1_0(0x6000000L, 0x0L);
231       case 102:
232          return jjMoveStringLiteralDfa1_0(0xf8000000L, 0x0L);
233       case 103:
234          return jjMoveStringLiteralDfa1_0(0x100000000L, 0x0L);
235       case 105:
236          return jjMoveStringLiteralDfa1_0(0x7e00000000L, 0x0L);
237       case 108:
238          return jjMoveStringLiteralDfa1_0(0x8000000000L, 0x0L);
239       case 110:
240          return jjMoveStringLiteralDfa1_0(0x70000000000L, 0x0L);
241       case 112:
242          return jjMoveStringLiteralDfa1_0(0x780000000000L, 0x0L);
243       case 114:
244          return jjMoveStringLiteralDfa1_0(0x800000000000L, 0x0L);
245       case 115:
246          return jjMoveStringLiteralDfa1_0(0x401f000000000000L, 0x0L);
247       case 116:
248          return jjMoveStringLiteralDfa1_0(0x7e0000000000000L, 0x0L);
249       case 118:
250          return jjMoveStringLiteralDfa1_0(0x1800000000000000L, 0x0L);
251       case 119:
252          return jjMoveStringLiteralDfa1_0(0x2000000000000000L, 0x0L);
253       case 123:
254          return jjStopAtPos(0, 76);
255       case 124:
256          jjmatchedKind = 103;
257          return jjMoveStringLiteralDfa1_0(0x0L, 0x4000040000000L);
258       case 125:
259          return jjStopAtPos(0, 77);
260       case 126:
261          jjmatchedKind = 87;
262          return jjMoveStringLiteralDfa1_0(0x0L, 0x200000000000000L);
263       default :
264          return jjMoveNfa_0(0, 0);
265    }
266 }
267 private final int jjMoveStringLiteralDfa1_0(long active0, long active1)
268 {
269    try { curChar = input_stream.readChar(); }
270    catch(java.io.IOException e) {
271       jjStopStringLiteralDfa_0(0, active0, active1);
272       return 1;
273    }
274    switch(curChar)
275    {
276       case 38:
277          if ((active1 & 0x80000000L) != 0L)
278             return jjStopAtPos(1, 95);
279          break;
280       case 42:
281          if ((active0 & 0x100L) != 0L)
282             return jjStartNfaWithStates_0(1, 8, 54);
283          break;
284       case 43:
285          if ((active1 & 0x100000000L) != 0L)
286             return jjStopAtPos(1, 96);
287          break;
288       case 45:
289          if ((active1 & 0x200000000L) != 0L)
290             return jjStopAtPos(1, 97);
291          break;
292       case 60:
293          if ((active1 & 0x40000000000L) != 0L)
294          {
295             jjmatchedKind = 106;
296             jjmatchedPos = 1;
297          }
298          return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x20000000000000L);
299       case 61:
300          if ((active1 & 0x4000000L) != 0L)
301             return jjStopAtPos(1, 90);
302          else if ((active1 & 0x8000000L) != 0L)
303             return jjStopAtPos(1, 91);
304          else if ((active1 & 0x10000000L) != 0L)
305             return jjStopAtPos(1, 92);
306          else if ((active1 & 0x20000000L) != 0L)
307             return jjStopAtPos(1, 93);
308          else if ((active1 & 0x200000000000L) != 0L)
309             return jjStopAtPos(1, 109);
310          else if ((active1 & 0x400000000000L) != 0L)
311             return jjStopAtPos(1, 110);
312          else if ((active1 & 0x800000000000L) != 0L)
313             return jjStopAtPos(1, 111);
314          else if ((active1 & 0x1000000000000L) != 0L)
315             return jjStopAtPos(1, 112);
316          else if ((active1 & 0x2000000000000L) != 0L)
317             return jjStopAtPos(1, 113);
318          else if ((active1 & 0x4000000000000L) != 0L)
319             return jjStopAtPos(1, 114);
320          else if ((active1 & 0x8000000000000L) != 0L)
321             return jjStopAtPos(1, 115);
322          else if ((active1 & 0x10000000000000L) != 0L)
323             return jjStopAtPos(1, 116);
324          break;
325       case 62:
326          if ((active1 & 0x80000000000L) != 0L)
327          {
328             jjmatchedKind = 107;
329             jjmatchedPos = 1;
330          }
331          return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0xc0100000000000L);
332       case 91:
333          return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x200000000000000L);
334       case 97:
335          return jjMoveStringLiteralDfa2_0(active0, 0x90008030000L, active1, 0L);
336       case 98:
337          return jjMoveStringLiteralDfa2_0(active0, 0x1000L, active1, 0L);
338       case 101:
339          return jjMoveStringLiteralDfa2_0(active0, 0x820000400000L, active1, 0L);
340       case 102:
341          if ((active0 & 0x200000000L) != 0L)
342             return jjStartNfaWithStates_0(1, 33, 28);
343          break;
344       case 104:
345          return jjMoveStringLiteralDfa2_0(active0, 0x20e1000000040000L, active1, 0L);
346       case 105:
347          return jjMoveStringLiteralDfa2_0(active0, 0x30000000L, active1, 0L);
348       case 108:
349          return jjMoveStringLiteralDfa2_0(active0, 0x42080000L, active1, 0L);
350       case 109:
351          return jjMoveStringLiteralDfa2_0(active0, 0xc00000000L, active1, 0L);
352       case 110:
353          return jjMoveStringLiteralDfa2_0(active0, 0x7000000000L, active1, 0L);
354       case 111:
355          if ((active0 & 0x800000L) != 0L)
356          {
357             jjmatchedKind = 23;
358             jjmatchedPos = 1;
359          }
360          return jjMoveStringLiteralDfa2_0(active0, 0x1800008181302000L, active1, 0L);
361       case 114:
362          return jjMoveStringLiteralDfa2_0(active0, 0x700300000004000L, active1, 0L);
363       case 116:
364          return jjMoveStringLiteralDfa2_0(active0, 0x4002000000000000L, active1, 0L);
365       case 117:
366          return jjMoveStringLiteralDfa2_0(active0, 0x4440000000000L, active1, 0L);
367       case 119:
368          return jjMoveStringLiteralDfa2_0(active0, 0x8000000000000L, active1, 0L);
369       case 120:
370          return jjMoveStringLiteralDfa2_0(active0, 0x4000000L, active1, 0L);
371       case 121:
372          return jjMoveStringLiteralDfa2_0(active0, 0x10000000008000L, active1, 0L);
373       case 124:
374          if ((active1 & 0x40000000L) != 0L)
375             return jjStopAtPos(1, 94);
376          break;
377       default :
378          break;
379    }
380    return jjStartNfa_0(0, active0, active1);
381 }
382 private final int jjMoveStringLiteralDfa2_0(long old0, long active0, long old1, long active1)
383 {
384    if (((active0 &= old0) | (active1 &= old1)) == 0L)
385       return jjStartNfa_0(0, old0, old1); 
386    try { curChar = input_stream.readChar(); }
387    catch(java.io.IOException e) {
388       jjStopStringLiteralDfa_0(1, active0, active1);
389       return 2;
390    }
391    switch(curChar)
392    {
393       case 61:
394          if ((active1 & 0x20000000000000L) != 0L)
395             return jjStopAtPos(2, 117);
396          else if ((active1 & 0x40000000000000L) != 0L)
397             return jjStopAtPos(2, 118);
398          break;
399       case 62:
400          if ((active1 & 0x100000000000L) != 0L)
401          {
402             jjmatchedKind = 108;
403             jjmatchedPos = 2;
404          }
405          return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x80000000000000L);
406       case 93:
407          if ((active1 & 0x200000000000000L) != 0L)
408             return jjStopAtPos(2, 121);
409          break;
410       case 97:
411          return jjMoveStringLiteralDfa3_0(active0, 0x1020000000c0000L, active1, 0L);
412       case 98:
413          return jjMoveStringLiteralDfa3_0(active0, 0x400000000000L, active1, 0L);
414       case 99:
415          return jjMoveStringLiteralDfa3_0(active0, 0x80000000000L, active1, 0L);
416       case 101:
417          return jjMoveStringLiteralDfa3_0(active0, 0x4000L, active1, 0L);
418       case 102:
419          return jjMoveStringLiteralDfa3_0(active0, 0x400000L, active1, 0L);
420       case 105:
421          return jjMoveStringLiteralDfa3_0(active0, 0x2828100000000000L, active1, 0L);
422       case 108:
423          return jjMoveStringLiteralDfa3_0(active0, 0x1000040008000000L, active1, 0L);
424       case 110:
425          return jjMoveStringLiteralDfa3_0(active0, 0x10008030300000L, active1, 0L);
426       case 111:
427          return jjMoveStringLiteralDfa3_0(active0, 0x1200040002000L, active1, 0L);
428       case 112:
429          return jjMoveStringLiteralDfa3_0(active0, 0x4000c00000000L, active1, 0L);
430       case 114:
431          if ((active0 & 0x80000000L) != 0L)
432             return jjStartNfaWithStates_0(2, 31, 28);
433          return jjMoveStringLiteralDfa3_0(active0, 0x40c0000000000000L, active1, 0L);
434       case 115:
435          return jjMoveStringLiteralDfa3_0(active0, 0x1002011000L, active1, 0L);
436       case 116:
437          if ((active0 & 0x2000000000L) != 0L)
438          {
439             jjmatchedKind = 37;
440             jjmatchedPos = 2;
441          }
442          return jjMoveStringLiteralDfa3_0(active0, 0x814104028000L, active1, 0L);
443       case 117:
444          return jjMoveStringLiteralDfa3_0(active0, 0x200000001000000L, active1, 0L);
445       case 119:
446          if ((active0 & 0x20000000000L) != 0L)
447             return jjStartNfaWithStates_0(2, 41, 28);
448          break;
449       case 121:
450          if ((active0 & 0x400000000000000L) != 0L)
451             return jjStartNfaWithStates_0(2, 58, 28);
452          break;
453       default :
454          break;
455    }
456    return jjStartNfa_0(1, active0, active1);
457 }
458 private final int jjMoveStringLiteralDfa3_0(long old0, long active0, long old1, long active1)
459 {
460    if (((active0 &= old0) | (active1 &= old1)) == 0L)
461       return jjStartNfa_0(1, old0, old1); 
462    try { curChar = input_stream.readChar(); }
463    catch(java.io.IOException e) {
464       jjStopStringLiteralDfa_0(2, active0, active1);
465       return 3;
466    }
467    switch(curChar)
468    {
469       case 61:
470          if ((active1 & 0x80000000000000L) != 0L)
471             return jjStopAtPos(3, 119);
472          break;
473       case 97:
474          return jjMoveStringLiteralDfa4_0(active0, 0x1000000070404000L, active1, 0L);
475       case 98:
476          return jjMoveStringLiteralDfa4_0(active0, 0x1000000L, active1, 0L);
477       case 99:
478          return jjMoveStringLiteralDfa4_0(active0, 0x10000000020000L, active1, 0L);
479       case 100:
480          if ((active0 & 0x800000000000000L) != 0L)
481             return jjStartNfaWithStates_0(3, 59, 28);
482          break;
483       case 101:
484          if ((active0 & 0x8000L) != 0L)
485             return jjStartNfaWithStates_0(3, 15, 28);
486          else if ((active0 & 0x10000L) != 0L)
487             return jjStartNfaWithStates_0(3, 16, 28);
488          else if ((active0 & 0x2000000L) != 0L)
489             return jjStartNfaWithStates_0(3, 25, 28);
490          else if ((active0 & 0x200000000000000L) != 0L)
491             return jjStartNfaWithStates_0(3, 57, 28);
492          return jjMoveStringLiteralDfa4_0(active0, 0x4004004000000L, active1, 0L);
493       case 103:
494          if ((active0 & 0x8000000000L) != 0L)
495             return jjStartNfaWithStates_0(3, 39, 28);
496          break;
497       case 105:
498          return jjMoveStringLiteralDfa4_0(active0, 0x4000010000000000L, active1, 0L);
499       case 107:
500          return jjMoveStringLiteralDfa4_0(active0, 0x80000000000L, active1, 0L);
501       case 108:
502          if ((active0 & 0x40000000000L) != 0L)
503             return jjStartNfaWithStates_0(3, 42, 28);
504          return jjMoveStringLiteralDfa4_0(active0, 0x2000400400002000L, active1, 0L);
505       case 110:
506          return jjMoveStringLiteralDfa4_0(active0, 0x100000000000000L, active1, 0L);
507       case 111:
508          if ((active0 & 0x100000000L) != 0L)
509             return jjStartNfaWithStates_0(3, 32, 28);
510          return jjMoveStringLiteralDfa4_0(active0, 0xc0000800000000L, active1, 0L);
511       case 114:
512          if ((active0 & 0x40000L) != 0L)
513             return jjStartNfaWithStates_0(3, 18, 28);
514          return jjMoveStringLiteralDfa4_0(active0, 0x1000000000000L, active1, 0L);
515       case 115:
516          if ((active0 & 0x20000000000000L) != 0L)
517             return jjStartNfaWithStates_0(3, 53, 28);
518          return jjMoveStringLiteralDfa4_0(active0, 0x8180000L, active1, 0L);
519       case 116:
520          return jjMoveStringLiteralDfa4_0(active0, 0xa201000201000L, active1, 0L);
521       case 117:
522          return jjMoveStringLiteralDfa4_0(active0, 0x800000000000L, active1, 0L);
523       case 118:
524          return jjMoveStringLiteralDfa4_0(active0, 0x100000000000L, active1, 0L);
525       default :
526          break;
527    }
528    return jjStartNfa_0(2, active0, active1);
529 }
530 private final int jjMoveStringLiteralDfa4_0(long old0, long active0, long old1, long active1)
531 {
532    if (((active0 &= old0) | (active1 &= old1)) == 0L)
533       return jjStartNfa_0(2, old0, old1); 
534    try { curChar = input_stream.readChar(); }
535    catch(java.io.IOException e) {
536       jjStopStringLiteralDfa_0(3, active0, 0L);
537       return 4;
538    }
539    switch(curChar)
540    {
541       case 97:
542          return jjMoveStringLiteralDfa5_0(active0, 0x181000000000L);
543       case 99:
544          return jjMoveStringLiteralDfa5_0(active0, 0x4008000000000000L);
545       case 101:
546          if ((active0 & 0x8000000L) != 0L)
547             return jjStartNfaWithStates_0(4, 27, 28);
548          else if ((active0 & 0x2000000000000000L) != 0L)
549             return jjStartNfaWithStates_0(4, 61, 28);
550          return jjMoveStringLiteralDfa5_0(active0, 0x200400002000L);
551       case 104:
552          if ((active0 & 0x20000L) != 0L)
553             return jjStartNfaWithStates_0(4, 17, 28);
554          return jjMoveStringLiteralDfa5_0(active0, 0x10000000000000L);
555       case 105:
556          return jjMoveStringLiteralDfa5_0(active0, 0x2400000200000L);
557       case 107:
558          if ((active0 & 0x4000L) != 0L)
559             return jjStartNfaWithStates_0(4, 14, 28);
560          break;
561       case 108:
562          if ((active0 & 0x10000000L) != 0L)
563          {
564             jjmatchedKind = 28;
565             jjmatchedPos = 4;
566          }
567          return jjMoveStringLiteralDfa5_0(active0, 0x21000000L);
568       case 110:
569          return jjMoveStringLiteralDfa5_0(active0, 0x4000000L);
570       case 114:
571          if ((active0 & 0x4000000000000L) != 0L)
572             return jjStartNfaWithStates_0(4, 50, 28);
573          return jjMoveStringLiteralDfa5_0(active0, 0x804800001000L);
574       case 115:
575          if ((active0 & 0x80000L) != 0L)
576             return jjStartNfaWithStates_0(4, 19, 28);
577          return jjMoveStringLiteralDfa5_0(active0, 0x100000000000000L);
578       case 116:
579          if ((active0 & 0x100000L) != 0L)
580             return jjStartNfaWithStates_0(4, 20, 28);
581          else if ((active0 & 0x40000000L) != 0L)
582             return jjStartNfaWithStates_0(4, 30, 28);
583          else if ((active0 & 0x1000000000000L) != 0L)
584             return jjStartNfaWithStates_0(4, 48, 28);
585          return jjMoveStringLiteralDfa5_0(active0, 0x1000000000000000L);
586       case 117:
587          return jjMoveStringLiteralDfa5_0(active0, 0x400000L);
588       case 118:
589          return jjMoveStringLiteralDfa5_0(active0, 0x10000000000L);
590       case 119:
591          if ((active0 & 0x40000000000000L) != 0L)
592          {
593             jjmatchedKind = 54;
594             jjmatchedPos = 4;
595          }
596          return jjMoveStringLiteralDfa5_0(active0, 0x80000000000000L);
597       default :
598          break;
599    }
600    return jjStartNfa_0(3, active0, 0L);
601 }
602 private final int jjMoveStringLiteralDfa5_0(long old0, long active0)
603 {
604    if (((active0 &= old0)) == 0L)
605       return jjStartNfa_0(3, old0, 0L);
606    try { curChar = input_stream.readChar(); }
607    catch(java.io.IOException e) {
608       jjStopStringLiteralDfa_0(4, active0, 0L);
609       return 5;
610    }
611    switch(curChar)
612    {
613       case 97:
614          return jjMoveStringLiteralDfa6_0(active0, 0x3000L);
615       case 99:
616          if ((active0 & 0x400000000000L) != 0L)
617             return jjStartNfaWithStates_0(5, 46, 28);
618          else if ((active0 & 0x2000000000000L) != 0L)
619             return jjStartNfaWithStates_0(5, 49, 28);
620          return jjMoveStringLiteralDfa6_0(active0, 0x200000000000L);
621       case 100:
622          return jjMoveStringLiteralDfa6_0(active0, 0x4000000L);
623       case 101:
624          if ((active0 & 0x1000000L) != 0L)
625             return jjStartNfaWithStates_0(5, 24, 28);
626          else if ((active0 & 0x10000000000L) != 0L)
627             return jjStartNfaWithStates_0(5, 40, 28);
628          break;
629       case 102:
630          return jjMoveStringLiteralDfa6_0(active0, 0x4000000000L);
631       case 103:
632          return jjMoveStringLiteralDfa6_0(active0, 0x80000000000L);
633       case 104:
634          if ((active0 & 0x8000000000000L) != 0L)
635             return jjStartNfaWithStates_0(5, 51, 28);
636          break;
637       case 105:
638          return jjMoveStringLiteralDfa6_0(active0, 0x1100000000000000L);
639       case 108:
640          return jjMoveStringLiteralDfa6_0(active0, 0x20400000L);
641       case 109:
642          return jjMoveStringLiteralDfa6_0(active0, 0x400000000L);
643       case 110:
644          if ((active0 & 0x800000000000L) != 0L)
645             return jjStartNfaWithStates_0(5, 47, 28);
646          return jjMoveStringLiteralDfa6_0(active0, 0x1000200000L);
647       case 114:
648          return jjMoveStringLiteralDfa6_0(active0, 0x10000000000000L);
649       case 115:
650          if ((active0 & 0x80000000000000L) != 0L)
651             return jjStartNfaWithStates_0(5, 55, 28);
652          break;
653       case 116:
654          if ((active0 & 0x800000000L) != 0L)
655             return jjStartNfaWithStates_0(5, 35, 28);
656          return jjMoveStringLiteralDfa6_0(active0, 0x4000100000000000L);
657       default :
658          break;
659    }
660    return jjStartNfa_0(4, active0, 0L);
661 }
662 private final int jjMoveStringLiteralDfa6_0(long old0, long active0)
663 {
664    if (((active0 &= old0)) == 0L)
665       return jjStartNfa_0(4, old0, 0L);
666    try { curChar = input_stream.readChar(); }
667    catch(java.io.IOException e) {
668       jjStopStringLiteralDfa_0(5, active0, 0L);
669       return 6;
670    }
671    switch(curChar)
672    {
673       case 97:
674          return jjMoveStringLiteralDfa7_0(active0, 0x4000000000L);
675       case 99:
676          return jjMoveStringLiteralDfa7_0(active0, 0x1000001000L);
677       case 101:
678          if ((active0 & 0x80000000000L) != 0L)
679             return jjStartNfaWithStates_0(6, 43, 28);
680          else if ((active0 & 0x100000000000L) != 0L)
681             return jjStartNfaWithStates_0(6, 44, 28);
682          return jjMoveStringLiteralDfa7_0(active0, 0x100000400000000L);
683       case 102:
684          return jjMoveStringLiteralDfa7_0(active0, 0x4000000000000000L);
685       case 108:
686          return jjMoveStringLiteralDfa7_0(active0, 0x1000000000000000L);
687       case 110:
688          if ((active0 & 0x2000L) != 0L)
689             return jjStartNfaWithStates_0(6, 13, 28);
690          break;
691       case 111:
692          return jjMoveStringLiteralDfa7_0(active0, 0x10000000000000L);
693       case 115:
694          if ((active0 & 0x4000000L) != 0L)
695             return jjStartNfaWithStates_0(6, 26, 28);
696          break;
697       case 116:
698          if ((active0 & 0x400000L) != 0L)
699             return jjStartNfaWithStates_0(6, 22, 28);
700          return jjMoveStringLiteralDfa7_0(active0, 0x200000000000L);
701       case 117:
702          return jjMoveStringLiteralDfa7_0(active0, 0x200000L);
703       case 121:
704          if ((active0 & 0x20000000L) != 0L)
705             return jjStartNfaWithStates_0(6, 29, 28);
706          break;
707       default :
708          break;
709    }
710    return jjStartNfa_0(5, active0, 0L);
711 }
712 private final int jjMoveStringLiteralDfa7_0(long old0, long active0)
713 {
714    if (((active0 &= old0)) == 0L)
715       return jjStartNfa_0(5, old0, 0L);
716    try { curChar = input_stream.readChar(); }
717    catch(java.io.IOException e) {
718       jjStopStringLiteralDfa_0(6, active0, 0L);
719       return 7;
720    }
721    switch(curChar)
722    {
723       case 99:
724          return jjMoveStringLiteralDfa8_0(active0, 0x4000000000L);
725       case 101:
726          if ((active0 & 0x200000L) != 0L)
727             return jjStartNfaWithStates_0(7, 21, 28);
728          else if ((active0 & 0x1000000000000000L) != 0L)
729             return jjStartNfaWithStates_0(7, 60, 28);
730          return jjMoveStringLiteralDfa8_0(active0, 0x201000000000L);
731       case 110:
732          return jjMoveStringLiteralDfa8_0(active0, 0x110000400000000L);
733       case 112:
734          if ((active0 & 0x4000000000000000L) != 0L)
735             return jjStartNfaWithStates_0(7, 62, 28);
736          break;
737       case 116:
738          if ((active0 & 0x1000L) != 0L)
739             return jjStartNfaWithStates_0(7, 12, 28);
740          break;
741       default :
742          break;
743    }
744    return jjStartNfa_0(6, active0, 0L);
745 }
746 private final int jjMoveStringLiteralDfa8_0(long old0, long active0)
747 {
748    if (((active0 &= old0)) == 0L)
749       return jjStartNfa_0(6, old0, 0L);
750    try { curChar = input_stream.readChar(); }
751    catch(java.io.IOException e) {
752       jjStopStringLiteralDfa_0(7, active0, 0L);
753       return 8;
754    }
755    switch(curChar)
756    {
757       case 100:
758          if ((active0 & 0x200000000000L) != 0L)
759             return jjStartNfaWithStates_0(8, 45, 28);
760          break;
761       case 101:
762          if ((active0 & 0x4000000000L) != 0L)
763             return jjStartNfaWithStates_0(8, 38, 28);
764          break;
765       case 105:
766          return jjMoveStringLiteralDfa9_0(active0, 0x10000000000000L);
767       case 111:
768          return jjMoveStringLiteralDfa9_0(active0, 0x1000000000L);
769       case 116:
770          if ((active0 & 0x100000000000000L) != 0L)
771             return jjStartNfaWithStates_0(8, 56, 28);
772          return jjMoveStringLiteralDfa9_0(active0, 0x400000000L);
773       default :
774          break;
775    }
776    return jjStartNfa_0(7, active0, 0L);
777 }
778 private final int jjMoveStringLiteralDfa9_0(long old0, long active0)
779 {
780    if (((active0 &= old0)) == 0L)
781       return jjStartNfa_0(7, old0, 0L);
782    try { curChar = input_stream.readChar(); }
783    catch(java.io.IOException e) {
784       jjStopStringLiteralDfa_0(8, active0, 0L);
785       return 9;
786    }
787    switch(curChar)
788    {
789       case 102:
790          if ((active0 & 0x1000000000L) != 0L)
791             return jjStartNfaWithStates_0(9, 36, 28);
792          break;
793       case 115:
794          if ((active0 & 0x400000000L) != 0L)
795             return jjStartNfaWithStates_0(9, 34, 28);
796          break;
797       case 122:
798          return jjMoveStringLiteralDfa10_0(active0, 0x10000000000000L);
799       default :
800          break;
801    }
802    return jjStartNfa_0(8, active0, 0L);
803 }
804 private final int jjMoveStringLiteralDfa10_0(long old0, long active0)
805 {
806    if (((active0 &= old0)) == 0L)
807       return jjStartNfa_0(8, old0, 0L);
808    try { curChar = input_stream.readChar(); }
809    catch(java.io.IOException e) {
810       jjStopStringLiteralDfa_0(9, active0, 0L);
811       return 10;
812    }
813    switch(curChar)
814    {
815       case 101:
816          return jjMoveStringLiteralDfa11_0(active0, 0x10000000000000L);
817       default :
818          break;
819    }
820    return jjStartNfa_0(9, active0, 0L);
821 }
822 private final int jjMoveStringLiteralDfa11_0(long old0, long active0)
823 {
824    if (((active0 &= old0)) == 0L)
825       return jjStartNfa_0(9, old0, 0L);
826    try { curChar = input_stream.readChar(); }
827    catch(java.io.IOException e) {
828       jjStopStringLiteralDfa_0(10, active0, 0L);
829       return 11;
830    }
831    switch(curChar)
832    {
833       case 100:
834          if ((active0 & 0x10000000000000L) != 0L)
835             return jjStartNfaWithStates_0(11, 52, 28);
836          break;
837       default :
838          break;
839    }
840    return jjStartNfa_0(10, active0, 0L);
841 }
842 private final void jjCheckNAdd(int state)
843 {
844    if (jjrounds[state] != jjround)
845    {
846       jjstateSet[jjnewStateCnt++] = state;
847       jjrounds[state] = jjround;
848    }
849 }
850 private final void jjAddStates(int start, int end)
851 {
852    do {
853       jjstateSet[jjnewStateCnt++] = jjnextStates[start];
854    } while (start++ != end);
855 }
856 private final void jjCheckNAddTwoStates(int state1, int state2)
857 {
858    jjCheckNAdd(state1);
859    jjCheckNAdd(state2);
860 }
861 private final void jjCheckNAddStates(int start, int end)
862 {
863    do {
864       jjCheckNAdd(jjnextStates[start]);
865    } while (start++ != end);
866 }
867 private final void jjCheckNAddStates(int start)
868 {
869    jjCheckNAdd(jjnextStates[start]);
870    jjCheckNAdd(jjnextStates[start + 1]);
871 }
872 static final long[] jjbitVec0 = {
873    0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
874 };
875 static final long[] jjbitVec2 = {
876    0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
877 };
878 static final long[] jjbitVec3 = {
879    0x1ff00000fffffffeL, 0xffffffffffffc000L, 0xffffffffL, 0x600000000000000L
880 };
881 static final long[] jjbitVec4 = {
882    0x0L, 0x0L, 0x0L, 0xff7fffffff7fffffL
883 };
884 static final long[] jjbitVec5 = {
885    0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
886 };
887 static final long[] jjbitVec6 = {
888    0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffL, 0x0L
889 };
890 static final long[] jjbitVec7 = {
891    0xffffffffffffffffL, 0xffffffffffffffffL, 0x0L, 0x0L
892 };
893 static final long[] jjbitVec8 = {
894    0x3fffffffffffL, 0x0L, 0x0L, 0x0L
895 };
896 private final int jjMoveNfa_0(int startState, int curPos)
897 {
898    int[] nextStates;
899    int startsAt = 0;
900    jjnewStateCnt = 57;
901    int i = 1;
902    jjstateSet[0] = startState;
903    int j, kind = 0x7fffffff;
904    for (;;)
905    {
906       if (++jjround == 0x7fffffff)
907          ReInitRounds();
908       if (curChar < 64)
909       {
910          long l = 1L << curChar;
911          MatchLoop: do
912          {
913             switch(jjstateSet[--i])
914             {
915                case 49:
916                   if (curChar == 42)
917                      jjstateSet[jjnewStateCnt++] = 54;
918                   else if (curChar == 47)
919                   {
920                      if (kind > 6)
921                         kind = 6;
922                      jjCheckNAddStates(0, 2);
923                   }
924                   break;
925                case 0:
926                   if ((0x3ff000000000000L & l) != 0L)
927                      jjCheckNAddStates(3, 9);
928                   else if (curChar == 47)
929                      jjAddStates(10, 11);
930                   else if (curChar == 36)
931                   {
932                      if (kind > 71)
933                         kind = 71;
934                      jjCheckNAdd(28);
935                   }
936                   else if (curChar == 34)
937                      jjCheckNAddStates(12, 14);
938                   else if (curChar == 39)
939                      jjAddStates(15, 16);
940                   else if (curChar == 46)
941                      jjCheckNAdd(4);
942                   if ((0x3fe000000000000L & l) != 0L)
943                   {
944                      if (kind > 63)
945                         kind = 63;
946                      jjCheckNAddTwoStates(1, 2);
947                   }
948                   else if (curChar == 48)
949                   {
950                      if (kind > 63)
951                         kind = 63;
952                      jjCheckNAddStates(17, 19);
953                   }
954                   break;
955                case 1:
956                   if ((0x3ff000000000000L & l) == 0L)
957                      break;
958                   if (kind > 63)
959                      kind = 63;
960                   jjCheckNAddTwoStates(1, 2);
961                   break;
962                case 3:
963                   if (curChar == 46)
964                      jjCheckNAdd(4);
965                   break;
966                case 4:
967                   if ((0x3ff000000000000L & l) == 0L)
968                      break;
969                   if (kind > 67)
970                      kind = 67;
971                   jjCheckNAddStates(20, 22);
972                   break;
973                case 6:
974                   if ((0x280000000000L & l) != 0L)
975                      jjCheckNAdd(7);
976                   break;
977                case 7:
978                   if ((0x3ff000000000000L & l) == 0L)
979                      break;
980                   if (kind > 67)
981                      kind = 67;
982                   jjCheckNAddTwoStates(7, 8);
983                   break;
984                case 9:
985                   if (curChar == 39)
986                      jjAddStates(15, 16);
987                   break;
988                case 10:
989                   if ((0xffffff7fffffdbffL & l) != 0L)
990                      jjCheckNAdd(11);
991                   break;
992                case 11:
993                   if (curChar == 39 && kind > 69)
994                      kind = 69;
995                   break;
996                case 13:
997                   if ((0x8400000000L & l) != 0L)
998                      jjCheckNAdd(11);
999                   break;
1000                case 14:
1001                   if ((0xff000000000000L & l) != 0L)
1002                      jjCheckNAddTwoStates(15, 11);
1003                   break;
1004                case 15:
1005                   if ((0xff000000000000L & l) != 0L)
1006                      jjCheckNAdd(11);
1007                   break;
1008                case 16:
1009                   if ((0xf000000000000L & l) != 0L)
1010                      jjstateSet[jjnewStateCnt++] = 17;
1011                   break;
1012                case 17:
1013                   if ((0xff000000000000L & l) != 0L)
1014                      jjCheckNAdd(15);
1015                   break;
1016                case 18:
1017                   if (curChar == 34)
1018                      jjCheckNAddStates(12, 14);
1019                   break;
1020                case 19:
1021                   if ((0xfffffffbffffdbffL & l) != 0L)
1022                      jjCheckNAddStates(12, 14);
1023                   break;
1024                case 21:
1025                   if ((0x8400000000L & l) != 0L)
1026                      jjCheckNAddStates(12, 14);
1027                   break;
1028                case 22:
1029                   if (curChar == 34 && kind > 70)
1030                      kind = 70;
1031                   break;
1032                case 23:
1033                   if ((0xff000000000000L & l) != 0L)
1034                      jjCheckNAddStates(23, 26);
1035                   break;
1036                case 24:
1037                   if ((0xff000000000000L & l) != 0L)
1038                      jjCheckNAddStates(12, 14);
1039                   break;
1040                case 25:
1041                   if ((0xf000000000000L & l) != 0L)
1042                      jjstateSet[jjnewStateCnt++] = 26;
1043                   break;
1044                case 26:
1045                   if ((0xff000000000000L & l) != 0L)
1046                      jjCheckNAdd(24);
1047                   break;
1048                case 27:
1049                   if (curChar != 36)
1050                      break;
1051                   if (kind > 71)
1052                      kind = 71;
1053                   jjCheckNAdd(28);
1054                   break;
1055                case 28:
1056                   if ((0x3ff001000000000L & l) == 0L)
1057                      break;
1058                   if (kind > 71)
1059                      kind = 71;
1060                   jjCheckNAdd(28);
1061                   break;
1062                case 29:
1063                   if ((0x3ff000000000000L & l) != 0L)
1064                      jjCheckNAddStates(3, 9);
1065                   break;
1066                case 30:
1067                   if ((0x3ff000000000000L & l) != 0L)
1068                      jjCheckNAddTwoStates(30, 31);
1069                   break;
1070                case 31:
1071                   if (curChar != 46)
1072                      break;
1073                   if (kind > 67)
1074                      kind = 67;
1075                   jjCheckNAddStates(27, 29);
1076                   break;
1077                case 32:
1078                   if ((0x3ff000000000000L & l) == 0L)
1079                      break;
1080                   if (kind > 67)
1081                      kind = 67;
1082                   jjCheckNAddStates(27, 29);
1083                   break;
1084                case 34:
1085                   if ((0x280000000000L & l) != 0L)
1086                      jjCheckNAdd(35);
1087                   break;
1088                case 35:
1089                   if ((0x3ff000000000000L & l) == 0L)
1090                      break;
1091                   if (kind > 67)
1092                      kind = 67;
1093                   jjCheckNAddTwoStates(35, 8);
1094                   break;
1095                case 36:
1096                   if ((0x3ff000000000000L & l) != 0L)
1097                      jjCheckNAddTwoStates(36, 37);
1098                   break;
1099                case 38:
1100                   if ((0x280000000000L & l) != 0L)
1101                      jjCheckNAdd(39);
1102                   break;
1103                case 39:
1104                   if ((0x3ff000000000000L & l) == 0L)
1105                      break;
1106                   if (kind > 67)
1107                      kind = 67;
1108                   jjCheckNAddTwoStates(39, 8);
1109                   break;
1110                case 40:
1111                   if ((0x3ff000000000000L & l) != 0L)
1112                      jjCheckNAddStates(30, 32);
1113                   break;
1114                case 42:
1115                   if ((0x280000000000L & l) != 0L)
1116                      jjCheckNAdd(43);
1117                   break;
1118                case 43:
1119                   if ((0x3ff000000000000L & l) != 0L)
1120                      jjCheckNAddTwoStates(43, 8);
1121                   break;
1122                case 44:
1123                   if (curChar != 48)
1124                      break;
1125                   if (kind > 63)
1126                      kind = 63;
1127                   jjCheckNAddStates(17, 19);
1128                   break;
1129                case 46:
1130                   if ((0x3ff000000000000L & l) == 0L)
1131                      break;
1132                   if (kind > 63)
1133                      kind = 63;
1134                   jjCheckNAddTwoStates(46, 2);
1135                   break;
1136                case 47:
1137                   if ((0xff000000000000L & l) == 0L)
1138                      break;
1139                   if (kind > 63)
1140                      kind = 63;
1141                   jjCheckNAddTwoStates(47, 2);
1142                   break;
1143                case 48:
1144                   if (curChar == 47)
1145                      jjAddStates(10, 11);
1146                   break;
1147                case 50:
1148                   if ((0xffffffffffffdbffL & l) == 0L)
1149                      break;
1150                   if (kind > 6)
1151                      kind = 6;
1152                   jjCheckNAddStates(0, 2);
1153                   break;
1154                case 51:
1155                   if ((0x2400L & l) != 0L && kind > 6)
1156                      kind = 6;
1157                   break;
1158                case 52:
1159                   if (curChar == 10 && kind > 6)
1160                      kind = 6;
1161                   break;
1162                case 53:
1163                   if (curChar == 13)
1164                      jjstateSet[jjnewStateCnt++] = 52;
1165                   break;
1166                case 54:
1167                   if (curChar == 42)
1168                      jjstateSet[jjnewStateCnt++] = 55;
1169                   break;
1170                case 55:
1171                   if ((0xffff7fffffffffffL & l) != 0L && kind > 7)
1172                      kind = 7;
1173                   break;
1174                case 56:
1175                   if (curChar == 42)
1176                      jjstateSet[jjnewStateCnt++] = 54;
1177                   break;
1178                default : break;
1179             }
1180          } while(i != startsAt);
1181       }
1182       else if (curChar < 128)
1183       {
1184          long l = 1L << (curChar & 077);
1185          MatchLoop: do
1186          {
1187             switch(jjstateSet[--i])
1188             {
1189                case 0:
1190                case 28:
1191                   if ((0x7fffffe87fffffeL & l) == 0L)
1192                      break;
1193                   if (kind > 71)
1194                      kind = 71;
1195                   jjCheckNAdd(28);
1196                   break;
1197                case 2:
1198                   if ((0x100000001000L & l) != 0L && kind > 63)
1199                      kind = 63;
1200                   break;
1201                case 5:
1202                   if ((0x2000000020L & l) != 0L)
1203                      jjAddStates(33, 34);
1204                   break;
1205                case 8:
1206                   if ((0x5000000050L & l) != 0L && kind > 67)
1207                      kind = 67;
1208                   break;
1209                case 10:
1210                   if ((0xffffffffefffffffL & l) != 0L)
1211                      jjCheckNAdd(11);
1212                   break;
1213                case 12:
1214                   if (curChar == 92)
1215                      jjAddStates(35, 37);
1216                   break;
1217                case 13:
1218                   if ((0x14404410000000L & l) != 0L)
1219                      jjCheckNAdd(11);
1220                   break;
1221                case 19:
1222                   if ((0xffffffffefffffffL & l) != 0L)
1223                      jjCheckNAddStates(12, 14);
1224                   break;
1225                case 20:
1226                   if (curChar == 92)
1227                      jjAddStates(38, 40);
1228                   break;
1229                case 21:
1230                   if ((0x14404410000000L & l) != 0L)
1231                      jjCheckNAddStates(12, 14);
1232                   break;
1233                case 33:
1234                   if ((0x2000000020L & l) != 0L)
1235                      jjAddStates(41, 42);
1236                   break;
1237                case 37:
1238                   if ((0x2000000020L & l) != 0L)
1239                      jjAddStates(43, 44);
1240                   break;
1241                case 41:
1242                   if ((0x2000000020L & l) != 0L)
1243                      jjAddStates(45, 46);
1244                   break;
1245                case 45:
1246                   if ((0x100000001000000L & l) != 0L)
1247                      jjCheckNAdd(46);
1248                   break;
1249                case 46:
1250                   if ((0x7e0000007eL & l) == 0L)
1251                      break;
1252                   if (kind > 63)
1253                      kind = 63;
1254                   jjCheckNAddTwoStates(46, 2);
1255                   break;
1256                case 50:
1257                   if (kind > 6)
1258                      kind = 6;
1259                   jjAddStates(0, 2);
1260                   break;
1261                case 55:
1262                   if (kind > 7)
1263                      kind = 7;
1264                   break;
1265                default : break;
1266             }
1267          } while(i != startsAt);
1268       }
1269       else
1270       {
1271          int hiByte = (int)(curChar >> 8);
1272          int i1 = hiByte >> 6;
1273          long l1 = 1L << (hiByte & 077);
1274          int i2 = (curChar & 0xff) >> 6;
1275          long l2 = 1L << (curChar & 077);
1276          MatchLoop: do
1277          {
1278             switch(jjstateSet[--i])
1279             {
1280                case 0:
1281                case 28:
1282                   if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
1283                      break;
1284                   if (kind > 71)
1285                      kind = 71;
1286                   jjCheckNAdd(28);
1287                   break;
1288                case 10:
1289                   if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1290                      jjstateSet[jjnewStateCnt++] = 11;
1291                   break;
1292                case 19:
1293                   if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1294                      jjAddStates(12, 14);
1295                   break;
1296                case 50:
1297                   if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
1298                      break;
1299                   if (kind > 6)
1300                      kind = 6;
1301                   jjAddStates(0, 2);
1302                   break;
1303                case 55:
1304                   if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 7)
1305                      kind = 7;
1306                   break;
1307                default : break;
1308             }
1309          } while(i != startsAt);
1310       }
1311       if (kind != 0x7fffffff)
1312       {
1313          jjmatchedKind = kind;
1314          jjmatchedPos = curPos;
1315          kind = 0x7fffffff;
1316       }
1317       ++curPos;
1318       if ((i = jjnewStateCnt) == (startsAt = 57 - (jjnewStateCnt = startsAt)))
1319          return curPos;
1320       try { curChar = input_stream.readChar(); }
1321       catch(java.io.IOException e) { return curPos; }
1322    }
1323 }
1324 private final int jjMoveStringLiteralDfa0_2()
1325 {
1326    switch(curChar)
1327    {
1328       case 42:
1329          return jjMoveStringLiteralDfa1_2(0x400L);
1330       default :
1331          return 1;
1332    }
1333 }
1334 private final int jjMoveStringLiteralDfa1_2(long active0)
1335 {
1336    try { curChar = input_stream.readChar(); }
1337    catch(java.io.IOException e) {
1338       return 1;
1339    }
1340    switch(curChar)
1341    {
1342       case 47:
1343          if ((active0 & 0x400L) != 0L)
1344             return jjStopAtPos(1, 10);
1345          break;
1346       default :
1347          return 2;
1348    }
1349    return 2;
1350 }
1351 private final int jjMoveStringLiteralDfa0_1()
1352 {
1353    switch(curChar)
1354    {
1355       case 42:
1356          return jjMoveStringLiteralDfa1_1(0x200L);
1357       default :
1358          return 1;
1359    }
1360 }
1361 private final int jjMoveStringLiteralDfa1_1(long active0)
1362 {
1363    try { curChar = input_stream.readChar(); }
1364    catch(java.io.IOException e) {
1365       return 1;
1366    }
1367    switch(curChar)
1368    {
1369       case 47:
1370          if ((active0 & 0x200L) != 0L)
1371             return jjStopAtPos(1, 9);
1372          break;
1373       default :
1374          return 2;
1375    }
1376    return 2;
1377 }
1378 static final int[] jjnextStates = {
1379    50, 51, 53, 30, 31, 36, 37, 40, 41, 8, 49, 56, 19, 20, 22, 10, 
1380    12, 45, 47, 2, 4, 5, 8, 19, 20, 24, 22, 32, 33, 8, 40, 41, 
1381    8, 6, 7, 13, 14, 16, 21, 23, 25, 34, 35, 38, 39, 42, 43, 
1382 };
1383 private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2)
1384 {
1385    switch(hiByte)
1386    {
1387       case 0:
1388          return ((jjbitVec2[i2] & l2) != 0L);
1389       default : 
1390          if ((jjbitVec0[i1] & l1) != 0L)
1391             return true;
1392          return false;
1393    }
1394 }
1395 private static final boolean jjCanMove_1(int hiByte, int i1, int i2, long l1, long l2)
1396 {
1397    switch(hiByte)
1398    {
1399       case 0:
1400          return ((jjbitVec4[i2] & l2) != 0L);
1401       case 48:
1402          return ((jjbitVec5[i2] & l2) != 0L);
1403       case 49:
1404          return ((jjbitVec6[i2] & l2) != 0L);
1405       case 51:
1406          return ((jjbitVec7[i2] & l2) != 0L);
1407       case 61:
1408          return ((jjbitVec8[i2] & l2) != 0L);
1409       default : 
1410          if ((jjbitVec3[i1] & l1) != 0L)
1411             return true;
1412          return false;
1413    }
1414 }
1415 public static final String[] jjstrLiteralImages = {
1416 "", null, null, null, null, null, null, null, null, null, null, null, 
1417 "\141\142\163\164\162\141\143\164", "\142\157\157\154\145\141\156", "\142\162\145\141\153", "\142\171\164\145", 
1418 "\143\141\163\145", "\143\141\164\143\150", "\143\150\141\162", "\143\154\141\163\163", 
1419 "\143\157\156\163\164", "\143\157\156\164\151\156\165\145", "\144\145\146\141\165\154\164", 
1420 "\144\157", "\144\157\165\142\154\145", "\145\154\163\145", 
1421 "\145\170\164\145\156\144\163", "\146\141\154\163\145", "\146\151\156\141\154", 
1422 "\146\151\156\141\154\154\171", "\146\154\157\141\164", "\146\157\162", "\147\157\164\157", "\151\146", 
1423 "\151\155\160\154\145\155\145\156\164\163", "\151\155\160\157\162\164", "\151\156\163\164\141\156\143\145\157\146", 
1424 "\151\156\164", "\151\156\164\145\162\146\141\143\145", "\154\157\156\147", 
1425 "\156\141\164\151\166\145", "\156\145\167", "\156\165\154\154", "\160\141\143\153\141\147\145", 
1426 "\160\162\151\166\141\164\145", "\160\162\157\164\145\143\164\145\144", "\160\165\142\154\151\143", 
1427 "\162\145\164\165\162\156", "\163\150\157\162\164", "\163\164\141\164\151\143", "\163\165\160\145\162", 
1428 "\163\167\151\164\143\150", "\163\171\156\143\150\162\157\156\151\172\145\144", "\164\150\151\163", 
1429 "\164\150\162\157\167", "\164\150\162\157\167\163", "\164\162\141\156\163\151\145\156\164", 
1430 "\164\162\165\145", "\164\162\171", "\166\157\151\144", "\166\157\154\141\164\151\154\145", 
1431 "\167\150\151\154\145", "\163\164\162\151\143\164\146\160", null, null, null, null, null, null, null, 
1432 null, null, null, null, "\50", "\51", "\173", "\175", "\133", "\135", "\73", "\54", 
1433 "\56", "\75", "\76", "\74", "\41", "\176", "\77", "\72", "\75\75", "\74\75", 
1434 "\76\75", "\41\75", "\174\174", "\46\46", "\53\53", "\55\55", "\53", "\55", "\52", 
1435 "\57", "\46", "\174", "\136", "\45", "\74\74", "\76\76", "\76\76\76", "\53\75", 
1436 "\55\75", "\52\75", "\57\75", "\46\75", "\174\75", "\136\75", "\45\75", "\74\74\75", 
1437 "\76\76\75", "\76\76\76\75", "\32", "\176\133\135", };
1438 public static final String[] lexStateNames = {
1439    "DEFAULT", 
1440    "IN_FORMAL_COMMENT", 
1441    "IN_MULTI_LINE_COMMENT", 
1442 };
1443 public static final int[] jjnewLexState = {
1444    -1, -1, -1, -1, -1, -1, -1, 1, 2, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
1445    -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, 
1446    -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, 
1447    -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, 
1448    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
1449 };
1450 static final long[] jjtoToken = {
1451    0xfffffffffffff001L, 0x3fffffffffffce8L, 
1452 };
1453 static final long[] jjtoSkip = {
1454    0x67eL, 0x0L, 
1455 };
1456 static final long[] jjtoSpecial = {
1457    0x67eL, 0x0L, 
1458 };
1459 static final long[] jjtoMore = {
1460    0x980L, 0x0L, 
1461 };
1462 protected CharStream input_stream;
1463 private final int[] jjrounds = new int[57];
1464 private final int[] jjstateSet = new int[114];
1465 StringBuffer image;
1466 int jjimageLen;
1467 int lengthOfMatch;
1468 protected char curChar;
1469 public JavaParserTokenManager(CharStream stream)
1470 {
1471    input_stream = stream;
1472 }
1473 public JavaParserTokenManager(CharStream stream, int lexState)
1474 {
1475    this(stream);
1476    SwitchTo(lexState);
1477 }
1478 public void ReInit(CharStream stream)
1479 {
1480    jjmatchedPos = jjnewStateCnt = 0;
1481    curLexState = defaultLexState;
1482    input_stream = stream;
1483    ReInitRounds();
1484 }
1485 private final void ReInitRounds()
1486 {
1487    int i;
1488    jjround = 0x80000001;
1489    for (i = 57; i-- > 0;)
1490       jjrounds[i] = 0x80000000;
1491 }
1492 public void ReInit(CharStream stream, int lexState)
1493 {
1494    ReInit(stream);
1495    SwitchTo(lexState);
1496 }
1497 public void SwitchTo(int lexState)
1498 {
1499    if (lexState >= 3 || lexState < 0)
1500       throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
1501    else
1502       curLexState = lexState;
1503 }
1504 
1505 protected Token jjFillToken()
1506 {
1507    Token t = Token.newToken(jjmatchedKind);
1508    t.kind = jjmatchedKind;
1509    String im = jjstrLiteralImages[jjmatchedKind];
1510    t.image = (im == null) ? input_stream.GetImage() : im;
1511    t.beginLine = input_stream.getBeginLine();
1512    t.beginColumn = input_stream.getBeginColumn();
1513    t.endLine = input_stream.getEndLine();
1514    t.endColumn = input_stream.getEndColumn();
1515    return t;
1516 }
1517 
1518 int curLexState = 0;
1519 int defaultLexState = 0;
1520 int jjnewStateCnt;
1521 int jjround;
1522 int jjmatchedPos;
1523 int jjmatchedKind;
1524 
1525 public Token getNextToken() 
1526 {
1527   int kind;
1528   Token specialToken = null;
1529   Token matchedToken;
1530   int curPos = 0;
1531 
1532   EOFLoop :
1533   for (;;)
1534   {   
1535    try   
1536    {     
1537       curChar = input_stream.BeginToken();
1538    }     
1539    catch(java.io.IOException e)
1540    {        
1541       jjmatchedKind = 0;
1542       matchedToken = jjFillToken();
1543       matchedToken.specialToken = specialToken;
1544       return matchedToken;
1545    }
1546    image = null;
1547    jjimageLen = 0;
1548 
1549    for (;;)
1550    {
1551      switch(curLexState)
1552      {
1553        case 0:
1554          jjmatchedKind = 0x7fffffff;
1555          jjmatchedPos = 0;
1556          curPos = jjMoveStringLiteralDfa0_0();
1557          break;
1558        case 1:
1559          jjmatchedKind = 0x7fffffff;
1560          jjmatchedPos = 0;
1561          curPos = jjMoveStringLiteralDfa0_1();
1562          if (jjmatchedPos == 0 && jjmatchedKind > 11)
1563          {
1564             jjmatchedKind = 11;
1565          }
1566          break;
1567        case 2:
1568          jjmatchedKind = 0x7fffffff;
1569          jjmatchedPos = 0;
1570          curPos = jjMoveStringLiteralDfa0_2();
1571          if (jjmatchedPos == 0 && jjmatchedKind > 11)
1572          {
1573             jjmatchedKind = 11;
1574          }
1575          break;
1576      }
1577      if (jjmatchedKind != 0x7fffffff)
1578      {
1579         if (jjmatchedPos + 1 < curPos)
1580            input_stream.backup(curPos - jjmatchedPos - 1);
1581         if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
1582         {
1583            matchedToken = jjFillToken();
1584            matchedToken.specialToken = specialToken;
1585        if (jjnewLexState[jjmatchedKind] != -1)
1586          curLexState = jjnewLexState[jjmatchedKind];
1587            return matchedToken;
1588         }
1589         else if ((jjtoSkip[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
1590         {
1591            if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
1592            {
1593               matchedToken = jjFillToken();
1594               if (specialToken == null)
1595                  specialToken = matchedToken;
1596               else
1597               {
1598                  matchedToken.specialToken = specialToken;
1599                  specialToken = (specialToken.next = matchedToken);
1600               }
1601               SkipLexicalActions(matchedToken);
1602            }
1603            else 
1604               SkipLexicalActions(null);
1605          if (jjnewLexState[jjmatchedKind] != -1)
1606            curLexState = jjnewLexState[jjmatchedKind];
1607            continue EOFLoop;
1608         }
1609         MoreLexicalActions();
1610       if (jjnewLexState[jjmatchedKind] != -1)
1611         curLexState = jjnewLexState[jjmatchedKind];
1612         curPos = 0;
1613         jjmatchedKind = 0x7fffffff;
1614         try {
1615            curChar = input_stream.readChar();
1616            continue;
1617         }
1618         catch (java.io.IOException e1) { }
1619      }
1620      int error_line = input_stream.getEndLine();
1621      int error_column = input_stream.getEndColumn();
1622      String error_after = null;
1623      boolean EOFSeen = false;
1624      try { input_stream.readChar(); input_stream.backup(1); }
1625      catch (java.io.IOException e1) {
1626         EOFSeen = true;
1627         error_after = curPos <= 1 ? "" : input_stream.GetImage();
1628         if (curChar == '\n' || curChar == '\r') {
1629            error_line++;
1630            error_column = 0;
1631         }
1632         else
1633            error_column++;
1634      }
1635      if (!EOFSeen) {
1636         input_stream.backup(1);
1637         error_after = curPos <= 1 ? "" : input_stream.GetImage();
1638      }
1639      throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
1640    }
1641   }
1642 }
1643 
1644 void SkipLexicalActions(Token matchedToken)
1645 {
1646    switch(jjmatchedKind)
1647    {
1648       default :
1649          break;
1650    }
1651 }
1652 void MoreLexicalActions()
1653 {
1654    jjimageLen += (lengthOfMatch = jjmatchedPos + 1);
1655    switch(jjmatchedKind)
1656    {
1657       case 7 :
1658          if (image == null)
1659               image = new StringBuffer(new String(input_stream.GetSuffix(jjimageLen)));
1660          else
1661             image.append(input_stream.GetSuffix(jjimageLen));
1662          jjimageLen = 0;
1663                    input_stream.backup(1);
1664          break;
1665       default : 
1666          break;
1667    }
1668 }
1669 }