View Javadoc

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