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