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