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