View Javadoc

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