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