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