KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > com > versant > core > jdo > query > JDOQLParserTokenManager


1 /* Generated By:JavaCC: Do not edit this line. JDOQLParserTokenManager.java */
2 package com.versant.core.jdo.query;
3 import com.versant.core.util.CharBuf;
4 import com.versant.core.util.IntArray;
5 import java.util.ArrayList JavaDoc;
6
7 public class JDOQLParserTokenManager implements JDOQLParserConstants
8 {
9   public java.io.PrintStream JavaDoc debugStream = System.out;
10   public void setDebugStream(java.io.PrintStream JavaDoc ds) { debugStream = ds; }
11 private final int jjStopStringLiteralDfa_0(int pos, long active0, long active1)
12 {
13    switch (pos)
14    {
15       case 0:
16          if ((active0 & 0x4000000L) != 0L)
17          {
18             jjmatchedKind = 42;
19             return 24;
20          }
21          if ((active0 & 0x807bfffe00L) != 0L)
22          {
23             jjmatchedKind = 42;
24             return 36;
25          }
26          if ((active1 & 0x8L) != 0L)
27             return 53;
28          if ((active0 & 0x20000000000000L) != 0L)
29             return 4;
30          if ((active0 & 0x80000000L) != 0L)
31          {
32             jjmatchedKind = 42;
33             return 20;
34          }
35          return -1;
36       case 1:
37          if ((active0 & 0x100400L) != 0L)
38             return 36;
39          if ((active0 & 0x80ffeffa00L) != 0L)
40          {
41             if (jjmatchedPos != 1)
42             {
43                jjmatchedKind = 42;
44                jjmatchedPos = 1;
45             }
46             return 36;
47          }
48          return -1;
49       case 2:
50          if ((active0 & 0x1009c000L) != 0L)
51             return 36;
52          if ((active0 & 0x80efe63e00L) != 0L)
53          {
54             jjmatchedKind = 42;
55             jjmatchedPos = 2;
56             return 36;
57          }
58          return -1;
59       case 3:
60          if ((active0 & 0x80a0c00000L) != 0L)
61             return 36;
62          if ((active0 & 0x4f263e00L) != 0L)
63          {
64             jjmatchedKind = 42;
65             jjmatchedPos = 3;
66             return 36;
67          }
68          return -1;
69       case 4:
70          if ((active0 & 0x44061000L) != 0L)
71             return 36;
72          if ((active0 & 0xb202e00L) != 0L)
73          {
74             if (jjmatchedPos != 4)
75             {
76                jjmatchedKind = 42;
77                jjmatchedPos = 4;
78             }
79             return 36;
80          }
81          return -1;
82       case 5:
83          if ((active0 & 0xa002000L) != 0L)
84             return 36;
85          if ((active0 & 0x1200e00L) != 0L)
86          {
87             jjmatchedKind = 42;
88             jjmatchedPos = 5;
89             return 36;
90          }
91          return -1;
92       case 6:
93          if ((active0 & 0x200000L) != 0L)
94             return 36;
95          if ((active0 & 0x1000e00L) != 0L)
96          {
97             jjmatchedKind = 42;
98             jjmatchedPos = 6;
99             return 36;
100          }
101          return -1;
102       case 7:
103          if ((active0 & 0xa00L) != 0L)
104             return 36;
105          if ((active0 & 0x1000400L) != 0L)
106          {
107             jjmatchedKind = 42;
108             jjmatchedPos = 7;
109             return 36;
110          }
111          return -1;
112       case 8:
113          if ((active0 & 0x400L) != 0L)
114             return 36;
115          if ((active0 & 0x1000000L) != 0L)
116          {
117             jjmatchedKind = 42;
118             jjmatchedPos = 8;
119             return 36;
120          }
121          return -1;
122       default :
123          return -1;
124    }
125 }
126 private final int jjStartNfa_0(int pos, long active0, long active1)
127 {
128    return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0, active1), pos + 1);
129 }
130 private final int jjStopAtPos(int pos, int kind)
131 {
132    jjmatchedKind = kind;
133    jjmatchedPos = pos;
134    return pos + 1;
135 }
136 private final int jjStartNfaWithStates_0(int pos, int kind, int state)
137 {
138    jjmatchedKind = kind;
139    jjmatchedPos = pos;
140    try { curChar = input_stream.readChar(); }
141    catch(java.io.IOException JavaDoc e) { return pos + 1; }
142    return jjMoveNfa_0(state, pos + 1);
143 }
144 private final int jjMoveStringLiteralDfa0_0()
145 {
146    switch(curChar)
147    {
148       case 33:
149          jjmatchedKind = 56;
150          return jjMoveStringLiteralDfa1_0(0x2000000000000000L);
151       case 38:
152          jjmatchedKind = 68;
153          return jjMoveStringLiteralDfa1_0(0x8000000000000000L);
154       case 40:
155          return jjStopAtPos(0, 45);
156       case 41:
157          return jjStopAtPos(0, 46);
158       case 42:
159          return jjStopAtPos(0, 66);
160       case 43:
161          return jjStopAtPos(0, 64);
162       case 44:
163          return jjStopAtPos(0, 52);
164       case 45:
165          return jjStopAtPos(0, 65);
166       case 46:
167          return jjStartNfaWithStates_0(0, 53, 4);
168       case 47:
169          return jjStartNfaWithStates_0(0, 67, 53);
170       case 59:
171          return jjStopAtPos(0, 51);
172       case 60:
173          jjmatchedKind = 55;
174          return jjMoveStringLiteralDfa1_0(0x800000000000000L);
175       case 61:
176          return jjMoveStringLiteralDfa1_0(0x400000000000000L);
177       case 62:
178          jjmatchedKind = 54;
179          return jjMoveStringLiteralDfa1_0(0x1000000000000000L);
180       case 91:
181          return jjStopAtPos(0, 49);
182       case 93:
183          return jjStopAtPos(0, 50);
184       case 97:
185          return jjMoveStringLiteralDfa1_0(0x110600L);
186       case 98:
187          return jjMoveStringLiteralDfa1_0(0x600000L);
188       case 99:
189          return jjMoveStringLiteralDfa1_0(0x860000L);
190       case 100:
191          return jjMoveStringLiteralDfa1_0(0x3000800L);
192       case 102:
193          return jjMoveStringLiteralDfa1_0(0x4000000L);
194       case 103:
195          return jjMoveStringLiteralDfa1_0(0x1000L);
196       case 104:
197          return jjMoveStringLiteralDfa1_0(0x2000L);
198       case 105:
199          return jjMoveStringLiteralDfa1_0(0x18000000L);
200       case 108:
201          return jjMoveStringLiteralDfa1_0(0x20000000L);
202       case 109:
203          return jjMoveStringLiteralDfa1_0(0xc000L);
204       case 110:
205          return jjMoveStringLiteralDfa1_0(0x8000000000L);
206       case 115:
207          return jjMoveStringLiteralDfa1_0(0x40080000L);
208       case 116:
209          return jjMoveStringLiteralDfa1_0(0x80000000L);
210       case 123:
211          return jjStopAtPos(0, 47);
212       case 124:
213          jjmatchedKind = 69;
214          return jjMoveStringLiteralDfa1_0(0x4000000000000000L);
215       case 125:
216          return jjStopAtPos(0, 48);
217       case 126:
218          return jjStopAtPos(0, 57);
219       default :
220          return jjMoveNfa_0(0, 0);
221    }
222 }
223 private final int jjMoveStringLiteralDfa1_0(long active0)
224 {
225    try { curChar = input_stream.readChar(); }
226    catch(java.io.IOException JavaDoc e) {
227       jjStopStringLiteralDfa_0(0, active0, 0L);
228       return 1;
229    }
230    switch(curChar)
231    {
232       case 38:
233          if ((active0 & 0x8000000000000000L) != 0L)
234             return jjStopAtPos(1, 63);
235          break;
236       case 61:
237          if ((active0 & 0x400000000000000L) != 0L)
238             return jjStopAtPos(1, 58);
239          else if ((active0 & 0x800000000000000L) != 0L)
240             return jjStopAtPos(1, 59);
241          else if ((active0 & 0x1000000000000000L) != 0L)
242             return jjStopAtPos(1, 60);
243          else if ((active0 & 0x2000000000000000L) != 0L)
244             return jjStopAtPos(1, 61);
245          break;
246       case 97:
247          return jjMoveStringLiteralDfa2_0(active0, 0x6000L);
248       case 98:
249          return jjMoveStringLiteralDfa2_0(active0, 0x200L);
250       case 101:
251          return jjMoveStringLiteralDfa2_0(active0, 0x1000000L);
252       case 104:
253          return jjMoveStringLiteralDfa2_0(active0, 0xc0800000L);
254       case 105:
255          return jjMoveStringLiteralDfa2_0(active0, 0x8800L);
256       case 108:
257          return jjMoveStringLiteralDfa2_0(active0, 0x4000000L);
258       case 109:
259          return jjMoveStringLiteralDfa2_0(active0, 0x8000000L);
260       case 110:
261          return jjMoveStringLiteralDfa2_0(active0, 0x10000000L);
262       case 111:
263          return jjMoveStringLiteralDfa2_0(active0, 0x22260000L);
264       case 114:
265          return jjMoveStringLiteralDfa2_0(active0, 0x1000L);
266       case 115:
267          if ((active0 & 0x100000L) != 0L)
268          {
269             jjmatchedKind = 20;
270             jjmatchedPos = 1;
271          }
272          return jjMoveStringLiteralDfa2_0(active0, 0x400L);
273       case 117:
274          return jjMoveStringLiteralDfa2_0(active0, 0x8000080000L);
275       case 118:
276          return jjMoveStringLiteralDfa2_0(active0, 0x10000L);
277       case 121:
278          return jjMoveStringLiteralDfa2_0(active0, 0x400000L);
279       case 124:
280          if ((active0 & 0x4000000000000000L) != 0L)
281             return jjStopAtPos(1, 62);
282          break;
283       default :
284          break;
285    }
286    return jjStartNfa_0(0, active0, 0L);
287 }
288 private final int jjMoveStringLiteralDfa2_0(long old0, long active0)
289 {
290    if (((active0 &= old0)) == 0L)
291       return jjStartNfa_0(0, old0, 0L);
292    try { curChar = input_stream.readChar(); }
293    catch(java.io.IOException JavaDoc e) {
294       jjStopStringLiteralDfa_0(1, active0, 0L);
295       return 2;
296    }
297    switch(curChar)
298    {
299       case 97:
300          return jjMoveStringLiteralDfa3_0(active0, 0x800000L);
301       case 99:
302          return jjMoveStringLiteralDfa3_0(active0, 0x400L);
303       case 103:
304          if ((active0 & 0x10000L) != 0L)
305             return jjStartNfaWithStates_0(2, 16, 36);
306          break;
307       case 105:
308          return jjMoveStringLiteralDfa3_0(active0, 0x80000000L);
309       case 108:
310          return jjMoveStringLiteralDfa3_0(active0, 0x8000000000L);
311       case 109:
312          if ((active0 & 0x80000L) != 0L)
313             return jjStartNfaWithStates_0(2, 19, 36);
314          break;
315       case 110:
316          if ((active0 & 0x8000L) != 0L)
317             return jjStartNfaWithStates_0(2, 15, 36);
318          return jjMoveStringLiteralDfa3_0(active0, 0x20000000L);
319       case 111:
320          return jjMoveStringLiteralDfa3_0(active0, 0x44201000L);
321       case 112:
322          return jjMoveStringLiteralDfa3_0(active0, 0x8000000L);
323       case 115:
324          return jjMoveStringLiteralDfa3_0(active0, 0x1000a00L);
325       case 116:
326          if ((active0 & 0x10000000L) != 0L)
327             return jjStartNfaWithStates_0(2, 28, 36);
328          return jjMoveStringLiteralDfa3_0(active0, 0x400000L);
329       case 117:
330          return jjMoveStringLiteralDfa3_0(active0, 0x2060000L);
331       case 118:
332          return jjMoveStringLiteralDfa3_0(active0, 0x2000L);
333       case 120:
334          if ((active0 & 0x4000L) != 0L)
335             return jjStartNfaWithStates_0(2, 14, 36);
336          break;
337       default :
338          break;
339    }
340    return jjStartNfa_0(1, active0, 0L);
341 }
342 private final int jjMoveStringLiteralDfa3_0(long old0, long active0)
343 {
344    if (((active0 &= old0)) == 0L)
345       return jjStartNfa_0(1, old0, 0L);
346    try { curChar = input_stream.readChar(); }
347    catch(java.io.IOException JavaDoc e) {
348       jjStopStringLiteralDfa_0(2, active0, 0L);
349       return 3;
350    }
351    switch(curChar)
352    {
353       case 97:
354          return jjMoveStringLiteralDfa4_0(active0, 0x4000000L);
355       case 98:
356          return jjMoveStringLiteralDfa4_0(active0, 0x2000000L);
357       case 99:
358          return jjMoveStringLiteralDfa4_0(active0, 0x1000000L);
359       case 101:
360          if ((active0 & 0x400000L) != 0L)
361             return jjStartNfaWithStates_0(3, 22, 36);
362          return jjMoveStringLiteralDfa4_0(active0, 0x400L);
363       case 103:
364          if ((active0 & 0x20000000L) != 0L)
365             return jjStartNfaWithStates_0(3, 29, 36);
366          break;
367       case 105:
368          return jjMoveStringLiteralDfa4_0(active0, 0x2000L);
369       case 108:
370          if ((active0 & 0x8000000000L) != 0L)
371             return jjStartNfaWithStates_0(3, 39, 36);
372          return jjMoveStringLiteralDfa4_0(active0, 0x200000L);
373       case 110:
374          return jjMoveStringLiteralDfa4_0(active0, 0x60000L);
375       case 111:
376          return jjMoveStringLiteralDfa4_0(active0, 0x8000000L);
377       case 114:
378          if ((active0 & 0x800000L) != 0L)
379             return jjStartNfaWithStates_0(3, 23, 36);
380          return jjMoveStringLiteralDfa4_0(active0, 0x40000000L);
381       case 115:
382          if ((active0 & 0x80000000L) != 0L)
383             return jjStartNfaWithStates_0(3, 31, 36);
384          break;
385       case 116:
386          return jjMoveStringLiteralDfa4_0(active0, 0xa00L);
387       case 117:
388          return jjMoveStringLiteralDfa4_0(active0, 0x1000L);
389       default :
390          break;
391    }
392    return jjStartNfa_0(2, active0, 0L);
393 }
394 private final int jjMoveStringLiteralDfa4_0(long old0, long active0)
395 {
396    if (((active0 &= old0)) == 0L)
397       return jjStartNfa_0(2, old0, 0L);
398    try { curChar = input_stream.readChar(); }
399    catch(java.io.IOException JavaDoc e) {
400       jjStopStringLiteralDfa_0(3, active0, 0L);
401       return 4;
402    }
403    switch(curChar)
404    {
405       case 101:
406          return jjMoveStringLiteralDfa5_0(active0, 0x1200000L);
407       case 105:
408          return jjMoveStringLiteralDfa5_0(active0, 0x800L);
409       case 108:
410          return jjMoveStringLiteralDfa5_0(active0, 0x2000000L);
411       case 110:
412          return jjMoveStringLiteralDfa5_0(active0, 0x2400L);
413       case 112:
414          if ((active0 & 0x1000L) != 0L)
415             return jjStartNfaWithStates_0(4, 12, 36);
416          break;
417       case 114:
418          return jjMoveStringLiteralDfa5_0(active0, 0x8000200L);
419       case 116:
420          if ((active0 & 0x40000L) != 0L)
421          {
422             jjmatchedKind = 18;
423             jjmatchedPos = 4;
424          }
425          else if ((active0 & 0x4000000L) != 0L)
426             return jjStartNfaWithStates_0(4, 26, 36);
427          else if ((active0 & 0x40000000L) != 0L)
428             return jjStartNfaWithStates_0(4, 30, 36);
429          return jjMoveStringLiteralDfa5_0(active0, 0x20000L);
430       default :
431          break;
432    }
433    return jjStartNfa_0(3, active0, 0L);
434 }
435 private final int jjMoveStringLiteralDfa5_0(long old0, long active0)
436 {
437    if (((active0 &= old0)) == 0L)
438       return jjStartNfa_0(3, old0, 0L);
439    try { curChar = input_stream.readChar(); }
440    catch(java.io.IOException JavaDoc e) {
441       jjStopStringLiteralDfa_0(4, active0, 0L);
442       return 5;
443    }
444    switch(curChar)
445    {
446       case 40:
447          return jjMoveStringLiteralDfa6_0(active0, 0x20000L);
448       case 97:
449          return jjMoveStringLiteralDfa6_0(active0, 0x200200L);
450       case 100:
451          return jjMoveStringLiteralDfa6_0(active0, 0x400L);
452       case 101:
453          if ((active0 & 0x2000000L) != 0L)
454             return jjStartNfaWithStates_0(5, 25, 36);
455          break;
456       case 103:
457          if ((active0 & 0x2000L) != 0L)
458             return jjStartNfaWithStates_0(5, 13, 36);
459          break;
460       case 110:
461          return jjMoveStringLiteralDfa6_0(active0, 0x1000800L);
462       case 116:
463          if ((active0 & 0x8000000L) != 0L)
464             return jjStartNfaWithStates_0(5, 27, 36);
465          break;
466       default :
467          break;
468    }
469    return jjStartNfa_0(4, active0, 0L);
470 }
471 private final int jjMoveStringLiteralDfa6_0(long old0, long active0)
472 {
473    if (((active0 &= old0)) == 0L)
474       return jjStartNfa_0(4, old0, 0L);
475    try { curChar = input_stream.readChar(); }
476    catch(java.io.IOException JavaDoc e) {
477       jjStopStringLiteralDfa_0(5, active0, 0L);
478       return 6;
479    }
480    switch(curChar)
481    {
482       case 42:
483          return jjMoveStringLiteralDfa7_0(active0, 0x20000L);
484       case 99:
485          return jjMoveStringLiteralDfa7_0(active0, 0xa00L);
486       case 100:
487          return jjMoveStringLiteralDfa7_0(active0, 0x1000000L);
488       case 105:
489          return jjMoveStringLiteralDfa7_0(active0, 0x400L);
490       case 110:
491          if ((active0 & 0x200000L) != 0L)
492             return jjStartNfaWithStates_0(6, 21, 36);
493          break;
494       default :
495          break;
496    }
497    return jjStartNfa_0(5, active0, 0L);
498 }
499 private final int jjMoveStringLiteralDfa7_0(long old0, long active0)
500 {
501    if (((active0 &= old0)) == 0L)
502       return jjStartNfa_0(5, old0, 0L);
503    try { curChar = input_stream.readChar(); }
504    catch(java.io.IOException JavaDoc e) {
505       jjStopStringLiteralDfa_0(6, active0, 0L);
506       return 7;
507    }
508    switch(curChar)
509    {
510       case 41:
511          if ((active0 & 0x20000L) != 0L)
512             return jjStopAtPos(7, 17);
513          break;
514       case 105:
515          return jjMoveStringLiteralDfa8_0(active0, 0x1000000L);
516       case 110:
517          return jjMoveStringLiteralDfa8_0(active0, 0x400L);
518       case 116:
519          if ((active0 & 0x200L) != 0L)
520             return jjStartNfaWithStates_0(7, 9, 36);
521          else if ((active0 & 0x800L) != 0L)
522             return jjStartNfaWithStates_0(7, 11, 36);
523          break;
524       default :
525          break;
526    }
527    return jjStartNfa_0(6, active0, 0L);
528 }
529 private final int jjMoveStringLiteralDfa8_0(long old0, long active0)
530 {
531    if (((active0 &= old0)) == 0L)
532       return jjStartNfa_0(6, old0, 0L);
533    try { curChar = input_stream.readChar(); }
534    catch(java.io.IOException JavaDoc e) {
535       jjStopStringLiteralDfa_0(7, active0, 0L);
536       return 8;
537    }
538    switch(curChar)
539    {
540       case 103:
541          if ((active0 & 0x400L) != 0L)
542             return jjStartNfaWithStates_0(8, 10, 36);
543          break;
544       case 110:
545          return jjMoveStringLiteralDfa9_0(active0, 0x1000000L);
546       default :
547          break;
548    }
549    return jjStartNfa_0(7, active0, 0L);
550 }
551 private final int jjMoveStringLiteralDfa9_0(long old0, long active0)
552 {
553    if (((active0 &= old0)) == 0L)
554       return jjStartNfa_0(7, old0, 0L);
555    try { curChar = input_stream.readChar(); }
556    catch(java.io.IOException JavaDoc e) {
557       jjStopStringLiteralDfa_0(8, active0, 0L);
558       return 9;
559    }
560    switch(curChar)
561    {
562       case 103:
563          if ((active0 & 0x1000000L) != 0L)
564             return jjStartNfaWithStates_0(9, 24, 36);
565          break;
566       default :
567          break;
568    }
569    return jjStartNfa_0(8, active0, 0L);
570 }
571 private final void jjCheckNAdd(int state)
572 {
573    if (jjrounds[state] != jjround)
574    {
575       jjstateSet[jjnewStateCnt++] = state;
576       jjrounds[state] = jjround;
577    }
578 }
579 private final void jjAddStates(int start, int end)
580 {
581    do {
582       jjstateSet[jjnewStateCnt++] = jjnextStates[start];
583    } while (start++ != end);
584 }
585 private final void jjCheckNAddTwoStates(int state1, int state2)
586 {
587    jjCheckNAdd(state1);
588    jjCheckNAdd(state2);
589 }
590 private final void jjCheckNAddStates(int start, int end)
591 {
592    do {
593       jjCheckNAdd(jjnextStates[start]);
594    } while (start++ != end);
595 }
596 private final void jjCheckNAddStates(int start)
597 {
598    jjCheckNAdd(jjnextStates[start]);
599    jjCheckNAdd(jjnextStates[start + 1]);
600 }
601 static final long[] jjbitVec0 = {
602    0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
603 };
604 static final long[] jjbitVec2 = {
605    0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
606 };
607 private final int jjMoveNfa_0(int startState, int curPos)
608 {
609    int[] nextStates;
610    int startsAt = 0;
611    jjnewStateCnt = 76;
612    int i = 1;
613    jjstateSet[0] = startState;
614    int j, kind = 0x7fffffff;
615    for (;;)
616    {
617       if (++jjround == 0x7fffffff)
618          ReInitRounds();
619       if (curChar < 64)
620       {
621          long l = 1L << curChar;
622          MatchLoop: do
623          {
624             switch(jjstateSet[--i])
625             {
626                case 53:
627                   if (curChar == 42)
628                      jjCheckNAddTwoStates(66, 67);
629                   else if (curChar == 47)
630                      jjCheckNAddStates(0, 2);
631                   if (curChar == 42)
632                      jjstateSet[jjnewStateCnt++] = 58;
633                   break;
634                case 24:
635                case 36:
636                   if ((0x3ff000000000000L & l) == 0L)
637                      break;
638                   if (kind > 42)
639                      kind = 42;
640                   jjCheckNAdd(36);
641                   break;
642                case 20:
643                   if ((0x3ff000000000000L & l) == 0L)
644                      break;
645                   if (kind > 42)
646                      kind = 42;
647                   jjCheckNAdd(36);
648                   break;
649                case 0:
650                   if ((0x3ff000000000000L & l) != 0L)
651                      jjCheckNAddStates(3, 9);
652                   else if (curChar == 47)
653                      jjAddStates(10, 12);
654                   else if (curChar == 34)
655                      jjCheckNAddStates(13, 15);
656                   else if (curChar == 39)
657                      jjCheckNAddStates(16, 18);
658                   else if (curChar == 46)
659                      jjCheckNAdd(4);
660                   if ((0x3fe000000000000L & l) != 0L)
661                   {
662                      if (kind > 32)
663                         kind = 32;
664                      jjCheckNAddTwoStates(1, 2);
665                   }
666                   else if (curChar == 48)
667                   {
668                      if (kind > 32)
669                         kind = 32;
670                      jjCheckNAddStates(19, 22);
671                   }
672                   break;
673                case 1:
674                   if ((0x3ff000000000000L & l) == 0L)
675                      break;
676                   if (kind > 32)
677                      kind = 32;
678                   jjCheckNAddTwoStates(1, 2);
679                   break;
680                case 3:
681                   if (curChar == 46)
682                      jjCheckNAdd(4);
683                   break;
684                case 4:
685                   if ((0x3ff000000000000L & l) == 0L)
686                      break;
687                   if (kind > 36)
688                      kind = 36;
689                   jjCheckNAddStates(23, 25);
690                   break;
691                case 6:
692                   if ((0x280000000000L & l) != 0L)
693                      jjCheckNAdd(7);
694                   break;
695                case 7:
696                   if ((0x3ff000000000000L & l) == 0L)
697                      break;
698                   if (kind > 36)
699                      kind = 36;
700                   jjCheckNAddTwoStates(7, 8);
701                   break;
702                case 9:
703                   if (curChar == 39)
704                      jjCheckNAddStates(16, 18);
705                   break;
706                case 10:
707                   if ((0xffffff7fffffdbffL & l) != 0L)
708                      jjCheckNAddStates(16, 18);
709                   break;
710                case 12:
711                   if ((0x8400000000L & l) != 0L)
712                      jjCheckNAddStates(16, 18);
713                   break;
714                case 13:
715                   if (curChar == 39 && kind > 38)
716                      kind = 38;
717                   break;
718                case 14:
719                   if ((0xff000000000000L & l) != 0L)
720                      jjCheckNAddStates(26, 29);
721                   break;
722                case 15:
723                   if ((0xff000000000000L & l) != 0L)
724                      jjCheckNAddStates(16, 18);
725                   break;
726                case 16:
727                   if ((0xf000000000000L & l) != 0L)
728                      jjstateSet[jjnewStateCnt++] = 17;
729                   break;
730                case 17:
731                   if ((0xff000000000000L & l) != 0L)
732                      jjCheckNAdd(15);
733                   break;
734                case 26:
735                   if (curChar == 34)
736                      jjCheckNAddStates(13, 15);
737                   break;
738                case 27:
739                   if ((0xfffffffbffffdbffL & l) != 0L)
740                      jjCheckNAddStates(13, 15);
741                   break;
742                case 29:
743                   if ((0x8400000000L & l) != 0L)
744                      jjCheckNAddStates(13, 15);
745                   break;
746                case 30:
747                   if (curChar == 34 && kind > 41)
748                      kind = 41;
749                   break;
750                case 31:
751                   if ((0xff000000000000L & l) != 0L)
752                      jjCheckNAddStates(30, 33);
753                   break;
754                case 32:
755                   if ((0xff000000000000L & l) != 0L)
756                      jjCheckNAddStates(13, 15);
757                   break;
758                case 33:
759                   if ((0xf000000000000L & l) != 0L)
760                      jjstateSet[jjnewStateCnt++] = 34;
761                   break;
762                case 34:
763                   if ((0xff000000000000L & l) != 0L)
764                      jjCheckNAdd(32);
765                   break;
766                case 37:
767                   if ((0x3ff000000000000L & l) != 0L)
768                      jjCheckNAddStates(3, 9);
769                   break;
770                case 38:
771                   if ((0x3ff000000000000L & l) != 0L)
772                      jjCheckNAddTwoStates(38, 39);
773                   break;
774                case 39:
775                   if (curChar != 46)
776                      break;
777                   if (kind > 36)
778                      kind = 36;
779                   jjCheckNAddStates(34, 36);
780                   break;
781                case 40:
782                   if ((0x3ff000000000000L & l) == 0L)
783                      break;
784                   if (kind > 36)
785                      kind = 36;
786                   jjCheckNAddStates(34, 36);
787                   break;
788                case 42:
789                   if ((0x280000000000L & l) != 0L)
790                      jjCheckNAdd(43);
791                   break;
792                case 43:
793                   if ((0x3ff000000000000L & l) == 0L)
794                      break;
795                   if (kind > 36)
796                      kind = 36;
797                   jjCheckNAddTwoStates(43, 8);
798                   break;
799                case 44:
800                   if ((0x3ff000000000000L & l) != 0L)
801                      jjCheckNAddTwoStates(44, 45);
802                   break;
803                case 46:
804                   if ((0x280000000000L & l) != 0L)
805                      jjCheckNAdd(47);
806                   break;
807                case 47:
808                   if ((0x3ff000000000000L & l) == 0L)
809                      break;
810                   if (kind > 36)
811                      kind = 36;
812                   jjCheckNAddTwoStates(47, 8);
813                   break;
814                case 48:
815                   if ((0x3ff000000000000L & l) != 0L)
816                      jjCheckNAddStates(37, 39);
817                   break;
818                case 50:
819                   if ((0x280000000000L & l) != 0L)
820                      jjCheckNAdd(51);
821                   break;
822                case 51:
823                   if ((0x3ff000000000000L & l) != 0L)
824                      jjCheckNAddTwoStates(51, 8);
825                   break;
826                case 52:
827                   if (curChar == 47)
828                      jjAddStates(10, 12);
829                   break;
830                case 54:
831                   if ((0xffffffffffffdbffL & l) != 0L)
832                      jjCheckNAddStates(0, 2);
833                   break;
834                case 55:
835                   if ((0x2400L & l) != 0L && kind > 6)
836                      kind = 6;
837                   break;
838                case 56:
839                   if (curChar == 10 && kind > 6)
840                      kind = 6;
841                   break;
842                case 57:
843                   if (curChar == 13)
844                      jjstateSet[jjnewStateCnt++] = 56;
845                   break;
846                case 58:
847                   if (curChar == 42)
848                      jjCheckNAddTwoStates(59, 60);
849                   break;
850                case 59:
851                   if ((0xfffffbffffffffffL & l) != 0L)
852                      jjCheckNAddTwoStates(59, 60);
853                   break;
854                case 60:
855                   if (curChar == 42)
856                      jjCheckNAddStates(40, 42);
857                   break;
858                case 61:
859                   if ((0xffff7bffffffffffL & l) != 0L)
860                      jjCheckNAddTwoStates(62, 60);
861                   break;
862                case 62:
863                   if ((0xfffffbffffffffffL & l) != 0L)
864                      jjCheckNAddTwoStates(62, 60);
865                   break;
866                case 63:
867                   if (curChar == 47 && kind > 7)
868                      kind = 7;
869                   break;
870                case 64:
871                   if (curChar == 42)
872                      jjstateSet[jjnewStateCnt++] = 58;
873                   break;
874                case 65:
875                   if (curChar == 42)
876                      jjCheckNAddTwoStates(66, 67);
877                   break;
878                case 66:
879                   if ((0xfffffbffffffffffL & l) != 0L)
880                      jjCheckNAddTwoStates(66, 67);
881                   break;
882                case 67:
883                   if (curChar == 42)
884                      jjCheckNAddStates(43, 45);
885                   break;
886                case 68:
887                   if ((0xffff7bffffffffffL & l) != 0L)
888                      jjCheckNAddTwoStates(69, 67);
889                   break;
890                case 69:
891                   if ((0xfffffbffffffffffL & l) != 0L)
892                      jjCheckNAddTwoStates(69, 67);
893                   break;
894                case 70:
895                   if (curChar == 47 && kind > 8)
896                      kind = 8;
897                   break;
898                case 71:
899                   if (curChar != 48)
900                      break;
901                   if (kind > 32)
902                      kind = 32;
903                   jjCheckNAddStates(19, 22);
904                   break;
905                case 73:
906                   if ((0x3ff000000000000L & l) == 0L)
907                      break;
908                   if (kind > 32)
909                      kind = 32;
910                   jjCheckNAddTwoStates(73, 2);
911                   break;
912                case 74:
913                   if ((0xff000000000000L & l) == 0L)
914                      break;
915                   if (kind > 32)
916                      kind = 32;
917                   jjCheckNAddTwoStates(74, 2);
918                   break;
919                case 75:
920                   if ((0xff000000000000L & l) == 0L)
921                      break;
922                   if (kind > 35)
923                      kind = 35;
924                   jjCheckNAdd(75);
925                   break;
926                default : break;
927             }
928          } while(i != startsAt);
929       }
930       else if (curChar < 128)
931       {
932          long l = 1L << (curChar & 077);
933          MatchLoop: do
934          {
935             switch(jjstateSet[--i])
936             {
937                case 24:
938                   if ((0x7fffffe87fffffeL & l) != 0L)
939                   {
940                      if (kind > 42)
941                         kind = 42;
942                      jjCheckNAdd(36);
943                   }
944                   if (curChar == 97)
945                      jjstateSet[jjnewStateCnt++] = 23;
946                   break;
947                case 20:
948                   if ((0x7fffffe87fffffeL & l) != 0L)
949                   {
950                      if (kind > 42)
951                         kind = 42;
952                      jjCheckNAdd(36);
953                   }
954                   if (curChar == 114)
955                      jjstateSet[jjnewStateCnt++] = 19;
956                   break;
957                case 0:
958                   if ((0x7fffffe87fffffeL & l) != 0L)
959                   {
960                      if (kind > 42)
961                         kind = 42;
962                      jjCheckNAdd(36);
963                   }
964                   if (curChar == 102)
965                      jjstateSet[jjnewStateCnt++] = 24;
966                   else if (curChar == 116)
967                      jjstateSet[jjnewStateCnt++] = 20;
968                   break;
969                case 2:
970                   if ((0x100000001000L & l) != 0L && kind > 32)
971                      kind = 32;
972                   break;
973                case 5:
974                   if ((0x2000000020L & l) != 0L)
975                      jjAddStates(46, 47);
976                   break;
977                case 8:
978                   if ((0x5000000050L & l) != 0L && kind > 36)
979                      kind = 36;
980                   break;
981                case 10:
982                   if ((0xffffffffefffffffL & l) != 0L)
983                      jjCheckNAddStates(16, 18);
984                   break;
985                case 11:
986                   if (curChar == 92)
987                      jjAddStates(48, 50);
988                   break;
989                case 12:
990                   if ((0x14404410000000L & l) != 0L)
991                      jjCheckNAddStates(16, 18);
992                   break;
993                case 18:
994                   if (curChar == 101 && kind > 40)
995                      kind = 40;
996                   break;
997                case 19:
998                   if (curChar == 117)
999                      jjCheckNAdd(18);
1000                  break;
1001               case 21:
1002                  if (curChar == 116)
1003                     jjstateSet[jjnewStateCnt++] = 20;
1004                  break;
1005               case 22:
1006                  if (curChar == 115)
1007                     jjCheckNAdd(18);
1008                  break;
1009               case 23:
1010                  if (curChar == 108)
1011                     jjstateSet[jjnewStateCnt++] = 22;
1012                  break;
1013               case 25:
1014                  if (curChar == 102)
1015                     jjstateSet[jjnewStateCnt++] = 24;
1016                  break;
1017               case 27:
1018                  if ((0xffffffffefffffffL & l) != 0L)
1019                     jjCheckNAddStates(13, 15);
1020                  break;
1021               case 28:
1022                  if (curChar == 92)
1023                     jjAddStates(51, 53);
1024                  break;
1025               case 29:
1026                  if ((0x14404410000000L & l) != 0L)
1027                     jjCheckNAddStates(13, 15);
1028                  break;
1029               case 35:
1030                  if ((0x7fffffe87fffffeL & l) == 0L)
1031                     break;
1032                  if (kind > 42)
1033                     kind = 42;
1034                  jjCheckNAdd(36);
1035                  break;
1036               case 36:
1037                  if ((0x7fffffe87fffffeL & l) == 0L)
1038                     break;
1039                  if (kind > 42)
1040                     kind = 42;
1041                  jjCheckNAdd(36);
1042                  break;
1043               case 41:
1044                  if ((0x2000000020L & l) != 0L)
1045                     jjAddStates(54, 55);
1046                  break;
1047               case 45:
1048                  if ((0x2000000020L & l) != 0L)
1049                     jjAddStates(56, 57);
1050                  break;
1051               case 49:
1052                  if ((0x2000000020L & l) != 0L)
1053                     jjAddStates(58, 59);
1054                  break;
1055               case 54:
1056                  jjAddStates(0, 2);
1057                  break;
1058               case 59:
1059                  jjCheckNAddTwoStates(59, 60);
1060                  break;
1061               case 61:
1062               case 62:
1063                  jjCheckNAddTwoStates(62, 60);
1064                  break;
1065               case 66:
1066                  jjCheckNAddTwoStates(66, 67);
1067                  break;
1068               case 68:
1069               case 69:
1070                  jjCheckNAddTwoStates(69, 67);
1071                  break;
1072               case 72:
1073                  if ((0x100000001000000L & l) != 0L)
1074                     jjCheckNAdd(73);
1075                  break;
1076               case 73:
1077                  if ((0x7e0000007eL & l) == 0L)
1078                     break;
1079                  if (kind > 32)
1080                     kind = 32;
1081                  jjCheckNAddTwoStates(73, 2);
1082                  break;
1083               default : break;
1084            }
1085         } while(i != startsAt);
1086      }
1087      else
1088      {
1089         int hiByte = (int)(curChar >> 8);
1090         int i1 = hiByte >> 6;
1091         long l1 = 1L << (hiByte & 077);
1092         int i2 = (curChar & 0xff) >> 6;
1093         long l2 = 1L << (curChar & 077);
1094         MatchLoop: do
1095         {
1096            switch(jjstateSet[--i])
1097            {
1098               case 10:
1099                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1100                     jjAddStates(16, 18);
1101                  break;
1102               case 27:
1103                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1104                     jjAddStates(13, 15);
1105                  break;
1106               case 54:
1107                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1108                     jjAddStates(0, 2);
1109                  break;
1110               case 59:
1111                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1112                     jjCheckNAddTwoStates(59, 60);
1113                  break;
1114               case 61:
1115               case 62:
1116                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1117                     jjCheckNAddTwoStates(62, 60);
1118                  break;
1119               case 66:
1120                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1121                     jjCheckNAddTwoStates(66, 67);
1122                  break;
1123               case 68:
1124               case 69:
1125                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1126                     jjCheckNAddTwoStates(69, 67);
1127                  break;
1128               default : break;
1129            }
1130         } while(i != startsAt);
1131      }
1132      if (kind != 0x7fffffff)
1133      {
1134         jjmatchedKind = kind;
1135         jjmatchedPos = curPos;
1136         kind = 0x7fffffff;
1137      }
1138      ++curPos;
1139      if ((i = jjnewStateCnt) == (startsAt = 76 - (jjnewStateCnt = startsAt)))
1140         return curPos;
1141      try { curChar = input_stream.readChar(); }
1142      catch(java.io.IOException JavaDoc e) { return curPos; }
1143   }
1144}
1145static final int[] jjnextStates = {
1146   54, 55, 57, 38, 39, 44, 45, 48, 49, 8, 53, 64, 65, 27, 28, 30,
1147   10, 11, 13, 72, 74, 2, 75, 4, 5, 8, 10, 11, 15, 13, 27, 28,
1148   32, 30, 40, 41, 8, 48, 49, 8, 60, 61, 63, 67, 68, 70, 6, 7,
1149   12, 14, 16, 29, 31, 33, 42, 43, 46, 47, 50, 51,
1150};
1151private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2)
1152{
1153   switch(hiByte)
1154   {
1155      case 0:
1156         return ((jjbitVec2[i2] & l2) != 0L);
1157      default :
1158         if ((jjbitVec0[i1] & l1) != 0L)
1159            return true;
1160         return false;
1161   }
1162}
1163public static final String JavaDoc[] jjstrLiteralImages = {
1164"", null, null, null, null, null, null, null, null,
1165"\141\142\163\164\162\141\143\164", "\141\163\143\145\156\144\151\156\147", "\144\151\163\164\151\156\143\164",
1166"\147\162\157\165\160", "\150\141\166\151\156\147", "\155\141\170", "\155\151\156", "\141\166\147",
1167"\143\157\165\156\164\50\52\51", "\143\157\165\156\164", "\163\165\155", "\141\163",
1168"\142\157\157\154\145\141\156", "\142\171\164\145", "\143\150\141\162",
1169"\144\145\163\143\145\156\144\151\156\147", "\144\157\165\142\154\145", "\146\154\157\141\164",
1170"\151\155\160\157\162\164", "\151\156\164", "\154\157\156\147", "\163\150\157\162\164",
1171"\164\150\151\163", null, null, null, null, null, null, null, "\156\165\154\154", null, null, null,
1172null, null, "\50", "\51", "\173", "\175", "\133", "\135", "\73", "\54", "\56",
1173"\76", "\74", "\41", "\176", "\75\75", "\74\75", "\76\75", "\41\75", "\174\174",
1174"\46\46", "\53", "\55", "\52", "\57", "\46", "\174", };
1175public static final String JavaDoc[] lexStateNames = {
1176   "DEFAULT",
1177};
1178static final long[] jjtoToken = {
1179   0xffffe7d9fffffe01L, 0x3fL,
1180};
1181static final long[] jjtoSkip = {
1182   0x1feL, 0x0L,
1183};
1184static final long[] jjtoSpecial = {
1185   0x1c0L, 0x0L,
1186};
1187protected JavaCharStream input_stream;
1188private final int[] jjrounds = new int[76];
1189private final int[] jjstateSet = new int[152];
1190protected char curChar;
1191public JDOQLParserTokenManager(JavaCharStream stream)
1192{
1193   if (JavaCharStream.staticFlag)
1194      throw new Error JavaDoc("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
1195   input_stream = stream;
1196}
1197public JDOQLParserTokenManager(JavaCharStream stream, int lexState)
1198{
1199   this(stream);
1200   SwitchTo(lexState);
1201}
1202public void ReInit(JavaCharStream stream)
1203{
1204   jjmatchedPos = jjnewStateCnt = 0;
1205   curLexState = defaultLexState;
1206   input_stream = stream;
1207   ReInitRounds();
1208}
1209private final void ReInitRounds()
1210{
1211   int i;
1212   jjround = 0x80000001;
1213   for (i = 76; i-- > 0;)
1214      jjrounds[i] = 0x80000000;
1215}
1216public void ReInit(JavaCharStream stream, int lexState)
1217{
1218   ReInit(stream);
1219   SwitchTo(lexState);
1220}
1221public void SwitchTo(int lexState)
1222{
1223   if (lexState >= 1 || lexState < 0)
1224      throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
1225   else
1226      curLexState = lexState;
1227}
1228
1229protected Token jjFillToken()
1230{
1231   Token t = Token.newToken(jjmatchedKind);
1232   t.kind = jjmatchedKind;
1233   String JavaDoc im = jjstrLiteralImages[jjmatchedKind];
1234   t.image = (im == null) ? input_stream.GetImage() : im;
1235   t.beginLine = input_stream.getBeginLine();
1236   t.beginColumn = input_stream.getBeginColumn();
1237   t.endLine = input_stream.getEndLine();
1238   t.endColumn = input_stream.getEndColumn();
1239   return t;
1240}
1241
1242int curLexState = 0;
1243int defaultLexState = 0;
1244int jjnewStateCnt;
1245int jjround;
1246int jjmatchedPos;
1247int jjmatchedKind;
1248
1249public Token getNextToken()
1250{
1251  int kind;
1252  Token specialToken = null;
1253  Token matchedToken;
1254  int curPos = 0;
1255
1256  EOFLoop :
1257  for (;;)
1258  {
1259   try
1260   {
1261      curChar = input_stream.BeginToken();
1262   }
1263   catch(java.io.IOException JavaDoc e)
1264   {
1265      jjmatchedKind = 0;
1266      matchedToken = jjFillToken();
1267      matchedToken.specialToken = specialToken;
1268      return matchedToken;
1269   }
1270
1271   try { input_stream.backup(0);
1272      while (curChar <= 32 && (0x100003600L & (1L << curChar)) != 0L)
1273         curChar = input_stream.BeginToken();
1274   }
1275   catch (java.io.IOException JavaDoc e1) { continue EOFLoop; }
1276   jjmatchedKind = 0x7fffffff;
1277   jjmatchedPos = 0;
1278   curPos = jjMoveStringLiteralDfa0_0();
1279   if (jjmatchedKind != 0x7fffffff)
1280   {
1281      if (jjmatchedPos + 1 < curPos)
1282         input_stream.backup(curPos - jjmatchedPos - 1);
1283      if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
1284      {
1285         matchedToken = jjFillToken();
1286         matchedToken.specialToken = specialToken;
1287         return matchedToken;
1288      }
1289      else
1290      {
1291         if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
1292         {
1293            matchedToken = jjFillToken();
1294            if (specialToken == null)
1295               specialToken = matchedToken;
1296            else
1297            {
1298               matchedToken.specialToken = specialToken;
1299               specialToken = (specialToken.next = matchedToken);
1300            }
1301         }
1302         continue EOFLoop;
1303      }
1304   }
1305   int error_line = input_stream.getEndLine();
1306   int error_column = input_stream.getEndColumn();
1307   String JavaDoc error_after = null;
1308   boolean EOFSeen = false;
1309   try { input_stream.readChar(); input_stream.backup(1); }
1310   catch (java.io.IOException JavaDoc e1) {
1311      EOFSeen = true;
1312      error_after = curPos <= 1 ? "" : input_stream.GetImage();
1313      if (curChar == '\n' || curChar == '\r') {
1314         error_line++;
1315         error_column = 0;
1316      }
1317      else
1318         error_column++;
1319   }
1320   if (!EOFSeen) {
1321      input_stream.backup(1);
1322      error_after = curPos <= 1 ? "" : input_stream.GetImage();
1323   }
1324   throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
1325  }
1326}
1327
1328}
1329
Popular Tags