|
1
2 package org.xquark.xquery.parser;
3 import java.util.*;
4 import org.xquark.xquery.*;
5 import org.xquark.xquery.typing.*;
6 import org.xquark.xquery.parser.util.*;
7 import org.xquark.xquery.parser.primitivefunctions.fnfunctions.*;
8 import org.xquark.xquery.parser.primitivefunctions.xsfunctions.*;
9 import org.xquark.xquery.parser.hinttree.*;
10 import org.xquark.xquery.normalize.*;
11 import org.xquark.util.*;
12 import org.xquark.xpath.*;
13 import org.xquark.xquery.metadata.*;
14 import org.xquark.schema.*;
15 import org.xquark.xquery.metadata.resolver.*;
16 import java.net.*;
17 import org.xml.sax.SAXException  ;
18
19 public class XQueryParserTokenManager implements XQueryParserConstants
20 {
21 private Stack stateStack = new Stack();
22
23 public Stack getStateStack() {
24 return stateStack;
25 }
26
27 public void switchState(int newState) {
28 SwitchTo(newState);
29 }
30
31 public void pushState(int newState) {
32 stateStack.push(new Integer (newState));
33 }
34
35 public void popState() {
36 if (!stateStack.isEmpty()) {
37 SwitchTo(((Integer )stateStack.peek()).intValue());
38 stateStack.pop();
39 }
40 }
41
42 void CommonTokenAction(Token t) {
43 System.err.println("Token: "+t+" -- State: "+lexStateNames[curLexState]);
44 }
45
46 void handlePragma() {
47 Token token = getNextToken();
48 if (!token.image.equals("hint")) {
49 pushState(curLexState);
50 switchState(EXPR_COMMENT);
51 } else {
52 pushState(curLexState);
53 switchState(HINT_STATE);
54 }
55 }
56
57 void handleCommentAfterQName(Token matchedToken) {
58 char c = '0';
59 try {
60 c = input_stream.readChar();
61 } catch (java.io.IOException ex) {
62 return;
63 }
64 if (c == ':') {
65 for (int i = 0; i < image.length(); i++) {
66 switch (image.charAt(i)) {
67 case ' ':
68 case '\n':
69 case '\t':
70 case '\r':
71 case '(':
72 input_stream.backup(1+image.length()-i);
73 image.setLength(i);
74 matchedToken.kind = QNAME;
75 matchedToken.image = image.toString();
76 switchState(OPERATOR);
77 return;
78 default:
79 break;
80 }
81 }
82 } else {
83 input_stream.backup(1);
84 }
85 }
86 public java.io.PrintStream debugStream = System.out;
87 public void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
88 private final int jjMoveStringLiteralDfa0_4()
89 {
90 return jjMoveNfa_4(23, 0);
91 }
92 private final void jjCheckNAdd(int state)
93 {
94 if (jjrounds[state] != jjround)
95 {
96 jjstateSet[jjnewStateCnt++] = state;
97 jjrounds[state] = jjround;
98 }
99 }
100 private final void jjAddStates(int start, int end)
101 {
102 do {
103 jjstateSet[jjnewStateCnt++] = jjnextStates[start];
104 } while (start++ != end);
105 }
106 private final void jjCheckNAddTwoStates(int state1, int state2)
107 {
108 jjCheckNAdd(state1);
109 jjCheckNAdd(state2);
110 }
111 private final void jjCheckNAddStates(int start, int end)
112 {
113 do {
114 jjCheckNAdd(jjnextStates[start]);
115 } while (start++ != end);
116 }
117 private final void jjCheckNAddStates(int start)
118 {
119 jjCheckNAdd(jjnextStates[start]);
120 jjCheckNAdd(jjnextStates[start + 1]);
121 }
122 static final long[] jjbitVec0 = {
123 0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
124 };
125 static final long[] jjbitVec2 = {
126 0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
127 };
128 static final long[] jjbitVec3 = {
129 0x0L, 0xffffffffffffc000L, 0xfffff0007fffffffL, 0x7fffffL
130 };
131 static final long[] jjbitVec4 = {
132 0x0L, 0x0L, 0x0L, 0xff7fffffff7fffffL
133 };
134 static final long[] jjbitVec5 = {
135 0x7ff3ffffffffffffL, 0x7ffffffffffffdfeL, 0xffffffffffffffffL, 0xfc31ffffffffe00fL
136 };
137 static final long[] jjbitVec6 = {
138 0xffffffL, 0xffffffffffff0000L, 0xf80001ffffffffffL, 0x3L
139 };
140 static final long[] jjbitVec7 = {
141 0x0L, 0x0L, 0xfffffffbffffd740L, 0xffffd547f7fffL
142 };
143 static final long[] jjbitVec8 = {
144 0xffffffffffffdffeL, 0xffffffffdffeffffL, 0xffffffffffff0003L, 0x33fcfffffff199fL
145 };
146 static final long[] jjbitVec9 = {
147 0xfffe000000000000L, 0xfffffffe027fffffL, 0x7fL, 0x707ffffff0000L
148 };
149 static final long[] jjbitVec10 = {
150 0x7fffffe00000000L, 0xfffe0000000007feL, 0x7cffffffffffffffL, 0x60002f7fffL
151 };
152 static final long[] jjbitVec11 = {
153 0x23ffffffffffffe0L, 0x3ff000000L, 0x3c5fdfffff99fe0L, 0x30003b0000000L
154 };
155 static final long[] jjbitVec12 = {
156 0x36dfdfffff987e0L, 0x1c00005e000000L, 0x23edfdfffffbafe0L, 0x100000000L
157 };
158 static final long[] jjbitVec13 = {
159 0x23cdfdfffff99fe0L, 0x3b0000000L, 0x3bfc718d63dc7e0L, 0x0L
160 };
161 static final long[] jjbitVec14 = {
162 0x3effdfffffddfe0L, 0x300000000L, 0x3effdfffffddfe0L, 0x340000000L
163 };
164 static final long[] jjbitVec15 = {
165 0x3fffdfffffddfe0L, 0x300000000L, 0x0L, 0x0L
166 };
167 static final long[] jjbitVec16 = {
168 0xd7ffffffffffeL, 0x3fL, 0x200d6caefef02596L, 0x1fL
169 };
170 static final long[] jjbitVec17 = {
171 0x0L, 0x3fffffffeffL, 0x0L, 0x0L
172 };
173 static final long[] jjbitVec18 = {
174 0x0L, 0x0L, 0xffffffff00000000L, 0x7fffffffff003fL
175 };
176 static final long[] jjbitVec19 = {
177 0x500000000007daedL, 0x2c62ab82315001L, 0xf580c90040000000L, 0x201080000000007L
178 };
179 static final long[] jjbitVec20 = {
180 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffff0fffffffL, 0x3ffffffffffffffL
181 };
182 static final long[] jjbitVec21 = {
183 0xffffffff3f3fffffL, 0x3fffffffaaff3f3fL, 0x5fdfffffffffffffL, 0x1fdc1fff0fcf1fdcL
184 };
185 static final long[] jjbitVec22 = {
186 0x4c4000000000L, 0x0L, 0x7L, 0x0L
187 };
188 static final long[] jjbitVec23 = {
189 0x3fe00000080L, 0xfffffffffffffffeL, 0xfffffffe001fffffL, 0x7ffffffffffffffL
190 };
191 static final long[] jjbitVec24 = {
192 0x1fffffffffe0L, 0x0L, 0x0L, 0x0L
193 };
194 static final long[] jjbitVec25 = {
195 0xffffffffffffffffL, 0xffffffffffffffffL, 0x3fffffffffL, 0x0L
196 };
197 static final long[] jjbitVec26 = {
198 0xffffffffffffffffL, 0xffffffffffffffffL, 0xfffffffffL, 0x0L
199 };
200 static final long[] jjbitVec27 = {
201 0x0L, 0x0L, 0x80000000000000L, 0xff7fffffff7fffffL
202 };
203 static final long[] jjbitVec28 = {
204 0xffffffL, 0xffffffffffff0000L, 0xf80001ffffffffffL, 0x30003L
205 };
206 static final long[] jjbitVec29 = {
207 0xffffffffffffffffL, 0x30000003fL, 0xfffffffbffffd7c0L, 0xffffd547f7fffL
208 };
209 static final long[] jjbitVec30 = {
210 0xffffffffffffdffeL, 0xffffffffdffeffffL, 0xffffffffffff007bL, 0x33fcfffffff199fL
211 };
212 static final long[] jjbitVec31 = {
213 0xfffe000000000000L, 0xfffffffe027fffffL, 0xbbfffffbfffe007fL, 0x707ffffff0016L
214 };
215 static final long[] jjbitVec32 = {
216 0x7fffffe00000000L, 0xffff03ff0007ffffL, 0x7cffffffffffffffL, 0x3ff3dffffef7fffL
217 };
218 static final long[] jjbitVec33 = {
219 0xf3ffffffffffffeeL, 0xffcfff1e3fffL, 0xd3c5fdfffff99feeL, 0x3ffcfb080399fL
220 };
221 static final long[] jjbitVec34 = {
222 0xd36dfdfffff987e4L, 0x1fffc05e003987L, 0xf3edfdfffffbafeeL, 0xffc100003bbfL
223 };
224 static final long[] jjbitVec35 = {
225 0xf3cdfdfffff99feeL, 0xffc3b0c0398fL, 0xc3bfc718d63dc7ecL, 0xff8000803dc7L
226 };
227 static final long[] jjbitVec36 = {
228 0xc3effdfffffddfeeL, 0xffc300603ddfL, 0xc3effdfffffddfecL, 0xffc340603ddfL
229 };
230 static final long[] jjbitVec37 = {
231 0xc3fffdfffffddfecL, 0xffc300803dcfL, 0x0L, 0x0L
232 };
233 static final long[] jjbitVec38 = {
234 0x7ff7ffffffffffeL, 0x3ff7fffL, 0x3bff6caefef02596L, 0x3ff3f5fL
235 };
236 static final long[] jjbitVec39 = {
237 0xc2a003ff03000000L, 0xfffe03fffffffeffL, 0x2fe3ffffebf0fdfL, 0x0L
238 };
239 static final long[] jjbitVec40 = {
240 0x0L, 0x0L, 0x0L, 0x21fff0000L
241 };
242 static final long[] jjbitVec41 = {
243 0x3efffe000000a0L, 0xfffffffffffffffeL, 0xfffffffe661fffffL, 0x77ffffffffffffffL
244 };
245 private final int jjMoveNfa_4(int startState, int curPos)
246 {
247 int[] nextStates;
248 int startsAt = 0;
249 jjnewStateCnt = 26;
250 int i = 1;
251 jjstateSet[0] = startState;
252 int j, kind = 0x7fffffff;
253 for (;;)
254 {
255 if (++jjround == 0x7fffffff)
256 ReInitRounds();
257 if (curChar < 64)
258 {
259 long l = 1L << curChar;
260 MatchLoop: do
261 {
262 switch(jjstateSet[--i])
263 {
264 case 23:
265 if (curChar == 40)
266 jjstateSet[jjnewStateCnt++] = 22;
267 break;
268 case 0:
269 if (curChar == 58)
270 jjCheckNAddTwoStates(4, 5);
271 break;
272 case 1:
273 if (curChar == 58)
274 jjCheckNAddTwoStates(2, 21);
275 break;
276 case 2:
277 if ((0xfbffffffffffffffL & l) != 0L)
278 jjCheckNAddTwoStates(2, 21);
279 break;
280 case 3:
281 if (curChar == 41)
282 jjCheckNAddStates(0, 3);
283 break;
284 case 4:
285 if (curChar == 40)
286 jjstateSet[jjnewStateCnt++] = 1;
287 break;
288 case 5:
289 if ((0x100002600L & l) != 0L)
290 jjCheckNAddStates(0, 3);
291 break;
292 case 21:
293 if (curChar == 58)
294 jjstateSet[jjnewStateCnt++] = 3;
295 break;
296 case 22:
297 if (curChar == 58)
298 jjstateSet[jjnewStateCnt++] = 0;
299 break;
300 case 25:
301 if ((0x3ff600000000000L & l) == 0L)
302 break;
303 if (kind > 251)
304 kind = 251;
305 jjstateSet[jjnewStateCnt++] = 25;
306 break;
307 default : break;
308 }
309 } while(i != startsAt);
310 }
311 else if (curChar < 128)
312 {
313 long l = 1L << (curChar & 077);
314 MatchLoop: do
315 {
316 switch(jjstateSet[--i])
317 {
318 case 23:
319 case 25:
320 if ((0x7fffffe87fffffeL & l) == 0L)
321 break;
322 if (kind > 251)
323 kind = 251;
324 jjCheckNAdd(25);
325 break;
326 case 2:
327 jjAddStates(4, 5);
328 break;
329 case 6:
330 if (curChar == 97 && kind > 1)
331 kind = 1;
332 break;
333 case 7:
334 if (curChar == 109)
335 jjstateSet[jjnewStateCnt++] = 6;
336 break;
337 case 8:
338 if (curChar == 103)
339 jjstateSet[jjnewStateCnt++] = 7;
340 break;
341 case 9:
342 if (curChar == 97)
343 jjstateSet[jjnewStateCnt++] = 8;
344 break;
345 case 10:
346 if (curChar == 114)
347 jjstateSet[jjnewStateCnt++] = 9;
348 break;
349 case 11:
350 if (curChar == 112)
351 jjstateSet[jjnewStateCnt++] = 10;
352 break;
353 case 12:
354 if (curChar == 110 && kind > 1)
355 kind = 1;
356 break;
357 case 13:
358 if (curChar == 111)
359 jjstateSet[jjnewStateCnt++] = 12;
360 break;
361 case 14:
362 if (curChar == 105)
363 jjstateSet[jjnewStateCnt++] = 13;
364 break;
365 case 15:
366 if (curChar == 115)
367 jjstateSet[jjnewStateCnt++] = 14;
368 break;
369 case 16:
370 if (curChar == 110)
371 jjstateSet[jjnewStateCnt++] = 15;
372 break;
373 case 17:
374 if (curChar == 101)
375 jjstateSet[jjnewStateCnt++] = 16;
376 break;
377 case 18:
378 if (curChar == 116)
379 jjstateSet[jjnewStateCnt++] = 17;
380 break;
381 case 19:
382 if (curChar == 120)
383 jjstateSet[jjnewStateCnt++] = 18;
384 break;
385 case 20:
386 if (curChar == 101)
387 jjstateSet[jjnewStateCnt++] = 19;
388 break;
389 default : break;
390 }
391 } while(i != startsAt);
392 }
393 else
394 {
395 int hiByte = (int)(curChar >> 8);
396 int i1 = hiByte >> 6;
397 long l1 = 1L << (hiByte & 077);
398 int i2 = (curChar & 0xff) >> 6;
399 long l2 = 1L << (curChar & 077);
400 MatchLoop: do
401 {
402 switch(jjstateSet[--i])
403 {
404 case 23:
405 if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
406 break;
407 if (kind > 251)
408 kind = 251;
409 jjCheckNAdd(25);
410 break;
411 case 2:
412 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
413 jjAddStates(4, 5);
414 break;
415 case 25:
416 if (!jjCanMove_2(hiByte, i1, i2, l1, l2))
417 break;
418 if (kind > 251)
419 kind = 251;
420 jjCheckNAdd(25);
421 break;
422 default : break;
423 }
424 } while(i != startsAt);
425 }
426 if (kind != 0x7fffffff)
427 {
428 jjmatchedKind = kind;
429 jjmatchedPos = curPos;
430 kind = 0x7fffffff;
431 }
432 ++curPos;
433 if ((i = jjnewStateCnt) == (startsAt = 26 - (jjnewStateCnt = startsAt)))
434 return curPos;
435 try { curChar = input_stream.readChar(); }
436 catch(java.io.IOException e) { return curPos; }
437 }
438 }
439 private final int jjStopStringLiteralDfa_3(int pos, long active0, long active1, long active2, long active3)
440 {
441 switch (pos)
442 {
443 case 0:
444 if ((active3 & 0x1000000000000000L) != 0L)
445 {
446 jjmatchedKind = 253;
447 return -1;
448 }
449 return -1;
450 default :
451 return -1;
452 }
453 }
454 private final int jjStartNfa_3(int pos, long active0, long active1, long active2, long active3)
455 {
456 return jjMoveNfa_3(jjStopStringLiteralDfa_3(pos, active0, active1, active2, active3), pos + 1);
457 }
458 private final int jjStopAtPos(int pos, int kind)
459 {
460 jjmatchedKind = kind;
461 jjmatchedPos = pos;
462 return pos + 1;
463 }
464 private final int jjStartNfaWithStates_3(int pos, int kind, int state)
465 {
466 jjmatchedKind = kind;
467 jjmatchedPos = pos;
468 try { curChar = input_stream.readChar(); }
469 catch(java.io.IOException e) { return pos + 1; }
470 return jjMoveNfa_3(state, pos + 1);
471 }
472 private final int jjMoveStringLiteralDfa0_3()
473 {
474 switch(curChar)
475 {
476 case 63:
477 return jjMoveStringLiteralDfa1_3(0x1000000000000000L);
478 default :
479 return jjMoveNfa_3(23, 0);
480 }
481 }
482 private final int jjMoveStringLiteralDfa1_3(long active3)
483 {
484 try { curChar = input_stream.readChar(); }
485 catch(java.io.IOException e) {
486 jjStopStringLiteralDfa_3(0, 0L, 0L, 0L, active3);
487 return 1;
488 }
489 switch(curChar)
490 {
491 case 62:
492 if ((active3 & 0x1000000000000000L) != 0L)
493 return jjStopAtPos(1, 252);
494 break;
495 default :
496 break;
497 }
498 return jjStartNfa_3(0, 0L, 0L, 0L, active3);
499 }
500 static final long[] jjbitVec42 = {
501 0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffL
502 };
503 private final int jjMoveNfa_3(int startState, int curPos)
504 {
505 int[] nextStates;
506 int startsAt = 0;
507 jjnewStateCnt = 25;
508 int i = 1;
509 jjstateSet[0] = startState;
510 int j, kind = 0x7fffffff;
511 for (;;)
512 {
513 if (++jjround == 0x7fffffff)
514 ReInitRounds();
515 if (curChar < 64)
516 {
517 long l = 1L << curChar;
518 MatchLoop: do
519 {
520 switch(jjstateSet[--i])
521 {
522 case 23:
523 if ((0xffffffff00002600L & l) != 0L)
524 {
525 if (kind > 253)
526 kind = 253;
527 }
528 if (curChar == 40)
529 jjstateSet[jjnewStateCnt++] = 22;
530 break;
531 case 0:
532 if (curChar == 58)
533 jjCheckNAddTwoStates(4, 5);
534 break;
535 case 1:
536 if (curChar == 58)
537 jjCheckNAddTwoStates(2, 21);
538 break;
539 case 2:
540 if ((0xfbffffffffffffffL & l) != 0L)
541 jjCheckNAddTwoStates(2, 21);
542 break;
543 case 3:
544 if (curChar == 41)
545 jjCheckNAddStates(0, 3);
546 break;
547 case 4:
548 if (curChar == 40)
549 jjstateSet[jjnewStateCnt++] = 1;
550 break;
551 case 5:
552 if ((0x100002600L & l) != 0L)
553 jjCheckNAddStates(0, 3);
554 break;
555 case 21:
556 if (curChar == 58)
557 jjstateSet[jjnewStateCnt++] = 3;
558 break;
559 case 22:
560 if (curChar == 58)
561 jjstateSet[jjnewStateCnt++] = 0;
562 break;
563 case 24:
564 if ((0xffffffff00002600L & l) != 0L && kind > 253)
565 kind = 253;
566 break;
567 default : break;
568 }
569 } while(i != startsAt);
570 }
571 else if (curChar < 128)
572 {
573 long l = 1L << (curChar & 077);
574 MatchLoop: do
575 {
576 switch(jjstateSet[--i])
577 {
578 case 23:
579 if (kind > 253)
580 kind = 253;
581 break;
582 case 2:
583 jjAddStates(4, 5);
584 break;
585 case 6:
586 if (curChar == 97 && kind > 1)
587 kind = 1;
588 break;
589 case 7:
590 if (curChar == 109)
591 jjstateSet[jjnewStateCnt++] = 6;
592 break;
593 case 8:
594 if (curChar == 103)
595 jjstateSet[jjnewStateCnt++] = 7;
596 break;
597 case 9:
598 if (curChar == 97)
599 jjstateSet[jjnewStateCnt++] = 8;
600 break;
601 case 10:
602 if (curChar == 114)
603 jjstateSet[jjnewStateCnt++] = 9;
604 break;
605 case 11:
606 if (curChar == 112)
607 jjstateSet[jjnewStateCnt++] = 10;
608 break;
609 case 12:
610 if (curChar == 110 && kind > 1)
611 kind = 1;
612 break;
613 case 13:
614 if (curChar == 111)
615 jjstateSet[jjnewStateCnt++] = 12;
616 break;
617 case 14:
618 if (curChar == 105)
619 jjstateSet[jjnewStateCnt++] = 13;
620 break;
621 case 15:
622 if (curChar == 115)
623 jjstateSet[jjnewStateCnt++] = 14;
624 break;
625 case 16:
626 if (curChar == 110)
627 jjstateSet[jjnewStateCnt++] = 15;
628 break;
629 case 17:
630 if (curChar == 101)
631 jjstateSet[jjnewStateCnt++] = 16;
632 break;
633 case 18:
634 if (curChar == 116)
635 jjstateSet[jjnewStateCnt++] = 17;
636 break;
637 case 19:
638 if (curChar == 120)
639 jjstateSet[jjnewStateCnt++] = 18;
640 break;
641 case 20:
642 if (curChar == 101)
643 jjstateSet[jjnewStateCnt++] = 19;
644 break;
645 default : break;
646 }
647 } while(i != startsAt);
648 }
649 else
650 {
651 int hiByte = (int)(curChar >> 8);
652 int i1 = hiByte >> 6;
653 long l1 = 1L << (hiByte & 077);
654 int i2 = (curChar & 0xff) >> 6;
655 long l2 = 1L << (curChar & 077);
656 MatchLoop: do
657 {
658 switch(jjstateSet[--i])
659 {
660 case 23:
661 if (jjCanMove_3(hiByte, i1, i2, l1, l2) && kind > 253)
662 kind = 253;
663 break;
664 case 2:
665 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
666 jjAddStates(4, 5);
667 break;
668 default : break;
669 }
670 } while(i != startsAt);
671 }
672 if (kind != 0x7fffffff)
673 {
674 jjmatchedKind = kind;
675 jjmatchedPos = curPos;
676 kind = 0x7fffffff;
677 }
678 ++curPos;
679 if ((i = jjnewStateCnt) == (startsAt = 25 - (jjnewStateCnt = startsAt)))
680 return curPos;
681 try { curChar = input_stream.readChar(); }
682 catch(java.io.IOException e) { return curPos; }
683 }
684 }
685 private final int jjStopStringLiteralDfa_7(int pos, long active0, long active1, long active2, long active3)
686 {
687 switch (pos)
688 {
689 default :
690 return -1;
691 }
692 }
693 private final int jjStartNfa_7(int pos, long active0, long active1, long active2, long active3)
694 {
695 return jjMoveNfa_7(jjStopStringLiteralDfa_7(pos, active0, active1, active2, active3), pos + 1);
696 }
697 private final int jjStartNfaWithStates_7(int pos, int kind, int state)
698 {
699 jjmatchedKind = kind;
700 jjmatchedPos = pos;
701 try { curChar = input_stream.readChar(); }
702 catch(java.io.IOException e) { return pos + 1; }
703 return jjMoveNfa_7(state, pos + 1);
704 }
705 private final int jjMoveStringLiteralDfa0_7()
706 {
707 switch(curChar)
708 {
709 case 62:
710 return jjStopAtPos(0, 242);
711 case 123:
712 return jjStopAtPos(0, 243);
713 default :
714 return jjMoveNfa_7(23, 0);
715 }
716 }
717 private final int jjMoveNfa_7(int startState, int curPos)
718 {
719 int[] nextStates;
720 int startsAt = 0;
721 jjnewStateCnt = 30;
722 int i = 1;
723 jjstateSet[0] = startState;
724 int j, kind = 0x7fffffff;
725 for (;;)
726 {
727 if (++jjround == 0x7fffffff)
728 ReInitRounds();
729 if (curChar < 64)
730 {
731 long l = 1L << curChar;
732 MatchLoop: do
733 {
734 switch(jjstateSet[--i])
735 {
736 case 23:
737 if ((0x100002600L & l) != 0L)
738
|
Java API By Example, From Geeks To Geeks.