KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > de > gulden > util > javasource > jjt > ParserTokenManager


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