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 & 0x100L) != 0L)
20           {
21              jjmatchedKind = 137;
22              return 19;
23           }
24           if ((active0 & 0x80000000L) != 0L || (active1 & 0xaL) != 0L)
25              return 1;
26           return -1;
27        case 1:
28           if ((active1 & 0x7fffffff7f3fe0L) != 0L || (active2 & 0x100L) != 0L)
29           {
30              if (jjmatchedPos != 1)
31              {
32                 jjmatchedKind = 137;
33                 jjmatchedPos = 1;
34              }
35              return 19;
36           }
37           if ((active1 & 0x80c000L) != 0L)
38              return 19;
39           return -1;
40        case 2:
41           if ((active1 & 0x7ff7fff56fbfe0L) != 0L || (active2 & 0x100L) != 0L)
42           {
43              jjmatchedKind = 137;
44              jjmatchedPos = 2;
45              return 19;
46           }
47           if ((active1 & 0x8000a100000L) != 0L)
48              return 19;
49           return -1;
50        case 3:
51           if ((active1 & 0x6ef3fff12cbd40L) != 0L || (active2 & 0x100L) != 0L)
52           {
53              jjmatchedKind = 137;
54              jjmatchedPos = 3;
55              return 19;
56           }
57           if ((active1 & 0x110400044302a0L) != 0L)
58              return 19;
59           return -1;
60        case 4:
61           if ((active1 & 0xad37bf124b800L) != 0L || (active2 & 0x100L) != 0L)
62           {
63              jjmatchedKind = 137;
64              jjmatchedPos = 4;
65              return 19;
66           }
67           if ((active1 & 0x64208400080540L) != 0L)
68              return 19;
69           return -1;
70        case 5:
71           if ((active1 & 0x17a4124a000L) != 0L)
72              return 19;
73           if ((active1 & 0xad201b0001800L) != 0L || (active2 & 0x100L) != 0L)
74           {
75              jjmatchedKind = 137;
76              jjmatchedPos = 5;
77              return 19;
78           }
79           return -1;
80        case 6:
81           if ((active1 & 0xa4201a0000800L) != 0L)
82           {
83              jjmatchedKind = 137;
84              jjmatchedPos = 6;
85              return 19;
86           }
87           if ((active1 & 0x900010001000L) != 0L || (active2 & 0x100L) != 0L)
88              return 19;
89           return -1;
90        case 7:
91           if ((active1 & 0xa0000000L) != 0L)
92           {
93              jjmatchedKind = 137;
94              jjmatchedPos = 7;
95              return 19;
96           }
97           if ((active1 & 0xa420100000800L) != 0L)
98              return 19;
99           return -1;
100       case 8:
101          if ((active1 & 0x80000000L) != 0L)
102          {
103             jjmatchedKind = 137;
104             jjmatchedPos = 8;
105             return 19;
106          }
107          if ((active1 & 0x20000000L) != 0L)
108             return 19;
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, 0x100L);
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(18, 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, 19);
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, 0x100L);
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, 0x100L);
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, 19);
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, 19);
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, 19);
432          break;
433       case 121:
434          if ((active1 & 0x80000000000L) != 0L)
435             return jjStartNfaWithStates_0(2, 107, 19);
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, 0x100L);
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, 19);
464          break;
465       case 101:
466          if ((active1 & 0x80L) != 0L)
467             return jjStartNfaWithStates_0(3, 71, 19);
468          else if ((active1 & 0x10000L) != 0L)
469             return jjStartNfaWithStates_0(3, 80, 19);
470          else if ((active1 & 0x10000000000000L) != 0L)
471             return jjStartNfaWithStates_0(3, 116, 19);
472          return jjMoveStringLiteralDfa4_0(active1, 0x101080242000L, active2, 0L);
473       case 103:
474          if ((active1 & 0x4000000L) != 0L)
475             return jjStartNfaWithStates_0(3, 90, 19);
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, 19);
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, 19);
490          else if ((active1 & 0x400000L) != 0L)
491             return jjStartNfaWithStates_0(3, 86, 19);
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, 19);
498          return jjMoveStringLiteralDfa4_0(active1, 0x8000400000000L, active2, 0L);
499       case 115:
500          if ((active1 & 0x40000000000L) != 0L)
501             return jjStartNfaWithStates_0(3, 106, 19);
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, 19);
534          else if ((active1 & 0x20000000000000L) != 0L)
535             return jjStartNfaWithStates_0(4, 117, 19);
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, 19);
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, 19);
548          break;
549       case 108:
550          return jjMoveStringLiteralDfa5_0(active1, 0x20000008000L, active2, 0x100L);
551       case 110:
552          if ((active1 & 0x200000000000L) != 0L)
553             return jjStartNfaWithStates_0(4, 109, 19);
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, 19);
562          return jjMoveStringLiteralDfa5_0(active1, 0x100000000L, active2, 0L);
563       case 116:
564          if ((active1 & 0x400L) != 0L)
565             return jjStartNfaWithStates_0(4, 74, 19);
566          else if ((active1 & 0x80000L) != 0L)
567             return jjStartNfaWithStates_0(4, 83, 19);
568          else if ((active1 & 0x400000000L) != 0L)
569             return jjStartNfaWithStates_0(4, 98, 19);
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, 19);
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, 19);
598          else if ((active1 & 0x2000000000L) != 0L)
599             return jjStartNfaWithStates_0(5, 101, 19);
600          return jjMoveStringLiteralDfa6_0(active1, 0x20000000L, active2, 0L);
601       case 100:
602          if ((active1 & 0x200000L) != 0L)
603             return jjStartNfaWithStates_0(5, 85, 19);
604          else if ((active1 & 0x800000000L) != 0L)
605             return jjStartNfaWithStates_0(5, 99, 19);
606          break;
607       case 101:
608          if ((active1 & 0x2000L) != 0L)
609             return jjStartNfaWithStates_0(5, 77, 19);
610          else if ((active1 & 0x8000L) != 0L)
611             return jjStartNfaWithStates_0(5, 79, 19);
612          else if ((active1 & 0x1000000L) != 0L)
613             return jjStartNfaWithStates_0(5, 88, 19);
614          return jjMoveStringLiteralDfa6_0(active1, 0x100000000000L, active2, 0L);
615       case 102:
616          if ((active1 & 0x1000000000L) != 0L)
617             return jjStartNfaWithStates_0(5, 100, 19);
618          break;
619       case 104:
620          if ((active1 & 0x10000000000L) != 0L)
621             return jjStartNfaWithStates_0(5, 104, 19);
622          break;
623       case 105:
624          return jjMoveStringLiteralDfa6_0(active1, 0x2000000000000L, active2, 0L);
625       case 108:
626          return jjMoveStringLiteralDfa6_0(active1, 0x80001000L, active2, 0x100L);
627       case 110:
628          if ((active1 & 0x40000L) != 0L)
629             return jjStartNfaWithStates_0(5, 82, 19);
630          else if ((active1 & 0x200000000L) != 0L)
631             return jjStartNfaWithStates_0(5, 97, 19);
632          return jjMoveStringLiteralDfa6_0(active1, 0x400000000800L, active2, 0L);
633       case 116:
634          if ((active1 & 0x4000000000L) != 0L)
635             return jjStartNfaWithStates_0(5, 102, 19);
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, 19);
658          return jjMoveStringLiteralDfa7_0(active1, 0x400100000000L, active2, 0L);
659       case 102:
660          if ((active1 & 0x100000000000L) != 0L)
661             return jjStartNfaWithStates_0(6, 108, 19);
662          break;
663       case 108:
664          if ((active1 & 0x800000000000L) != 0L)
665             return jjStartNfaWithStates_0(6, 111, 19);
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, 19);
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 & 0x100L) != 0L)
677             return jjStartNfaWithStates_0(6, 136, 19);
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, 19);
698          break;
699       case 101:
700          if ((active1 & 0x800L) != 0L)
701             return jjStartNfaWithStates_0(7, 75, 19);
702          else if ((active1 & 0x20000000000L) != 0L)
703             return jjStartNfaWithStates_0(7, 105, 19);
704          else if ((active1 & 0x2000000000000L) != 0L)
705             return jjStartNfaWithStates_0(7, 113, 19);
706          return jjMoveStringLiteralDfa8_0(active1, 0x20000000L);
707       case 114:
708          if ((active1 & 0x100000000L) != 0L)
709             return jjStartNfaWithStates_0(7, 96, 19);
710          else if ((active1 & 0x8000000000000L) != 0L)
711             return jjStartNfaWithStates_0(7, 115, 19);
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, 19);
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, 19);
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 = 68;
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 18:
793                   if ((0x3ff000000000000L & l) != 0L)
794                      jjCheckNAddStates(0, 5);
795                   else if (curChar == 36)
796                   {
797                      if (kind > 137)
798                         kind = 137;
799                      jjCheckNAdd(19);
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 19:
885                   if ((0x3ff001000000000L & l) == 0L)
886                      break;
887                   if (kind > 137)
888                      kind = 137;
889                   jjCheckNAdd(19);
890                   break;
891                case 20:
892                   if (curChar != 48)
893                      break;
894                   if (kind > 120)
895                      kind = 120;
896                   jjCheckNAddStates(24, 31);
897                   break;
898                case 21:
899                   if ((0xff000000000000L & l) == 0L)
900                      break;
901                   if (kind > 120)
902                      kind = 120;
903                   jjCheckNAdd(21);
904                   break;
905                case 22:
906                   if ((0xff000000000000L & l) != 0L)
907                      jjCheckNAddTwoStates(22, 23);
908                   break;
909                case 24:
910                   if ((0xff000000000000L & l) != 0L)
911                      jjCheckNAddTwoStates(24, 25);
912                   break;
913                case 26:
914                   if ((0xff000000000000L & l) != 0L)
915                      jjCheckNAddStates(35, 37);
916                   break;
917                case 31:
918                   if ((0x3fe000000000000L & l) == 0L)
919                      break;
920                   if (kind > 124)
921                      kind = 124;
922                   jjCheckNAddStates(12, 19);
923                   break;
924                case 32:
925                   if ((0x3ff000000000000L & l) == 0L)
926                      break;
927                   if (kind > 124)
928                      kind = 124;
929                   jjCheckNAdd(32);
930                   break;
931                case 33:
932                   if ((0x3ff000000000000L & l) != 0L)
933                      jjCheckNAddTwoStates(33, 34);
934                   break;
935                case 35:
936                   if ((0x3ff000000000000L & l) != 0L)
937                      jjCheckNAddTwoStates(35, 36);
938                   break;
939                case 37:
940                   if ((0x3ff000000000000L & l) != 0L)
941                      jjCheckNAddStates(38, 40);
942                   break;
943                case 42:
944                   if (curChar == 48)
945                      jjAddStates(20, 23);
946                   break;
947                case 44:
948                   if ((0x3ff000000000000L & l) == 0L)
949                      break;
950                   if (kind > 128)
951                      kind = 128;
952                   jjstateSet[jjnewStateCnt++] = 44;
953                   break;
954                case 46:
955                   if ((0x3ff000000000000L & l) == 0L)
956                      break;
957                   if (kind > 129)
958                      kind = 129;
959                   jjAddStates(41, 42);
960                   break;
961                case 49:
962                   if ((0x3ff000000000000L & l) != 0L)
963                      jjAddStates(43, 44);
964                   break;
965                case 52:
966                   if ((0x3ff000000000000L & l) != 0L)
967                      jjAddStates(45, 47);
968                   break;
969                case 57:
970                   if ((0x3ff000000000000L & l) != 0L)
971                      jjCheckNAddStates(0, 5);
972                   break;
973                case 58:
974                   if ((0x3ff000000000000L & l) != 0L)
975                      jjCheckNAddTwoStates(58, 59);
976                   break;
977                case 59:
978                   if (curChar != 46)
979                      break;
980                   if (kind > 132)
981                      kind = 132;
982                   jjCheckNAddStates(48, 50);
983                   break;
984                case 60:
985                   if ((0x3ff000000000000L & l) == 0L)
986                      break;
987                   if (kind > 132)
988                      kind = 132;
989                   jjCheckNAddStates(48, 50);
990                   break;
991                case 61:
992                   if ((0x3ff000000000000L & l) != 0L)
993                      jjCheckNAddTwoStates(61, 0);
994                   break;
995                case 62:
996                   if ((0x3ff000000000000L & l) != 0L)
997                      jjCheckNAddTwoStates(62, 63);
998                   break;
999                case 64:
1000                   if ((0x280000000000L & l) != 0L)
1001                      jjCheckNAdd(65);
1002                   break;
1003                case 65:
1004                   if ((0x3ff000000000000L & l) == 0L)
1005                      break;
1006                   if (kind > 133)
1007                      kind = 133;
1008                   jjCheckNAddTwoStates(65, 66);
1009                   break;
1010                default : break;
1011             }
1012          } while(i != startsAt);
1013       }
1014       else if (curChar < 128)
1015       {
1016          long l = 1L << (curChar & 077);
1017          do
1018          {
1019             switch(jjstateSet[--i])
1020             {
1021                case 18:
1022                   if ((0x7fffffe87fffffeL & l) != 0L)
1023                   {
1024                      if (kind > 137)
1025                         kind = 137;
1026                      jjCheckNAdd(19);
1027                   }
1028                   if (curChar == 76)
1029                      jjAddStates(51, 52);
1030                   break;
1031                case 2:
1032                   if ((0x2000000020L & l) != 0L)
1033                      jjAddStates(53, 54);
1034                   break;
1035                case 5:
1036                   if ((0x104000001040L & l) != 0L && kind > 132)
1037                      kind = 132;
1038                   break;
1039                case 7:
1040                   if ((0xffffffffefffffffL & l) != 0L)
1041                      jjCheckNAddStates(9, 11);
1042                   break;
1043                case 8:
1044                   if (curChar == 92)
1045                      jjstateSet[jjnewStateCnt++] = 9;
1046                   break;
1047                case 9:
1048                   jjCheckNAddStates(9, 11);
1049                   break;
1050                case 12:
1051                   if ((0xffffffffefffffffL & l) != 0L)
1052                      jjCheckNAddStates(6, 8);
1053                   break;
1054                case 13:
1055                   if (curChar == 92)
1056                      jjAddStates(55, 56);
1057                   break;
1058                case 14:
1059                   jjCheckNAddStates(6, 8);
1060                   break;
1061                case 19:
1062                   if ((0x7fffffe87fffffeL & l) == 0L)
1063                      break;
1064                   if (kind > 137)
1065                      kind = 137;
1066                   jjCheckNAdd(19);
1067                   break;
1068                case 23:
1069                   if ((0x100000001000L & l) != 0L && kind > 121)
1070                      kind = 121;
1071                   break;
1072                case 25:
1073                   if ((0x20000000200000L & l) != 0L && kind > 122)
1074                      kind = 122;
1075                   break;
1076                case 27:
1077                   if ((0x100000001000L & l) != 0L && kind > 123)
1078                      kind = 123;
1079                   break;
1080                case 28:
1081                   if ((0x20000000200000L & l) != 0L)
1082                      jjstateSet[jjnewStateCnt++] = 27;
1083                   break;
1084                case 29:
1085                   if ((0x20000000200000L & l) != 0L && kind > 123)
1086                      kind = 123;
1087                   break;
1088                case 30:
1089                   if ((0x100000001000L & l) != 0L)
1090                      jjstateSet[jjnewStateCnt++] = 29;
1091                   break;
1092                case 34:
1093                   if ((0x20100000201000L & l) != 0L && kind > 125)
1094                      kind = 125;
1095                   break;
1096                case 36:
1097                   if ((0x20000000200000L & l) != 0L && kind > 126)
1098                      kind = 126;
1099                   break;
1100                case 38:
1101                   if ((0x100000001000L & l) != 0L && kind > 127)
1102                      kind = 127;
1103                   break;
1104                case 39:
1105                   if ((0x20000000200000L & l) != 0L)
1106                      jjstateSet[jjnewStateCnt++] = 38;
1107                   break;
1108                case 40:
1109                   if ((0x20000000200000L & l) != 0L && kind > 127)
1110                      kind = 127;
1111                   break;
1112                case 41:
1113                   if ((0x100000001000L & l) != 0L)
1114                      jjstateSet[jjnewStateCnt++] = 40;
1115                   break;
1116                case 43:
1117                   if ((0x100000001000000L & l) != 0L)
1118                      jjCheckNAdd(44);
1119                   break;
1120                case 44:
1121                   if ((0x7e0000007eL & l) == 0L)
1122                      break;
1123                   if (kind > 128)
1124                      kind = 128;
1125                   jjCheckNAdd(44);
1126                   break;
1127                case 45:
1128                   if ((0x100000001000000L & l) != 0L)
1129                      jjCheckNAdd(46);
1130                   break;
1131                case 46:
1132                   if ((0x7e0000007eL & l) == 0L)
1133                      break;
1134                   if (kind > 129)
1135                      kind = 129;
1136                   jjCheckNAddTwoStates(46, 47);
1137                   break;
1138                case 47:
1139                   if ((0x20100000201000L & l) != 0L && kind > 129)
1140                      kind = 129;
1141                   break;
1142                case 48:
1143                   if ((0x100000001000000L & l) != 0L)
1144                      jjCheckNAdd(49);
1145                   break;
1146                case 49:
1147                   if ((0x7e0000007eL & l) != 0L)
1148                      jjCheckNAddTwoStates(49, 50);
1149                   break;
1150                case 50:
1151                   if ((0x20000000200000L & l) != 0L && kind > 130)
1152                      kind = 130;
1153                   break;
1154                case 51:
1155                   if ((0x100000001000000L & l) != 0L)
1156                      jjCheckNAdd(52);
1157                   break;
1158                case 52:
1159                   if ((0x7e0000007eL & l) != 0L)
1160                      jjCheckNAddStates(45, 47);
1161                   break;
1162                case 53:
1163                   if ((0x100000001000L & l) != 0L && kind > 131)
1164                      kind = 131;
1165                   break;
1166                case 54:
1167                   if ((0x20000000200000L & l) != 0L)
1168                      jjstateSet[jjnewStateCnt++] = 53;
1169                   break;
1170                case 55:
1171                   if ((0x20000000200000L & l) != 0L && kind > 131)
1172                      kind = 131;
1173                   break;
1174                case 56:
1175                   if ((0x100000001000L & l) != 0L)
1176                      jjstateSet[jjnewStateCnt++] = 55;
1177                   break;
1178                case 63:
1179                   if ((0x2000000020L & l) != 0L)
1180                      jjAddStates(57, 58);
1181                   break;
1182                case 66:
1183                   if ((0x104000001040L & l) != 0L && kind > 133)
1184                      kind = 133;
1185                   break;
1186                case 67:
1187                   if (curChar == 76)
1188                      jjAddStates(51, 52);
1189                   break;
1190                default : break;
1191             }
1192          } while(i != startsAt);
1193       }
1194       else
1195       {
1196          int hiByte = (int)(curChar >> 8);
1197          int i1 = hiByte >> 6;
1198          long l1 = 1L << (hiByte & 077);
1199          int i2 = (curChar & 0xff) >> 6;
1200          long l2 = 1L << (curChar & 077);
1201          do
1202          {
1203             switch(jjstateSet[--i])
1204             {
1205                case 7:
1206                case 9:
1207                   if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1208                      jjCheckNAddStates(9, 11);
1209                   break;
1210                case 12:
1211                case 14:
1212                   if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1213                      jjCheckNAddStates(6, 8);
1214                   break;
1215                default : break;
1216             }
1217          } while(i != startsAt);
1218       }
1219       if (kind != 0x7fffffff)
1220       {
1221          jjmatchedKind = kind;
1222          jjmatchedPos = curPos;
1223          kind = 0x7fffffff;
1224       }
1225       ++curPos;
1226       if ((i = jjnewStateCnt) == (startsAt = 68 - (jjnewStateCnt = startsAt)))
1227          return curPos;
1228       try { curChar = input_stream.readChar(); }
1229       catch(java.io.IOException e) { return curPos; }
1230    }
1231 }
1232 private int jjMoveStringLiteralDfa0_1()
1233 {
1234    switch(curChar)
1235    {
1236       case 10:
1237          return jjStopAtPos(0, 9);
1238       default :
1239          return 1;
1240    }
1241 }
1242 private int jjMoveStringLiteralDfa0_4()
1243 {
1244    switch(curChar)
1245    {
1246       case 10:
1247          return jjStopAtPos(0, 14);
1248       case 47:
1249          return jjMoveStringLiteralDfa1_4(0x18000L);
1250       case 92:
1251          return jjMoveStringLiteralDfa1_4(0x60000L);
1252       default :
1253          return 1;
1254    }
1255 }
1256 private int jjMoveStringLiteralDfa1_4(long active0)
1257 {
1258    try { curChar = input_stream.readChar(); }
1259    catch(java.io.IOException e) {
1260       return 1;
1261    }
1262    switch(curChar)
1263    {
1264       case 10:
1265          if ((active0 & 0x20000L) != 0L)
1266             return jjStopAtPos(1, 17);
1267          break;
1268       case 13:
1269          return jjMoveStringLiteralDfa2_4(active0, 0x40000L);
1270       case 42:
1271          if ((active0 & 0x8000L) != 0L)
1272             return jjStopAtPos(1, 15);
1273          break;
1274       case 47:
1275          if ((active0 & 0x10000L) != 0L)
1276             return jjStopAtPos(1, 16);
1277          break;
1278       default :
1279          return 2;
1280    }
1281    return 2;
1282 }
1283 private int jjMoveStringLiteralDfa2_4(long old0, long active0)
1284 {
1285    if (((active0 &= old0)) == 0L)
1286       return 2;
1287    try { curChar = input_stream.readChar(); }
1288    catch(java.io.IOException e) {
1289       return 2;
1290    }
1291    switch(curChar)
1292    {
1293       case 10:
1294          if ((active0 & 0x40000L) != 0L)
1295             return jjStopAtPos(2, 18);
1296          break;
1297       default :
1298          return 3;
1299    }
1300    return 3;
1301 }
1302 private int jjMoveStringLiteralDfa0_3()
1303 {
1304    switch(curChar)
1305    {
1306       case 42:
1307          return jjMoveStringLiteralDfa1_3(0x2000L);
1308       default :
1309          return 1;
1310    }
1311 }
1312 private int jjMoveStringLiteralDfa1_3(long active0)
1313 {
1314    try { curChar = input_stream.readChar(); }
1315    catch(java.io.IOException e) {
1316       return 1;
1317    }
1318    switch(curChar)
1319    {
1320       case 47:
1321          if ((active0 & 0x2000L) != 0L)
1322             return jjStopAtPos(1, 13);
1323          break;
1324       default :
1325          return 2;
1326    }
1327    return 2;
1328 }
1329 private int jjMoveStringLiteralDfa0_2()
1330 {
1331    switch(curChar)
1332    {
1333       case 42:
1334          return jjMoveStringLiteralDfa1_2(0x800L);
1335       default :
1336          return 1;
1337    }
1338 }
1339 private int jjMoveStringLiteralDfa1_2(long active0)
1340 {
1341    try { curChar = input_stream.readChar(); }
1342    catch(java.io.IOException e) {
1343       return 1;
1344    }
1345    switch(curChar)
1346    {
1347       case 47:
1348          if ((active0 & 0x800L) != 0L)
1349             return jjStopAtPos(1, 11);
1350          break;
1351       default :
1352          return 2;
1353    }
1354    return 2;
1355 }
1356 static final int[] jjnextStates = {
1357    58, 59, 61, 0, 62, 63, 12, 13, 15, 7, 8, 10, 32, 33, 34, 35, 
1358    36, 37, 39, 41, 43, 45, 48, 51, 21, 22, 23, 24, 25, 26, 28, 30, 
1359    1, 2, 5, 26, 28, 30, 37, 39, 41, 46, 47, 49, 50, 52, 54, 56, 
1360    60, 2, 5, 6, 11, 3, 4, 14, 17, 64, 65, 
1361 };
1362 private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2)
1363 {
1364    switch(hiByte)
1365    {
1366       case 0:
1367          return ((jjbitVec2[i2] & l2) != 0L);
1368       default :
1369          if ((jjbitVec0[i1] & l1) != 0L)
1370             return true;
1371          return false;
1372    }
1373 }
1374 
1375 /** Token literal values. */
1376 public static final String[] jjstrLiteralImages = {
1377 "", null, null, null, null, null, null, null, null, null, null, null, null, 
1378 null, null, null, null, null, null, null, "\173", "\175", "\133", "\135", "\50", 
1379 "\51", "\72\72", "\72", "\73", "\54", "\77", "\56\56\56", "\75", "\52\75", "\57\75", 
1380 "\45\75", "\53\75", "\55\75", "\74\74\75", "\76\76\75", "\46\75", "\136\75", "\174\75", 
1381 "\174\174", "\46\46", "\174", "\136", "\46", "\75\75", "\41\75", "\74", "\76", "\74\75", 
1382 "\76\75", "\74\74", "\76\76", "\53", "\55", "\52", "\57", "\45", "\53\53", "\55\55", 
1383 "\176", "\41", "\56", "\55\76", "\56\52", "\55\76\52", "\141\165\164\157", 
1384 "\142\162\145\141\153", "\143\141\163\145", "\143\141\164\143\150", "\143\150\141\162", 
1385 "\143\157\156\163\164", "\143\157\156\164\151\156\165\145", "\144\145\146\141\165\154\164", 
1386 "\144\145\154\145\164\145", "\144\157", "\144\157\165\142\154\145", "\145\154\163\145", 
1387 "\145\156\165\155", "\145\170\164\145\162\156", "\146\154\157\141\164", "\146\157\162", 
1388 "\146\162\151\145\156\144", "\147\157\164\157", "\151\146", "\151\156\154\151\156\145", "\151\156\164", 
1389 "\154\157\156\147", "\156\145\167", "\160\162\151\166\141\164\145", 
1390 "\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", 
1391 "\162\145\147\151\163\164\145\162", "\162\145\164\165\162\156", "\163\150\157\162\164", 
1392 "\163\151\147\156\145\144", "\163\151\172\145\157\146", "\163\164\141\164\151\143", 
1393 "\163\164\162\165\143\164", "\143\154\141\163\163", "\163\167\151\164\143\150", 
1394 "\164\145\155\160\154\141\164\145", "\164\150\151\163", "\164\162\171", "\164\171\160\145\144\145\146", 
1395 "\165\156\151\157\156", "\165\156\163\151\147\156\145\144", "\166\151\162\164\165\141\154", 
1396 "\166\157\151\144", "\166\157\154\141\164\151\154\145", "\167\150\151\154\145", 
1397 "\157\160\145\162\141\164\157\162", "\164\162\165\145", "\146\141\154\163\145", "\164\150\162\157\167", "\100", 
1398 null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
1399 null, null, "\146\151\156\141\154\154\171", null, };
1400 
1401 /** Lexer state names. */
1402 public static final String[] lexStateNames = {
1403    "DEFAULT",
1404    "IN_LINE_COMMENT",
1405    "IN_COMMENT",
1406    "IN_PREPROCESSOR_OUTPUT_COMMENT",
1407    "PREPROCESSOR_OUTPUT",
1408 };
1409 
1410 /** Lex State array. */
1411 public static final int[] jjnewLexState = {
1412    -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, 
1413    -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, 
1414    -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, 
1415    -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, 
1416    -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, 
1417    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
1418 };
1419 static final long[] jjtoToken = {
1420    0xfffffffffff00001L, 0xffffffffffffffffL, 0x3ffL, 
1421 };
1422 static final long[] jjtoSkip = {
1423    0x1ebfeL, 0x0L, 0x0L, 
1424 };
1425 static final long[] jjtoMore = {
1426    0xe1400L, 0x0L, 0x0L, 
1427 };
1428 protected CharStream input_stream;
1429 private final int[] jjrounds = new int[68];
1430 private final int[] jjstateSet = new int[136];
1431 protected char curChar;
1432 /** Constructor. */
1433 public CppParserTokenManager(CharStream stream){
1434    input_stream = stream;
1435 }
1436 
1437 /** Constructor. */
1438 public CppParserTokenManager(CharStream stream, int lexState){
1439    this(stream);
1440    SwitchTo(lexState);
1441 }
1442 
1443 /** Reinitialise parser. */
1444 public void ReInit(CharStream stream)
1445 {
1446    jjmatchedPos = jjnewStateCnt = 0;
1447    curLexState = defaultLexState;
1448    input_stream = stream;
1449    ReInitRounds();
1450 }
1451 private void ReInitRounds()
1452 {
1453    int i;
1454    jjround = 0x80000001;
1455    for (i = 68; i-- > 0;)
1456       jjrounds[i] = 0x80000000;
1457 }
1458 
1459 /** Reinitialise parser. */
1460 public void ReInit(CharStream stream, int lexState)
1461 {
1462    ReInit(stream);
1463    SwitchTo(lexState);
1464 }
1465 
1466 /** Switch to specified lex state. */
1467 public void SwitchTo(int lexState)
1468 {
1469    if (lexState >= 5 || lexState < 0)
1470       throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
1471    else
1472       curLexState = lexState;
1473 }
1474 
1475 protected Token jjFillToken()
1476 {
1477    final Token t;
1478    final String curTokenImage;
1479    final int beginLine;
1480    final int endLine;
1481    final int beginColumn;
1482    final int endColumn;
1483    String im = jjstrLiteralImages[jjmatchedKind];
1484    curTokenImage = (im == null) ? input_stream.GetImage() : im;
1485    beginLine = input_stream.getBeginLine();
1486    beginColumn = input_stream.getBeginColumn();
1487    endLine = input_stream.getEndLine();
1488    endColumn = input_stream.getEndColumn();
1489    t = Token.newToken(jjmatchedKind, curTokenImage);
1490 
1491    t.beginLine = beginLine;
1492    t.endLine = endLine;
1493    t.beginColumn = beginColumn;
1494    t.endColumn = endColumn;
1495 
1496    return t;
1497 }
1498 
1499 int curLexState = 0;
1500 int defaultLexState = 0;
1501 int jjnewStateCnt;
1502 int jjround;
1503 int jjmatchedPos;
1504 int jjmatchedKind;
1505 
1506 /** Get the next Token. */
1507 public Token getNextToken() 
1508 {
1509   Token matchedToken;
1510   int curPos = 0;
1511 
1512   EOFLoop :
1513   for (;;)
1514   {
1515    try
1516    {
1517       curChar = input_stream.BeginToken();
1518    }
1519    catch(java.io.IOException e)
1520    {
1521       jjmatchedKind = 0;
1522       matchedToken = jjFillToken();
1523       return matchedToken;
1524    }
1525 
1526    for (;;)
1527    {
1528      switch(curLexState)
1529      {
1530        case 0:
1531          try { input_stream.backup(0);
1532             while (curChar <= 32 && (0x100001600L & (1L << curChar)) != 0L)
1533                curChar = input_stream.BeginToken();
1534          }
1535          catch (java.io.IOException e1) { continue EOFLoop; }
1536          jjmatchedKind = 0x7fffffff;
1537          jjmatchedPos = 0;
1538          curPos = jjMoveStringLiteralDfa0_0();
1539          break;
1540        case 1:
1541          jjmatchedKind = 0x7fffffff;
1542          jjmatchedPos = 0;
1543          curPos = jjMoveStringLiteralDfa0_1();
1544          if (jjmatchedPos == 0 && jjmatchedKind > 10)
1545          {
1546             jjmatchedKind = 10;
1547          }
1548          break;
1549        case 2:
1550          jjmatchedKind = 0x7fffffff;
1551          jjmatchedPos = 0;
1552          curPos = jjMoveStringLiteralDfa0_2();
1553          if (jjmatchedPos == 0 && jjmatchedKind > 12)
1554          {
1555             jjmatchedKind = 12;
1556          }
1557          break;
1558        case 3:
1559          jjmatchedKind = 0x7fffffff;
1560          jjmatchedPos = 0;
1561          curPos = jjMoveStringLiteralDfa0_3();
1562          if (jjmatchedPos == 0 && jjmatchedKind > 12)
1563          {
1564             jjmatchedKind = 12;
1565          }
1566          break;
1567        case 4:
1568          jjmatchedKind = 0x7fffffff;
1569          jjmatchedPos = 0;
1570          curPos = jjMoveStringLiteralDfa0_4();
1571          if (jjmatchedPos == 0 && jjmatchedKind > 19)
1572          {
1573             jjmatchedKind = 19;
1574          }
1575          break;
1576      }
1577      if (jjmatchedKind != 0x7fffffff)
1578      {
1579         if (jjmatchedPos + 1 < curPos)
1580            input_stream.backup(curPos - jjmatchedPos - 1);
1581         if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
1582         {
1583            matchedToken = jjFillToken();
1584        if (jjnewLexState[jjmatchedKind] != -1)
1585          curLexState = jjnewLexState[jjmatchedKind];
1586            return matchedToken;
1587         }
1588         else if ((jjtoSkip[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
1589         {
1590          if (jjnewLexState[jjmatchedKind] != -1)
1591            curLexState = jjnewLexState[jjmatchedKind];
1592            continue EOFLoop;
1593         }
1594       if (jjnewLexState[jjmatchedKind] != -1)
1595         curLexState = jjnewLexState[jjmatchedKind];
1596         curPos = 0;
1597         jjmatchedKind = 0x7fffffff;
1598         try {
1599            curChar = input_stream.readChar();
1600            continue;
1601         }
1602         catch (java.io.IOException e1) { }
1603      }
1604      int error_line = input_stream.getEndLine();
1605      int error_column = input_stream.getEndColumn();
1606      String error_after = null;
1607      boolean EOFSeen = false;
1608      try { input_stream.readChar(); input_stream.backup(1); }
1609      catch (java.io.IOException e1) {
1610         EOFSeen = true;
1611         error_after = curPos <= 1 ? "" : input_stream.GetImage();
1612         if (curChar == '\n' || curChar == '\r') {
1613            error_line++;
1614            error_column = 0;
1615         }
1616         else
1617            error_column++;
1618      }
1619      if (!EOFSeen) {
1620         input_stream.backup(1);
1621         error_after = curPos <= 1 ? "" : input_stream.GetImage();
1622      }
1623      throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
1624    }
1625   }
1626 }
1627 
1628 private void jjCheckNAdd(int state)
1629 {
1630    if (jjrounds[state] != jjround)
1631    {
1632       jjstateSet[jjnewStateCnt++] = state;
1633       jjrounds[state] = jjround;
1634    }
1635 }
1636 private void jjAddStates(int start, int end)
1637 {
1638    do {
1639       jjstateSet[jjnewStateCnt++] = jjnextStates[start];
1640    } while (start++ != end);
1641 }
1642 private void jjCheckNAddTwoStates(int state1, int state2)
1643 {
1644    jjCheckNAdd(state1);
1645    jjCheckNAdd(state2);
1646 }
1647 
1648 private void jjCheckNAddStates(int start, int end)
1649 {
1650    do {
1651       jjCheckNAdd(jjnextStates[start]);
1652    } while (start++ != end);
1653 }
1654 
1655 }