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