|
1
2 package org.apache.commons.jxpath.ri.parser;
3 import org.apache.commons.jxpath.ri.Compiler;
4 import java.util.ArrayList  ;
5
6 public class XPathParserTokenManager implements XPathParserConstants
7 {
8 public java.io.PrintStream debugStream = System.out;
9 public void setDebugStream(java.io.PrintStream 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 ((active1 & 0xc0000L) != 0L)
16 return 10;
17 if ((active0 & 0xfffffffff8000000L) != 0L || (active1 & 0x3fffL) != 0L)
18 {
19 jjmatchedKind = 78;
20 return 12;
21 }
22 return -1;
23 case 1:
24 if ((active0 & 0x8000008000000L) != 0L)
25 return 12;
26 if ((active0 & 0xfff7fffff0000000L) != 0L || (active1 & 0x3fffL) != 0L)
27 {
28 jjmatchedKind = 78;
29 jjmatchedPos = 1;
30 return 12;
31 }
32 return -1;
33 case 2:
34 if ((active0 & 0x10000070000000L) != 0L || (active1 & 0x208L) != 0L)
35 return 12;
36 if ((active0 & 0xffe7ffff80000000L) != 0L || (active1 & 0x3df7L) != 0L)
37 {
38 jjmatchedKind = 78;
39 jjmatchedPos = 2;
40 return 12;
41 }
42 return -1;
43 case 3:
44 if ((active0 & 0xc1010180000000L) != 0L || (active1 & 0xd0L) != 0L)
45 return 12;
46 if ((active0 & 0xff26fefe00000000L) != 0L || (active1 & 0x3d27L) != 0L)
47 {
48 if (jjmatchedPos != 3)
49 {
50 jjmatchedKind = 78;
51 jjmatchedPos = 3;
52 }
53 return 12;
54 }
55 return -1;
56 case 4:
57 if ((active0 & 0xff62fff600000000L) != 0L || (active1 & 0x2907L) != 0L)
58 {
59 jjmatchedKind = 78;
60 jjmatchedPos = 4;
61 return 12;
62 }
63 if ((active0 & 0x4000000000000L) != 0L || (active1 & 0x1420L) != 0L)
64 return 12;
65 if ((active0 & 0x800000000L) != 0L)
66 {
67 if (jjmatchedPos < 3)
68 {
69 jjmatchedKind = 78;
70 jjmatchedPos = 3;
71 }
72 return -1;
73 }
74 return -1;
75 case 5:
76 if ((active0 & 0x8300000000000000L) != 0L || (active1 & 0x100L) != 0L)
77 return 12;
78 if ((active0 & 0x7c62ffe600000000L) != 0L || (active1 & 0x2807L) != 0L)
79 {
80 if (jjmatchedPos != 5)
81 {
82 jjmatchedKind = 78;
83 jjmatchedPos = 5;
84 }
85 return 12;
86 }
87 if ((active0 & 0x1000000000L) != 0L)
88 {
89 if (jjmatchedPos < 4)
90 {
91 jjmatchedKind = 78;
92 jjmatchedPos = 4;
93 }
94 return -1;
95 }
96 if ((active0 & 0x800000000L) != 0L)
97 {
98 if (jjmatchedPos < 3)
99 {
100 jjmatchedKind = 78;
101 jjmatchedPos = 3;
102 }
103 return -1;
104 }
105 return -1;
106 case 6:
107 if ((active0 & 0x200000000L) != 0L || (active1 & 0x804L) != 0L)
108 return 12;
109 if ((active0 & 0x2000000000L) != 0L)
110 {
111 if (jjmatchedPos < 5)
112 {
113 jjmatchedKind = 78;
114 jjmatchedPos = 5;
115 }
116 return -1;
117 }
118 if ((active0 & 0x1000000000L) != 0L)
119 {
120 if (jjmatchedPos < 4)
121 {
122 jjmatchedKind = 78;
123 jjmatchedPos = 4;
124 }
125 return -1;
126 }
127 if ((active0 & 0xfc62ffc400000000L) != 0L || (active1 & 0x2003L) != 0L)
128 {
129 jjmatchedKind = 78;
130 jjmatchedPos = 6;
131 return 12;
132 }
133 return -1;
134 case 7:
135 if ((active0 & 0xf460ffc400000000L) != 0L || (active1 & 0x2003L) != 0L)
136 {
137 jjmatchedKind = 78;
138 jjmatchedPos = 7;
139 return 12;
140 }
141 if ((active0 & 0x802000000000000L) != 0L)
142 return 12;
143 if ((active0 & 0x2000000000L) != 0L)
144 {
145 if (jjmatchedPos < 5)
146 {
147 jjmatchedKind = 78;
148 jjmatchedPos = 5;
149 }
150 return -1;
151 }
152 return -1;
153 case 8:
154 if ((active0 & 0x7000000000000000L) != 0L || (active1 & 0x2L) != 0L)
155 return 12;
156 if ((active0 & 0x4000000000L) != 0L)
157 {
158 if (jjmatchedPos < 7)
159 {
160 jjmatchedKind = 78;
161 jjmatchedPos = 7;
162 }
163 return -1;
164 }
165 if ((active0 & 0x8460ff8400000000L) != 0L || (active1 & 0x2001L) != 0L)
166 {
167 if (jjmatchedPos != 8)
168 {
169 jjmatchedKind = 78;
170 jjmatchedPos = 8;
171 }
172 return 12;
173 }
174 return -1;
175 case 9:
176 if ((active0 & 0x20000000000000L) != 0L)
177 return 12;
178 if ((active0 & 0x78000000000L) != 0L)
179 {
180 if (jjmatchedPos < 8)
181 {
182 jjmatchedKind = 78;
183 jjmatchedPos = 8;
184 }
185 return -1;
186 }
187 if ((active0 & 0x4000000000L) != 0L)
188 {
189 if (jjmatchedPos < 7)
190 {
191 jjmatchedKind = 78;
192 jjmatchedPos = 7;
193 }
194 return -1;
195 }
196 if ((active0 & 0xb440f80400000000L) != 0L || (active1 & 0x2001L) != 0L)
197 {
198 jjmatchedKind = 78;
199 jjmatchedPos = 9;
200 return 12;
201 }
202 return -1;
203 case 10:
204 if ((active0 & 0x400000000000000L) != 0L)
205 return 12;
206 if ((active0 & 0x80000000000L) != 0L)
207 {
208 if (jjmatchedPos < 9)
209 {
210 jjmatchedKind = 78;
211 jjmatchedPos = 9;
212 }
213 return -1;
214 }
215 if ((active0 & 0x78000000000L) != 0L)
216 {
217 if (jjmatchedPos < 8)
218 {
219 jjmatchedKind = 78;
220 jjmatchedPos = 8;
221 }
222 return -1;
223 }
224 if ((active0 & 0xb040f00400000000L) != 0L || (active1 & 0x2001L) != 0L)
225 {
226 jjmatchedKind = 78;
227 jjmatchedPos = 10;
228 return 12;
229 }
230 return -1;
231 case 11:
232 if ((active0 & 0xb040f00400000000L) != 0L || (active1 & 0x2001L) != 0L)
233 {
234 jjmatchedKind = 78;
235 jjmatchedPos = 11;
236 return 12;
237 }
238 if ((active0 & 0x80000000000L) != 0L)
239 {
240 if (jjmatchedPos < 9)
241 {
242 jjmatchedKind = 78;
243 jjmatchedPos = 9;
244 }
245 return -1;
246 }
247 return -1;
248 case 12:
249 if ((active0 & 0x8040000000000000L) != 0L || (active1 & 0x2000L) != 0L)
250 return 12;
251 if ((active0 & 0x3000f00400000000L) != 0L || (active1 & 0x1L) != 0L)
252 {
253 jjmatchedKind = 78;
254 jjmatchedPos = 12;
255 return 12;
256 }
257 return -1;
258 case 13:
259 if ((active0 & 0x3000f00400000000L) != 0L || (active1 & 0x1L) != 0L)
260 {
261 jjmatchedKind = 78;
262 jjmatchedPos = 13;
263 return 12;
264 }
265 return -1;
266 case 14:
267 if ((active0 & 0x2000000000000000L) != 0L || (active1 & 0x1L) != 0L)
268 return 12;
269 if ((active0 & 0x1000f00400000000L) != 0L)
270 {
271 jjmatchedKind = 78;
272 jjmatchedPos = 14;
273 return 12;
274 }
275 return -1;
276 case 15:
277 if ((active0 & 0x1000000000000000L) != 0L)
278 return 12;
279 if ((active0 & 0xf00400000000L) != 0L)
280 {
281 jjmatchedKind = 78;
282 jjmatchedPos = 15;
283 return 12;
284 }
285 return -1;
286 case 16:
287 if ((active0 & 0xe00400000000L) != 0L)
288 {
289 jjmatchedKind = 78;
290 jjmatchedPos = 16;
291 return 12;
292 }
293 if ((active0 & 0x100000000000L) != 0L)
294 {
295 if (jjmatchedPos < 15)
296 {
297 jjmatchedKind = 78;
298 jjmatchedPos = 15;
299 }
300 return -1;
301 }
302 return -1;
303 case 17:
304 if ((active0 & 0x600000000000L) != 0L)
305 {
306 if (jjmatchedPos < 16)
307 {
308 jjmatchedKind = 78;
309 jjmatchedPos = 16;
310 }
311 return -1;
312 }
313 if ((active0 & 0x100000000000L) != 0L)
314 {
315 if (jjmatchedPos < 15)
316 {
317 jjmatchedKind = 78;
318 jjmatchedPos = 15;
319 }
320 return -1;
321 }
322 if ((active0 & 0x800400000000L) != 0L)
323 {
324 jjmatchedKind = 78;
325 jjmatchedPos = 17;
326 return 12;
327 }
328 return -1;
329 case 18:
330 if ((active0 & 0x400000000L) != 0L)
331 {
332 jjmatchedKind = 78;
333 jjmatchedPos = 18;
334 return 12;
335 }
336 if ((active0 & 0x800000000000L) != 0L)
337 {
338 if (jjmatchedPos < 17)
339 {
340 jjmatchedKind = 78;
341 jjmatchedPos = 17;
342 }
343 return -1;
344 }
345 if ((active0 & 0x600000000000L) != 0L)
346 {
347 if (jjmatchedPos < 16)
348 {
349 jjmatchedKind = 78;
350 jjmatchedPos = 16;
351 }
352 return -1;
353 }
354 return -1;
355 case 19:
356 if ((active0 & 0x400000000L) != 0L)
357 {
358 jjmatchedKind = 78;
359 jjmatchedPos = 19;
360 return 12;
361 }
362 if ((active0 & 0x800000000000L) != 0L)
363 {
364 if (jjmatchedPos < 17)
365 {
366 jjmatchedKind = 78;
367 jjmatchedPos = 17;
368 }
369 return -1;
370 }
371 return -1;
372 case 20:
373 if ((active0 & 0x400000000L) != 0L)
374 {
375 jjmatchedKind = 78;
376 jjmatchedPos = 20;
377 return 12;
378 }
379 return -1;
380 default :
381 return -1;
382 }
383 }
384 private final int jjStartNfa_0(int pos, long active0, long active1)
385 {
386 return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0, active1), pos + 1);
387 }
388 private final int jjStopAtPos(int pos, int kind)
389 {
390 jjmatchedKind = kind;
391 jjmatchedPos = pos;
392 return pos + 1;
393 }
394 private final int jjStartNfaWithStates_0(int pos, int kind, int state)
395 {
396 jjmatchedKind = kind;
397 jjmatchedPos = pos;
398 try { curChar = input_stream.readChar(); }
399 catch(java.io.IOException e) { return pos + 1; }
400 return jjMoveNfa_0(state, pos + 1);
401 }
402 private final int jjMoveStringLiteralDfa0_0()
403 {
404 switch(curChar)
405 {
406 case 33:
407 return jjMoveStringLiteralDfa1_0(0x1000L, 0x0L);
408 case 36:
409 return jjStopAtPos(0, 17);
410 case 40:
411 return jjStopAtPos(0, 80);
412 case 41:
413 return jjStopAtPos(0, 81);
414 case 42:
415 return jjStopAtPos(0, 88);
416 case 43:
417 return jjStopAtPos(0, 9);
418 case 44:
419 return jjStopAtPos(0, 87);
420 case 45:
421 return jjStopAtPos(0, 10);
422 case 46:
423 jjmatchedKind = 82;
424 return jjMoveStringLiteralDfa1_0(0x0L, 0x80000L);
425 case 47:
426 jjmatchedKind = 6;
427 return jjMoveStringLiteralDfa1_0(0x80L, 0x0L);
428 case 58:
429 return jjStopAtPos(0, 79);
430 case 60:
431 jjmatchedKind = 13;
432 return jjMoveStringLiteralDfa1_0(0x4000L, 0x0L);
433 case 61:
434 return jjStopAtPos(0, 11);
435 case 62:
436 jjmatchedKind = 15;
437 return jjMoveStringLiteralDfa1_0(0x10000L, 0x0L);
438 case 64:
439 return jjStopAtPos(0, 86);
440 case 91:
441 return jjStopAtPos(0, 84);
442 case 93:
443 return jjStopAtPos(0, 85);
444 case 97:
445 return jjMoveStringLiteralDfa1_0(0x10c010000000L, 0x0L);
446 case 98:
447 return jjMoveStringLiteralDfa1_0(0x0L, 0x4L);
448 case 99:
449 return jjMoveStringLiteralDfa1_0(0xa04001200000000L, 0x800L);
450 case 100:
451 return jjMoveStringLiteralDfa1_0(0x880040000000L, 0x0L);
452 case 102:
453 return jjMoveStringLiteralDfa1_0(0x240000000000L, 0x2420L);
454 case 105:
455 return jjMoveStringLiteralDfa1_0(0x8000000000000L, 0x0L);
456 case 107:
457 return jjMoveStringLiteralDfa1_0(0x10000000000000L, 0x0L);
458 case 108:
459 return jjMoveStringLiteralDfa1_0(0x21000000000000L, 0x80L);
460 case 109:
461 return jjMoveStringLiteralDfa1_0(0x20000000L, 0x0L);
462 case 110:
463 return jjMoveStringLiteralDfa1_0(0xc0010080000000L, 0x149L);
464 case 111:
465 return jjMoveStringLiteralDfa1_0(0x8000000L, 0x0L);
466 case 112:
467 return jjMoveStringLiteralDfa1_0(0x2422400000000L, 0x0L);
468 case 114:
469 return jjMoveStringLiteralDfa1_0(0x0L, 0x1000L);
470 case 115:
471 return jjMoveStringLiteralDfa1_0(0xf500000800000000L, 0x200L);
472 case 116:
473 return jjMoveStringLiteralDfa1_0(0x100000000L, 0x12L);
474 case 124:
475 return jjStopAtPos(0, 8);
476 default :
477 return jjMoveNfa_0(0, 0);
478 }
479 }
480 private final int jjMoveStringLiteralDfa1_0(long active0, long active1)
481 {
482 try { curChar = input_stream.readChar(); }
483 catch(java.io.IOException e) {
484 jjStopStringLiteralDfa_0(0, active0, active1);
485 return 1;
486 }
487 switch(curChar)
488 {
489 case 46:
490 if ((active1 & 0x80000L) != 0L)
491 return jjStopAtPos(1, 83);
492 break;
493 case 47:
494 if ((active0 & 0x80L) != 0L)
495 return jjStopAtPos(1, 7);
496 break;
497 case 61:
498 if ((active0 & 0x1000L) != 0L)
499 return jjStopAtPos(1, 12);
500 else if ((active0 & 0x4000L) != 0L)
501 return jjStopAtPos(1, 14);
502 else if ((active0 & 0x10000L) != 0L)
503 return jjStopAtPos(1, 16);
504 break;
505 case 97:
506 return jjMoveStringLiteralDfa2_0(active0, 0xc1012000000000L, active1, 0xa0L);
507 case 100:
508 if ((active0 & 0x8000000000000L) != 0L)
509 return jjStartNfaWithStates_0(1, 51, 12);
510 break;
511 case 101:
512 return jjMoveStringLiteralDfa2_0(active0, 0x10880900000000L, active1, 0x800L);
513 case 104:
514 return jjMoveStringLiteralDfa2_0(active0, 0x1000000000L, active1, 0L);
515 case 105:
516 return jjMoveStringLiteralDfa2_0(active0, 0x40000000L, active1, 0L);
517 case 108:
518 return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x400L);
519 case 110:
520 return jjMoveStringLiteralDfa2_0(active0, 0x104010000000L, active1, 0L);
521 case 111:
522 return jjMoveStringLiteralDfa2_0(active0, 0xa262402a0000000L, active1, 0x300dL);
523 case 114:
524 if ((active0 & 0x8000000L) != 0L)
525 return jjStartNfaWithStates_0(1, 27, 12);
526 return jjMoveStringLiteralDfa2_0(active0, 0x420400000000L, active1, 0x12L);
527 case 116:
528 return jjMoveStringLiteralDfa2_0(active0, 0x8500008000000000L, active1, 0L);
529 case 117:
530 return jjMoveStringLiteralDfa2_0(active0, 0x7000000000000000L, active1, 0x340L);
531 default :
532 break;
533 }
534 return jjStartNfa_0(0, active0, active1);
535 }
536 private final int jjMoveStringLiteralDfa2_0(long old0, long active0, long old1, long active1)
537 {
538 if (((active0 &= old0) | (active1 &= old1)) == 0L)
539 return jjStartNfa_0(0, old0, old1);
540 try { curChar = input_stream.readChar(); }
541 catch(java.io.IOException e) {
542 jjStopStringLiteralDfa_0(1, active0, active1);
543 return 2;
544 }
545 switch(curChar)
546 {
547 case 97:
548 return jjMoveStringLiteralDfa3_0(active0, 0x400000000000000L, active1, 0x2L);
549 case 98:
550 return jjMoveStringLiteralDfa3_0(active0, 0x7000000000000000L, active1, 0L);
551 case 99:
552 return jjMoveStringLiteralDfa3_0(active0, 0x20104000000000L, active1, 0L);
553 case 100:
554 if ((active0 & 0x10000000L) != 0L)
555 return jjStartNfaWithStates_0(2, 28, 12);
556 else if ((active0 & 0x20000000L) != 0L)
557 return jjStartNfaWithStates_0(2, 29, 12);
558 return jjMoveStringLiteralDfa3_0(active0, 0x80000000L, active1, 0L);
559 case 101:
560 return jjMoveStringLiteralDfa3_0(active0, 0x420000000000L, active1, 0L);
561 case 105:
562 return jjMoveStringLiteralDfa3_0(active0, 0x1000000000L, active1, 0x800L);
563 case 108:
564 return jjMoveStringLiteralDfa3_0(active0, 0x240800000000L, active1, 0x60L);
565 case 109:
566 if ((active1 & 0x200L) != 0L)
567 return jjStartNfaWithStates_0(2, 73, 12);
568 return jjMoveStringLiteralDfa3_0(active0, 0xc0010200000000L, active1, 0x100L);
569 case 110:
570 return jjMoveStringLiteralDfa3_0(active0, 0xa00000000000000L, active1, 0x80L);
571 case 111:
572 return jjMoveStringLiteralDfa3_0(active0, 0x400000000L, active1, 0x404L);
573 case 114:
574 return jjMoveStringLiteralDfa3_0(active0, 0x8100002000000000L, active1, 0x2001L);
575 case 115:
576 return jjMoveStringLiteralDfa3_0(active0, 0x3880000000000L, active1, 0L);
577 case 116:
578 if ((active1 & 0x8L) != 0L)
579 return jjStartNfaWithStates_0(2, 67, 12);
580 return jjMoveStringLiteralDfa3_0(active0, 0x8000000000L, active1, 0L);
581 case 117:
582 return jjMoveStringLiteralDfa3_0(active0, 0x4000000000000L, active1, 0x1010L);
583 case 118:
584 if ((active0 & 0x40000000L) != 0L)
585 return jjStartNfaWithStates_0(2, 30, 12);
586 break;
587 case 120:
588 return jjMoveStringLiteralDfa3_0(active0, 0x100000000L, active1, 0L);
589 case 121:
590 if ((active0 & 0x10000000000000L) != 0L)
591 return jjStartNfaWithStates_0(2, 52, 12);
592 break;
593 default :
594 break;
595 }
596 return jjStartNfa_0(1, active0, active1);
597 }
598 private final int jjMoveStringLiteralDfa3_0(long old0, long active0, long old1, long active1)
599 {
600 if (((active0 &= old0) | (active1 &= old1)) == 0L)
601 return jjStartNfa_0(1, old0, old1);
602 try { curChar = input_stream.readChar(); }
603 catch(java.io.IOException e) {
604 jjStopStringLiteralDfa_0(2, active0, active1);
605 return 3;
606 }
607 switch(curChar)
608 {
609 case 97:
610 return jjMoveStringLiteralDfa4_0(active0, 0x20000000000000L, active1, 0L);
611 case 98:
612 return jjMoveStringLiteralDfa4_0(active0, 0L, active1, 0x100L);
613 case 99:
614 return jjMoveStringLiteralDfa4_0(active0, 0x200ca0400000000L, active1, 0L);
615 case 101:
616 if ((active0 & 0x80000000L) != 0L)
617 return jjStartNfaWithStates_0(3, 31, 12);
618 else if ((active0 & 0x80000000000000L) != 0L)
619 {
620 jjmatchedKind = 55;
621 jjmatchedPos = 3;
622 }
623 else if ((active1 & 0x10L) != 0L)
624 return jjStartNfaWithStates_0(3, 68, 12);
625 return jjMoveStringLiteralDfa4_0(active0, 0x40116000000000L, active1, 0L);
626 case 102:
627 return jjMoveStringLiteralDfa4_0(active0, 0x800000000L, active1, 0L);
628 case 103:
629 if ((active1 & 0x80L) != 0L)
630 return jjStartNfaWithStates_0(3, 71, 12);
631 break;
632 case 105:
633 return jjMoveStringLiteralDfa4_0(active0, 0x8102000000000000L, active1, 0L);
634 case 108:
635 if ((active1 & 0x40L) != 0L)
636 return jjStartNfaWithStates_0(3, 70, 12);
637 return jjMoveStringLiteralDfa4_0(active0, 0x241000000000L, active1, 0x804L);
638 case 109:
639 return jjMoveStringLiteralDfa4_0(active0, 0x200000000L, active1, 0x2001L);
640 case 110:
641 return jjMoveStringLiteralDfa4_0(active0, 0x4000000000000L, active1, 0x1002L);
642 case 111:
643 return jjMoveStringLiteralDfa4_0(active0, 0L, active1, 0x400L);
644 case 114:
645 return jjMoveStringLiteralDfa4_0(active0, 0x400008000000000L, active1, 0L);
646 case 115:
647 return jjMoveStringLiteralDfa4_0(active0, 0x7000000000000000L, active1, 0x20L);
648 case 116:
649 if ((active0 & 0x100000000L) != 0L)
650 return jjStartNfaWithStates_0(3, 32, 12);
651 else if ((active0 & 0x1000000000000L) != 0L)
652 return jjStartNfaWithStates_0(3, 48, 12);
653 return jjMoveStringLiteralDfa4_0(active0, 0x800000000000000L, active1, 0L);
654 default :
655 break;
656 }
657 return jjStartNfa_0(2, active0, active1);
658 }
659 private final int jjMoveStringLiteralDfa4_0(long old0, long active0, long old1, long active1)
660 {
661 if (((active0 &= old0) | (active1 &= old1)) == 0L)
662 return jjStartNfa_0(2, old0, old1);
663 try { curChar = input_stream.readChar(); }
664 catch(java.io.IOException e) {
665 jjStopStringLiteralDfa_0(3, active0, active1);
666 return 4;
667 }
668 switch(curChar)
669 {
670 case 58:
671 return jjMoveStringLiteralDfa5_0(active0, 0x800000000L, active1, 0L);
672 case 97:
673 return jjMoveStringLiteralDfa5_0(active0, 0xa00000000000000L, active1, 0x2001L);
674 case 100:
675 if ((active1 & 0x1000L) != 0L)
676 return jjStartNfaWithStates_0(4, 76, 12);
677 return jjMoveStringLiteralDfa5_0(active0, 0x1000000000L, active1, 0L);
678 case 101:
679 if ((active1 & 0x20L) != 0L)
680 return jjStartNfaWithStates_0(4, 69, 12);
681 return jjMoveStringLiteralDfa5_0(active0, 0xca0600000000L, active1, 0x104L);
682 case 105:
683 return jjMoveStringLiteralDfa5_0(active0, 0x8000000000L, active1, 0x800L);
684 case 108:
685 return jjMoveStringLiteralDfa5_0(active0, 0x20000000000000L, active1, 0L);
686 case 110:
687 return jjMoveStringLiteralDfa5_0(active0, 0x8100002000000000L, active1, 0L);
688 case 111:
689 return jjMoveStringLiteralDfa5_0(active0, 0x240000000000L, active1, 0L);
690 case 114:
691 if ((active1 & 0x400L) != 0L)
692 return jjStartNfaWithStates_0(4, 74, 12);
693 break;
694 case 115:
695 return jjMoveStringLiteralDfa5_0(active0, 0x40114000000000L, active1, 0x2L);
696 case 116:
697 if ((active0 & 0x4000000000000L) != 0L)
698 return jjStartNfaWithStates_0(4, 50, 12);
699 return jjMoveStringLiteralDfa5_0(active0, 0x7402000000000000L, active1, 0L);
700 default :
701 break;
702 }
703 return jjStartNfa_0(3, active0, active1);
704 }
705 private final int jjMoveStringLiteralDfa5_0(long old0, long active0, long old1, long active1)
706 {
707 if (((active0 &= old0) | (active1 &= old1)) == 0L)
708 return jjStartNfa_0(3, old0, old1);
709 try { curChar = input_stream.readChar(); }
710 catch(java.io.IOException e) {
711 jjStopStringLiteralDfa_0(4, active0, active1);
712 return 5;
713 }
714 switch(curChar)
715 {
716 case 45:
717 return jjMoveStringLiteralDfa6_0(active0, 0x20000000000000L, active1, 0L);
718 case 58:
719 if ((active0 & 0x800000000L) != 0L)
720 return jjStopAtPos(5, 35);
721 return jjMoveStringLiteralDfa6_0(active0, 0x1000000000L, active1, 0L);
722 case 97:
723 return jjMoveStringLiteralDfa6_0(active0, 0L, active1, 0x4L);
724 case 98:
725 return jjMoveStringLiteralDfa6_0(active0, 0x8000000000L, active1, 0L);
726 case 100:
727 return jjMoveStringLiteralDfa6_0(active0, 0x420000000000L, active1, 0L);
728 case 103:
729 if ((active0 & 0x100000000000000L) != 0L)
730 {
731 jjmatchedKind = 56;
732 jjmatchedPos = 5;
733 }
734 return jjMoveStringLiteralDfa6_0(active0, 0x8000000000000000L, active1, 0L);
735 case 105:
736 return jjMoveStringLiteralDfa6_0(active0, 0x802000000000000L, active1, 0L);
737 case 108:
738 return jjMoveStringLiteralDfa6_0(active0, 0L, active1, 0x3L);
739 case 110:
740 return jjMoveStringLiteralDfa6_0(active0, 0x880200000000L, active1, 0x800L);
741 case 112:
742 return jjMoveStringLiteralDfa6_0(active0, 0x40010000000000L, active1, 0L);
743 case 114:
744 if ((active1 & 0x100L) != 0L)
745 return jjStartNfaWithStates_0(5, 72, 12);
746 return jjMoveStringLiteralDfa6_0(active0, 0x7000000000000000L, active1, 0L);
747 case 115:
748 return jjMoveStringLiteralDfa6_0(active0, 0x400000400000000L, active1, 0L);
749 case 116:
750 if ((active0 & 0x200000000000000L) != 0L)
751 return jjStartNfaWithStates_0(5, 57, 12);
752 return jjMoveStringLiteralDfa6_0(active0, 0x106000000000L, active1, 0x2000L);
753 case 119:
754 return jjMoveStringLiteralDfa6_0(active0, 0x240000000000L, active1, 0L);
755 default :
756 break;
757 }
758 return jjStartNfa_0(4, active0, active1);
759 }
760 private final int jjMoveStringLiteralDfa6_0(long old0, long active0, long old1, long active1)
761 {
762 if (((active0 &= old0) | (active1 &= old1)) == 0L)
763 return jjStartNfa_0(4, old0, old1);
764 try { curChar = input_stream.readChar(); }
765 catch(java.io.IOException e) {
766 jjStopStringLiteralDfa_0(5, active0, active1);
767 return 6;
768 }
769 switch(curChar)
770 {
771 case 45:
772 return jjMoveStringLiteralDfa7_0(active0, 0x8400000000000000L, active1, 0x2000L);
773 case 58:
774 if ((active0 & 0x1000000000L) != 0L)
775 return jjStopAtPos(6, 36);
776 return jjMoveStringLiteralDfa7_0(active0, 0x2000000000L, active1, 0L);
777 case 97:
778 return jjMoveStringLiteralDfa7_0(active0, 0x40010000000000L, active1, 0x2L);
779 case 100:
780 return jjMoveStringLiteralDfa7_0(active0, 0x880000000000L, active1, 0L);
781 case 103:
782 if ((active1 & 0x800L) != 0L)
783 return jjStartNfaWithStates_0(6, 75, 12);
784 break;
785 case 105:
786 return jjMoveStringLiteralDfa7_0(active0, 0x7000660000000000L, active1, 0x1L);
787 case 110:
788 if ((active1 & 0x4L) != 0L)
789 return jjStartNfaWithStates_0(6, 66, 12);
790 return jjMoveStringLiteralDfa7_0(active0, 0x820000000000000L, active1, 0L);
791 case 111:
792 return jjMoveStringLiteralDfa7_0(active0, 0x2104000000000L, active1, 0L);
793 case 115:
794 return jjMoveStringLiteralDfa7_0(active0, 0x400000000L, active1, 0L);
795 case 116:
796 if ((active0 & 0x200000000L) != 0L)
797 return jjStartNfaWithStates_0(6, 33, 12);
798 break;
799 case 117:
800 return jjMoveStringLiteralDfa7_0(active0, 0x8000000000L, active1, 0L);
801 default :
802 break;
803 }
804 return jjStartNfa_0(5, active0, active1);
805 }
806 private final int jjMoveStringLiteralDfa7_0(long old0, long active0, long old1, long active1)
807 {
808 if (((active0 &= old0) | (active1 &= old1)) == 0L)
809 return jjStartNfa_0(5, old0, old1);
810 try { curChar = input_stream.readChar(); }
811 catch(java.io.IOException e) {
812 jjStopStringLiteralDfa_0(6, active0, active1);
813 return 7;
814 }
815 switch(curChar)
816 {
817 case 58:
818 if ((active0 & 0x2000000000L) != 0L)
819 return jjStopAtPos(7, 37);
820 break;
821 case 97:
822 return jjMoveStringLiteralDfa8_0(active0, 0x20880000000000L, active1, 0L);
823 case 99:
824 return jjMoveStringLiteralDfa8_0(active0, 0x40010000000000L, active1, 0L);
825 case 105:
826 return jjMoveStringLiteralDfa8_0(active0, 0x400000000L, active1, 0L);
827 case 108:
828 return jjMoveStringLiteralDfa8_0(active0, 0x8000000000000000L, active1, 0L);
829 case 110:
830 if ((active0 & 0x2000000000000L) != 0L)
831 return jjStartNfaWithStates_0(7, 49, 12);
832 return jjMoveStringLiteralDfa8_0(active0, 0x7000660000000000L, active1, 0x2000L);
833 case 114:
834 return jjMoveStringLiteralDfa8_0(active0, 0x104000000000L, active1, 0L);
835 case 115:
836 if ((active0 & 0x800000000000000L) != 0L)
837 return jjStartNfaWithStates_0(7, 59, 12);
838 break;
839 case 116:
840 return jjMoveStringLiteralDfa8_0(active0, 0x8000000000L, active1, 0x2L);
841 case 119:
842 return jjMoveStringLiteralDfa8_0(active0, 0x400000000000000L, active1, 0L);
843 case 122:
844 return jjMoveStringLiteralDfa8_0(active0, 0L, active1, 0x1L);
845 default :
846 break;
847 }
848 return jjStartNfa_0(6, active0, active1);
849 }
850 private final int jjMoveStringLiteralDfa8_0(long old0, long active0, long old1, long active1)
851 {
852 if (((active0 &= old0) | (active1 &= old1)) == 0L)
853 return jjStartNfa_0(6, old0, old1);
854 try { curChar = input_stream.readChar(); }
855 catch(java.io.IOException e) {
856 jjStopStringLiteralDfa_0(7, active0, active1);
857 return 8;
858 }
859 switch(curChar)
860 {
861 case 45:
862 return jjMoveStringLiteralDfa9_0(active0, 0x100000000000L, active1, 0L);
863 case 58:
864 return jjMoveStringLiteralDfa9_0(active0, 0x4000000000L, active1, 0L);
865 case 101:
866 if ((active1 & 0x2L) != 0L)
867 return jjStartNfaWithStates_0(8, 65, 12);
868 return jjMoveStringLiteralDfa9_0(active0, 0x8040018000000000L, active1, 0x1L);
869 case 103:
870 if ((active0 & 0x4000000000000000L) != 0L)
871 {
872 jjmatchedKind = 62;
873 jjmatchedPos = 8;
874 }
875 return jjMoveStringLiteralDfa9_0(active0, 0x3000660000000000L, active1, 0L);
876 case 105:
877 return jjMoveStringLiteralDfa9_0(active0, 0x400000000000000L, active1, 0L);
878 case 109:
879 return jjMoveStringLiteralDfa9_0(active0, 0x20000000000000L, active1, 0L);
880 case 110:
881 return jjMoveStringLiteralDfa9_0(active0, 0x880400000000L, active1, 0L);
882 case 117:
883 return jjMoveStringLiteralDfa9_0(active0, 0L, active1, 0x2000L);
884 default :
885 break;
886 }
887 return jjStartNfa_0(7, active0, active1);
888 }
889 private final int jjMoveStringLiteralDfa9_0(long old0, long active0, long old1, long active1)
890 {
891 if (((active0 &= old0) | (active1 &= old1)) == 0L)
892 return jjStartNfa_0(7, old0, old1);
893 try { curChar = input_stream.readChar(); }
894 catch(java.io.IOException e) {
895 jjStopStringLiteralDfa_0(8, active0, active1);
896 return 9;
897 }
898 switch(curChar)
899 {
900 case 45:
901 return jjMoveStringLiteralDfa10_0(active0, 0x3040600000000000L, active1, 0x1L);
902 case 58:
903 if ((active0 & 0x4000000000L) != 0L)
904 return jjStopAtPos(9, 38);
905 return jjMoveStringLiteralDfa10_0(active0, 0x78000000000L, active1, 0L);
906 case 101:
907 if ((active0 & 0x20000000000000L) != 0L)
908 return jjStartNfaWithStates_0(9, 53, 12);
909 break;
910 case 103:
911 return jjMoveStringLiteralDfa10_0(active0, 0x400000000L, active1, 0L);
912 case 109:
913 return jjMoveStringLiteralDfa10_0(active0, 0L, active1, 0x2000L);
914 case 110:
915 return jjMoveStringLiteralDfa10_0(active0, 0x8000000000000000L, active1, 0L);
916 case 111:
917 return jjMoveStringLiteralDfa10_0(active0, 0x100000000000L, active1, 0L);
918 case 116:
919 return jjMoveStringLiteralDfa10_0(active0, 0x400880000000000L, active1, 0L);
920 default :
921 break;
922 }
923 return jjStartNfa_0(8, active0, active1);
924 }
925 private final int jjMoveStringLiteralDfa10_0(long old0, long active0, long old1, long active1)
926 {
927 if (((active0 &= old0) | (active1 &= old1)) == 0L)
928 return jjStartNfa_0(8, old0, old1);
929 try { curChar = input_stream.readChar(); }
930 catch(java.io.IOException e) {
931 jjStopStringLiteralDfa_0(9, active0, active1);
932 return 10;
933 }
934 switch(curChar)
935 {
936 case 45:
937 return jjMoveStringLiteralDfa11_0(active0, 0x800400000000L, active1, 0L);
938 case 58:
939 if ((active0 & 0x8000000000L) != 0L)
940 return jjStopAtPos(10, 39);
941 else if ((active0 & 0x10000000000L) != 0L)
942 return jjStopAtPos(10, 40);
943 else if ((active0 & 0x20000000000L) != 0L)
944 return jjStopAtPos(10, 41);
945 else if ((active0 & 0x40000000000L) != 0L)
946 return jjStopAtPos(10, 42);
947 return jjMoveStringLiteralDfa11_0(active0, 0x80000000000L, active1, 0L);
948 case 97:
949 return jjMoveStringLiteralDfa11_0(active0, 0x2000000000000000L, active1, 0L);
950 case 98:
951 return jjMoveStringLiteralDfa11_0(active0, 0x1000000000000000L, active1, 0x2000L);
952 case 103:
953 return jjMoveStringLiteralDfa11_0(active0, 0x8000000000000000L, active1, 0L);
954 case 104:
955 if ((active0 & 0x400000000000000L) != 0L)
956 return jjStartNfaWithStates_0(10, 58, 12);
957 break;
958 case 114:
959 return jjMoveStringLiteralDfa11_0(active0, 0x100000000000L, active1, 0L);
960 case 115:
961 return jjMoveStringLiteralDfa11_0(active0, 0x600000000000L, active1, 0x1L);
962 case 117:
963 return jjMoveStringLiteralDfa11_0(active0, 0x40000000000000L, active1, 0L);
964 default :
965 break;
966 }
967 return jjStartNfa_0(9, active0, active1);
968 }
969 private final int jjMoveStringLiteralDfa11_0(long old0, long active0, long old1, long active1)
970 {
971 if (((active0 &= old0) | (active1 &= old1)) == 0L)
972 return jjStartNfa_0(9, old0, old1);
973 try { curChar = input_stream.readChar(); }
974 catch(java.io.IOException e) {
975 jjStopStringLiteralDfa_0(10, active0, active1);
976 return 11;
977 }
978 switch(curChar)
979 {
980 case 45:
981 return jjMoveStringLiteralDfa12_0(active0, 0x100000000000L, active1, 0L);
982 case 58:
983 if ((active0 & 0x80000000000L) != 0L)
984 return jjStopAtPos(11, 43);
985 break;
986 case 101:
987 return jjMoveStringLiteralDfa12_0(active0, 0x1000000000000000L, active1, 0x2000L);
988 case 102:
989 return jjMoveStringLiteralDfa12_0(active0, 0x2000000000000000L, active1, 0L);
990 case 105:
991 return jjMoveStringLiteralDfa12_0(active0, 0x600400000000L, active1, 0L);
992 case 111:
993 return jjMoveStringLiteralDfa12_0(active0, 0x800000000000L, active1, 0L);
994 case 112:
995 return jjMoveStringLiteralDfa12_0(active0, 0L, active1, 0x1L);
996 case 114:
997 return jjMoveStringLiteralDfa12_0(active0, 0x40000000000000L, active1, 0L);
998 case 116:
999 return jjMoveStringLiteralDfa12_0(active0, 0x8000000000000000L, active1, 0L);
1000 default :
1001 break;
1002 }
1003 return jjStartNfa_0(10, active0, active1);
1004}
1005private final int jjMoveStringLiteralDfa12_0(long old0, long active0, long old1, long active1)
1006{
1007 if (((active0 &= old0) | (active1 &= old1)) == 0L)
1008 return jjStartNfa_0(10, old0, old1);
1009 try { curChar = input_stream.readChar(); }
1010 catch(java.io.IOException e) {
1011 jjStopStringLiteralDfa_0(11, active0, active1);
1012 return 12;
1013 }
1014 switch(curChar)
1015 {
1016 case 97:
1017 return jjMoveStringLiteralDfa13_0(active0, 0L, active1, 0x1L);
1018 case 98:
1019 return jjMoveStringLiteralDfa13_0(active0, 0x600000000000L, active1, 0L);
1020 case 102:
1021 return jjMoveStringLiteralDfa13_0(active0, 0x1000000000000000L, active1, 0L);
1022 case 104:
1023 if ((active0 & 0x8000000000000000L) != 0L)
1024 return jjStartNfaWithStates_0(12, 63, 12);
1025 break;
1026 case 105:
1027 if ((active0 & 0x40000000000000L) != 0L)
1028 return jjStartNfaWithStates_0(12, 54, 12);
1029 break;
1030 case 110:
1031 return jjMoveStringLiteralDfa13_0(active0, 0x400000000L, active1, 0L);
1032 case 114:
1033 if ((active1 & 0x2000L) != 0L)
1034 return jjStartNfaWithStates_0(12, 77, 12);
1035 return jjMoveStringLiteralDfa13_0(active0, 0x800000000000L, active1, 0L);
1036 case 115:
1037 return jjMoveStringLiteralDfa13_0(active0, 0x100000000000L, active1, 0L);
1038 case 116:
1039 return jjMoveStringLiteralDfa13_0(active0, 0x2000000000000000L, active1, 0L);
1040 default :
1041 break;
1042 }
1043 return jjStartNfa_0(11, active0, active1);
1044}
1045private final int jjMoveStringLiteralDfa13_0(long old0, long active0, long old1, long active1)
1046{
1047 if (((active0 &= old0) | (active1 &= old1)) == 0L)
1048 return jjStartNfa_0(11, old0, old1);
1049 try { curChar = input_stream.readChar(); }
1050 catch(java.io.IOException e) {
1051 jjStopStringLiteralDfa_0(12, active0, active1);
1052 return 13;
1053 }
1054 switch(curChar)
1055 {
1056 case 45:
1057 return jjMoveStringLiteralDfa14_0(active0, 0x800000000000L, active1, 0L);
1058 case 99:
1059 return jjMoveStringLiteralDfa14_0(active0, 0L, active1, 0x1L);
1060 case 101:
1061 return jjMoveStringLiteralDfa14_0(active0, 0x2000100000000000L, active1, 0L);
1062 case 108:
1063 return jjMoveStringLiteralDfa14_0(active0, 0x600000000000L, active1, 0L);
1064 case 111:
1065 return jjMoveStringLiteralDfa14_0(active0, 0x1000000000000000L, active1, 0L);
1066 case 115:
1067 return jjMoveStringLiteralDfa14_0(active0, 0x400000000L, active1, 0L);
1068 default :
1069 break;
1070 }
1071 return jjStartNfa_0(12, active0, active1);
1072}
1073private final int jjMoveStringLiteralDfa14_0(long old0, long active0, long old1, long active1)
1074{
1075 if (((active0 &= old0) | (active1 &= old1)) == 0L)
1076 return jjStartNfa_0(12, old0, old1);
1077 try { curChar = input_stream.readChar(); }
1078 catch(java.io.IOException e) {
1079 jjStopStringLiteralDfa_0(13, active0, active1);
1080 return 14;
1081 }
1082 switch(curChar)
1083 {
1084 case 101:
1085 if ((active1 & 0x1L) != 0L)
1086 return jjStartNfaWithStates_0(14, 64, 12);
1087 break;
1088 case 105:
1089 return jjMoveStringLiteralDfa15_0(active0, 0x600000000000L, active1, 0L);
1090 case 108:
1091 return jjMoveStringLiteralDfa15_0(active0, 0x100000000000L, active1, 0L);
1092 case 114:
1093 if ((active0 & 0x2000000000000000L) != 0L)
1094 return jjStartNfaWithStates_0(14, 61, 12);
1095 return jjMoveStringLiteralDfa15_0(active0, 0x1000000000000000L, active1, 0L);
1096 case 115:
1097 return jjMoveStringLiteralDfa15_0(active0, 0x800000000000L, active1, 0L);
1098 case 116:
1099 return jjMoveStringLiteralDfa15_0(active0, 0x400000000L, active1, 0L);
1100 default :
1101 break;
1102 }
1103 return jjStartNfa_0(13, active0, active1);
1104}
1105private final int jjMoveStringLiteralDfa15_0(long old0, long active0, long old1, long active1)
1106{
1107 if (((active0 &= old0) | (active1 &= old1)) == 0L)
1108 return jjStartNfa_0(13, old0, old1);
1109 try { curChar = input_stream.readChar(); }
1110 catch(java.io.IOException e) {
1111 jjStopStringLiteralDfa_0(14, active0, 0L);
1112 return 15;
1113 }
1114 switch(curChar)
1115 {
1116 case 101:
1117 if ((active0 & 0x1000000000000000L) != 0L)
1118 return jjStartNfaWithStates_0(15, 60, 12);
1119 return jjMoveStringLiteralDfa16_0(active0, 0x800000000000L);
1120 case 102:
1121 return jjMoveStringLiteralDfa16_0(active0, 0x100000000000L);
1122 case 110:
1123 return jjMoveStringLiteralDfa16_0(active0, 0x600000000000L);
1124 case 114:
1125 return jjMoveStringLiteralDfa16_0(active0, 0x400000000L);
1126 default :
1127 break;
1128 }
1129 return jjStartNfa_0(14, active0, 0L);
1130}
1131private final int jjMoveStringLiteralDfa16_0(long old0, long active0)
1132{
1133 if (((active0 &= old0)) == 0L)
1134 return jjStartNfa_0(14, old0, 0L);
1135 try { curChar = input_stream.readChar(); }
1136 catch(java.io.IOException e) {
1137 jjStopStringLiteralDfa_0(15, active0, 0L);
1138 return 16;
1139 }
1140 switch(curChar)
1141 {
1142 case 58:
1143 return jjMoveStringLiteralDfa17_0(active0, 0x100000000000L);
1144 case 103:
1145 return jjMoveStringLiteralDfa17_0(active0, 0x600000000000L);
1146 case 108:
1147 return jjMoveStringLiteralDfa17_0(active0, 0x800000000000L);
1148 case 117:
1149 return jjMoveStringLiteralDfa17_0(active0, 0x400000000L);
1150 default :
1151 break;
1152 }
1153 return jjStartNfa_0(15, active0, 0L);
1154}
1155private final int jjMoveStringLiteralDfa17_0(long old0, long active0)
1156{
1157 if (((active0 &= old0)) == 0L)
1158 return jjStartNfa_0(15, old0, 0L);
1159 try { curChar = input_stream.readChar(); }
1160 catch(java.io.IOException e) {
1161 jjStopStringLiteralDfa_0(16, active0, 0L);
1162 return 17;
1163 }
1164 switch(curChar)
1165 {
1166 case 58:
1167 if ((active0 & 0x100000000000L) != 0L)
1168 return jjStopAtPos(17, 44);
1169 return jjMoveStringLiteralDfa18_0(active0, 0x600000000000L);
1170 case 99:
1171 return jjMoveStringLiteralDfa18_0(active0, 0x400000000L);
1172 case 102:
1173 return jjMoveStringLiteralDfa18_0(active0, 0x800000000000L);
1174 default :
1175 break;
1176 }
1177 return jjStartNfa_0(16, active0, 0L);
1178}
1179private final int jjMoveStringLiteralDfa18_0(long old0, long active0)
1180{
1181 if (((active0 &= old0)) == 0L)
1182 return jjStartNfa_0(16, old0, 0L);
1183 try { curChar = input_stream.readChar(); }
1184 catch(java.io.IOException e) {
1185 jjStopStringLiteralDfa_0(17, active0, 0L);
1186 return 18;
1187 }
1188 switch(curChar)
1189 {
1190 case 58:
1191 if ((active0 & 0x200000000000L) != 0L)
1192 return jjStopAtPos(18, 45);
1193 else if ((active0 & 0x400000000000L) != 0L)
1194 return jjStopAtPos(18, 46);
1195 return jjMoveStringLiteralDfa19_0(active0, 0x800000000000L);
1196 case 116:
1197 return jjMoveStringLiteralDfa19_0(active0, 0x400000000L);
1198 default :
1199 break;
1200 }
1201 return jjStartNfa_0(17, active0, 0L);
1202}
1203private final int jjMoveStringLiteralDfa19_0(long old0, long active0)
1204{
1205 if (((active0 &= old0)) == 0L)
1206 return jjStartNfa_0(17, old0, 0L);
1207 try { curChar = input_stream.readChar(); }
1208 catch(java.io.IOException e) {
1209 jjStopStringLiteralDfa_0(18, active0, 0L);
1210 return 19;
1211 }
1212 switch(curChar)
1213 {
1214 case 58:
1215 if ((active0 & 0x800000000000L) != 0L)
1216 return jjStopAtPos(19, 47);
1217 break;
1218 case 105:
1219 return jjMoveStringLiteralDfa20_0(active0, 0x400000000L);
1220 default :
1221 break;
1222 }
1223 return jjStartNfa_0(18, active0, 0L);
1224}
1225private final int jjMoveStringLiteralDfa20_0(long old0, long active0)
1226{
1227 if (((active0 &= old0)) == 0L)
1228 return jjStartNfa_0(18, old0, 0L);
1229 try { curChar = input_stream.readChar(); }
1230 catch(java.io.IOException e) {
1231 jjStopStringLiteralDfa_0(19, active0, 0L);
1232 return 20;
1233 }
1234 switch(curChar)
1235 {
1236 case 111:
1237 return jjMoveStringLiteralDfa21_0(active0, 0x400000000L);
1238 default :
1239 break;
1240 }
1241 return jjStartNfa_0(19, active0, 0L);
1242}
1243private final int jjMoveStringLiteralDfa21_0(long old0, long active0)
1244{
1245 if (((active0 &= old0)) == 0L)
1246 return jjStartNfa_0(19, old0, 0L);
1247 try { curChar = input_stream.readChar(); }
1248 catch(java.io.IOException e) {
1249 jjStopStringLiteralDfa_0(20, active0, 0L);
1250 return 21;
1251 }
1252 switch(curChar)
1253 {
1254 case 110:
1255 if ((active0 & 0x400000000L) != 0L)
1256 return jjStartNfaWithStates_0(21, 34, 12);
1257 break;
1258 default :
1259 break;
1260 }
1261 return jjStartNfa_0(20, active0, 0L);
1262}
1263private final void jjCheckNAdd(int state)
1264{
1265 if (jjrounds[state] != jjround)
1266 {
1267 jjstateSet[jjnewStateCnt++] = state;
1268 jjrounds[state] = jjround;
1269 }
1270}
1271private final void jjAddStates(int start, int end)
1272{
1273 do {
1274 jjstateSet[jjnewStateCnt++] = jjnextStates[start];
1275 } while (start++ != end);
1276}
1277private final void jjCheckNAddTwoStates(int state1, int state2)
1278{
1279 jjCheckNAdd(state1);
1280 jjCheckNAdd(state2);
1281}
1282private final void jjCheckNAddStates(int start, int end)
1283{
1284 do {
1285 jjCheckNAdd(jjnextStates[start]);
1286 } while (start++ != end);
1287}
1288private final void jjCheckNAddStates(int start)
1289{
1290 jjCheckNAdd(jjnextStates[start]);
1291 jjCheckNAdd(jjnextStates[start + 1]);
1292}
1293static final long[] jjbitVec0 = {
1294 0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
1295};
1296static final long[] jjbitVec2 = {
1297 0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
1298};
1299static final long[] jjbitVec3 = {
1300 0x0L, 0xffffffffffffc000L, 0xfffff0007fffffffL, 0x7fffffL
1301};
1302static final long[] jjbitVec4 = {
1303 0x0L, 0x0L, 0x0L, 0xff7fffffff7fffffL
1304};
1305static final long[] jjbitVec5 = {
1306 0x7ff3ffffffffffffL, 0x7ffffffffffffdfeL, 0xffffffffffffffffL, 0xfc31ffffffffe00fL
1307};
1308static final long[] jjbitVec6 = {
1309 0xffffffL, 0xffffffffffff0000L, 0xf80001ffffffffffL, 0x3L
1310};
1311static final long[] jjbitVec7 = {
1312 0x0L, 0x0L, 0xfffffffbffffd740L, 0xffffd547f7fffL
1313};
1314static final long[] jjbitVec8 = {
1315 0xffffffffffffdffeL, 0xffffffffdffeffffL, 0xffffffffffff0003L, 0x33fcfffffff199fL
1316};
1317static final long[] jjbitVec9 = {
1318 0xfffe000000000000L, 0xfffffffe027fffffL, 0x7fL, 0x707ffffff0000L
1319};
1320static final long[] jjbitVec10 = {
1321 0x7fffffe00000000L, 0xfffe0000000007feL, 0x7cffffffffffffffL, 0x60002f7fffL
1322};
1323static final long[] jjbitVec11 = {
1324 0x23ffffffffffffe0L, 0x3ff000000L, 0x3c5fdfffff99fe0L, 0x30003b0000000L
1325};
1326static final long[] jjbitVec12 = {
1327 0x36dfdfffff987e0L, 0x1c00005e000000L, 0x23edfdfffffbafe0L, 0x100000000L
1328};
1329static final long[] jjbitVec13 = {
1330 0x23cdfdfffff99fe0L, 0x3b0000000L, 0x3bfc718d63dc7e0L, 0x0L
1331};
1332static final long[] jjbitVec14 = {
1333 0x3effdfffffddfe0L, 0x300000000L, 0x3effdfffffddfe0L, 0x340000000L
1334};
1335static final long[] jjbitVec15 = {
1336 0x3fffdfffffddfe0L, 0x300000000L, 0x0L, 0x0L
1337};
1338static final long[] jjbitVec16 = {
1339 0xd7ffffffffffeL, 0x3fL, 0x200d6caefef02596L, 0x1fL
1340};
1341static final long[] jjbitVec17 = {
1342 0x0L, 0x3fffffffeffL, 0x0L, 0x0L
1343};
1344static final long[] jjbitVec18 = {
1345 0x0L, 0x0L, 0xffffffff00000000L, 0x7fffffffff003fL
1346};
1347static final long[] jjbitVec19 = {
1348 0x500000000007daedL, 0x2c62ab82315001L, 0xf580c90040000000L, 0x201080000000007L
1349};
1350static final long[] jjbitVec20 = {
1351 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffff0fffffffL, 0x3ffffffffffffffL
1352};
1353static final long[] jjbitVec21 = {
1354 0xffffffff3f3fffffL, 0x3fffffffaaff3f3fL, 0x5fdfffffffffffffL, 0x1fdc1fff0fcf1fdcL
1355};
1356static final long[] jjbitVec22 = {
1357 0x4c4000000000L, 0x0L, 0x7L, 0x0L
1358};
1359static final long[] jjbitVec23 = {
1360 0x3fe00000080L, 0xfffffffffffffffeL, 0xfffffffe001fffffL, 0x7ffffffffffffffL
1361};
1362static final long[] jjbitVec24 = {
1363 0x1fffffffffe0L, 0x0L, 0x0L, 0x0L
1364};
1365static final long[] jjbitVec25 = {
1366 0xffffffffffffffffL, 0xffffffffffffffffL, 0x3fffffffffL, 0x0L
1367};
1368static final long[] jjbitVec26 = {
1369 0xffffffffffffffffL, 0xffffffffffffffffL, 0xfffffffffL, 0x0L
1370};
1371static final long[] jjbitVec27 = {
1372 0x0L, 0x0L, 0x80000000000000L, 0xff7fffffff7fffffL
1373};
1374static final long[] jjbitVec28 = {
1375 0xffffffL, 0xffffffffffff0000L, 0xf80001ffffffffffL, 0x30003L
1376};
1377static final long[] jjbitVec29 = {
1378 0xffffffffffffffffL, 0x30000003fL, 0xfffffffbffffd7c0L, 0xffffd547f7fffL
1379};
1380static final long[] jjbitVec30 = {
1381 0xffffffffffffdffeL, 0xffffffffdffeffffL, 0xffffffffffff007bL, 0x33fcfffffff199fL
1382};
1383static final long[] jjbitVec31 = {
1384 0xfffe000000000000L, 0xfffffffe027fffffL, 0xbbfffffbfffe007fL, 0x707ffffff0016L
1385};
1386static final long[] jjbitVec32 = {
1387 0x7fffffe00000000L, 0xffff03ff0007ffffL, 0x7cffffffffffffffL, 0x3ff3dffffef7fffL
1388};
1389static final long[] jjbitVec33 = {
1390 0xf3ffffffffffffeeL, 0xffcfff1e3fffL, 0xd3c5fdfffff99feeL, 0x3ffcfb080399fL
1391};
1392static final long[] jjbitVec34 = {
1393 0xd36dfdfffff987e4L, 0x1fffc05e003987L, 0xf3edfdfffffbafeeL, 0xffc100003bbfL
1394};
1395static final long[] jjbitVec35 = {
1396 0xf3cdfdfffff99feeL, 0xffc3b0c0398fL, 0xc3bfc718d63dc7ecL, 0xff8000803dc7L
1397};
1398static final long[] jjbitVec36 = {
1399 0xc3effdfffffddfeeL, 0xffc300603ddfL, 0xc3effdfffffddfecL, 0xffc340603ddfL
1400};
1401static final long[] jjbitVec37 = {
1402 0xc3fffdfffffddfecL, 0xffc300803dcfL, 0x0L, 0x0L
1403};
1404static final long[] jjbitVec38 = {
1405 0x7ff7ffffffffffeL, 0x3ff7fffL, 0x3bff6caefef02596L, 0x3ff3f5fL
1406};
1407static final long[] jjbitVec39 = {
1408 0xc2a003ff03000000L, 0xfffe03fffffffeffL, 0x2fe3ffffebf0fdfL, 0x0L
1409};
1410static final long[] jjbitVec40 = {
1411 0x0L, 0x0L, 0x0L, 0x21fff0000L
1412};
1413static final long[] jjbitVec41 = {
1414 0x3efffe000000a0L, 0xfffffffffffffffeL, 0xfffffffe661fffffL, 0x77ffffffffffffffL
1415};
1416private final int jjMoveNfa_0(int startState, int curPos)
1417{
1418 int[] nextStates;
1419 int startsAt = 0;
1420 jjnewStateCnt = 13;
1421 int i = 1;
1422 jjstateSet[0] = startState;
1423 int j, kind = 0x7fffffff;
1424 for (;;)
1425 {
1426 if (++jjround == 0x7fffffff)
1427 ReInitRounds();
1428 if (curChar < 64)
1429 {
1430 long l = 1L << curChar;
1431 MatchLoop: do
1432 {
1433 switch(jjstateSet[--i])
1434 {
1435 case 0:
1436 if ((0x3ff000000000000L & l) != 0L)
1437 {
1438 if (kind > 20)
1439 kind = 20;
1440 jjCheckNAddTwoStates(6, 7);
1441 }
1442 else if (curChar == 46)
1443 jjCheckNAdd(10);
1444 else if (curChar == 39)
1445 jjCheckNAddTwoStates(4, 5);
1446 else if (curChar == 34)
1447 jjCheckNAddTwoStates(1, 2);
1448 break;
1449 case 1:
1450 if ((0xfffffffbffffffffL & l) != 0L)
1451 jjCheckNAddTwoStates(1, 2);
1452 break;
1453 case 2:
1454 if (curChar == 34 && kind > 18)
1455 kind = 18;
1456 break;
1457 case 3:
1458 if (curChar == 39)
1459 jjCheckNAddTwoStates(4, 5);
1460 break;
1461 case 4:
1462 if ((0xffffff7fffffffffL & l) != 0L)
1463 jjCheckNAddTwoStates(4, 5);
1464 break;
1465 case 5:
1466 if (curChar == 39 && kind > 18)
1467 kind = 18;
1468 break;
1469 case 6:
1470 if ((0x3ff000000000000L & l) == 0L)
1471 break;
1472 if (kind > 20)
1473 kind = 20;
1474 jjCheckNAddTwoStates(6, 7);
1475 break;
1476 case 7:
1477 if (curChar != 46)
1478 break;
1479 if (kind > 20)
1480 kind = 20;
1481 jjCheckNAdd(8);
1482 break;
1483 case 8:
1484 if ((0x3ff000000000000L & l) == 0L)
1485 break;
1486 if (kind > 20)
1487 kind = 20;
1488 jjCheckNAdd(8);
1489 break;
1490 case 9:
1491 if (curChar == 46)
1492 jjCheckNAdd(10);
1493 break;
1494 case 10:
1495 if ((0x3ff000000000000L & l) == 0L)
1496 break;
1497 if (kind > 20)
1498 kind = 20;
1499 jjCheckNAdd(10);
1500 break;
1501 case 12:
1502 if ((0x3ff600000000000L & l) == 0L)
1503 break;
1504 if (kind > 78)
1505 kind = 78;
1506 jjstateSet[jjnewStateCnt++] = 12;
1507 break;
1508 default : break;
1509 }
1510 } while(i != startsAt);
1511 }
1512 else if (curChar < 128)
1513 {
1514 long l = 1L << (curChar & 077);
1515 MatchLoop: do
1516 {
1517 switch(jjstateSet[--i])
1518 {
1519 case 0:
1520 case 12:
1521 if ((0x7fffffe87fffffeL & l) == 0L)
1522 break;
1523 if (kind > 78)
1524 kind = 78;
1525 jjCheckNAdd(12);
1526 break;
1527 case 1:
1528 jjAddStates(0, 1);
1529 break;
1530 case 4:
1531 jjAddStates(2, 3);
1532 break;
1533 default : break;
1534 }
1535 } while(i != startsAt);
1536 }
1537 else
1538 {
1539 int hiByte = (int)(curChar >> 8);
1540 int i1 = hiByte >> 6;
1541 long l1 = 1L << (hiByte & 077);
1542 int i2 = (curChar & 0xff) >> 6;
1543 long l2 = 1L << (curChar & 077);
1544 MatchLoop: do
1545 {
1546 switch(jjstateSet[--i])
1547 {
1548 case 0:
1549 if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
1550 break;
1551 if (kind > 78)
1552 kind = 78;
1553 jjCheckNAdd(12);
1554 break;
1555 case 1:
1556 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1557 jjAddStates(0, 1);
1558 break;
1559 case 4:
1560 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1561 jjAddStates(2, 3);
1562 break;
1563 case 12:
1564 if (!jjCanMove_2(hiByte, i1, i2, l1, l2))
1565 break;
1566 if (kind > 78)
1567 kind = 78;
1568 jjCheckNAdd(12);
1569 break;
1570 default : break;
1571 }
1572 } while(i != startsAt);
1573 }
1574 if (kind != 0x7fffffff)
1575 {
1576 jjmatchedKind = kind;
1577 jjmatchedPos = curPos;
1578 kind = 0x7fffffff;
1579 }
1580 ++curPos;
1581 if ((i = jjnewStateCnt) == (startsAt = 13 - (jjnewStateCnt = startsAt)))
1582 return curPos;
1583 try { curChar = input_stream.readChar(); }
1584 catch(java.io.IOException e) { return curPos; }
1585 }
1586}
1587static final int[] jjnextStates = {
1588 1, 2, 4, 5,
1589};
1590private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2)
1591{
1592 switch(hiByte)
1593 {
1594 case 0:
1595 return ((jjbitVec2[i2] & l2) != 0L);
1596 default :
1597 if ((jjbitVec0[i1] & l1) != 0L)
1598 return true;
1599 return false;
1600 }
1601}
1602private static final boolean jjCanMove_1(int hiByte, int i1, int i2, long l1, long l2)
1603{
1604 switch(hiByte)
1605 {
1606 case 0:
1607 return ((jjbitVec4[i2] & l2) != 0L);
1608 case 1:
1609 return ((jjbitVec5[i2] & l2) != 0L);
1610 case 2:
1611 return ((jjbitVec6[i2] & l2) != 0L);
1612 case 3:
1613 return ((jjbitVec7[i2] & l2) != 0L);
1614 case 4:
1615 return ((jjbitVec8[i2] & l2) != 0L);
1616 case 5:
1617 return ((jjbitVec9[i2] & l2) != 0L);
1618 case 6:
1619 return ((jjbitVec10[i2] & l2) != 0L);
1620 case 9:
1621 return ((jjbitVec11[i2] & l2) != 0L);
1622 case 10:
1623 return ((jjbitVec12[i2] & l2) != 0L);
1624 case 11:
1625 return ((jjbitVec13[i2] & l2) != 0L);
1626 case 12:
1627 return ((jjbitVec14[i2] & l2) != 0L);
1628 case 13:
1629 return ((jjbitVec15[i2] & l2) != 0L);
1630 case 14:
1631 return ((jjbitVec16[i2] & l2) != 0L);
1632 case 15:
1633 return ((jjbitVec17[i2] & l2) != 0L);
1634 case 16:
1635 return ((jjbitVec18[i2] & l2) != 0L);
1636 case 17:
1637 return ((jjbitVec19[i2] & l2) != 0L);
1638 case 30:
1639 return ((jjbitVec20[i2] & l2) != 0L);
1640 case 31:
1641 return ((jjbitVec21[i2] & l2) != 0L);
1642 case 33:
1643 return ((jjbitVec22[i2] & l2) != 0L);
1644 case 48:
1645 return ((jjbitVec23[i2] & l2) != 0L);
1646 case 49:
1647 return ((jjbitVec24[i2] & l2) != 0L);
1648 case 159:
1649 return ((jjbitVec25[i2] & l2) != 0L);
1650 case 215:
1651 return ((jjbitVec26[i2] & l2) != 0L);
1652 default :
1653 if ((jjbitVec3[i1] & l1) != 0L)
1654 return true;
1655 return false;
1656 }
1657}
1658private static final boolean jjCanMove_2(int hiByte, int i1, int i2, long l1, long l2)
1659{
1660 switch(hiByte)
1661 {
1662 case 0:
1663 return ((jjbitVec27[i2] & l2) != 0L);
1664 case 1:
1665 return ((jjbitVec5[i2] & l2) != 0L);
1666 case 2:
1667 return ((jjbitVec28[i2] & l2) != 0L);
1668 case 3:
1669 return ((jjbitVec29[i2] & l2) != 0L);
1670 case 4:
1671 return ((jjbitVec30[i2] & l2) != 0L);
1672 case 5:
1673 return ((jjbitVec31[i2] & l2) != 0L);
1674 case 6:
1675 return ((jjbitVec32[i2] & l2) != 0L);
1676 case 9:
1677 return ((jjbitVec33[i2] & l2) != 0L);
1678 case 10:
1679 return ((jjbitVec34[i2] & l2) != 0L);
1680 case 11:
1681 return ((jjbitVec35[i2] & l2) != 0L);
1682 case 12:
1683 return ((jjbitVec36[i2] & l2) != 0L);
1684 case 13:
1685 return ((jjbitVec37[i2] & l2) != 0L);
1686 case 14:
1687 return ((jjbitVec38[i2] & l2) != 0L);
1688 case 15:
1689 return ((jjbitVec39[i2] & l2) != 0L);
1690 case 16:
1691 return ((jjbitVec18[i2] & l2) != 0L);
1692 case 17:
1693 return ((jjbitVec19[i2] & l2) != 0L);
1694 case 30:
1695 return ((jjbitVec20[i2] & l2) != 0L);
1696 case 31:
1697 return ((jjbitVec21[i2] & l2) != 0L);
1698 case 32:
1699 return ((jjbitVec40[i2] & l2) != 0L);
1700 case 33:
1701 return ((jjbitVec22[i2] & l2) != 0L);
1702 case 48:
1703 return ((jjbitVec41[i2] & l2) != 0L);
1704 case 49:
1705 return ((jjbitVec24[i2] & l2) != 0L);
1706 case 159:
1707 return ((jjbitVec25[i2] & l2) != 0L);
1708 case 215:
1709 return ((jjbitVec26[i2] & l2) != 0L);
1710 default :
1711 if ((jjbitVec3[i1] & l1) != 0L)
1712 return true;
1713 return false;
1714 }
1715}
1716public static final String [] jjstrLiteralImages = {
1717"", null, null, null, null, null, "\57", "\57\57", "\174", "\53", "\55",
1718"\75", "\41\75", "\74", "\74\75", "\76", "\76\75", "\44", null, null, null, null,
1719null, null, null, null, null, "\157\162", "\141\156\144", "\155\157\144",
1720"\144\151\166", "\156\157\144\145", "\164\145\170\164", "\143\157\155\155\145\156\164",
1721"\160\162\157\143\145\163\163\151\156\147\55\151\156\163\164\162\165\143\164\151\157\156", "\163\145\154\146\72\72", "\143\150\151\154\144\72\72",
1722"\160\141\162\145\156\164\72\72", "\141\156\143\145\163\164\157\162\72\72",
1723"\141\164\164\162\151\142\165\164\145\72\72", "\156\141\155\145\163\160\141\143\145\72\72",
1724"\160\162\145\143\145\144\151\156\147\72\72", "\146\157\154\154\157\167\151\156\147\72\72",
1725"\144\145\163\143\145\156\144\141\156\164\72\72", "\141\156\143\145\163\164\157\162\55\157\162\55\163\145\154\146\72\72",
1726"\146\157\154\154\157\167\151\156\147\55\163\151\142\154\151\156\147\72\72", "\160\162\145\143\145\144\151\156\147\55\163\151\142\154\151\156\147\72\72",
1727"\144\145\163\143\145\156\144\141\156\164\55\157\162\55\163\145\154\146\72\72", "\154\141\163\164", "\160\157\163\151\164\151\157\156",
1728"\143\157\165\156\164", "\151\144", "\153\145\171", "\154\157\143\141\154\55\156\141\155\145",
1729"\156\141\155\145\163\160\141\143\145\55\165\162\151", "\156\141\155\145", "\163\164\162\151\156\147", "\143\157\156\143\141\164",
1730"\163\164\141\162\164\163\55\167\151\164\150", "\143\157\156\164\141\151\156\163",
1731"\163\165\142\163\164\162\151\156\147\55\142\145\146\157\162\145", "\163\165\142\163\164\162\151\156\147\55\141\146\164\145\162",
1732"\163\165\142\163\164\162\151\156\147", "\163\164\162\151\156\147\55\154\145\156\147\164\150",
1733"\156\157\162\155\141\154\151\172\145\55\163\160\141\143\145", "\164\162\141\156\163\154\141\164\145", "\142\157\157\154\145\141\156",
1734"\156\157\164", "\164\162\165\145", "\146\141\154\163\145", "\156\165\154\154",
1735"\154\141\156\147", "\156\165\155\142\145\162", "\163\165\155", "\146\154\157\157\162",
1736"\143\145\151\154\151\156\147", "\162\157\165\156\144", "\146\157\162\155\141\164\55\156\165\155\142\145\162",
1737null, "\72", "\50", "\51", "\56", "\56\56", "\133", "\135", "\100", "\54", "\52", };
1738public static final String [] lexStateNames = {
1739 "DEFAULT",
1740};
1741static final long[] jjtoToken = {
1742 0xfffffffff817ffc1L, 0x1ffffffL,
1743};
1744static final long[] jjtoSkip = {
1745 0x3eL, 0x0L,
1746};
1747protected SimpleCharStream input_stream;
1748private final int[] jjrounds = new int[13];
1749private final int[] jjstateSet = new int[26];
1750protected char curChar;
1751public XPathParserTokenManager(SimpleCharStream stream)
1752{
1753 if (SimpleCharStream.staticFlag)
1754 throw new Error ("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
1755 input_stream = stream;
1756}
1757public XPathParserTokenManager(SimpleCharStream stream, int lexState)
1758{
1759 this(stream);
1760 SwitchTo(lexState);
1761}
1762public void ReInit(SimpleCharStream stream)
1763{
1764 jjmatchedPos = jjnewStateCnt = 0;
1765 curLexState = defaultLexState;
1766 input_stream = stream;
1767 ReInitRounds();
1768}
1769private final void ReInitRounds()
1770{
1771 int i;
1772 jjround = 0x80000001;
1773 for (i = 13; i-- > 0;)
1774 jjrounds[i] = 0x80000000;
1775}
1776public void ReInit(SimpleCharStream stream, int lexState)
1777{
1778 ReInit(stream);
1779 SwitchTo(lexState);
1780}
1781public void SwitchTo(int lexState)
1782{
1783 if (lexState >= 1 || lexState < 0)
1784 throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
1785 else
1786 curLexState = lexState;
1787}
1788
1789protected Token jjFillToken()
1790{
1791 Token t = Token.newToken(jjmatchedKind);
1792 t.kind = jjmatchedKind;
1793 String im = jjstrLiteralImages[jjmatchedKind];
1794 t.image = (im == null) ? input_stream.GetImage() : im;
1795 t.beginLine = input_stream.getBeginLine();
1796 t.beginColumn = input_stream.getBeginColumn();
1797 t.endLine = input_stream.getEndLine();
1798 t.endColumn = input_stream.getEndColumn();
1799 return t;
1800}
1801
1802int curLexState = 0;
1803int defaultLexState = 0;
1804int jjnewStateCnt;
1805int jjround;
1806int jjmatchedPos;
1807int jjmatchedKind;
1808
1809public Token getNextToken()
1810{
1811 int kind;
1812 Token specialToken = null;
1813 Token matchedToken;
1814 int curPos = 0;
1815
1816 EOFLoop :
1817 for (;;)
1818 {
1819 try
1820 {
1821 curChar = input_stream.BeginToken();
1822 }
1823 catch(java.io.IOException e)
1824 {
1825 jjmatchedKind = 0;
1826 matchedToken = jjFillToken();
1827 return matchedToken;
1828 }
1829
1830 try { input_stream.backup(0);
1831 while (curChar <= 32 && (0x100003600L & (1L << curChar)) != 0L)
1832 curChar = input_stream.BeginToken();
1833 }
1834 catch (java.io.IOException e1) { continue EOFLoop; }
1835 jjmatchedKind = 0x7fffffff;
1836 jjmatchedPos = 0;
1837 curPos = jjMoveStringLiteralDfa0_0();
1838 if (jjmatchedKind != 0x7fffffff)
1839 {
1840 if (jjmatchedPos + 1 < curPos)
1841 input_stream.backup(curPos - jjmatchedPos - 1);
1842 if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
1843 {
1844 matchedToken = jjFillToken();
1845 return matchedToken;
1846 }
1847 else
1848 {
1849 continue EOFLoop;
1850 }
1851 }
1852 int error_line = input_stream.getEndLine();
1853 int error_column = input_stream.getEndColumn();
1854 String error_after = null;
1855 boolean EOFSeen = false;
1856 try { input_stream.readChar(); input_stream.backup(1); }
1857 catch (java.io.IOException e1) {
1858 EOFSeen = true;
1859 error_after = curPos <= 1 ? "" : input_stream.GetImage();
1860 if (curChar == '\n' || curChar == '\r') {
1861 error_line++;
1862 error_column = 0;
1863 }
1864 else
1865 error_column++;
1866 }
1867 if (!EOFSeen) {
1868 input_stream.backup(1);
1869 error_after = curPos <= 1 ? "" : input_stream.GetImage();
1870 }
1871 throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
1872 }
1873}
1874
1875}
1876 |
Popular Tags |
Java API By Example, From Geeks To Geeks.