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