View Javadoc

1   /* Generated By:JJTree&JavaCC: Do not edit this line. JavaParserTokenManager.java */
2   package net.sourceforge.pmd.ast;
3   import java.util.*;
4   import net.sourceforge.pmd.PMD;
5   
6   /** Token Manager. */
7   public class JavaParserTokenManager implements JavaParserConstants
8   {
9       protected List<Comment> comments = new ArrayList<Comment>();
10  
11      private Map<Integer, String> excludeMap = new HashMap<Integer, String>();
12      private String excludeMarker = PMD.EXCLUDE_MARKER;
13  
14      public void setExcludeMarker(String marker) {
15          this.excludeMarker = marker;
16      }
17      public Map<Integer, String> getExcludeMap() {
18          return excludeMap;
19      }
20  
21    /** Debug output. */
22    public  java.io.PrintStream debugStream = System.out;
23    /** Set debug output. */
24    public  void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
25  private final int jjStopStringLiteralDfa_0(int pos, long active0, long active1)
26  {
27     switch (pos)
28     {
29        case 0:
30           if ((active1 & 0x80000000080000L) != 0L)
31              return 4;
32           if ((active0 & 0x7ffffffffffff000L) != 0L)
33           {
34              jjmatchedKind = 72;
35              return 28;
36           }
37           if ((active0 & 0x100L) != 0L || (active1 & 0x804000000000L) != 0L)
38              return 45;
39           return -1;
40        case 1:
41           if ((active0 & 0x201800000L) != 0L)
42              return 28;
43           if ((active0 & 0x7ffffffdfe7ff000L) != 0L)
44           {
45              if (jjmatchedPos != 1)
46              {
47                 jjmatchedKind = 72;
48                 jjmatchedPos = 1;
49              }
50              return 28;
51           }
52           if ((active0 & 0x100L) != 0L)
53              return 50;
54           return -1;
55        case 2:
56           if ((active0 & 0x400026080000000L) != 0L)
57              return 28;
58           if ((active0 & 0x7bfffd9d7f7ff000L) != 0L)
59           {
60              if (jjmatchedPos != 2)
61              {
62                 jjmatchedKind = 72;
63                 jjmatchedPos = 2;
64              }
65              return 28;
66           }
67           return -1;
68        case 3:
69           if ((active0 & 0x71dff95c7d7a7000L) != 0L)
70           {
71              jjmatchedKind = 72;
72              jjmatchedPos = 3;
73              return 28;
74           }
75           if ((active0 & 0xa20048102058000L) != 0L)
76              return 28;
77           return -1;
78        case 4:
79           if ((active0 & 0x20c50000781a4000L) != 0L)
80              return 28;
81           if ((active0 & 0x511af95c05603000L) != 0L)
82           {
83              if (jjmatchedPos != 4)
84              {
85                 jjmatchedKind = 72;
86                 jjmatchedPos = 4;
87              }
88              return 28;
89           }
90           return -1;
91        case 5:
92           if ((active0 & 0x8ac10801000000L) != 0L)
93              return 28;
94           if ((active0 & 0x5110385424603000L) != 0L)
95           {
96              jjmatchedKind = 72;
97              jjmatchedPos = 5;
98              return 28;
99           }
100          return -1;
101       case 6:
102          if ((active0 & 0x5110205400201000L) != 0L)
103          {
104             jjmatchedKind = 72;
105             jjmatchedPos = 6;
106             return 28;
107          }
108          if ((active0 & 0x180024402000L) != 0L)
109             return 28;
110          return -1;
111       case 7:
112          if ((active0 & 0x5000000000201000L) != 0L)
113             return 28;
114          if ((active0 & 0x110205400000000L) != 0L)
115          {
116             jjmatchedKind = 72;
117             jjmatchedPos = 7;
118             return 28;
119          }
120          return -1;
121       case 8:
122          if ((active0 & 0x100204000000000L) != 0L)
123             return 28;
124          if ((active0 & 0x10001400000000L) != 0L)
125          {
126             jjmatchedKind = 72;
127             jjmatchedPos = 8;
128             return 28;
129          }
130          return -1;
131       case 9:
132          if ((active0 & 0x1400000000L) != 0L)
133             return 28;
134          if ((active0 & 0x10000000000000L) != 0L)
135          {
136             jjmatchedKind = 72;
137             jjmatchedPos = 9;
138             return 28;
139          }
140          return -1;
141       case 10:
142          if ((active0 & 0x10000000000000L) != 0L)
143          {
144             jjmatchedKind = 72;
145             jjmatchedPos = 10;
146             return 28;
147          }
148          return -1;
149       default :
150          return -1;
151    }
152 }
153 private final int jjStartNfa_0(int pos, long active0, long active1)
154 {
155    return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0, active1), pos + 1);
156 }
157 private int jjStopAtPos(int pos, int kind)
158 {
159    jjmatchedKind = kind;
160    jjmatchedPos = pos;
161    return pos + 1;
162 }
163 private int jjMoveStringLiteralDfa0_0()
164 {
165    switch(curChar)
166    {
167       case 9:
168          return jjStopAtPos(0, 2);
169       case 10:
170          return jjStopAtPos(0, 3);
171       case 12:
172          return jjStopAtPos(0, 5);
173       case 13:
174          return jjStopAtPos(0, 4);
175       case 26:
176          return jjStopAtPos(0, 123);
177       case 32:
178          return jjStopAtPos(0, 1);
179       case 33:
180          jjmatchedKind = 87;
181          return jjMoveStringLiteralDfa1_0(0x0L, 0x40000000L);
182       case 37:
183          jjmatchedKind = 106;
184          return jjMoveStringLiteralDfa1_0(0x0L, 0x8000000000000L);
185       case 38:
186          jjmatchedKind = 103;
187          return jjMoveStringLiteralDfa1_0(0x0L, 0x1000100000000L);
188       case 40:
189          return jjStopAtPos(0, 75);
190       case 41:
191          return jjStopAtPos(0, 76);
192       case 42:
193          jjmatchedKind = 101;
194          return jjMoveStringLiteralDfa1_0(0x0L, 0x400000000000L);
195       case 43:
196          jjmatchedKind = 99;
197          return jjMoveStringLiteralDfa1_0(0x0L, 0x100200000000L);
198       case 44:
199          return jjStopAtPos(0, 82);
200       case 45:
201          jjmatchedKind = 100;
202          return jjMoveStringLiteralDfa1_0(0x0L, 0x200400000000L);
203       case 46:
204          jjmatchedKind = 83;
205          return jjMoveStringLiteralDfa1_0(0x0L, 0x80000000000000L);
206       case 47:
207          jjmatchedKind = 102;
208          return jjMoveStringLiteralDfa1_0(0x100L, 0x800000000000L);
209       case 58:
210          return jjStopAtPos(0, 90);
211       case 59:
212          return jjStopAtPos(0, 81);
213       case 60:
214          jjmatchedKind = 86;
215          return jjMoveStringLiteralDfa1_0(0x0L, 0x10080010000000L);
216       case 61:
217          jjmatchedKind = 85;
218          return jjMoveStringLiteralDfa1_0(0x0L, 0x8000000L);
219       case 62:
220          jjmatchedKind = 122;
221          return jjMoveStringLiteralDfa1_0(0x0L, 0x360000020000000L);
222       case 63:
223          return jjStopAtPos(0, 89);
224       case 64:
225          return jjStopAtPos(0, 84);
226       case 91:
227          return jjStopAtPos(0, 79);
228       case 93:
229          return jjStopAtPos(0, 80);
230       case 94:
231          jjmatchedKind = 105;
232          return jjMoveStringLiteralDfa1_0(0x0L, 0x4000000000000L);
233       case 97:
234          return jjMoveStringLiteralDfa1_0(0x1000L, 0x0L);
235       case 98:
236          return jjMoveStringLiteralDfa1_0(0xe000L, 0x0L);
237       case 99:
238          return jjMoveStringLiteralDfa1_0(0x3f0000L, 0x0L);
239       case 100:
240          return jjMoveStringLiteralDfa1_0(0x1c00000L, 0x0L);
241       case 101:
242          return jjMoveStringLiteralDfa1_0(0x6000000L, 0x0L);
243       case 102:
244          return jjMoveStringLiteralDfa1_0(0xf8000000L, 0x0L);
245       case 103:
246          return jjMoveStringLiteralDfa1_0(0x100000000L, 0x0L);
247       case 105:
248          return jjMoveStringLiteralDfa1_0(0x7e00000000L, 0x0L);
249       case 108:
250          return jjMoveStringLiteralDfa1_0(0x8000000000L, 0x0L);
251       case 110:
252          return jjMoveStringLiteralDfa1_0(0x70000000000L, 0x0L);
253       case 112:
254          return jjMoveStringLiteralDfa1_0(0x780000000000L, 0x0L);
255       case 114:
256          return jjMoveStringLiteralDfa1_0(0x800000000000L, 0x0L);
257       case 115:
258          return jjMoveStringLiteralDfa1_0(0x401f000000000000L, 0x0L);
259       case 116:
260          return jjMoveStringLiteralDfa1_0(0x7e0000000000000L, 0x0L);
261       case 118:
262          return jjMoveStringLiteralDfa1_0(0x1800000000000000L, 0x0L);
263       case 119:
264          return jjMoveStringLiteralDfa1_0(0x2000000000000000L, 0x0L);
265       case 123:
266          return jjStopAtPos(0, 77);
267       case 124:
268          jjmatchedKind = 104;
269          return jjMoveStringLiteralDfa1_0(0x0L, 0x2000080000000L);
270       case 125:
271          return jjStopAtPos(0, 78);
272       case 126:
273          jjmatchedKind = 88;
274          return jjMoveStringLiteralDfa1_0(0x0L, 0x1000000000000000L);
275       default :
276          return jjMoveNfa_0(0, 0);
277    }
278 }
279 private int jjMoveStringLiteralDfa1_0(long active0, long active1)
280 {
281    try { curChar = input_stream.readChar(); }
282    catch(java.io.IOException e) {
283       jjStopStringLiteralDfa_0(0, active0, active1);
284       return 1;
285    }
286    switch(curChar)
287    {
288       case 38:
289          if ((active1 & 0x100000000L) != 0L)
290             return jjStopAtPos(1, 96);
291          break;
292       case 42:
293          if ((active0 & 0x100L) != 0L)
294             return jjStartNfaWithStates_0(1, 8, 50);
295          break;
296       case 43:
297          if ((active1 & 0x200000000L) != 0L)
298             return jjStopAtPos(1, 97);
299          break;
300       case 45:
301          if ((active1 & 0x400000000L) != 0L)
302             return jjStopAtPos(1, 98);
303          break;
304       case 46:
305          return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x80000000000000L);
306       case 60:
307          if ((active1 & 0x80000000000L) != 0L)
308          {
309             jjmatchedKind = 107;
310             jjmatchedPos = 1;
311          }
312          return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x10000000000000L);
313       case 61:
314          if ((active1 & 0x8000000L) != 0L)
315             return jjStopAtPos(1, 91);
316          else if ((active1 & 0x10000000L) != 0L)
317             return jjStopAtPos(1, 92);
318          else if ((active1 & 0x20000000L) != 0L)
319             return jjStopAtPos(1, 93);
320          else if ((active1 & 0x40000000L) != 0L)
321             return jjStopAtPos(1, 94);
322          else if ((active1 & 0x100000000000L) != 0L)
323             return jjStopAtPos(1, 108);
324          else if ((active1 & 0x200000000000L) != 0L)
325             return jjStopAtPos(1, 109);
326          else if ((active1 & 0x400000000000L) != 0L)
327             return jjStopAtPos(1, 110);
328          else if ((active1 & 0x800000000000L) != 0L)
329             return jjStopAtPos(1, 111);
330          else if ((active1 & 0x1000000000000L) != 0L)
331             return jjStopAtPos(1, 112);
332          else if ((active1 & 0x2000000000000L) != 0L)
333             return jjStopAtPos(1, 113);
334          else if ((active1 & 0x4000000000000L) != 0L)
335             return jjStopAtPos(1, 114);
336          else if ((active1 & 0x8000000000000L) != 0L)
337             return jjStopAtPos(1, 115);
338          break;
339       case 62:
340          if ((active1 & 0x200000000000000L) != 0L)
341          {
342             jjmatchedKind = 121;
343             jjmatchedPos = 1;
344          }
345          return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x160000000000000L);
346       case 91:
347          return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x1000000000000000L);
348       case 97:
349          return jjMoveStringLiteralDfa2_0(active0, 0x90008030000L, active1, 0L);
350       case 98:
351          return jjMoveStringLiteralDfa2_0(active0, 0x1000L, active1, 0L);
352       case 101:
353          return jjMoveStringLiteralDfa2_0(active0, 0x820000400000L, active1, 0L);
354       case 102:
355          if ((active0 & 0x200000000L) != 0L)
356             return jjStartNfaWithStates_0(1, 33, 28);
357          break;
358       case 104:
359          return jjMoveStringLiteralDfa2_0(active0, 0x20e1000000040000L, active1, 0L);
360       case 105:
361          return jjMoveStringLiteralDfa2_0(active0, 0x30000000L, active1, 0L);
362       case 108:
363          return jjMoveStringLiteralDfa2_0(active0, 0x42080000L, active1, 0L);
364       case 109:
365          return jjMoveStringLiteralDfa2_0(active0, 0xc00000000L, active1, 0L);
366       case 110:
367          return jjMoveStringLiteralDfa2_0(active0, 0x7000000000L, active1, 0L);
368       case 111:
369          if ((active0 & 0x800000L) != 0L)
370          {
371             jjmatchedKind = 23;
372             jjmatchedPos = 1;
373          }
374          return jjMoveStringLiteralDfa2_0(active0, 0x1800008181302000L, active1, 0L);
375       case 114:
376          return jjMoveStringLiteralDfa2_0(active0, 0x700300000004000L, active1, 0L);
377       case 116:
378          return jjMoveStringLiteralDfa2_0(active0, 0x4002000000000000L, active1, 0L);
379       case 117:
380          return jjMoveStringLiteralDfa2_0(active0, 0x4440000000000L, active1, 0L);
381       case 119:
382          return jjMoveStringLiteralDfa2_0(active0, 0x8000000000000L, active1, 0L);
383       case 120:
384          return jjMoveStringLiteralDfa2_0(active0, 0x4000000L, active1, 0L);
385       case 121:
386          return jjMoveStringLiteralDfa2_0(active0, 0x10000000008000L, active1, 0L);
387       case 124:
388          if ((active1 & 0x80000000L) != 0L)
389             return jjStopAtPos(1, 95);
390          break;
391       default :
392          break;
393    }
394    return jjStartNfa_0(0, active0, active1);
395 }
396 private int jjMoveStringLiteralDfa2_0(long old0, long active0, long old1, long active1)
397 {
398    if (((active0 &= old0) | (active1 &= old1)) == 0L)
399       return jjStartNfa_0(0, old0, old1);
400    try { curChar = input_stream.readChar(); }
401    catch(java.io.IOException e) {
402       jjStopStringLiteralDfa_0(1, active0, active1);
403       return 2;
404    }
405    switch(curChar)
406    {
407       case 46:
408          if ((active1 & 0x80000000000000L) != 0L)
409             return jjStopAtPos(2, 119);
410          break;
411       case 61:
412          if ((active1 & 0x10000000000000L) != 0L)
413             return jjStopAtPos(2, 116);
414          else if ((active1 & 0x20000000000000L) != 0L)
415             return jjStopAtPos(2, 117);
416          break;
417       case 62:
418          if ((active1 & 0x100000000000000L) != 0L)
419          {
420             jjmatchedKind = 120;
421             jjmatchedPos = 2;
422          }
423          return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x40000000000000L);
424       case 93:
425          if ((active1 & 0x1000000000000000L) != 0L)
426             return jjStopAtPos(2, 124);
427          break;
428       case 97:
429          return jjMoveStringLiteralDfa3_0(active0, 0x1020000000c0000L, active1, 0L);
430       case 98:
431          return jjMoveStringLiteralDfa3_0(active0, 0x400000000000L, active1, 0L);
432       case 99:
433          return jjMoveStringLiteralDfa3_0(active0, 0x80000000000L, active1, 0L);
434       case 101:
435          return jjMoveStringLiteralDfa3_0(active0, 0x4000L, active1, 0L);
436       case 102:
437          return jjMoveStringLiteralDfa3_0(active0, 0x400000L, active1, 0L);
438       case 105:
439          return jjMoveStringLiteralDfa3_0(active0, 0x2828100000000000L, active1, 0L);
440       case 108:
441          return jjMoveStringLiteralDfa3_0(active0, 0x1000040008000000L, active1, 0L);
442       case 110:
443          return jjMoveStringLiteralDfa3_0(active0, 0x10008030300000L, active1, 0L);
444       case 111:
445          return jjMoveStringLiteralDfa3_0(active0, 0x1200040002000L, active1, 0L);
446       case 112:
447          return jjMoveStringLiteralDfa3_0(active0, 0x4000c00000000L, active1, 0L);
448       case 114:
449          if ((active0 & 0x80000000L) != 0L)
450             return jjStartNfaWithStates_0(2, 31, 28);
451          return jjMoveStringLiteralDfa3_0(active0, 0x40c0000000000000L, active1, 0L);
452       case 115:
453          return jjMoveStringLiteralDfa3_0(active0, 0x1002011000L, active1, 0L);
454       case 116:
455          if ((active0 & 0x2000000000L) != 0L)
456          {
457             jjmatchedKind = 37;
458             jjmatchedPos = 2;
459          }
460          return jjMoveStringLiteralDfa3_0(active0, 0x814104028000L, active1, 0L);
461       case 117:
462          return jjMoveStringLiteralDfa3_0(active0, 0x200000001000000L, active1, 0L);
463       case 119:
464          if ((active0 & 0x20000000000L) != 0L)
465             return jjStartNfaWithStates_0(2, 41, 28);
466          break;
467       case 121:
468          if ((active0 & 0x400000000000000L) != 0L)
469             return jjStartNfaWithStates_0(2, 58, 28);
470          break;
471       default :
472          break;
473    }
474    return jjStartNfa_0(1, active0, active1);
475 }
476 private int jjMoveStringLiteralDfa3_0(long old0, long active0, long old1, long active1)
477 {
478    if (((active0 &= old0) | (active1 &= old1)) == 0L)
479       return jjStartNfa_0(1, old0, old1);
480    try { curChar = input_stream.readChar(); }
481    catch(java.io.IOException e) {
482       jjStopStringLiteralDfa_0(2, active0, active1);
483       return 3;
484    }
485    switch(curChar)
486    {
487       case 61:
488          if ((active1 & 0x40000000000000L) != 0L)
489             return jjStopAtPos(3, 118);
490          break;
491       case 97:
492          return jjMoveStringLiteralDfa4_0(active0, 0x1000000070404000L, active1, 0L);
493       case 98:
494          return jjMoveStringLiteralDfa4_0(active0, 0x1000000L, active1, 0L);
495       case 99:
496          return jjMoveStringLiteralDfa4_0(active0, 0x10000000020000L, active1, 0L);
497       case 100:
498          if ((active0 & 0x800000000000000L) != 0L)
499             return jjStartNfaWithStates_0(3, 59, 28);
500          break;
501       case 101:
502          if ((active0 & 0x8000L) != 0L)
503             return jjStartNfaWithStates_0(3, 15, 28);
504          else if ((active0 & 0x10000L) != 0L)
505             return jjStartNfaWithStates_0(3, 16, 28);
506          else if ((active0 & 0x2000000L) != 0L)
507             return jjStartNfaWithStates_0(3, 25, 28);
508          else if ((active0 & 0x200000000000000L) != 0L)
509             return jjStartNfaWithStates_0(3, 57, 28);
510          return jjMoveStringLiteralDfa4_0(active0, 0x4004004000000L, active1, 0L);
511       case 103:
512          if ((active0 & 0x8000000000L) != 0L)
513             return jjStartNfaWithStates_0(3, 39, 28);
514          break;
515       case 105:
516          return jjMoveStringLiteralDfa4_0(active0, 0x4000010000000000L, active1, 0L);
517       case 107:
518          return jjMoveStringLiteralDfa4_0(active0, 0x80000000000L, active1, 0L);
519       case 108:
520          if ((active0 & 0x40000000000L) != 0L)
521             return jjStartNfaWithStates_0(3, 42, 28);
522          return jjMoveStringLiteralDfa4_0(active0, 0x2000400400002000L, active1, 0L);
523       case 110:
524          return jjMoveStringLiteralDfa4_0(active0, 0x100000000000000L, active1, 0L);
525       case 111:
526          if ((active0 & 0x100000000L) != 0L)
527             return jjStartNfaWithStates_0(3, 32, 28);
528          return jjMoveStringLiteralDfa4_0(active0, 0xc0000800000000L, active1, 0L);
529       case 114:
530          if ((active0 & 0x40000L) != 0L)
531             return jjStartNfaWithStates_0(3, 18, 28);
532          return jjMoveStringLiteralDfa4_0(active0, 0x1000000000000L, active1, 0L);
533       case 115:
534          if ((active0 & 0x20000000000000L) != 0L)
535             return jjStartNfaWithStates_0(3, 53, 28);
536          return jjMoveStringLiteralDfa4_0(active0, 0x8180000L, active1, 0L);
537       case 116:
538          return jjMoveStringLiteralDfa4_0(active0, 0xa201000201000L, active1, 0L);
539       case 117:
540          return jjMoveStringLiteralDfa4_0(active0, 0x800000000000L, active1, 0L);
541       case 118:
542          return jjMoveStringLiteralDfa4_0(active0, 0x100000000000L, active1, 0L);
543       default :
544          break;
545    }
546    return jjStartNfa_0(2, active0, active1);
547 }
548 private int jjMoveStringLiteralDfa4_0(long old0, long active0, long old1, long active1)
549 {
550    if (((active0 &= old0) | (active1 &= old1)) == 0L)
551       return jjStartNfa_0(2, old0, old1);
552    try { curChar = input_stream.readChar(); }
553    catch(java.io.IOException e) {
554       jjStopStringLiteralDfa_0(3, active0, 0L);
555       return 4;
556    }
557    switch(curChar)
558    {
559       case 97:
560          return jjMoveStringLiteralDfa5_0(active0, 0x181000000000L);
561       case 99:
562          return jjMoveStringLiteralDfa5_0(active0, 0x4008000000000000L);
563       case 101:
564          if ((active0 & 0x8000000L) != 0L)
565             return jjStartNfaWithStates_0(4, 27, 28);
566          else if ((active0 & 0x2000000000000000L) != 0L)
567             return jjStartNfaWithStates_0(4, 61, 28);
568          return jjMoveStringLiteralDfa5_0(active0, 0x200400002000L);
569       case 104:
570          if ((active0 & 0x20000L) != 0L)
571             return jjStartNfaWithStates_0(4, 17, 28);
572          return jjMoveStringLiteralDfa5_0(active0, 0x10000000000000L);
573       case 105:
574          return jjMoveStringLiteralDfa5_0(active0, 0x2400000200000L);
575       case 107:
576          if ((active0 & 0x4000L) != 0L)
577             return jjStartNfaWithStates_0(4, 14, 28);
578          break;
579       case 108:
580          if ((active0 & 0x10000000L) != 0L)
581          {
582             jjmatchedKind = 28;
583             jjmatchedPos = 4;
584          }
585          return jjMoveStringLiteralDfa5_0(active0, 0x21000000L);
586       case 110:
587          return jjMoveStringLiteralDfa5_0(active0, 0x4000000L);
588       case 114:
589          if ((active0 & 0x4000000000000L) != 0L)
590             return jjStartNfaWithStates_0(4, 50, 28);
591          return jjMoveStringLiteralDfa5_0(active0, 0x804800001000L);
592       case 115:
593          if ((active0 & 0x80000L) != 0L)
594             return jjStartNfaWithStates_0(4, 19, 28);
595          return jjMoveStringLiteralDfa5_0(active0, 0x100000000000000L);
596       case 116:
597          if ((active0 & 0x100000L) != 0L)
598             return jjStartNfaWithStates_0(4, 20, 28);
599          else if ((active0 & 0x40000000L) != 0L)
600             return jjStartNfaWithStates_0(4, 30, 28);
601          else if ((active0 & 0x1000000000000L) != 0L)
602             return jjStartNfaWithStates_0(4, 48, 28);
603          return jjMoveStringLiteralDfa5_0(active0, 0x1000000000000000L);
604       case 117:
605          return jjMoveStringLiteralDfa5_0(active0, 0x400000L);
606       case 118:
607          return jjMoveStringLiteralDfa5_0(active0, 0x10000000000L);
608       case 119:
609          if ((active0 & 0x40000000000000L) != 0L)
610          {
611             jjmatchedKind = 54;
612             jjmatchedPos = 4;
613          }
614          return jjMoveStringLiteralDfa5_0(active0, 0x80000000000000L);
615       default :
616          break;
617    }
618    return jjStartNfa_0(3, active0, 0L);
619 }
620 private int jjMoveStringLiteralDfa5_0(long old0, long active0)
621 {
622    if (((active0 &= old0)) == 0L)
623       return jjStartNfa_0(3, old0, 0L);
624    try { curChar = input_stream.readChar(); }
625    catch(java.io.IOException e) {
626       jjStopStringLiteralDfa_0(4, active0, 0L);
627       return 5;
628    }
629    switch(curChar)
630    {
631       case 97:
632          return jjMoveStringLiteralDfa6_0(active0, 0x3000L);
633       case 99:
634          if ((active0 & 0x400000000000L) != 0L)
635             return jjStartNfaWithStates_0(5, 46, 28);
636          else if ((active0 & 0x2000000000000L) != 0L)
637             return jjStartNfaWithStates_0(5, 49, 28);
638          return jjMoveStringLiteralDfa6_0(active0, 0x200000000000L);
639       case 100:
640          return jjMoveStringLiteralDfa6_0(active0, 0x4000000L);
641       case 101:
642          if ((active0 & 0x1000000L) != 0L)
643             return jjStartNfaWithStates_0(5, 24, 28);
644          else if ((active0 & 0x10000000000L) != 0L)
645             return jjStartNfaWithStates_0(5, 40, 28);
646          break;
647       case 102:
648          return jjMoveStringLiteralDfa6_0(active0, 0x4000000000L);
649       case 103:
650          return jjMoveStringLiteralDfa6_0(active0, 0x80000000000L);
651       case 104:
652          if ((active0 & 0x8000000000000L) != 0L)
653             return jjStartNfaWithStates_0(5, 51, 28);
654          break;
655       case 105:
656          return jjMoveStringLiteralDfa6_0(active0, 0x1100000000000000L);
657       case 108:
658          return jjMoveStringLiteralDfa6_0(active0, 0x20400000L);
659       case 109:
660          return jjMoveStringLiteralDfa6_0(active0, 0x400000000L);
661       case 110:
662          if ((active0 & 0x800000000000L) != 0L)
663             return jjStartNfaWithStates_0(5, 47, 28);
664          return jjMoveStringLiteralDfa6_0(active0, 0x1000200000L);
665       case 114:
666          return jjMoveStringLiteralDfa6_0(active0, 0x10000000000000L);
667       case 115:
668          if ((active0 & 0x80000000000000L) != 0L)
669             return jjStartNfaWithStates_0(5, 55, 28);
670          break;
671       case 116:
672          if ((active0 & 0x800000000L) != 0L)
673             return jjStartNfaWithStates_0(5, 35, 28);
674          return jjMoveStringLiteralDfa6_0(active0, 0x4000100000000000L);
675       default :
676          break;
677    }
678    return jjStartNfa_0(4, active0, 0L);
679 }
680 private int jjMoveStringLiteralDfa6_0(long old0, long active0)
681 {
682    if (((active0 &= old0)) == 0L)
683       return jjStartNfa_0(4, old0, 0L);
684    try { curChar = input_stream.readChar(); }
685    catch(java.io.IOException e) {
686       jjStopStringLiteralDfa_0(5, active0, 0L);
687       return 6;
688    }
689    switch(curChar)
690    {
691       case 97:
692          return jjMoveStringLiteralDfa7_0(active0, 0x4000000000L);
693       case 99:
694          return jjMoveStringLiteralDfa7_0(active0, 0x1000001000L);
695       case 101:
696          if ((active0 & 0x80000000000L) != 0L)
697             return jjStartNfaWithStates_0(6, 43, 28);
698          else if ((active0 & 0x100000000000L) != 0L)
699             return jjStartNfaWithStates_0(6, 44, 28);
700          return jjMoveStringLiteralDfa7_0(active0, 0x100000400000000L);
701       case 102:
702          return jjMoveStringLiteralDfa7_0(active0, 0x4000000000000000L);
703       case 108:
704          return jjMoveStringLiteralDfa7_0(active0, 0x1000000000000000L);
705       case 110:
706          if ((active0 & 0x2000L) != 0L)
707             return jjStartNfaWithStates_0(6, 13, 28);
708          break;
709       case 111:
710          return jjMoveStringLiteralDfa7_0(active0, 0x10000000000000L);
711       case 115:
712          if ((active0 & 0x4000000L) != 0L)
713             return jjStartNfaWithStates_0(6, 26, 28);
714          break;
715       case 116:
716          if ((active0 & 0x400000L) != 0L)
717             return jjStartNfaWithStates_0(6, 22, 28);
718          return jjMoveStringLiteralDfa7_0(active0, 0x200000000000L);
719       case 117:
720          return jjMoveStringLiteralDfa7_0(active0, 0x200000L);
721       case 121:
722          if ((active0 & 0x20000000L) != 0L)
723             return jjStartNfaWithStates_0(6, 29, 28);
724          break;
725       default :
726          break;
727    }
728    return jjStartNfa_0(5, active0, 0L);
729 }
730 private int jjMoveStringLiteralDfa7_0(long old0, long active0)
731 {
732    if (((active0 &= old0)) == 0L)
733       return jjStartNfa_0(5, old0, 0L);
734    try { curChar = input_stream.readChar(); }
735    catch(java.io.IOException e) {
736       jjStopStringLiteralDfa_0(6, active0, 0L);
737       return 7;
738    }
739    switch(curChar)
740    {
741       case 99:
742          return jjMoveStringLiteralDfa8_0(active0, 0x4000000000L);
743       case 101:
744          if ((active0 & 0x200000L) != 0L)
745             return jjStartNfaWithStates_0(7, 21, 28);
746          else if ((active0 & 0x1000000000000000L) != 0L)
747             return jjStartNfaWithStates_0(7, 60, 28);
748          return jjMoveStringLiteralDfa8_0(active0, 0x201000000000L);
749       case 110:
750          return jjMoveStringLiteralDfa8_0(active0, 0x110000400000000L);
751       case 112:
752          if ((active0 & 0x4000000000000000L) != 0L)
753             return jjStartNfaWithStates_0(7, 62, 28);
754          break;
755       case 116:
756          if ((active0 & 0x1000L) != 0L)
757             return jjStartNfaWithStates_0(7, 12, 28);
758          break;
759       default :
760          break;
761    }
762    return jjStartNfa_0(6, active0, 0L);
763 }
764 private int jjMoveStringLiteralDfa8_0(long old0, long active0)
765 {
766    if (((active0 &= old0)) == 0L)
767       return jjStartNfa_0(6, old0, 0L);
768    try { curChar = input_stream.readChar(); }
769    catch(java.io.IOException e) {
770       jjStopStringLiteralDfa_0(7, active0, 0L);
771       return 8;
772    }
773    switch(curChar)
774    {
775       case 100:
776          if ((active0 & 0x200000000000L) != 0L)
777             return jjStartNfaWithStates_0(8, 45, 28);
778          break;
779       case 101:
780          if ((active0 & 0x4000000000L) != 0L)
781             return jjStartNfaWithStates_0(8, 38, 28);
782          break;
783       case 105:
784          return jjMoveStringLiteralDfa9_0(active0, 0x10000000000000L);
785       case 111:
786          return jjMoveStringLiteralDfa9_0(active0, 0x1000000000L);
787       case 116:
788          if ((active0 & 0x100000000000000L) != 0L)
789             return jjStartNfaWithStates_0(8, 56, 28);
790          return jjMoveStringLiteralDfa9_0(active0, 0x400000000L);
791       default :
792          break;
793    }
794    return jjStartNfa_0(7, active0, 0L);
795 }
796 private int jjMoveStringLiteralDfa9_0(long old0, long active0)
797 {
798    if (((active0 &= old0)) == 0L)
799       return jjStartNfa_0(7, old0, 0L);
800    try { curChar = input_stream.readChar(); }
801    catch(java.io.IOException e) {
802       jjStopStringLiteralDfa_0(8, active0, 0L);
803       return 9;
804    }
805    switch(curChar)
806    {
807       case 102:
808          if ((active0 & 0x1000000000L) != 0L)
809             return jjStartNfaWithStates_0(9, 36, 28);
810          break;
811       case 115:
812          if ((active0 & 0x400000000L) != 0L)
813             return jjStartNfaWithStates_0(9, 34, 28);
814          break;
815       case 122:
816          return jjMoveStringLiteralDfa10_0(active0, 0x10000000000000L);
817       default :
818          break;
819    }
820    return jjStartNfa_0(8, active0, 0L);
821 }
822 private int jjMoveStringLiteralDfa10_0(long old0, long active0)
823 {
824    if (((active0 &= old0)) == 0L)
825       return jjStartNfa_0(8, old0, 0L);
826    try { curChar = input_stream.readChar(); }
827    catch(java.io.IOException e) {
828       jjStopStringLiteralDfa_0(9, active0, 0L);
829       return 10;
830    }
831    switch(curChar)
832    {
833       case 101:
834          return jjMoveStringLiteralDfa11_0(active0, 0x10000000000000L);
835       default :
836          break;
837    }
838    return jjStartNfa_0(9, active0, 0L);
839 }
840 private int jjMoveStringLiteralDfa11_0(long old0, long active0)
841 {
842    if (((active0 &= old0)) == 0L)
843       return jjStartNfa_0(9, old0, 0L);
844    try { curChar = input_stream.readChar(); }
845    catch(java.io.IOException e) {
846       jjStopStringLiteralDfa_0(10, active0, 0L);
847       return 11;
848    }
849    switch(curChar)
850    {
851       case 100:
852          if ((active0 & 0x10000000000000L) != 0L)
853             return jjStartNfaWithStates_0(11, 52, 28);
854          break;
855       default :
856          break;
857    }
858    return jjStartNfa_0(10, active0, 0L);
859 }
860 private int jjStartNfaWithStates_0(int pos, int kind, int state)
861 {
862    jjmatchedKind = kind;
863    jjmatchedPos = pos;
864    try { curChar = input_stream.readChar(); }
865    catch(java.io.IOException e) { return pos + 1; }
866    return jjMoveNfa_0(state, pos + 1);
867 }
868 static final long[] jjbitVec0 = {
869    0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
870 };
871 static final long[] jjbitVec2 = {
872    0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
873 };
874 static final long[] jjbitVec3 = {
875    0xfff0000000200002L, 0xffffffffffffdfffL, 0xfffff00f7fffffffL, 0x12000000007fffffL
876 };
877 static final long[] jjbitVec4 = {
878    0x0L, 0x0L, 0x420043c00000000L, 0xff7fffffff7fffffL
879 };
880 static final long[] jjbitVec5 = {
881    0xffffcffffffffL, 0xffffffffffff0000L, 0xf9ff3fffffffffffL, 0x401f00030003L
882 };
883 static final long[] jjbitVec6 = {
884    0x0L, 0x400000000000000L, 0xfffffffbffffd740L, 0xffffffcff7fffL
885 };
886 static final long[] jjbitVec7 = {
887    0xffffffffffffffffL, 0xffffffffffffffffL, 0xfffffffffffff003L, 0x33fffffffff199fL
888 };
889 static final long[] jjbitVec8 = {
890    0xfffe000000000000L, 0xfffffffe027fffffL, 0xffL, 0x707ffffff0000L
891 };
892 static final long[] jjbitVec9 = {
893    0x7fffffe00000000L, 0xfffe0000000007ffL, 0xffffffffffffffffL, 0x1c000060002fffffL
894 };
895 static final long[] jjbitVec10 = {
896    0x1ffffffd0000L, 0x0L, 0x3fffffffffL, 0x0L
897 };
898 static final long[] jjbitVec11 = {
899    0x23ffffffffffffe0L, 0x3ff010000L, 0x3c5fdfffff99fe0L, 0xf0003b0000000L
900 };
901 static final long[] jjbitVec12 = {
902    0x36dfdfffff987e0L, 0x1c00005e000000L, 0x23edfdfffffbafe0L, 0x100010000L
903 };
904 static final long[] jjbitVec13 = {
905    0x23cdfdfffff99fe0L, 0x3b0000000L, 0x3bfc718d63dc7e0L, 0x0L
906 };
907 static final long[] jjbitVec14 = {
908    0x3effdfffffddfe0L, 0x300000000L, 0x3effdfffffddfe0L, 0x340000000L
909 };
910 static final long[] jjbitVec15 = {
911    0x3fffdfffffddfe0L, 0x300000000L, 0x2ffbfffffc7fffe0L, 0x7fL
912 };
913 static final long[] jjbitVec16 = {
914    0x800dfffffffffffeL, 0x7fL, 0x200decaefef02596L, 0x3000005fL
915 };
916 static final long[] jjbitVec17 = {
917    0x1L, 0x7fffffffeffL, 0xf00L, 0x0L
918 };
919 static final long[] jjbitVec18 = {
920    0x6fbffffffffL, 0x3f0000L, 0xffffffff00000000L, 0x7fffffffff003fL
921 };
922 static final long[] jjbitVec19 = {
923    0xffffffffffffffffL, 0xffffffff83ffffffL, 0xffffff07ffffffffL, 0x3ffffffffffffffL
924 };
925 static final long[] jjbitVec20 = {
926    0xffffffffffffff7fL, 0xffffffff3d7f3d7fL, 0x7f3d7fffffff3d7fL, 0xffff7fffff7f7f3dL
927 };
928 static final long[] jjbitVec21 = {
929    0xffffffff7f3d7fffL, 0x7ffff7fL, 0xffffffff00000000L, 0x1fffffffffffffL
930 };
931 static final long[] jjbitVec22 = {
932    0xffffffffffffffffL, 0x7f9fffffffffffL, 0xffffffff07fffffeL, 0x7ffffffffffL
933 };
934 static final long[] jjbitVec23 = {
935    0x0L, 0x0L, 0xfffffffffffffL, 0x8000000L
936 };
937 static final long[] jjbitVec24 = {
938    0xffffffff00000000L, 0xffffffffffffffL, 0x1ffffffffffL, 0x0L
939 };
940 static final long[] jjbitVec25 = {
941    0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffff0fffffffL, 0x3ffffffffffffffL
942 };
943 static final long[] jjbitVec26 = {
944    0xffffffff3f3fffffL, 0x3fffffffaaff3f3fL, 0x5fdfffffffffffffL, 0x1fdc1fff0fcf1fdcL
945 };
946 static final long[] jjbitVec27 = {
947    0x8000000000000000L, 0x8000000000000001L, 0xffff00000000L, 0x0L
948 };
949 static final long[] jjbitVec28 = {
950    0x3fbbd503e2ffc84L, 0xffffffff00000000L, 0xfL, 0x0L
951 };
952 static final long[] jjbitVec29 = {
953    0x73e03fe000000e0L, 0xfffffffffffffffeL, 0xfffffffe601fffffL, 0x7fffffffffffffffL
954 };
955 static final long[] jjbitVec30 = {
956    0xfffe1fffffffffe0L, 0xffffffffffffffffL, 0xffffff00007fffL, 0x0L
957 };
958 static final long[] jjbitVec31 = {
959    0xffffffffffffffffL, 0xffffffffffffffffL, 0x3fffffffffffffL, 0x0L
960 };
961 static final long[] jjbitVec32 = {
962    0xffffffffffffffffL, 0xffffffffffffffffL, 0x3fffffffffL, 0x0L
963 };
964 static final long[] jjbitVec33 = {
965    0xffffffffffffffffL, 0xffffffffffffffffL, 0x1fffL, 0x0L
966 };
967 static final long[] jjbitVec34 = {
968    0xffffffffffffffffL, 0xffffffffffffffffL, 0xfffffffffL, 0x0L
969 };
970 static final long[] jjbitVec35 = {
971    0x3fffffffffffL, 0x0L, 0x0L, 0x0L
972 };
973 static final long[] jjbitVec36 = {
974    0x5f7ffdffa0f8007fL, 0xffffffffffffffdbL, 0x3ffffffffffffL, 0xfffffffffff80000L
975 };
976 static final long[] jjbitVec37 = {
977    0x3fffffffffffffffL, 0xffffffffffff0000L, 0xfffffffffffcffffL, 0xfff0000000000ffL
978 };
979 static final long[] jjbitVec38 = {
980    0x18000000000000L, 0xffd702000000e000L, 0xffffffffffffffffL, 0x1fffffffffffffffL
981 };
982 static final long[] jjbitVec39 = {
983    0x87fffffe00000010L, 0xffffffe007fffffeL, 0x7fffffffffffffffL, 0x631cfcfcfcL
984 };
985 static final long[] jjbitVec40 = {
986    0x0L, 0x0L, 0x420043cffffffffL, 0xff7fffffff7fffffL
987 };
988 static final long[] jjbitVec41 = {
989    0xffffffffffffffffL, 0x400000700007fffL, 0xfffffffbffffd740L, 0xffffffcff7fffL
990 };
991 static final long[] jjbitVec42 = {
992    0xffffffffffffffffL, 0xffffffffffffffffL, 0xfffffffffffff07bL, 0x33fffffffff199fL
993 };
994 static final long[] jjbitVec43 = {
995    0xfffe000000000000L, 0xfffffffe027fffffL, 0xbbfffffbfffe00ffL, 0x707ffffff0016L
996 };
997 static final long[] jjbitVec44 = {
998    0x7fffffe00000000L, 0xffff03ff003fffffL, 0xffffffffffffffffL, 0x1fff3dff9fefffffL
999 };
1000 static final long[] jjbitVec45 = {
1001    0xffff1fffffff8000L, 0x7ffL, 0x1ffffffffffffL, 0x0L
1002 };
1003 static final long[] jjbitVec46 = {
1004    0xf3ffffffffffffeeL, 0xffcfff1f3fffL, 0xd3c5fdfffff99feeL, 0xfffcfb080399fL
1005 };
1006 static final long[] jjbitVec47 = {
1007    0xd36dfdfffff987e4L, 0x1fffc05e003987L, 0xf3edfdfffffbafeeL, 0xffc100013bbfL
1008 };
1009 static final long[] jjbitVec48 = {
1010    0xf3cdfdfffff99feeL, 0xffc3b0c0398fL, 0xc3bfc718d63dc7ecL, 0xff8000803dc7L
1011 };
1012 static final long[] jjbitVec49 = {
1013    0xc3effdfffffddfeeL, 0xffc300603ddfL, 0xc3effdfffffddfecL, 0xffc340603ddfL
1014 };
1015 static final long[] jjbitVec50 = {
1016    0xc3fffdfffffddfecL, 0xffc300803dcfL, 0x2ffbfffffc7fffecL, 0xc0000ff5f847fL
1017 };
1018 static final long[] jjbitVec51 = {
1019    0x87fffffffffffffeL, 0x3ff7fffL, 0x3bffecaefef02596L, 0x33ff3f5fL
1020 };
1021 static final long[] jjbitVec52 = {
1022    0xc2a003ff03000001L, 0xfffe07fffffffeffL, 0x1ffffffffeff0fdfL, 0x40L
1023 };
1024 static final long[] jjbitVec53 = {
1025    0x3c7f6fbffffffffL, 0x3ff03ffL, 0xffffffff00000000L, 0x7fffffffff003fL
1026 };
1027 static final long[] jjbitVec54 = {
1028    0xffffffff7f3d7fffL, 0x3fe0007ffff7fL, 0xffffffff00000000L, 0x1fffffffffffffL
1029 };
1030 static final long[] jjbitVec55 = {
1031    0x0L, 0x0L, 0xffffffffffffffffL, 0x3ff080fffffL
1032 };
1033 static final long[] jjbitVec56 = {
1034    0xffffffff03ff7800L, 0xffffffffffffffL, 0x3ffffffffffL, 0x0L
1035 };
1036 static final long[] jjbitVec57 = {
1037    0x80007c000000f000L, 0x8000fc0000000001L, 0xffff00000000L, 0x21fff0000L
1038 };
1039 static final long[] jjbitVec58 = {
1040    0x73efffe000000e0L, 0xfffffffffffffffeL, 0xfffffffe661fffffL, 0x7fffffffffffffffL
1041 };
1042 static final long[] jjbitVec59 = {
1043    0x5f7ffdffe0f8007fL, 0xffffffffffffffdbL, 0x3ffffffffffffL, 0xfffffffffff80000L
1044 };
1045 static final long[] jjbitVec60 = {
1046    0x18000f00000000L, 0xffd702000000e000L, 0xffffffffffffffffL, 0x9fffffffffffffffL
1047 };
1048 static final long[] jjbitVec61 = {
1049    0x87fffffe03ff0010L, 0xffffffe007fffffeL, 0x7fffffffffffffffL, 0xe0000631cfcfcfcL
1050 };
1051 private int jjMoveNfa_0(int startState, int curPos)
1052 {
1053    int startsAt = 0;
1054    jjnewStateCnt = 68;
1055    int i = 1;
1056    jjstateSet[0] = startState;
1057    int kind = 0x7fffffff;
1058    for (;;)
1059    {
1060       if (++jjround == 0x7fffffff)
1061          ReInitRounds();
1062       if (curChar < 64)
1063       {
1064          long l = 1L << curChar;
1065          do
1066          {
1067             switch(jjstateSet[--i])
1068             {
1069                case 45:
1070                   if (curChar == 42)
1071                      jjstateSet[jjnewStateCnt++] = 50;
1072                   else if (curChar == 47)
1073                   {
1074                      if (kind > 6)
1075                         kind = 6;
1076                      jjCheckNAddStates(0, 2);
1077                   }
1078                   break;
1079                case 0:
1080                   if ((0x3ff000000000000L & l) != 0L)
1081                      jjCheckNAddStates(3, 9);
1082                   else if (curChar == 47)
1083                      jjAddStates(10, 11);
1084                   else if (curChar == 36)
1085                   {
1086                      if (kind > 72)
1087                         kind = 72;
1088                      jjCheckNAdd(28);
1089                   }
1090                   else if (curChar == 34)
1091                      jjCheckNAddStates(12, 14);
1092                   else if (curChar == 39)
1093                      jjAddStates(15, 16);
1094                   else if (curChar == 46)
1095                      jjCheckNAdd(4);
1096                   if ((0x3fe000000000000L & l) != 0L)
1097                   {
1098                      if (kind > 63)
1099                         kind = 63;
1100                      jjCheckNAddTwoStates(1, 2);
1101                   }
1102                   else if (curChar == 48)
1103                   {
1104                      if (kind > 63)
1105                         kind = 63;
1106                      jjCheckNAddStates(17, 21);
1107                   }
1108                   break;
1109                case 1:
1110                   if ((0x3ff000000000000L & l) == 0L)
1111                      break;
1112                   if (kind > 63)
1113                      kind = 63;
1114                   jjCheckNAddTwoStates(1, 2);
1115                   break;
1116                case 3:
1117                   if (curChar == 46)
1118                      jjCheckNAdd(4);
1119                   break;
1120                case 4:
1121                   if ((0x3ff000000000000L & l) == 0L)
1122                      break;
1123                   if (kind > 67)
1124                      kind = 67;
1125                   jjCheckNAddStates(22, 24);
1126                   break;
1127                case 6:
1128                   if ((0x280000000000L & l) != 0L)
1129                      jjCheckNAdd(7);
1130                   break;
1131                case 7:
1132                   if ((0x3ff000000000000L & l) == 0L)
1133                      break;
1134                   if (kind > 67)
1135                      kind = 67;
1136                   jjCheckNAddTwoStates(7, 8);
1137                   break;
1138                case 9:
1139                   if (curChar == 39)
1140                      jjAddStates(15, 16);
1141                   break;
1142                case 10:
1143                   if ((0xffffff7fffffdbffL & l) != 0L)
1144                      jjCheckNAdd(11);
1145                   break;
1146                case 11:
1147                   if (curChar == 39 && kind > 70)
1148                      kind = 70;
1149                   break;
1150                case 13:
1151                   if ((0x8400000000L & l) != 0L)
1152                      jjCheckNAdd(11);
1153                   break;
1154                case 14:
1155                   if ((0xff000000000000L & l) != 0L)
1156                      jjCheckNAddTwoStates(15, 11);
1157                   break;
1158                case 15:
1159                   if ((0xff000000000000L & l) != 0L)
1160                      jjCheckNAdd(11);
1161                   break;
1162                case 16:
1163                   if ((0xf000000000000L & l) != 0L)
1164                      jjstateSet[jjnewStateCnt++] = 17;
1165                   break;
1166                case 17:
1167                   if ((0xff000000000000L & l) != 0L)
1168                      jjCheckNAdd(15);
1169                   break;
1170                case 18:
1171                   if (curChar == 34)
1172                      jjCheckNAddStates(12, 14);
1173                   break;
1174                case 19:
1175                   if ((0xfffffffbffffdbffL & l) != 0L)
1176                      jjCheckNAddStates(12, 14);
1177                   break;
1178                case 21:
1179                   if ((0x8400000000L & l) != 0L)
1180                      jjCheckNAddStates(12, 14);
1181                   break;
1182                case 22:
1183                   if (curChar == 34 && kind > 71)
1184                      kind = 71;
1185                   break;
1186                case 23:
1187                   if ((0xff000000000000L & l) != 0L)
1188                      jjCheckNAddStates(25, 28);
1189                   break;
1190                case 24:
1191                   if ((0xff000000000000L & l) != 0L)
1192                      jjCheckNAddStates(12, 14);
1193                   break;
1194                case 25:
1195                   if ((0xf000000000000L & l) != 0L)
1196                      jjstateSet[jjnewStateCnt++] = 26;
1197                   break;
1198                case 26:
1199                   if ((0xff000000000000L & l) != 0L)
1200                      jjCheckNAdd(24);
1201                   break;
1202                case 27:
1203                   if (curChar != 36)
1204                      break;
1205                   if (kind > 72)
1206                      kind = 72;
1207                   jjCheckNAdd(28);
1208                   break;
1209                case 28:
1210                   if ((0x3ff00100fffc1ffL & l) == 0L)
1211                      break;
1212                   if (kind > 72)
1213                      kind = 72;
1214                   jjCheckNAdd(28);
1215                   break;
1216                case 29:
1217                   if ((0x3ff000000000000L & l) != 0L)
1218                      jjCheckNAddStates(3, 9);
1219                   break;
1220                case 30:
1221                   if ((0x3ff000000000000L & l) != 0L)
1222                      jjCheckNAddTwoStates(30, 31);
1223                   break;
1224                case 31:
1225                   if (curChar != 46)
1226                      break;
1227                   if (kind > 67)
1228                      kind = 67;
1229                   jjCheckNAddStates(29, 31);
1230                   break;
1231                case 32:
1232                   if ((0x3ff000000000000L & l) == 0L)
1233                      break;
1234                   if (kind > 67)
1235                      kind = 67;
1236                   jjCheckNAddStates(29, 31);
1237                   break;
1238                case 34:
1239                   if ((0x280000000000L & l) != 0L)
1240                      jjCheckNAdd(35);
1241                   break;
1242                case 35:
1243                   if ((0x3ff000000000000L & l) == 0L)
1244                      break;
1245                   if (kind > 67)
1246                      kind = 67;
1247                   jjCheckNAddTwoStates(35, 8);
1248                   break;
1249                case 36:
1250                   if ((0x3ff000000000000L & l) != 0L)
1251                      jjCheckNAddTwoStates(36, 37);
1252                   break;
1253                case 38:
1254                   if ((0x280000000000L & l) != 0L)
1255                      jjCheckNAdd(39);
1256                   break;
1257                case 39:
1258                   if ((0x3ff000000000000L & l) == 0L)
1259                      break;
1260                   if (kind > 67)
1261                      kind = 67;
1262                   jjCheckNAddTwoStates(39, 8);
1263                   break;
1264                case 40:
1265                   if ((0x3ff000000000000L & l) != 0L)
1266                      jjCheckNAddStates(32, 34);
1267                   break;
1268                case 42:
1269                   if ((0x280000000000L & l) != 0L)
1270                      jjCheckNAdd(43);
1271                   break;
1272                case 43:
1273                   if ((0x3ff000000000000L & l) != 0L)
1274                      jjCheckNAddTwoStates(43, 8);
1275                   break;
1276                case 44:
1277                   if (curChar == 47)
1278                      jjAddStates(10, 11);
1279                   break;
1280                case 46:
1281                   if ((0xffffffffffffdbffL & l) == 0L)
1282                      break;
1283                   if (kind > 6)
1284                      kind = 6;
1285                   jjCheckNAddStates(0, 2);
1286                   break;
1287                case 47:
1288                   if ((0x2400L & l) != 0L && kind > 6)
1289                      kind = 6;
1290                   break;
1291                case 48:
1292                   if (curChar == 10 && kind > 6)
1293                      kind = 6;
1294                   break;
1295                case 49:
1296                   if (curChar == 13)
1297                      jjstateSet[jjnewStateCnt++] = 48;
1298                   break;
1299                case 50:
1300                   if (curChar == 42)
1301                      jjstateSet[jjnewStateCnt++] = 51;
1302                   break;
1303                case 51:
1304                   if ((0xffff7fffffffffffL & l) != 0L && kind > 7)
1305                      kind = 7;
1306                   break;
1307                case 52:
1308                   if (curChar == 42)
1309                      jjstateSet[jjnewStateCnt++] = 50;
1310                   break;
1311                case 53:
1312                   if (curChar != 48)
1313                      break;
1314                   if (kind > 63)
1315                      kind = 63;
1316                   jjCheckNAddStates(17, 21);
1317                   break;
1318                case 55:
1319                   if ((0x3ff000000000000L & l) == 0L)
1320                      break;
1321                   if (kind > 63)
1322                      kind = 63;
1323                   jjCheckNAddTwoStates(55, 2);
1324                   break;
1325                case 56:
1326                   if ((0xff000000000000L & l) == 0L)
1327                      break;
1328                   if (kind > 63)
1329                      kind = 63;
1330                   jjCheckNAddTwoStates(56, 2);
1331                   break;
1332                case 58:
1333                   if ((0x3ff000000000000L & l) != 0L)
1334                      jjCheckNAddStates(35, 37);
1335                   break;
1336                case 59:
1337                   if (curChar == 46)
1338                      jjCheckNAdd(60);
1339                   break;
1340                case 61:
1341                   if ((0x280000000000L & l) != 0L)
1342                      jjCheckNAdd(62);
1343                   break;
1344                case 62:
1345                   if ((0x3ff000000000000L & l) == 0L)
1346                      break;
1347                   if (kind > 68)
1348                      kind = 68;
1349                   jjCheckNAddTwoStates(62, 63);
1350                   break;
1351                case 65:
1352                   if ((0x3ff000000000000L & l) != 0L)
1353                      jjAddStates(38, 39);
1354                   break;
1355                case 66:
1356                   if (curChar == 46)
1357                      jjCheckNAdd(67);
1358                   break;
1359                case 67:
1360                   if ((0x3ff000000000000L & l) != 0L)
1361                      jjCheckNAddTwoStates(67, 60);
1362                   break;
1363                default : break;
1364             }
1365          } while(i != startsAt);
1366       }
1367       else if (curChar < 128)
1368       {
1369          long l = 1L << (curChar & 077);
1370          do
1371          {
1372             switch(jjstateSet[--i])
1373             {
1374                case 0:
1375                   if ((0x7fffffe87fffffeL & l) == 0L)
1376                      break;
1377                   if (kind > 72)
1378                      kind = 72;
1379                   jjCheckNAdd(28);
1380                   break;
1381                case 2:
1382                   if ((0x100000001000L & l) != 0L && kind > 63)
1383                      kind = 63;
1384                   break;
1385                case 5:
1386                   if ((0x2000000020L & l) != 0L)
1387                      jjAddStates(40, 41);
1388                   break;
1389                case 8:
1390                   if ((0x5000000050L & l) != 0L && kind > 67)
1391                      kind = 67;
1392                   break;
1393                case 10:
1394                   if ((0xffffffffefffffffL & l) != 0L)
1395                      jjCheckNAdd(11);
1396                   break;
1397                case 12:
1398                   if (curChar == 92)
1399                      jjAddStates(42, 44);
1400                   break;
1401                case 13:
1402                   if ((0x14404410000000L & l) != 0L)
1403                      jjCheckNAdd(11);
1404                   break;
1405                case 19:
1406                   if ((0xffffffffefffffffL & l) != 0L)
1407                      jjCheckNAddStates(12, 14);
1408                   break;
1409                case 20:
1410                   if (curChar == 92)
1411                      jjAddStates(45, 47);
1412                   break;
1413                case 21:
1414                   if ((0x14404410000000L & l) != 0L)
1415                      jjCheckNAddStates(12, 14);
1416                   break;
1417                case 28:
1418                   if ((0x87fffffe87fffffeL & l) == 0L)
1419                      break;
1420                   if (kind > 72)
1421                      kind = 72;
1422                   jjCheckNAdd(28);
1423                   break;
1424                case 33:
1425                   if ((0x2000000020L & l) != 0L)
1426                      jjAddStates(48, 49);
1427                   break;
1428                case 37:
1429                   if ((0x2000000020L & l) != 0L)
1430                      jjAddStates(50, 51);
1431                   break;
1432                case 41:
1433                   if ((0x2000000020L & l) != 0L)
1434                      jjAddStates(52, 53);
1435                   break;
1436                case 46:
1437                   if (kind > 6)
1438                      kind = 6;
1439                   jjAddStates(0, 2);
1440                   break;
1441                case 51:
1442                   if (kind > 7)
1443                      kind = 7;
1444                   break;
1445                case 54:
1446                   if ((0x100000001000000L & l) != 0L)
1447                      jjCheckNAdd(55);
1448                   break;
1449                case 55:
1450                   if ((0x7e0000007eL & l) == 0L)
1451                      break;
1452                   if (kind > 63)
1453                      kind = 63;
1454                   jjCheckNAddTwoStates(55, 2);
1455                   break;
1456                case 57:
1457                   if ((0x100000001000000L & l) != 0L)
1458                      jjCheckNAdd(58);
1459                   break;
1460                case 58:
1461                   if ((0x7e0000007eL & l) != 0L)
1462                      jjCheckNAddStates(35, 37);
1463                   break;
1464                case 60:
1465                   if ((0x1000000010000L & l) != 0L)
1466                      jjAddStates(54, 55);
1467                   break;
1468                case 63:
1469                   if ((0x5000000050L & l) != 0L && kind > 68)
1470                      kind = 68;
1471                   break;
1472                case 64:
1473                   if ((0x100000001000000L & l) != 0L)
1474                      jjCheckNAddTwoStates(65, 66);
1475                   break;
1476                case 65:
1477                   if ((0x7e0000007eL & l) != 0L)
1478                      jjCheckNAddTwoStates(65, 66);
1479                   break;
1480                case 67:
1481                   if ((0x7e0000007eL & l) != 0L)
1482                      jjCheckNAddTwoStates(67, 60);
1483                   break;
1484                default : break;
1485             }
1486          } while(i != startsAt);
1487       }
1488       else
1489       {
1490          int hiByte = (int)(curChar >> 8);
1491          int i1 = hiByte >> 6;
1492          long l1 = 1L << (hiByte & 077);
1493          int i2 = (curChar & 0xff) >> 6;
1494          long l2 = 1L << (curChar & 077);
1495          do
1496          {
1497             switch(jjstateSet[--i])
1498             {
1499                case 0:
1500                   if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
1501                      break;
1502                   if (kind > 72)
1503                      kind = 72;
1504                   jjCheckNAdd(28);
1505                   break;
1506                case 10:
1507                   if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1508                      jjstateSet[jjnewStateCnt++] = 11;
1509                   break;
1510                case 19:
1511                   if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1512                      jjAddStates(12, 14);
1513                   break;
1514                case 28:
1515                   if (!jjCanMove_2(hiByte, i1, i2, l1, l2))
1516                      break;
1517                   if (kind > 72)
1518                      kind = 72;
1519                   jjCheckNAdd(28);
1520                   break;
1521                case 46:
1522                   if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
1523                      break;
1524                   if (kind > 6)
1525                      kind = 6;
1526                   jjAddStates(0, 2);
1527                   break;
1528                case 51:
1529                   if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 7)
1530                      kind = 7;
1531                   break;
1532                default : break;
1533             }
1534          } while(i != startsAt);
1535       }
1536       if (kind != 0x7fffffff)
1537       {
1538          jjmatchedKind = kind;
1539          jjmatchedPos = curPos;
1540          kind = 0x7fffffff;
1541       }
1542       ++curPos;
1543       if ((i = jjnewStateCnt) == (startsAt = 68 - (jjnewStateCnt = startsAt)))
1544          return curPos;
1545       try { curChar = input_stream.readChar(); }
1546       catch(java.io.IOException e) { return curPos; }
1547    }
1548 }
1549 private int jjMoveStringLiteralDfa0_2()
1550 {
1551    switch(curChar)
1552    {
1553       case 42:
1554          return jjMoveStringLiteralDfa1_2(0x400L);
1555       default :
1556          return 1;
1557    }
1558 }
1559 private int jjMoveStringLiteralDfa1_2(long active0)
1560 {
1561    try { curChar = input_stream.readChar(); }
1562    catch(java.io.IOException e) {
1563       return 1;
1564    }
1565    switch(curChar)
1566    {
1567       case 47:
1568          if ((active0 & 0x400L) != 0L)
1569             return jjStopAtPos(1, 10);
1570          break;
1571       default :
1572          return 2;
1573    }
1574    return 2;
1575 }
1576 private int jjMoveStringLiteralDfa0_1()
1577 {
1578    switch(curChar)
1579    {
1580       case 42:
1581          return jjMoveStringLiteralDfa1_1(0x200L);
1582       default :
1583          return 1;
1584    }
1585 }
1586 private int jjMoveStringLiteralDfa1_1(long active0)
1587 {
1588    try { curChar = input_stream.readChar(); }
1589    catch(java.io.IOException e) {
1590       return 1;
1591    }
1592    switch(curChar)
1593    {
1594       case 47:
1595          if ((active0 & 0x200L) != 0L)
1596             return jjStopAtPos(1, 9);
1597          break;
1598       default :
1599          return 2;
1600    }
1601    return 2;
1602 }
1603 static final int[] jjnextStates = {
1604    46, 47, 49, 30, 31, 36, 37, 40, 41, 8, 45, 52, 19, 20, 22, 10, 
1605    12, 54, 56, 2, 57, 64, 4, 5, 8, 19, 20, 24, 22, 32, 33, 8, 
1606    40, 41, 8, 58, 59, 60, 65, 66, 6, 7, 13, 14, 16, 21, 23, 25, 
1607    34, 35, 38, 39, 42, 43, 61, 62, 
1608 };
1609 private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2)
1610 {
1611    switch(hiByte)
1612    {
1613       case 0:
1614          return ((jjbitVec2[i2] & l2) != 0L);
1615       default :
1616          if ((jjbitVec0[i1] & l1) != 0L)
1617             return true;
1618          return false;
1619    }
1620 }
1621 private static final boolean jjCanMove_1(int hiByte, int i1, int i2, long l1, long l2)
1622 {
1623    switch(hiByte)
1624    {
1625       case 0:
1626          return ((jjbitVec4[i2] & l2) != 0L);
1627       case 2:
1628          return ((jjbitVec5[i2] & l2) != 0L);
1629       case 3:
1630          return ((jjbitVec6[i2] & l2) != 0L);
1631       case 4:
1632          return ((jjbitVec7[i2] & l2) != 0L);
1633       case 5:
1634          return ((jjbitVec8[i2] & l2) != 0L);
1635       case 6:
1636          return ((jjbitVec9[i2] & l2) != 0L);
1637       case 7:
1638          return ((jjbitVec10[i2] & l2) != 0L);
1639       case 9:
1640          return ((jjbitVec11[i2] & l2) != 0L);
1641       case 10:
1642          return ((jjbitVec12[i2] & l2) != 0L);
1643       case 11:
1644          return ((jjbitVec13[i2] & l2) != 0L);
1645       case 12:
1646          return ((jjbitVec14[i2] & l2) != 0L);
1647       case 13:
1648          return ((jjbitVec15[i2] & l2) != 0L);
1649       case 14:
1650          return ((jjbitVec16[i2] & l2) != 0L);
1651       case 15:
1652          return ((jjbitVec17[i2] & l2) != 0L);
1653       case 16:
1654          return ((jjbitVec18[i2] & l2) != 0L);
1655       case 17:
1656          return ((jjbitVec19[i2] & l2) != 0L);
1657       case 18:
1658          return ((jjbitVec20[i2] & l2) != 0L);
1659       case 19:
1660          return ((jjbitVec21[i2] & l2) != 0L);
1661       case 20:
1662          return ((jjbitVec0[i2] & l2) != 0L);
1663       case 22:
1664          return ((jjbitVec22[i2] & l2) != 0L);
1665       case 23:
1666          return ((jjbitVec23[i2] & l2) != 0L);
1667       case 24:
1668          return ((jjbitVec24[i2] & l2) != 0L);
1669       case 30:
1670          return ((jjbitVec25[i2] & l2) != 0L);
1671       case 31:
1672          return ((jjbitVec26[i2] & l2) != 0L);
1673       case 32:
1674          return ((jjbitVec27[i2] & l2) != 0L);
1675       case 33:
1676          return ((jjbitVec28[i2] & l2) != 0L);
1677       case 48:
1678          return ((jjbitVec29[i2] & l2) != 0L);
1679       case 49:
1680          return ((jjbitVec30[i2] & l2) != 0L);
1681       case 77:
1682          return ((jjbitVec31[i2] & l2) != 0L);
1683       case 159:
1684          return ((jjbitVec32[i2] & l2) != 0L);
1685       case 164:
1686          return ((jjbitVec33[i2] & l2) != 0L);
1687       case 215:
1688          return ((jjbitVec34[i2] & l2) != 0L);
1689       case 250:
1690          return ((jjbitVec35[i2] & l2) != 0L);
1691       case 251:
1692          return ((jjbitVec36[i2] & l2) != 0L);
1693       case 253:
1694          return ((jjbitVec37[i2] & l2) != 0L);
1695       case 254:
1696          return ((jjbitVec38[i2] & l2) != 0L);
1697       case 255:
1698          return ((jjbitVec39[i2] & l2) != 0L);
1699       default :
1700          if ((jjbitVec3[i1] & l1) != 0L)
1701             return true;
1702          return false;
1703    }
1704 }
1705 private static final boolean jjCanMove_2(int hiByte, int i1, int i2, long l1, long l2)
1706 {
1707    switch(hiByte)
1708    {
1709       case 0:
1710          return ((jjbitVec40[i2] & l2) != 0L);
1711       case 2:
1712          return ((jjbitVec5[i2] & l2) != 0L);
1713       case 3:
1714          return ((jjbitVec41[i2] & l2) != 0L);
1715       case 4:
1716          return ((jjbitVec42[i2] & l2) != 0L);
1717       case 5:
1718          return ((jjbitVec43[i2] & l2) != 0L);
1719       case 6:
1720          return ((jjbitVec44[i2] & l2) != 0L);
1721       case 7:
1722          return ((jjbitVec45[i2] & l2) != 0L);
1723       case 9:
1724          return ((jjbitVec46[i2] & l2) != 0L);
1725       case 10:
1726          return ((jjbitVec47[i2] & l2) != 0L);
1727       case 11:
1728          return ((jjbitVec48[i2] & l2) != 0L);
1729       case 12:
1730          return ((jjbitVec49[i2] & l2) != 0L);
1731       case 13:
1732          return ((jjbitVec50[i2] & l2) != 0L);
1733       case 14:
1734          return ((jjbitVec51[i2] & l2) != 0L);
1735       case 15:
1736          return ((jjbitVec52[i2] & l2) != 0L);
1737       case 16:
1738          return ((jjbitVec53[i2] & l2) != 0L);
1739       case 17:
1740          return ((jjbitVec19[i2] & l2) != 0L);
1741       case 18:
1742          return ((jjbitVec20[i2] & l2) != 0L);
1743       case 19:
1744          return ((jjbitVec54[i2] & l2) != 0L);
1745       case 20:
1746          return ((jjbitVec0[i2] & l2) != 0L);
1747       case 22:
1748          return ((jjbitVec22[i2] & l2) != 0L);
1749       case 23:
1750          return ((jjbitVec55[i2] & l2) != 0L);
1751       case 24:
1752          return ((jjbitVec56[i2] & l2) != 0L);
1753       case 30:
1754          return ((jjbitVec25[i2] & l2) != 0L);
1755       case 31:
1756          return ((jjbitVec26[i2] & l2) != 0L);
1757       case 32:
1758          return ((jjbitVec57[i2] & l2) != 0L);
1759       case 33:
1760          return ((jjbitVec28[i2] & l2) != 0L);
1761       case 48:
1762          return ((jjbitVec58[i2] & l2) != 0L);
1763       case 49:
1764          return ((jjbitVec30[i2] & l2) != 0L);
1765       case 77:
1766          return ((jjbitVec31[i2] & l2) != 0L);
1767       case 159:
1768          return ((jjbitVec32[i2] & l2) != 0L);
1769       case 164:
1770          return ((jjbitVec33[i2] & l2) != 0L);
1771       case 215:
1772          return ((jjbitVec34[i2] & l2) != 0L);
1773       case 250:
1774          return ((jjbitVec35[i2] & l2) != 0L);
1775       case 251:
1776          return ((jjbitVec59[i2] & l2) != 0L);
1777       case 253:
1778          return ((jjbitVec37[i2] & l2) != 0L);
1779       case 254:
1780          return ((jjbitVec60[i2] & l2) != 0L);
1781       case 255:
1782          return ((jjbitVec61[i2] & l2) != 0L);
1783       default :
1784          if ((jjbitVec3[i1] & l1) != 0L)
1785             return true;
1786          return false;
1787    }
1788 }
1789 
1790 /** Token literal values. */
1791 public static final String[] jjstrLiteralImages = {
1792 "", null, null, null, null, null, null, null, null, null, null, null, 
1793 "\141\142\163\164\162\141\143\164", "\142\157\157\154\145\141\156", "\142\162\145\141\153", "\142\171\164\145", 
1794 "\143\141\163\145", "\143\141\164\143\150", "\143\150\141\162", "\143\154\141\163\163", 
1795 "\143\157\156\163\164", "\143\157\156\164\151\156\165\145", "\144\145\146\141\165\154\164", 
1796 "\144\157", "\144\157\165\142\154\145", "\145\154\163\145", 
1797 "\145\170\164\145\156\144\163", "\146\141\154\163\145", "\146\151\156\141\154", 
1798 "\146\151\156\141\154\154\171", "\146\154\157\141\164", "\146\157\162", "\147\157\164\157", "\151\146", 
1799 "\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", 
1800 "\151\156\164", "\151\156\164\145\162\146\141\143\145", "\154\157\156\147", 
1801 "\156\141\164\151\166\145", "\156\145\167", "\156\165\154\154", "\160\141\143\153\141\147\145", 
1802 "\160\162\151\166\141\164\145", "\160\162\157\164\145\143\164\145\144", "\160\165\142\154\151\143", 
1803 "\162\145\164\165\162\156", "\163\150\157\162\164", "\163\164\141\164\151\143", "\163\165\160\145\162", 
1804 "\163\167\151\164\143\150", "\163\171\156\143\150\162\157\156\151\172\145\144", "\164\150\151\163", 
1805 "\164\150\162\157\167", "\164\150\162\157\167\163", "\164\162\141\156\163\151\145\156\164", 
1806 "\164\162\165\145", "\164\162\171", "\166\157\151\144", "\166\157\154\141\164\151\154\145", 
1807 "\167\150\151\154\145", "\163\164\162\151\143\164\146\160", null, null, null, null, null, null, null, 
1808 null, null, null, null, null, "\50", "\51", "\173", "\175", "\133", "\135", "\73", 
1809 "\54", "\56", "\100", "\75", "\74", "\41", "\176", "\77", "\72", "\75\75", "\74\75", 
1810 "\76\75", "\41\75", "\174\174", "\46\46", "\53\53", "\55\55", "\53", "\55", "\52", 
1811 "\57", "\46", "\174", "\136", "\45", "\74\74", "\53\75", "\55\75", "\52\75", 
1812 "\57\75", "\46\75", "\174\75", "\136\75", "\45\75", "\74\74\75", "\76\76\75", 
1813 "\76\76\76\75", "\56\56\56", "\76\76\76", "\76\76", "\76", "\32", "\176\133\135", };
1814 
1815 /** Lexer state names. */
1816 public static final String[] lexStateNames = {
1817    "DEFAULT",
1818    "IN_FORMAL_COMMENT",
1819    "IN_MULTI_LINE_COMMENT",
1820 };
1821 
1822 /** Lex State array. */
1823 public static final int[] jjnewLexState = {
1824    -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, 
1825    -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, 
1826    -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, 
1827    -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, 
1828    -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, 
1829 };
1830 static final long[] jjtoToken = {
1831    0xfffffffffffff001L, 0x1ffffffffffff9d8L, 
1832 };
1833 static final long[] jjtoSkip = {
1834    0x67eL, 0x0L, 
1835 };
1836 static final long[] jjtoSpecial = {
1837    0x67eL, 0x0L, 
1838 };
1839 static final long[] jjtoMore = {
1840    0x980L, 0x0L, 
1841 };
1842 protected CharStream input_stream;
1843 private final int[] jjrounds = new int[68];
1844 private final int[] jjstateSet = new int[136];
1845 private final StringBuilder jjimage = new StringBuilder();
1846 private StringBuilder image = jjimage;
1847 private int jjimageLen;
1848 private int lengthOfMatch;
1849 protected char curChar;
1850 /** Constructor. */
1851 public JavaParserTokenManager(CharStream stream){
1852    input_stream = stream;
1853 }
1854 
1855 /** Constructor. */
1856 public JavaParserTokenManager(CharStream stream, int lexState){
1857    this(stream);
1858    SwitchTo(lexState);
1859 }
1860 
1861 /** Reinitialise parser. */
1862 public void ReInit(CharStream stream)
1863 {
1864    jjmatchedPos = jjnewStateCnt = 0;
1865    curLexState = defaultLexState;
1866    input_stream = stream;
1867    ReInitRounds();
1868 }
1869 private void ReInitRounds()
1870 {
1871    int i;
1872    jjround = 0x80000001;
1873    for (i = 68; i-- > 0;)
1874       jjrounds[i] = 0x80000000;
1875 }
1876 
1877 /** Reinitialise parser. */
1878 public void ReInit(CharStream stream, int lexState)
1879 {
1880    ReInit(stream);
1881    SwitchTo(lexState);
1882 }
1883 
1884 /** Switch to specified lex state. */
1885 public void SwitchTo(int lexState)
1886 {
1887    if (lexState >= 3 || lexState < 0)
1888       throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
1889    else
1890       curLexState = lexState;
1891 }
1892 
1893 protected Token jjFillToken()
1894 {
1895    final Token t;
1896    final String curTokenImage;
1897    final int beginLine;
1898    final int endLine;
1899    final int beginColumn;
1900    final int endColumn;
1901    String im = jjstrLiteralImages[jjmatchedKind];
1902    curTokenImage = (im == null) ? input_stream.GetImage() : im;
1903    beginLine = input_stream.getBeginLine();
1904    beginColumn = input_stream.getBeginColumn();
1905    endLine = input_stream.getEndLine();
1906    endColumn = input_stream.getEndColumn();
1907    t = Token.newToken(jjmatchedKind, curTokenImage);
1908 
1909    t.beginLine = beginLine;
1910    t.endLine = endLine;
1911    t.beginColumn = beginColumn;
1912    t.endColumn = endColumn;
1913 
1914    return t;
1915 }
1916 
1917 int curLexState = 0;
1918 int defaultLexState = 0;
1919 int jjnewStateCnt;
1920 int jjround;
1921 int jjmatchedPos;
1922 int jjmatchedKind;
1923 
1924 /** Get the next Token. */
1925 public Token getNextToken() 
1926 {
1927   Token specialToken = null;
1928   Token matchedToken;
1929   int curPos = 0;
1930 
1931   EOFLoop :
1932   for (;;)
1933   {
1934    try
1935    {
1936       curChar = input_stream.BeginToken();
1937    }
1938    catch(java.io.IOException e)
1939    {
1940       jjmatchedKind = 0;
1941       matchedToken = jjFillToken();
1942       matchedToken.specialToken = specialToken;
1943       return matchedToken;
1944    }
1945    image = jjimage;
1946    image.setLength(0);
1947    jjimageLen = 0;
1948 
1949    for (;;)
1950    {
1951      switch(curLexState)
1952      {
1953        case 0:
1954          jjmatchedKind = 0x7fffffff;
1955          jjmatchedPos = 0;
1956          curPos = jjMoveStringLiteralDfa0_0();
1957          break;
1958        case 1:
1959          jjmatchedKind = 0x7fffffff;
1960          jjmatchedPos = 0;
1961          curPos = jjMoveStringLiteralDfa0_1();
1962          if (jjmatchedPos == 0 && jjmatchedKind > 11)
1963          {
1964             jjmatchedKind = 11;
1965          }
1966          break;
1967        case 2:
1968          jjmatchedKind = 0x7fffffff;
1969          jjmatchedPos = 0;
1970          curPos = jjMoveStringLiteralDfa0_2();
1971          if (jjmatchedPos == 0 && jjmatchedKind > 11)
1972          {
1973             jjmatchedKind = 11;
1974          }
1975          break;
1976      }
1977      if (jjmatchedKind != 0x7fffffff)
1978      {
1979         if (jjmatchedPos + 1 < curPos)
1980            input_stream.backup(curPos - jjmatchedPos - 1);
1981         if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
1982         {
1983            matchedToken = jjFillToken();
1984            matchedToken.specialToken = specialToken;
1985            TokenLexicalActions(matchedToken);
1986        if (jjnewLexState[jjmatchedKind] != -1)
1987          curLexState = jjnewLexState[jjmatchedKind];
1988            return matchedToken;
1989         }
1990         else if ((jjtoSkip[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
1991         {
1992            if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
1993            {
1994               matchedToken = jjFillToken();
1995               if (specialToken == null)
1996                  specialToken = matchedToken;
1997               else
1998               {
1999                  matchedToken.specialToken = specialToken;
2000                  specialToken = (specialToken.next = matchedToken);
2001               }
2002               SkipLexicalActions(matchedToken);
2003            }
2004            else
2005               SkipLexicalActions(null);
2006          if (jjnewLexState[jjmatchedKind] != -1)
2007            curLexState = jjnewLexState[jjmatchedKind];
2008            continue EOFLoop;
2009         }
2010         MoreLexicalActions();
2011       if (jjnewLexState[jjmatchedKind] != -1)
2012         curLexState = jjnewLexState[jjmatchedKind];
2013         curPos = 0;
2014         jjmatchedKind = 0x7fffffff;
2015         try {
2016            curChar = input_stream.readChar();
2017            continue;
2018         }
2019         catch (java.io.IOException e1) { }
2020      }
2021      int error_line = input_stream.getEndLine();
2022      int error_column = input_stream.getEndColumn();
2023      String error_after = null;
2024      boolean EOFSeen = false;
2025      try { input_stream.readChar(); input_stream.backup(1); }
2026      catch (java.io.IOException e1) {
2027         EOFSeen = true;
2028         error_after = curPos <= 1 ? "" : input_stream.GetImage();
2029         if (curChar == '\n' || curChar == '\r') {
2030            error_line++;
2031            error_column = 0;
2032         }
2033         else
2034            error_column++;
2035      }
2036      if (!EOFSeen) {
2037         input_stream.backup(1);
2038         error_after = curPos <= 1 ? "" : input_stream.GetImage();
2039      }
2040      throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
2041    }
2042   }
2043 }
2044 
2045 void SkipLexicalActions(Token matchedToken)
2046 {
2047    switch(jjmatchedKind)
2048    {
2049       case 6 :
2050          image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
2051         int startOfNOPMD = matchedToken.image.indexOf(excludeMarker);
2052         if (startOfNOPMD != -1) {
2053             excludeMap.put(matchedToken.beginLine, matchedToken.image.substring(startOfNOPMD + excludeMarker.length()));
2054         }
2055         comments.add(new SingleLineComment(matchedToken));
2056          break;
2057       case 9 :
2058          image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
2059                             comments.add(new FormalComment(matchedToken));
2060          break;
2061       case 10 :
2062          image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
2063                                 comments.add(new MultiLineComment(matchedToken));
2064          break;
2065       default :
2066          break;
2067    }
2068 }
2069 void MoreLexicalActions()
2070 {
2071    jjimageLen += (lengthOfMatch = jjmatchedPos + 1);
2072    switch(jjmatchedKind)
2073    {
2074       case 7 :
2075          image.append(input_stream.GetSuffix(jjimageLen));
2076          jjimageLen = 0;
2077                    input_stream.backup(1);
2078          break;
2079       default :
2080          break;
2081    }
2082 }
2083 void TokenLexicalActions(Token matchedToken)
2084 {
2085    switch(jjmatchedKind)
2086    {
2087       case 120 :
2088         image.append(jjstrLiteralImages[120]);
2089         lengthOfMatch = jjstrLiteralImages[120].length();
2090      matchedToken.kind = GT;
2091      ((Token.GTToken)matchedToken).realKind = RUNSIGNEDSHIFT;
2092      input_stream.backup(2);
2093      matchedToken.image = ">";
2094          break;
2095       case 121 :
2096         image.append(jjstrLiteralImages[121]);
2097         lengthOfMatch = jjstrLiteralImages[121].length();
2098      matchedToken.kind = GT;
2099      ((Token.GTToken)matchedToken).realKind = RSIGNEDSHIFT;
2100      input_stream.backup(1);
2101      matchedToken.image = ">";
2102          break;
2103       default :
2104          break;
2105    }
2106 }
2107 private void jjCheckNAdd(int state)
2108 {
2109    if (jjrounds[state] != jjround)
2110    {
2111       jjstateSet[jjnewStateCnt++] = state;
2112       jjrounds[state] = jjround;
2113    }
2114 }
2115 private void jjAddStates(int start, int end)
2116 {
2117    do {
2118       jjstateSet[jjnewStateCnt++] = jjnextStates[start];
2119    } while (start++ != end);
2120 }
2121 private void jjCheckNAddTwoStates(int state1, int state2)
2122 {
2123    jjCheckNAdd(state1);
2124    jjCheckNAdd(state2);
2125 }
2126 
2127 private void jjCheckNAddStates(int start, int end)
2128 {
2129    do {
2130       jjCheckNAdd(jjnextStates[start]);
2131    } while (start++ != end);
2132 }
2133 
2134 }