1:
2: package ;
3: import ;
4: import ;
5: import ;
6: import ;
7: import ;
8: import ;
9: import ;
10: import ;
11: import ;
12: import ;
13: import ;
14: import ;
15: import ;
16: import ;
17: import ;
18: import ;
19: import ;
20: import ;
21: import ;
22:
23: public class ParserTokenManager implements ParserConstants
24: {
25: public java.io.PrintStream debugStream = System.out;
26: public void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
27: private final int jjStopStringLiteralDfa_0(int pos, long active0, long active1)
28: {
29: switch (pos)
30: {
31: case 0:
32: if ((active0 & 0xf800000000000000L) != 0L || (active1 & 0x1L) != 0L)
33: return 48;
34: if ((active0 & 0x200000L) != 0L)
35: return 387;
36: if ((active0 & 0x2040L) != 0L)
37: return 388;
38: return -1;
39: case 1:
40: if ((active0 & 0xf800000000000000L) != 0L || (active1 & 0x1L) != 0L)
41: {
42: jjmatchedKind = 65;
43: jjmatchedPos = 1;
44: return 389;
45: }
46: if ((active0 & 0x40L) != 0L)
47: {
48: jjmatchedKind = 36;
49: jjmatchedPos = 1;
50: return 388;
51: }
52: return -1;
53: case 2:
54: if ((active0 & 0xf800000000000000L) != 0L || (active1 & 0x1L) != 0L)
55: {
56: jjmatchedKind = 65;
57: jjmatchedPos = 2;
58: return 389;
59: }
60: return -1;
61: case 3:
62: if ((active0 & 0xf800000000000000L) != 0L || (active1 & 0x1L) != 0L)
63: {
64: jjmatchedKind = 65;
65: jjmatchedPos = 3;
66: return 389;
67: }
68: return -1;
69: case 4:
70: if ((active0 & 0xb800000000000000L) != 0L || (active1 & 0x1L) != 0L)
71: {
72: jjmatchedKind = 65;
73: jjmatchedPos = 4;
74: return 389;
75: }
76: if ((active0 & 0x4000000000000000L) != 0L)
77: return 389;
78: return -1;
79: case 5:
80: if ((active0 & 0xa800000000000000L) != 0L || (active1 & 0x1L) != 0L)
81: {
82: jjmatchedKind = 65;
83: jjmatchedPos = 5;
84: return 389;
85: }
86: if ((active0 & 0x1000000000000000L) != 0L)
87: return 389;
88: return -1;
89: case 6:
90: if ((active0 & 0x800000000000000L) != 0L)
91: return 389;
92: if ((active0 & 0xa000000000000000L) != 0L || (active1 & 0x1L) != 0L)
93: {
94: jjmatchedKind = 65;
95: jjmatchedPos = 6;
96: return 389;
97: }
98: return -1;
99: case 7:
100: if ((active0 & 0x8000000000000000L) != 0L || (active1 & 0x1L) != 0L)
101: {
102: jjmatchedKind = 65;
103: jjmatchedPos = 7;
104: return 389;
105: }
106: if ((active0 & 0x2000000000000000L) != 0L)
107: return 389;
108: return -1;
109: case 8:
110: if ((active0 & 0x8000000000000000L) != 0L || (active1 & 0x1L) != 0L)
111: {
112: jjmatchedKind = 65;
113: jjmatchedPos = 8;
114: return 389;
115: }
116: return -1;
117: default :
118: return -1;
119: }
120: }
121: private final int jjStartNfa_0(int pos, long active0, long active1)
122: {
123: return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0, active1), pos + 1);
124: }
125: private final int jjStopAtPos(int pos, int kind)
126: {
127: jjmatchedKind = kind;
128: jjmatchedPos = pos;
129: return pos + 1;
130: }
131: private final int jjStartNfaWithStates_0(int pos, int kind, int state)
132: {
133: jjmatchedKind = kind;
134: jjmatchedPos = pos;
135: try { curChar = input_stream.readChar(); }
136: catch(java.io.IOException e) { return pos + 1; }
137: return jjMoveNfa_0(state, pos + 1);
138: }
139: private final int jjMoveStringLiteralDfa0_0()
140: {
141: switch(curChar)
142: {
143: case 40:
144: return jjStopAtPos(0, 23);
145: case 41:
146: return jjStopAtPos(0, 22);
147: case 42:
148: return jjStopAtPos(0, 20);
149: case 43:
150: return jjStopAtPos(0, 12);
151: case 44:
152: return jjStopAtPos(0, 14);
153: case 45:
154: jjmatchedKind = 13;
155: return jjMoveStringLiteralDfa1_0(0x40L, 0x0L);
156: case 46:
157: return jjStartNfaWithStates_0(0, 21, 387);
158: case 47:
159: jjmatchedKind = 17;
160: return jjMoveStringLiteralDfa1_0(0x4L, 0x0L);
161: case 58:
162: return jjStopAtPos(0, 24);
163: case 59:
164: return jjStopAtPos(0, 15);
165: case 60:
166: return jjMoveStringLiteralDfa1_0(0x20L, 0x0L);
167: case 61:
168: return jjStopAtPos(0, 11);
169: case 62:
170: return jjStopAtPos(0, 16);
171: case 64:
172: return jjMoveStringLiteralDfa1_0(0xf800000000000000L, 0x1L);
173: case 91:
174: return jjStopAtPos(0, 18);
175: case 93:
176: return jjStopAtPos(0, 19);
177: case 123:
178: return jjStopAtPos(0, 7);
179: case 124:
180: return jjMoveStringLiteralDfa1_0(0x200L, 0x0L);
181: case 125:
182: return jjStopAtPos(0, 8);
183: case 126:
184: return jjMoveStringLiteralDfa1_0(0x400L, 0x0L);
185: default :
186: return jjMoveNfa_0(1, 0);
187: }
188: }
189: private final int jjMoveStringLiteralDfa1_0(long active0, long active1)
190: {
191: try { curChar = input_stream.readChar(); }
192: catch(java.io.IOException e) {
193: jjStopStringLiteralDfa_0(0, active0, active1);
194: return 1;
195: }
196: switch(curChar)
197: {
198: case 33:
199: return jjMoveStringLiteralDfa2_0(active0, 0x20L, active1, 0L);
200: case 42:
201: if ((active0 & 0x4L) != 0L)
202: return jjStopAtPos(1, 2);
203: break;
204: case 45:
205: return jjMoveStringLiteralDfa2_0(active0, 0x40L, active1, 0L);
206: case 61:
207: if ((active0 & 0x200L) != 0L)
208: return jjStopAtPos(1, 9);
209: else if ((active0 & 0x400L) != 0L)
210: return jjStopAtPos(1, 10);
211: break;
212: case 67:
213: case 99:
214: return jjMoveStringLiteralDfa2_0(active0, 0x2000000000000000L, active1, 0L);
215: case 70:
216: case 102:
217: return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x1L);
218: case 73:
219: case 105:
220: return jjMoveStringLiteralDfa2_0(active0, 0x800000000000000L, active1, 0L);
221: case 77:
222: case 109:
223: return jjMoveStringLiteralDfa2_0(active0, 0x1000000000000000L, active1, 0L);
224: case 78:
225: case 110:
226: return jjMoveStringLiteralDfa2_0(active0, 0x8000000000000000L, active1, 0L);
227: case 80:
228: case 112:
229: return jjMoveStringLiteralDfa2_0(active0, 0x4000000000000000L, active1, 0L);
230: default :
231: break;
232: }
233: return jjStartNfa_0(0, active0, active1);
234: }
235: private final int jjMoveStringLiteralDfa2_0(long old0, long active0, long old1, long active1)
236: {
237: if (((active0 &= old0) | (active1 &= old1)) == 0L)
238: return jjStartNfa_0(0, old0, old1);
239: try { curChar = input_stream.readChar(); }
240: catch(java.io.IOException e) {
241: jjStopStringLiteralDfa_0(1, active0, active1);
242: return 2;
243: }
244: switch(curChar)
245: {
246: case 45:
247: return jjMoveStringLiteralDfa3_0(active0, 0x20L, active1, 0L);
248: case 62:
249: if ((active0 & 0x40L) != 0L)
250: return jjStopAtPos(2, 6);
251: break;
252: case 65:
253: case 97:
254: return jjMoveStringLiteralDfa3_0(active0, 0xc000000000000000L, active1, 0L);
255: case 69:
256: case 101:
257: return jjMoveStringLiteralDfa3_0(active0, 0x1000000000000000L, active1, 0L);
258: case 72:
259: case 104:
260: return jjMoveStringLiteralDfa3_0(active0, 0x2000000000000000L, active1, 0L);
261: case 77:
262: case 109:
263: return jjMoveStringLiteralDfa3_0(active0, 0x800000000000000L, active1, 0L);
264: case 79:
265: case 111:
266: return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x1L);
267: default :
268: break;
269: }
270: return jjStartNfa_0(1, active0, active1);
271: }
272: private final int jjMoveStringLiteralDfa3_0(long old0, long active0, long old1, long active1)
273: {
274: if (((active0 &= old0) | (active1 &= old1)) == 0L)
275: return jjStartNfa_0(1, old0, old1);
276: try { curChar = input_stream.readChar(); }
277: catch(java.io.IOException e) {
278: jjStopStringLiteralDfa_0(2, active0, active1);
279: return 3;
280: }
281: switch(curChar)
282: {
283: case 45:
284: if ((active0 & 0x20L) != 0L)
285: return jjStopAtPos(3, 5);
286: break;
287: case 65:
288: case 97:
289: return jjMoveStringLiteralDfa4_0(active0, 0x2000000000000000L, active1, 0L);
290: case 68:
291: case 100:
292: return jjMoveStringLiteralDfa4_0(active0, 0x1000000000000000L, active1, 0L);
293: case 71:
294: case 103:
295: return jjMoveStringLiteralDfa4_0(active0, 0x4000000000000000L, active1, 0L);
296: case 77:
297: case 109:
298: return jjMoveStringLiteralDfa4_0(active0, 0x8000000000000000L, active1, 0L);
299: case 78:
300: case 110:
301: return jjMoveStringLiteralDfa4_0(active0, 0L, active1, 0x1L);
302: case 80:
303: case 112:
304: return jjMoveStringLiteralDfa4_0(active0, 0x800000000000000L, active1, 0L);
305: default :
306: break;
307: }
308: return jjStartNfa_0(2, active0, active1);
309: }
310: private final int jjMoveStringLiteralDfa4_0(long old0, long active0, long old1, long active1)
311: {
312: if (((active0 &= old0) | (active1 &= old1)) == 0L)
313: return jjStartNfa_0(2, old0, old1);
314: try { curChar = input_stream.readChar(); }
315: catch(java.io.IOException e) {
316: jjStopStringLiteralDfa_0(3, active0, active1);
317: return 4;
318: }
319: switch(curChar)
320: {
321: case 69:
322: case 101:
323: if ((active0 & 0x4000000000000000L) != 0L)
324: return jjStartNfaWithStates_0(4, 62, 389);
325: return jjMoveStringLiteralDfa5_0(active0, 0x8000000000000000L, active1, 0L);
326: case 73:
327: case 105:
328: return jjMoveStringLiteralDfa5_0(active0, 0x1000000000000000L, active1, 0L);
329: case 79:
330: case 111:
331: return jjMoveStringLiteralDfa5_0(active0, 0x800000000000000L, active1, 0L);
332: case 82:
333: case 114:
334: return jjMoveStringLiteralDfa5_0(active0, 0x2000000000000000L, active1, 0L);
335: case 84:
336: case 116:
337: return jjMoveStringLiteralDfa5_0(active0, 0L, active1, 0x1L);
338: default :
339: break;
340: }
341: return jjStartNfa_0(3, active0, active1);
342: }
343: private final int jjMoveStringLiteralDfa5_0(long old0, long active0, long old1, long active1)
344: {
345: if (((active0 &= old0) | (active1 &= old1)) == 0L)
346: return jjStartNfa_0(3, old0, old1);
347: try { curChar = input_stream.readChar(); }
348: catch(java.io.IOException e) {
349: jjStopStringLiteralDfa_0(4, active0, active1);
350: return 5;
351: }
352: switch(curChar)
353: {
354: case 45:
355: return jjMoveStringLiteralDfa6_0(active0, 0L, active1, 0x1L);
356: case 65:
357: case 97:
358: if ((active0 & 0x1000000000000000L) != 0L)
359: return jjStartNfaWithStates_0(5, 60, 389);
360: break;
361: case 82:
362: case 114:
363: return jjMoveStringLiteralDfa6_0(active0, 0x800000000000000L, active1, 0L);
364: case 83:
365: case 115:
366: return jjMoveStringLiteralDfa6_0(active0, 0xa000000000000000L, active1, 0L);
367: default :
368: break;
369: }
370: return jjStartNfa_0(4, active0, active1);
371: }
372: private final int jjMoveStringLiteralDfa6_0(long old0, long active0, long old1, long active1)
373: {
374: if (((active0 &= old0) | (active1 &= old1)) == 0L)
375: return jjStartNfa_0(4, old0, old1);
376: try { curChar = input_stream.readChar(); }
377: catch(java.io.IOException e) {
378: jjStopStringLiteralDfa_0(5, active0, active1);
379: return 6;
380: }
381: switch(curChar)
382: {
383: case 69:
384: case 101:
385: return jjMoveStringLiteralDfa7_0(active0, 0x2000000000000000L, active1, 0L);
386: case 70:
387: case 102:
388: return jjMoveStringLiteralDfa7_0(active0, 0L, active1, 0x1L);
389: case 80:
390: case 112:
391: return jjMoveStringLiteralDfa7_0(active0, 0x8000000000000000L, active1, 0L);
392: case 84:
393: case 116:
394: if ((active0 & 0x800000000000000L) != 0L)
395: return jjStartNfaWithStates_0(6, 59, 389);
396: break;
397: default :
398: break;
399: }
400: return jjStartNfa_0(5, active0, active1);
401: }
402: private final int jjMoveStringLiteralDfa7_0(long old0, long active0, long old1, long active1)
403: {
404: if (((active0 &= old0) | (active1 &= old1)) == 0L)
405: return jjStartNfa_0(5, old0, old1);
406: try { curChar = input_stream.readChar(); }
407: catch(java.io.IOException e) {
408: jjStopStringLiteralDfa_0(6, active0, active1);
409: return 7;
410: }
411: switch(curChar)
412: {
413: case 65:
414: case 97:
415: return jjMoveStringLiteralDfa8_0(active0, 0x8000000000000000L, active1, 0x1L);
416: case 84:
417: case 116:
418: if ((active0 & 0x2000000000000000L) != 0L)
419: return jjStartNfaWithStates_0(7, 61, 389);
420: break;
421: default :
422: break;
423: }
424: return jjStartNfa_0(6, active0, active1);
425: }
426: private final int jjMoveStringLiteralDfa8_0(long old0, long active0, long old1, long active1)
427: {
428: if (((active0 &= old0) | (active1 &= old1)) == 0L)
429: return jjStartNfa_0(6, old0, old1);
430: try { curChar = input_stream.readChar(); }
431: catch(java.io.IOException e) {
432: jjStopStringLiteralDfa_0(7, active0, active1);
433: return 8;
434: }
435: switch(curChar)
436: {
437: case 67:
438: case 99:
439: return jjMoveStringLiteralDfa9_0(active0, 0x8000000000000000L, active1, 0x1L);
440: default :
441: break;
442: }
443: return jjStartNfa_0(7, active0, active1);
444: }
445: private final int jjMoveStringLiteralDfa9_0(long old0, long active0, long old1, long active1)
446: {
447: if (((active0 &= old0) | (active1 &= old1)) == 0L)
448: return jjStartNfa_0(7, old0, old1);
449: try { curChar = input_stream.readChar(); }
450: catch(java.io.IOException e) {
451: jjStopStringLiteralDfa_0(8, active0, active1);
452: return 9;
453: }
454: switch(curChar)
455: {
456: case 69:
457: case 101:
458: if ((active0 & 0x8000000000000000L) != 0L)
459: return jjStartNfaWithStates_0(9, 63, 389);
460: else if ((active1 & 0x1L) != 0L)
461: return jjStartNfaWithStates_0(9, 64, 389);
462: break;
463: default :
464: break;
465: }
466: return jjStartNfa_0(8, active0, active1);
467: }
468: private final void jjCheckNAdd(int state)
469: {
470: if (jjrounds[state] != jjround)
471: {
472: jjstateSet[jjnewStateCnt++] = state;
473: jjrounds[state] = jjround;
474: }
475: }
476: private final void jjAddStates(int start, int end)
477: {
478: do {
479: jjstateSet[jjnewStateCnt++] = jjnextStates[start];
480: } while (start++ != end);
481: }
482: private final void jjCheckNAddTwoStates(int state1, int state2)
483: {
484: jjCheckNAdd(state1);
485: jjCheckNAdd(state2);
486: }
487: private final void jjCheckNAddStates(int start, int end)
488: {
489: do {
490: jjCheckNAdd(jjnextStates[start]);
491: } while (start++ != end);
492: }
493: private final void jjCheckNAddStates(int start)
494: {
495: jjCheckNAdd(jjnextStates[start]);
496: jjCheckNAdd(jjnextStates[start + 1]);
497: }
498: static final long[] jjbitVec0 = {
499: 0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
500: };
501: private final int jjMoveNfa_0(int startState, int curPos)
502: {
503: int[] nextStates;
504: int startsAt = 0;
505: jjnewStateCnt = 387;
506: int i = 1;
507: jjstateSet[0] = startState;
508: int j, kind = 0x7fffffff;
509: for (;;)
510: {
511: if (++jjround == 0x7fffffff)
512: ReInitRounds();
513: if (curChar < 64)
514: {
515: long l = 1L << curChar;
516: MatchLoop: do
517: {
518: switch(jjstateSet[--i])
519: {
520: case 388:
521: if ((0x3ff200000000000L & l) != 0L)
522: jjCheckNAddStates(0, 2);
523: else if (curChar == 40)
524: {
525: if (kind > 77)
526: kind = 77;
527: }
528: if ((0x3ff200000000000L & l) != 0L)
529: jjCheckNAddStates(3, 5);
530: if ((0x3ff200000000000L & l) != 0L)
531: jjCheckNAddStates(6, 8);
532: if ((0x3ff200000000000L & l) != 0L)
533: {
534: if (kind > 36)
535: kind = 36;
536: jjCheckNAddTwoStates(78, 79);
537: }
538: break;
539: case 1:
540: if ((0x3ff000000000000L & l) != 0L)
541: {
542: if (kind > 37)
543: kind = 37;
544: jjCheckNAddStates(9, 80);
545: }
546: else if ((0x100003600L & l) != 0L)
547: {
548: if (kind > 1)
549: kind = 1;
550: jjCheckNAdd(0);
551: }
552: else if (curChar == 46)
553: jjCheckNAddStates(81, 98);
554: else if (curChar == 45)
555: {
556: if (kind > 36)
557: kind = 36;
558: jjCheckNAddStates(99, 109);
559: }
560: else if (curChar == 33)
561: jjCheckNAddTwoStates(67, 76);
562: else if (curChar == 35)
563: jjCheckNAddTwoStates(37, 38);
564: else if (curChar == 39)
565: jjCheckNAddStates(110, 113);
566: else if (curChar == 34)
567: jjCheckNAddStates(114, 117);
568: break;
569: case 387:
570: if ((0x3ff000000000000L & l) != 0L)
571: jjCheckNAddStates(118, 120);
572: if ((0x3ff000000000000L & l) != 0L)
573: jjCheckNAddTwoStates(188, 191);
574: if ((0x3ff000000000000L & l) != 0L)
575: jjCheckNAddTwoStates(185, 187);
576: if ((0x3ff000000000000L & l) != 0L)
577: jjCheckNAddTwoStates(183, 184);
578: if ((0x3ff000000000000L & l) != 0L)
579: jjCheckNAddTwoStates(180, 182);
580: if ((0x3ff000000000000L & l) != 0L)
581: jjCheckNAddTwoStates(175, 179);
582: if ((0x3ff000000000000L & l) != 0L)
583: jjCheckNAddTwoStates(171, 174);
584: if ((0x3ff000000000000L & l) != 0L)
585: jjCheckNAddTwoStates(167, 170);
586: if ((0x3ff000000000000L & l) != 0L)
587: jjCheckNAddTwoStates(164, 166);
588: if ((0x3ff000000000000L & l) != 0L)
589: jjCheckNAddTwoStates(161, 163);
590: if ((0x3ff000000000000L & l) != 0L)
591: jjCheckNAddTwoStates(158, 160);
592: if ((0x3ff000000000000L & l) != 0L)
593: jjCheckNAddTwoStates(155, 157);
594: if ((0x3ff000000000000L & l) != 0L)
595: jjCheckNAddTwoStates(152, 154);
596: if ((0x3ff000000000000L & l) != 0L)
597: jjCheckNAddTwoStates(149, 151);
598: if ((0x3ff000000000000L & l) != 0L)
599: jjCheckNAddTwoStates(146, 148);
600: if ((0x3ff000000000000L & l) != 0L)
601: jjCheckNAddTwoStates(143, 145);
602: if ((0x3ff000000000000L & l) != 0L)
603: jjCheckNAddTwoStates(141, 142);
604: if ((0x3ff000000000000L & l) != 0L)
605: {
606: if (kind > 37)
607: kind = 37;
608: jjCheckNAdd(140);
609: }
610: break;
611: case 389:
612: case 49:
613: if ((0x3ff200000000000L & l) == 0L)
614: break;
615: if (kind > 65)
616: kind = 65;
617: jjCheckNAddTwoStates(49, 50);
618: break;
619: case 48:
620: if (curChar != 45)
621: break;
622: if (kind > 65)
623: kind = 65;
624: jjCheckNAddTwoStates(49, 50);
625: break;
626: case 0:
627: if ((0x100003600L & l) == 0L)
628: break;
629: if (kind > 1)
630: kind = 1;
631: jjCheckNAdd(0);
632: break;
633: case 2:
634: if (curChar == 34)
635: jjCheckNAddStates(114, 117);
636: break;
637: case 3:
638: if ((0xfffffffb00000200L & l) != 0L)
639: jjCheckNAddStates(114, 117);
640: break;
641: case 4:
642: if (curChar == 34 && kind > 35)
643: kind = 35;
644: break;
645: case 6:
646: if (curChar == 12)
647: jjCheckNAddStates(114, 117);
648: break;
649: case 8:
650: if ((0xffffffff00000000L & l) != 0L)
651: jjCheckNAddStates(114, 117);
652: break;
653: case 9:
654: if ((0x3ff000000000000L & l) != 0L)
655: jjCheckNAddStates(121, 126);
656: break;
657: case 10:
658: if ((0x100003600L & l) != 0L)
659: jjCheckNAddStates(114, 117);
660: break;
661: case 11:
662: if ((0x3ff000000000000L & l) != 0L)
663: jjCheckNAddStates(127, 135);
664: break;
665: case 12:
666: if ((0x3ff000000000000L & l) != 0L)
667: jjCheckNAddStates(136, 140);
668: break;
669: case 13:
670: if ((0x3ff000000000000L & l) != 0L)
671: jjCheckNAddStates(141, 146);
672: break;
673: case 14:
674: if ((0x3ff000000000000L & l) != 0L)
675: jjCheckNAddStates(147, 153);
676: break;
677: case 15:
678: if ((0x3ff000000000000L & l) != 0L)
679: jjCheckNAddStates(154, 161);
680: break;
681: case 16:
682: if (curChar == 13)
683: jjCheckNAddStates(114, 117);
684: break;
685: case 17:
686: if (curChar == 10)
687: jjCheckNAddStates(114, 117);
688: break;
689: case 18:
690: if (curChar == 13)
691: jjstateSet[jjnewStateCnt++] = 17;
692: break;
693: case 19:
694: if (curChar == 39)
695: jjCheckNAddStates(110, 113);
696: break;
697: case 20:
698: if ((0xffffff7f00000200L & l) != 0L)
699: jjCheckNAddStates(110, 113);
700: break;
701: case 21:
702: if (curChar == 39 && kind > 35)
703: kind = 35;
704: break;
705: case 23:
706: if (curChar == 12)
707: jjCheckNAddStates(110, 113);
708: break;
709: case 25:
710: if ((0xffffffff00000000L & l) != 0L)
711: jjCheckNAddStates(110, 113);
712: break;
713: case 26:
714: if ((0x3ff000000000000L & l) != 0L)
715: jjCheckNAddStates(162, 167);
716: break;
717: case 27:
718: if ((0x100003600L & l) != 0L)
719: jjCheckNAddStates(110, 113);
720: break;
721: case 28:
722: if ((0x3ff000000000000L & l) != 0L)
723: jjCheckNAddStates(168, 176);
724: break;
725: case 29:
726: if ((0x3ff000000000000L & l) != 0L)
727: jjCheckNAddStates(177, 181);
728: break;
729: case 30:
730: if ((0x3ff000000000000L & l) != 0L)
731: jjCheckNAddStates(182, 187);
732: break;
733: case 31:
734: if ((0x3ff000000000000L & l) != 0L)
735: jjCheckNAddStates(188, 194);
736: break;
737: case 32:
738: if ((0x3ff000000000000L & l) != 0L)
739: jjCheckNAddStates(195, 202);
740: break;
741: case 33:
742: if (curChar == 13)
743: jjCheckNAddStates(110, 113);
744: break;
745: case 34:
746: if (curChar == 10)
747: jjCheckNAddStates(110, 113);
748: break;
749: case 35:
750: if (curChar == 13)
751: jjstateSet[jjnewStateCnt++] = 34;
752: break;
753: case 36:
754: if (curChar == 35)
755: jjCheckNAddTwoStates(37, 38);
756: break;
757: case 37:
758: if ((0x3ff200000000000L & l) == 0L)
759: break;
760: if (kind > 58)
761: kind = 58;
762: jjCheckNAddTwoStates(37, 38);
763: break;
764: case 39:
765: if ((0xffffffff00000000L & l) == 0L)
766: break;
767: if (kind > 58)
768: kind = 58;
769: jjCheckNAddTwoStates(37, 38);
770: break;
771: case 40:
772: if ((0x3ff000000000000L & l) == 0L)
773: break;
774: if (kind > 58)
775: kind = 58;
776: jjCheckNAddStates(203, 206);
777: break;
778: case 41:
779: if ((0x100003600L & l) == 0L)
780: break;
781: if (kind > 58)
782: kind = 58;
783: jjCheckNAddTwoStates(37, 38);
784: break;
785: case 42:
786: if ((0x3ff000000000000L & l) == 0L)
787: break;
788: if (kind > 58)
789: kind = 58;
790: jjCheckNAddStates(207, 213);
791: break;
792: case 43:
793: if ((0x3ff000000000000L & l) == 0L)
794: break;
795: if (kind > 58)
796: kind = 58;
797: jjCheckNAddStates(214, 216);
798: break;
799: case 44:
800: if ((0x3ff000000000000L & l) == 0L)
801: break;
802: if (kind > 58)
803: kind = 58;
804: jjCheckNAddStates(217, 220);
805: break;
806: case 45:
807: if ((0x3ff000000000000L & l) == 0L)
808: break;
809: if (kind > 58)
810: kind = 58;
811: jjCheckNAddStates(221, 225);
812: break;
813: case 46:
814: if ((0x3ff000000000000L & l) == 0L)
815: break;
816: if (kind > 58)
817: kind = 58;
818: jjCheckNAddStates(226, 231);
819: break;
820: case 51:
821: if ((0xffffffff00000000L & l) == 0L)
822: break;
823: if (kind > 65)
824: kind = 65;
825: jjCheckNAddTwoStates(49, 50);
826: break;
827: case 52:
828: if ((0x3ff000000000000L & l) == 0L)
829: break;
830: if (kind > 65)
831: kind = 65;
832: jjCheckNAddStates(232, 235);
833: break;
834: case 53:
835: if ((0x100003600L & l) == 0L)
836: break;
837: if (kind > 65)
838: kind = 65;
839: jjCheckNAddTwoStates(49, 50);
840: break;
841: case 54:
842: if ((0x3ff000000000000L & l) == 0L)
843: break;
844: if (kind > 65)
845: kind = 65;
846: jjCheckNAddStates(236, 242);
847: break;
848: case 55:
849: if ((0x3ff000000000000L & l) == 0L)
850: break;
851: if (kind > 65)
852: kind = 65;
853: jjCheckNAddStates(243, 245);
854: break;
855: case 56:
856: if ((0x3ff000000000000L & l) == 0L)
857: break;
858: if (kind > 65)
859: kind = 65;
860: jjCheckNAddStates(246, 249);
861: break;
862: case 57:
863: if ((0x3ff000000000000L & l) == 0L)
864: break;
865: if (kind > 65)
866: kind = 65;
867: jjCheckNAddStates(250, 254);
868: break;
869: case 58:
870: if ((0x3ff000000000000L & l) == 0L)
871: break;
872: if (kind > 65)
873: kind = 65;
874: jjCheckNAddStates(255, 260);
875: break;
876: case 60:
877: if ((0x3ff000000000000L & l) == 0L)
878: break;
879: if (kind > 65)
880: kind = 65;
881: jjCheckNAddStates(261, 264);
882: break;
883: case 61:
884: if ((0x3ff000000000000L & l) == 0L)
885: break;
886: if (kind > 65)
887: kind = 65;
888: jjCheckNAddStates(265, 271);
889: break;
890: case 62:
891: if ((0x3ff000000000000L & l) == 0L)
892: break;
893: if (kind > 65)
894: kind = 65;
895: jjCheckNAddStates(272, 274);
896: break;
897: case 63:
898: if ((0x3ff000000000000L & l) == 0L)
899: break;
900: if (kind > 65)
901: kind = 65;
902: jjCheckNAddStates(275, 278);
903: break;
904: case 64:
905: if ((0x3ff000000000000L & l) == 0L)
906: break;
907: if (kind > 65)
908: kind = 65;
909: jjCheckNAddStates(279, 283);
910: break;
911: case 65:
912: if ((0x3ff000000000000L & l) == 0L)
913: break;
914: if (kind > 65)
915: kind = 65;
916: jjCheckNAddStates(284, 289);
917: break;
918: case 66:
919: if (curChar == 33)
920: jjCheckNAddTwoStates(67, 76);
921: break;
922: case 67:
923: if ((0x100003600L & l) != 0L)
924: jjCheckNAddTwoStates(67, 76);
925: break;
926: case 77:
927: if (curChar != 45)
928: break;
929: if (kind > 36)
930: kind = 36;
931: jjCheckNAddStates(99, 109);
932: break;
933: case 78:
934: if ((0x3ff200000000000L & l) == 0L)
935: break;
936: if (kind > 36)
937: kind = 36;
938: jjCheckNAddTwoStates(78, 79);
939: break;
940: case 80:
941: if ((0xffffffff00000000L & l) == 0L)
942: break;
943: if (kind > 36)
944: kind = 36;
945: jjCheckNAddTwoStates(78, 79);
946: break;
947: case 81:
948: if ((0x3ff000000000000L & l) == 0L)
949: break;
950: if (kind > 36)
951: kind = 36;
952: jjCheckNAddStates(290, 293);
953: break;
954: case 82:
955: if ((0x100003600L & l) == 0L)
956: break;
957: if (kind > 36)
958: kind = 36;
959: jjCheckNAddTwoStates(78, 79);
960: break;
961: case 83:
962: if ((0x3ff000000000000L & l) == 0L)
963: break;
964: if (kind > 36)
965: kind = 36;
966: jjCheckNAddStates(294, 300);
967: break;
968: case 84:
969: if ((0x3ff000000000000L & l) == 0L)
970: break;
971: if (kind > 36)
972: kind = 36;
973: jjCheckNAddStates(301, 303);
974: break;
975: case 85:
976: if ((0x3ff000000000000L & l) == 0L)
977: break;
978: if (kind > 36)
979: kind = 36;
980: jjCheckNAddStates(304, 307);
981: break;
982: case 86:
983: if ((0x3ff000000000000L & l) == 0L)
984: break;
985: if (kind > 36)
986: kind = 36;
987: jjCheckNAddStates(308, 312);
988: break;
989: case 87:
990: if ((0x3ff000000000000L & l) == 0L)
991: break;
992: if (kind > 36)
993: kind = 36;
994: jjCheckNAddStates(313, 318);
995: break;
996: case 88:
997: if ((0x3ff200000000000L & l) != 0L)
998: jjCheckNAddStates(6, 8);
999: break;
1000: case 91:
1001: if ((0xffffffff00000000L & l) != 0L)
1002: jjCheckNAddStates(6, 8);
1003: break;
1004: case 92:
1005: if ((0x3ff000000000000L & l) != 0L)
1006: jjCheckNAddStates(319, 323);
1007: break;
1008: case 93:
1009: if ((0x100003600L & l) != 0L)
1010: jjCheckNAddStates(6, 8);
1011: break;
1012: case 94:
1013: if ((0x3ff000000000000L & l) != 0L)
1014: jjCheckNAddStates(324, 331);
1015: break;
1016: case 95:
1017: if ((0x3ff000000000000L & l) != 0L)
1018: jjCheckNAddStates(332, 335);
1019: break;
1020: case 96:
1021: if ((0x3ff000000000000L & l) != 0L)
1022: jjCheckNAddStates(336, 340);
1023: break;
1024: case 97:
1025: if ((0x3ff000000000000L & l) != 0L)
1026: jjCheckNAddStates(341, 346);
1027: break;
1028: case 98:
1029: if ((0x3ff000000000000L & l) != 0L)
1030: jjCheckNAddStates(347, 353);
1031: break;
1032: case 99:
1033: if ((0x3ff200000000000L & l) != 0L)
1034: jjCheckNAddStates(3, 5);
1035: break;
1036: case 101:
1037: if (curChar != 45)
1038: break;
1039: if (kind > 40)
1040: kind = 40;
1041: jjCheckNAddTwoStates(102, 103);
1042: break;
1043: case 102:
1044: if ((0x3ff200000000000L & l) == 0L)
1045: break;
1046: if (kind > 40)
1047: kind = 40;
1048: jjCheckNAddTwoStates(102, 103);
1049: break;
1050: case 104:
1051: if ((0xffffffff00000000L & l) == 0L)
1052: break;
1053: if (kind > 40)
1054: kind = 40;
1055: jjCheckNAddTwoStates(102, 103);
1056: break;
1057: case 105:
1058: if ((0x3ff000000000000L & l) == 0L)
1059: break;
1060: if (kind > 40)
1061: kind = 40;
1062: jjCheckNAddStates(354, 357);
1063: break;
1064: case 106:
1065: if ((0x100003600L & l) == 0L)
1066: break;
1067: if (kind > 40)
1068: kind = 40;
1069: jjCheckNAddTwoStates(102, 103);
1070: break;
1071: case 107:
1072: if ((0x3ff000000000000L & l) == 0L)
1073: break;
1074: if (kind > 40)
1075: kind = 40;
1076: jjCheckNAddStates(358, 364);
1077: break;
1078: case 108:
1079: if ((0x3ff000000000000L & l) == 0L)
1080: break;
1081: if (kind > 40)
1082: kind = 40;
1083: jjCheckNAddStates(365, 367);
1084: break;
1085: case 109:
1086: if ((0x3ff000000000000L & l) == 0L)
1087: break;
1088: if (kind > 40)
1089: kind = 40;
1090: jjCheckNAddStates(368, 371);
1091: break;
1092: case 110:
1093: if ((0x3ff000000000000L & l) == 0L)
1094: break;
1095: if (kind > 40)
1096: kind = 40;
1097: jjCheckNAddStates(372, 376);
1098: break;
1099: case 111:
1100: if ((0x3ff000000000000L & l) == 0L)
1101: break;
1102: if (kind > 40)
1103: kind = 40;
1104: jjCheckNAddStates(377, 382);
1105: break;
1106: case 113:
1107: if ((0x3ff000000000000L & l) == 0L)
1108: break;
1109: if (kind > 40)
1110: kind = 40;
1111: jjCheckNAddStates(383, 386);
1112: break;
1113: case 114:
1114: if ((0x3ff000000000000L & l) == 0L)
1115: break;
1116: if (kind > 40)
1117: kind = 40;
1118: jjCheckNAddStates(387, 393);
1119: break;
1120: case 115:
1121: if ((0x3ff000000000000L & l) == 0L)
1122: break;
1123: if (kind > 40)
1124: kind = 40;
1125: jjCheckNAddStates(394, 396);
1126: break;
1127: case 116:
1128: if ((0x3ff000000000000L & l) == 0L)
1129: break;
1130: if (kind > 40)
1131: kind = 40;
1132: jjCheckNAddStates(397, 400);
1133: break;
1134: case 117:
1135: if ((0x3ff000000000000L & l) == 0L)
1136: break;
1137: if (kind > 40)
1138: kind = 40;
1139: jjCheckNAddStates(401, 405);
1140: break;
1141: case 118:
1142: if ((0x3ff000000000000L & l) == 0L)
1143: break;
1144: if (kind > 40)
1145: kind = 40;
1146: jjCheckNAddStates(406, 411);
1147: break;
1148: case 120:
1149: if ((0xffffffff00000000L & l) != 0L)
1150: jjCheckNAddStates(3, 5);
1151: break;
1152: case 121:
1153: if ((0x3ff000000000000L & l) != 0L)
1154: jjCheckNAddStates(412, 416);
1155: break;
1156: case 122:
1157: if ((0x100003600L & l) != 0L)
1158: jjCheckNAddStates(3, 5);
1159: break;
1160: case 123:
1161: if ((0x3ff000000000000L & l) != 0L)
1162: jjCheckNAddStates(417, 424);
1163: break;
1164: case 124:
1165: if ((0x3ff000000000000L & l) != 0L)
1166: jjCheckNAddStates(425, 428);
1167: break;
1168: case 125:
1169: if ((0x3ff000000000000L & l) != 0L)
1170: jjCheckNAddStates(429, 433);
1171: break;
1172: case 126:
1173: if ((0x3ff000000000000L & l) != 0L)
1174: jjCheckNAddStates(434, 439);
1175: break;
1176: case 127:
1177: if ((0x3ff000000000000L & l) != 0L)
1178: jjCheckNAddStates(440, 446);
1179: break;
1180: case 128:
1181: if ((0x3ff200000000000L & l) != 0L)
1182: jjCheckNAddStates(0, 2);
1183: break;
1184: case 129:
1185: if (curChar == 40 && kind > 77)
1186: kind = 77;
1187: break;
1188: case 131:
1189: if ((0xffffffff00000000L & l) != 0L)
1190: jjCheckNAddStates(0, 2);
1191: break;
1192: case 132:
1193: if ((0x3ff000000000000L & l) != 0L)
1194: jjCheckNAddStates(447, 451);
1195: break;
1196: case 133:
1197: if ((0x100003600L & l) != 0L)
1198: jjCheckNAddStates(0, 2);
1199: break;
1200: case 134:
1201: if ((0x3ff000000000000L & l) != 0L)
1202: jjCheckNAddStates(452, 459);
1203: break;
1204: case 135:
1205: if ((0x3ff000000000000L & l) != 0L)
1206: jjCheckNAddStates(460, 463);
1207: break;
1208: case 136:
1209: if ((0x3ff000000000000L & l) != 0L)
1210: jjCheckNAddStates(464, 468);
1211: break;
1212: case 137:
1213: if ((0x3ff000000000000L & l) != 0L)
1214: jjCheckNAddStates(469, 474);
1215: break;
1216: case 138:
1217: if ((0x3ff000000000000L & l) != 0L)
1218: jjCheckNAddStates(475, 481);
1219: break;
1220: case 139:
1221: if (curChar == 46)
1222: jjCheckNAddStates(81, 98);
1223: break;
1224: case 140:
1225: if ((0x3ff000000000000L & l) == 0L)
1226: break;
1227: if (kind > 37)
1228: kind = 37;
1229: jjCheckNAdd(140);
1230: break;
1231: case 141:
1232: if ((0x3ff000000000000L & l) != 0L)
1233: jjCheckNAddTwoStates(141, 142);
1234: break;
1235: case 142:
1236: if (curChar == 37 && kind > 41)
1237: kind = 41;
1238: break;
1239: case 143:
1240: if ((0x3ff000000000000L & l) != 0L)
1241: jjCheckNAddTwoStates(143, 145);
1242: break;
1243: case 146:
1244: if ((0x3ff000000000000L & l) != 0L)
1245: jjCheckNAddTwoStates(146, 148);
1246: break;
1247: case 149:
1248: if ((0x3ff000000000000L & l) != 0L)
1249: jjCheckNAddTwoStates(149, 151);
1250: break;
1251: case 152:
1252: if ((0x3ff000000000000L & l) != 0L)
1253: jjCheckNAddTwoStates(152, 154);
1254: break;
1255: case 155:
1256: if ((0x3ff000000000000L & l) != 0L)
1257: jjCheckNAddTwoStates(155, 157);
1258: break;
1259: case 158:
1260: if ((0x3ff000000000000L & l) != 0L)
1261: jjCheckNAddTwoStates(158, 160);
1262: break;
1263: case 161:
1264: if ((0x3ff000000000000L & l) != 0L)
1265: jjCheckNAddTwoStates(161, 163);
1266: break;
1267: case 164:
1268: if ((0x3ff000000000000L & l) != 0L)
1269: jjCheckNAddTwoStates(164, 166);
1270: break;
1271: case 167:
1272: if ((0x3ff000000000000L & l) != 0L)
1273: jjCheckNAddTwoStates(167, 170);
1274: break;
1275: case 171:
1276: if ((0x3ff000000000000L & l) != 0L)
1277: jjCheckNAddTwoStates(171, 174);
1278: break;
1279: case 175:
1280: if ((0x3ff000000000000L & l) != 0L)
1281: jjCheckNAddTwoStates(175, 179);
1282: break;
1283: case 180:
1284: if ((0x3ff000000000000L & l) != 0L)
1285: jjCheckNAddTwoStates(180, 182);
1286: break;
1287: case 183:
1288: if ((0x3ff000000000000L & l) != 0L)
1289: jjCheckNAddTwoStates(183, 184);
1290: break;
1291: case 185:
1292: if ((0x3ff000000000000L & l) != 0L)
1293: jjCheckNAddTwoStates(185, 187);
1294: break;
1295: case 188:
1296: if ((0x3ff000000000000L & l) != 0L)
1297: jjCheckNAddTwoStates(188, 191);
1298: break;
1299: case 192:
1300: if ((0x3ff000000000000L & l) != 0L)
1301: jjCheckNAddStates(118, 120);
1302: break;
1303: case 193:
1304: if (curChar != 45)
1305: break;
1306: if (kind > 57)
1307: kind = 57;
1308: jjCheckNAddTwoStates(194, 195);
1309: break;
1310: case 194:
1311: if ((0x3ff200000000000L & l) == 0L)
1312: break;
1313: if (kind > 57)
1314: kind = 57;
1315: jjCheckNAddTwoStates(194, 195);
1316: break;
1317: case 196:
1318: if ((0xffffffff00000000L & l) == 0L)
1319: break;
1320: if (kind > 57)
1321: kind = 57;
1322: jjCheckNAddTwoStates(194, 195);
1323: break;
1324: case 197:
1325: if ((0x3ff000000000000L & l) == 0L)
1326: break;
1327: if (kind > 57)
1328: kind = 57;
1329: jjCheckNAddStates(482, 485);
1330: break;
1331: case 198:
1332: if ((0x100003600L & l) == 0L)
1333: break;
1334: if (kind > 57)
1335: kind = 57;
1336: jjCheckNAddTwoStates(194, 195);
1337: break;
1338: case 199:
1339: if ((0x3ff000000000000L & l) == 0L)
1340: break;
1341: if (kind > 57)
1342: kind = 57;
1343: jjCheckNAddStates(486, 492);
1344: break;
1345: case 200:
1346: if ((0x3ff000000000000L & l) == 0L)
1347: break;
1348: if (kind > 57)
1349: kind = 57;
1350: jjCheckNAddStates(493, 495);
1351: break;
1352: case 201:
1353: if ((0x3ff000000000000L & l) == 0L)
1354: break;
1355: if (kind > 57)
1356: kind = 57;
1357: jjCheckNAddStates(496, 499);
1358: break;
1359: case 202:
1360: if ((0x3ff000000000000L & l) == 0L)
1361: break;
1362: if (kind > 57)
1363: kind = 57;
1364: jjCheckNAddStates(500, 504);
1365: break;
1366: case 203:
1367: if ((0x3ff000000000000L & l) == 0L)
1368: break;
1369: if (kind > 57)
1370: kind = 57;
1371: jjCheckNAddStates(505, 510);
1372: break;
1373: case 205:
1374: if ((0x3ff000000000000L & l) == 0L)
1375: break;
1376: if (kind > 57)
1377: kind = 57;
1378: jjCheckNAddStates(511, 514);
1379: break;
1380: case 206:
1381: if ((0x3ff000000000000L & l) == 0L)
1382: break;
1383: if (kind > 57)
1384: kind = 57;
1385: jjCheckNAddStates(515, 521);
1386: break;
1387: case 207:
1388: if ((0x3ff000000000000L & l) == 0L)
1389: break;
1390: if (kind > 57)
1391: kind = 57;
1392: jjCheckNAddStates(522, 524);
1393: break;
1394: case 208:
1395: if ((0x3ff000000000000L & l) == 0L)
1396: break;
1397: if (kind > 57)
1398: kind = 57;
1399: jjCheckNAddStates(525, 528);
1400: break;
1401: case 209:
1402: if ((0x3ff000000000000L & l) == 0L)
1403: break;
1404: if (kind > 57)
1405: kind = 57;
1406: jjCheckNAddStates(529, 533);
1407: break;
1408: case 210:
1409: if ((0x3ff000000000000L & l) == 0L)
1410: break;
1411: if (kind > 57)
1412: kind = 57;
1413: jjCheckNAddStates(534, 539);
1414: break;
1415: case 212:
1416: if (curChar == 40)
1417: jjCheckNAddStates(540, 545);
1418: break;
1419: case 213:
1420: if ((0xfffffc7a00000000L & l) != 0L)
1421: jjCheckNAddStates(546, 549);
1422: break;
1423: case 214:
1424: if ((0x100003600L & l) != 0L)
1425: jjCheckNAddTwoStates(214, 215);
1426: break;
1427: case 215:
1428: if (curChar == 41 && kind > 39)
1429: kind = 39;
1430: break;
1431: case 217:
1432: if ((0xffffffff00000000L & l) != 0L)
1433: jjCheckNAddStates(546, 549);
1434: break;
1435: case 218:
1436: if ((0x3ff000000000000L & l) != 0L)
1437: jjCheckNAddStates(550, 554);
1438: break;
1439: case 219:
1440: if ((0x100003600L & l) != 0L)
1441: jjCheckNAddStates(546, 549);
1442: break;
1443: case 220:
1444: if ((0x3ff000000000000L & l) != 0L)
1445: jjCheckNAddStates(555, 562);
1446: break;
1447: case 221:
1448: if ((0x3ff000000000000L & l) != 0L)
1449: jjCheckNAddStates(563, 566);
1450: break;
1451: case 222:
1452: if ((0x3ff000000000000L & l) != 0L)
1453: jjCheckNAddStates(567, 571);
1454: break;
1455: case 223:
1456: if ((0x3ff000000000000L & l) != 0L)
1457: jjCheckNAddStates(572, 577);
1458: break;
1459: case 224:
1460: if ((0x3ff000000000000L & l) != 0L)
1461: jjCheckNAddStates(578, 584);
1462: break;
1463: case 225:
1464: if (curChar == 39)
1465: jjCheckNAddStates(585, 588);
1466: break;
1467: case 226:
1468: if ((0xffffff7f00000200L & l) != 0L)
1469: jjCheckNAddStates(585, 588);
1470: break;
1471: case 227:
1472: if (curChar == 39)
1473: jjCheckNAddTwoStates(214, 215);
1474: break;
1475: case 229:
1476: if (curChar == 12)
1477: jjCheckNAddStates(585, 588);
1478: break;
1479: case 231:
1480: if ((0xffffffff00000000L & l) != 0L)
1481: jjCheckNAddStates(585, 588);
1482: break;
1483: case 232:
1484: if ((0x3ff000000000000L & l) != 0L)
1485: jjCheckNAddStates(589, 594);
1486: break;
1487: case 233:
1488: if ((0x100003600L & l) != 0L)
1489: jjCheckNAddStates(585, 588);
1490: break;
1491: case 234:
1492: if ((0x3ff000000000000L & l) != 0L)
1493: jjCheckNAddStates(595, 603);
1494: break;
1495: case 235:
1496: if ((0x3ff000000000000L & l) != 0L)
1497: jjCheckNAddStates(604, 608);
1498: break;
1499: case 236:
1500: if ((0x3ff000000000000L & l) != 0L)
1501: jjCheckNAddStates(609, 614);
1502: break;
1503: case 237:
1504: if ((0x3ff000000000000L & l) != 0L)
1505: jjCheckNAddStates(615, 621);
1506: break;
1507: case 238:
1508: if ((0x3ff000000000000L & l) != 0L)
1509: jjCheckNAddStates(622, 629);
1510: break;
1511: case 239:
1512: if (curChar == 13)
1513: jjCheckNAddStates(585, 588);
1514: break;
1515: case 240:
1516: if (curChar == 10)
1517: jjCheckNAddStates(585, 588);
1518: break;
1519: case 241:
1520: if (curChar == 13)
1521: jjstateSet[jjnewStateCnt++] = 240;
1522: break;
1523: case 242:
1524: if (curChar == 34)
1525: jjCheckNAddStates(630, 633);
1526: break;
1527: case 243:
1528: if ((0xfffffffb00000200L & l) != 0L)
1529: jjCheckNAddStates(630, 633);
1530: break;
1531: case 244:
1532: if (curChar == 34)
1533: jjCheckNAddTwoStates(214, 215);
1534: break;
1535: case 246:
1536: if (curChar == 12)
1537: jjCheckNAddStates(630, 633);
1538: break;
1539: case 248:
1540: if ((0xffffffff00000000L & l) != 0L)
1541: jjCheckNAddStates(630, 633);
1542: break;
1543: case 249:
1544: if ((0x3ff000000000000L & l) != 0L)
1545: jjCheckNAddStates(634, 639);
1546: break;
1547: case 250:
1548: if ((0x100003600L & l) != 0L)
1549: jjCheckNAddStates(630, 633);
1550: break;
1551: case 251:
1552: if ((0x3ff000000000000L & l) != 0L)
1553: jjCheckNAddStates(640, 648);
1554: break;
1555: case 252:
1556: if ((0x3ff000000000000L & l) != 0L)
1557: jjCheckNAddStates(649, 653);
1558: break;
1559: case 253:
1560: if ((0x3ff000000000000L & l) != 0L)
1561: jjCheckNAddStates(654, 659);
1562: break;
1563: case 254:
1564: if ((0x3ff000000000000L & l) != 0L)
1565: jjCheckNAddStates(660, 666);
1566: break;
1567: case 255:
1568: if ((0x3ff000000000000L & l) != 0L)
1569: jjCheckNAddStates(667, 674);
1570: break;
1571: case 256:
1572: if (curChar == 13)
1573: jjCheckNAddStates(630, 633);
1574: break;
1575: case 257:
1576: if (curChar == 10)
1577: jjCheckNAddStates(630, 633);
1578: break;
1579: case 258:
1580: if (curChar == 13)
1581: jjstateSet[jjnewStateCnt++] = 257;
1582: break;
1583: case 259:
1584: if ((0x100003600L & l) != 0L)
1585: jjCheckNAddStates(675, 681);
1586: break;
1587: case 262:
1588: if (curChar == 43)
1589: jjAddStates(682, 683);
1590: break;
1591: case 263:
1592: if (curChar != 63)
1593: break;
1594: if (kind > 76)
1595: kind = 76;
1596: jjstateSet[jjnewStateCnt++] = 264;
1597: break;
1598: case 264:
1599: if (curChar != 63)
1600: break;
1601: if (kind > 76)
1602: kind = 76;
1603: jjCheckNAddStates(684, 687);
1604: break;
1605: case 265:
1606: if (curChar == 63 && kind > 76)
1607: kind = 76;
1608: break;
1609: case 266:
1610: case 281:
1611: case 285:
1612: case 288:
1613: case 291:
1614: if (curChar != 63)
1615: break;
1616: if (kind > 76)
1617: kind = 76;
1618: jjCheckNAdd(265);
1619: break;
1620: case 267:
1621: if (curChar != 63)
1622: break;
1623: if (kind > 76)
1624: kind = 76;
1625: jjCheckNAddTwoStates(265, 266);
1626: break;
1627: case 268:
1628: if (curChar != 63)
1629: break;
1630: if (kind > 76)
1631: kind = 76;
1632: jjCheckNAddStates(688, 690);
1633: break;
1634: case 269:
1635: if ((0x3ff000000000000L & l) == 0L)
1636: break;
1637: if (kind > 76)
1638: kind = 76;
1639: jjAddStates(691, 696);
1640: break;
1641: case 270:
1642: if ((0x3ff000000000000L & l) != 0L)
1643: jjstateSet[jjnewStateCnt++] = 271;
1644: break;
1645: case 271:
1646: if ((0x3ff000000000000L & l) != 0L)
1647: jjstateSet[jjnewStateCnt++] = 272;
1648: break;
1649: case 272:
1650: if ((0x3ff000000000000L & l) != 0L)
1651: jjCheckNAdd(273);
1652: break;
1653: case 273:
1654: if ((0x3ff000000000000L & l) != 0L && kind > 76)
1655: kind = 76;
1656: break;
1657: case 274:
1658: if ((0x3ff000000000000L & l) != 0L)
1659: jjstateSet[jjnewStateCnt++] = 275;
1660: break;
1661: case 275:
1662: if ((0x3ff000000000000L & l) != 0L)
1663: jjstateSet[jjnewStateCnt++] = 276;
1664: break;
1665: case 276:
1666: if ((0x3ff000000000000L & l) != 0L)
1667: jjstateSet[jjnewStateCnt++] = 277;
1668: break;
1669: case 277:
1670: if ((0x3ff000000000000L & l) == 0L)
1671: break;
1672: if (kind > 76)
1673: kind = 76;
1674: jjCheckNAdd(265);
1675: break;
1676: case 278:
1677: if ((0x3ff000000000000L & l) != 0L)
1678: jjstateSet[jjnewStateCnt++] = 279;
1679: break;
1680: case 279:
1681: if ((0x3ff000000000000L & l) != 0L)
1682: jjstateSet[jjnewStateCnt++] = 280;
1683: break;
1684: case 280:
1685: if ((0x3ff000000000000L & l) == 0L)
1686: break;
1687: if (kind > 76)
1688: kind = 76;
1689: jjstateSet[jjnewStateCnt++] = 281;
1690: break;
1691: case 282:
1692: if ((0x3ff000000000000L & l) != 0L)
1693: jjstateSet[jjnewStateCnt++] = 283;
1694: break;
1695: case 283:
1696: if ((0x3ff000000000000L & l) == 0L)
1697: break;
1698: if (kind > 76)
1699: kind = 76;
1700: jjstateSet[jjnewStateCnt++] = 284;
1701: break;
1702: case 284:
1703: if (curChar != 63)
1704: break;
1705: if (kind > 76)
1706: kind = 76;
1707: jjCheckNAddTwoStates(265, 285);
1708: break;
1709: case 286:
1710: if ((0x3ff000000000000L & l) == 0L)
1711: break;
1712: if (kind > 76)
1713: kind = 76;
1714: jjstateSet[jjnewStateCnt++] = 287;
1715: break;
1716: case 287:
1717: if (curChar != 63)
1718: break;
1719: if (kind > 76)
1720: kind = 76;
1721: jjCheckNAddStates(697, 699);
1722: break;
1723: case 289:
1724: if (curChar != 63)
1725: break;
1726: if (kind > 76)
1727: kind = 76;
1728: jjCheckNAddTwoStates(265, 288);
1729: break;
1730: case 290:
1731: if (curChar != 63)
1732: break;
1733: if (kind > 76)
1734: kind = 76;
1735: jjCheckNAddStates(700, 703);
1736: break;
1737: case 292:
1738: if (curChar != 63)
1739: break;
1740: if (kind > 76)
1741: kind = 76;
1742: jjCheckNAddTwoStates(265, 291);
1743: break;
1744: case 293:
1745: if (curChar != 63)
1746: break;
1747: if (kind > 76)
1748: kind = 76;
1749: jjCheckNAddStates(704, 706);
1750: break;
1751: case 294:
1752: if (curChar == 43)
1753: jjstateSet[jjnewStateCnt++] = 295;
1754: break;
1755: case 295:
1756: if ((0x3ff000000000000L & l) != 0L)
1757: jjCheckNAddTwoStates(296, 302);
1758: break;
1759: case 296:
1760: if (curChar == 45)
1761: jjstateSet[jjnewStateCnt++] = 297;
1762: break;
1763: case 297:
1764: if ((0x3ff000000000000L & l) == 0L)
1765: break;
1766: if (kind > 76)
1767: kind = 76;
1768: jjstateSet[jjnewStateCnt++] = 298;
1769: break;
1770: case 298:
1771: if ((0x3ff000000000000L & l) == 0L)
1772: break;
1773: if (kind > 76)
1774: kind = 76;
1775: jjCheckNAddStates(707, 710);
1776: break;
1777: case 299:
1778: if ((0x3ff000000000000L & l) == 0L)
1779: break;
1780: if (kind > 76)
1781: kind = 76;
1782: jjCheckNAdd(273);
1783: break;
1784: case 300:
1785: if ((0x3ff000000000000L & l) == 0L)
1786: break;
1787: if (kind > 76)
1788: kind = 76;
1789: jjCheckNAddTwoStates(273, 299);
1790: break;
1791: case 301:
1792: if ((0x3ff000000000000L & l) == 0L)
1793: break;
1794: if (kind > 76)
1795: kind = 76;
1796: jjCheckNAddStates(711, 713);
1797: break;
1798: case 302:
1799: if ((0x3ff000000000000L & l) != 0L)
1800: jjCheckNAddStates(714, 718);
1801: break;
1802: case 303:
1803: if ((0x3ff000000000000L & l) != 0L)
1804: jjCheckNAdd(296);
1805: break;
1806: case 304:
1807: if ((0x3ff000000000000L & l) != 0L)
1808: jjCheckNAddTwoStates(303, 296);
1809: break;
1810: case 305:
1811: if ((0x3ff000000000000L & l) != 0L)
1812: jjCheckNAddStates(719, 721);
1813: break;
1814: case 306:
1815: if ((0x3ff000000000000L & l) != 0L)
1816: jjCheckNAddStates(722, 725);
1817: break;
1818: case 308:
1819: if ((0x3ff000000000000L & l) == 0L)
1820: break;
1821: if (kind > 36)
1822: kind = 36;
1823: jjCheckNAddStates(726, 729);
1824: break;
1825: case 309:
1826: if ((0x3ff000000000000L & l) == 0L)
1827: break;
1828: if (kind > 36)
1829: kind = 36;
1830: jjCheckNAddStates(730, 736);
1831: break;
1832: case 310:
1833: if ((0x3ff000000000000L & l) == 0L)
1834: break;
1835: if (kind > 36)
1836: kind = 36;
1837: jjCheckNAddStates(737, 739);
1838: break;
1839: case 311:
1840: if ((0x3ff000000000000L & l) == 0L)
1841: break;
1842: if (kind > 36)
1843: kind = 36;
1844: jjCheckNAddStates(740, 743);
1845: break;
1846: case 312:
1847: if ((0x3ff000000000000L & l) == 0L)
1848: break;
1849: if (kind > 36)
1850: kind = 36;
1851: jjCheckNAddStates(744, 748);
1852: break;
1853: case 313:
1854: if ((0x3ff000000000000L & l) == 0L)
1855: break;
1856: if (kind > 36)
1857: kind = 36;
1858: jjCheckNAddStates(749, 754);
1859: break;
1860: case 314:
1861: if ((0x3ff000000000000L & l) != 0L)
1862: jjCheckNAddStates(755, 759);
1863: break;
1864: case 315:
1865: if ((0x3ff000000000000L & l) != 0L)
1866: jjCheckNAddStates(760, 767);
1867: break;
1868: case 316:
1869: if ((0x3ff000000000000L & l) != 0L)
1870: jjCheckNAddStates(768, 771);
1871: break;
1872: case 317:
1873: if ((0x3ff000000000000L & l) != 0L)
1874: jjCheckNAddStates(772, 776);
1875: break;
1876: case 318:
1877: if ((0x3ff000000000000L & l) != 0L)
1878: jjCheckNAddStates(777, 782);
1879: break;
1880: case 319:
1881: if ((0x3ff000000000000L & l) != 0L)
1882: jjCheckNAddStates(783, 789);
1883: break;
1884: case 320:
1885: if ((0x3ff000000000000L & l) != 0L)
1886: jjCheckNAddStates(790, 794);
1887: break;
1888: case 321:
1889: if ((0x3ff000000000000L & l) != 0L)
1890: jjCheckNAddStates(795, 802);
1891: break;
1892: case 322:
1893: if ((0x3ff000000000000L & l) != 0L)
1894: jjCheckNAddStates(803, 806);
1895: break;
1896: case 323:
1897: if ((0x3ff000000000000L & l) != 0L)
1898: jjCheckNAddStates(807, 811);
1899: break;
1900: case 324:
1901: if ((0x3ff000000000000L & l) != 0L)
1902: jjCheckNAddStates(812, 817);
1903: break;
1904: case 325:
1905: if ((0x3ff000000000000L & l) != 0L)
1906: jjCheckNAddStates(818, 824);
1907: break;
1908: case 326:
1909: if ((0x3ff000000000000L & l) != 0L)
1910: jjCheckNAddStates(825, 829);
1911: break;
1912: case 327:
1913: if ((0x3ff000000000000L & l) != 0L)
1914: jjCheckNAddStates(830, 837);
1915: break;
1916: case 328:
1917: if ((0x3ff000000000000L & l) != 0L)
1918: jjCheckNAddStates(838, 841);
1919: break;
1920: case 329:
1921: if ((0x3ff000000000000L & l) != 0L)
1922: jjCheckNAddStates(842, 846);
1923: break;
1924: case 330:
1925: if ((0x3ff000000000000L & l) != 0L)
1926: jjCheckNAddStates(847, 852);
1927: break;
1928: case 331:
1929: if ((0x3ff000000000000L & l) != 0L)
1930: jjCheckNAddStates(853, 859);
1931: break;
1932: case 332:
1933: if ((0x3ff000000000000L & l) == 0L)
1934: break;
1935: if (kind > 37)
1936: kind = 37;
1937: jjCheckNAddStates(9, 80);
1938: break;
1939: case 333:
1940: if ((0x3ff000000000000L & l) == 0L)
1941: break;
1942: if (kind > 37)
1943: kind = 37;
1944: jjCheckNAdd(333);
1945: break;
1946: case 334:
1947: if ((0x3ff000000000000L & l) != 0L)
1948: jjCheckNAddTwoStates(334, 335);
1949: break;
1950: case 335:
1951: if (curChar == 46)
1952: jjCheckNAdd(140);
1953: break;
1954: case 336:
1955: if ((0x3ff000000000000L & l) != 0L)
1956: jjCheckNAddTwoStates(336, 142);
1957: break;
1958: case 337:
1959: if ((0x3ff000000000000L & l) != 0L)
1960: jjCheckNAddTwoStates(337, 338);
1961: break;
1962: case 338:
1963: if (curChar == 46)
1964: jjCheckNAdd(141);
1965: break;
1966: case 339:
1967: if ((0x3ff000000000000L & l) != 0L)
1968: jjCheckNAddTwoStates(339, 145);
1969: break;
1970: case 340:
1971: if ((0x3ff000000000000L & l) != 0L)
1972: jjCheckNAddTwoStates(340, 341);
1973: break;
1974: case 341:
1975: if (curChar == 46)
1976: jjCheckNAdd(143);
1977: break;
1978: case 342:
1979: if ((0x3ff000000000000L & l) != 0L)
1980: jjCheckNAddTwoStates(342, 148);
1981: break;
1982: case 343:
1983: if ((0x3ff000000000000L & l) != 0L)
1984: jjCheckNAddTwoStates(343, 344);
1985: break;
1986: case 344:
1987: if (curChar == 46)
1988: jjCheckNAdd(146);
1989: break;
1990: case 345:
1991: if ((0x3ff000000000000L & l) != 0L)
1992: jjCheckNAddTwoStates(345, 151);
1993: break;
1994: case 346:
1995: if ((0x3ff000000000000L & l) != 0L)
1996: jjCheckNAddTwoStates(346, 347);
1997: break;
1998: case 347:
1999: if (curChar == 46)
2000: jjCheckNAdd(149);
2001: break;
2002: case 348:
2003: if ((0x3ff000000000000L & l) != 0L)
2004: jjCheckNAddTwoStates(348, 154);
2005: break;
2006: case 349:
2007: if ((0x3ff000000000000L & l) != 0L)
2008: jjCheckNAddTwoStates(349, 350);
2009: break;
2010: case 350:
2011: if (curChar == 46)
2012: jjCheckNAdd(152);
2013: break;
2014: case 351:
2015: if ((0x3ff000000000000L & l) != 0L)
2016: jjCheckNAddTwoStates(351, 157);
2017: break;
2018: case 352:
2019: if ((0x3ff000000000000L & l) != 0L)
2020: jjCheckNAddTwoStates(352, 353);
2021: break;
2022: case 353:
2023: if (curChar == 46)
2024: jjCheckNAdd(155);
2025: break;
2026: case 354:
2027: if ((0x3ff000000000000L & l) != 0L)
2028: jjCheckNAddTwoStates(354, 160);
2029: break;
2030: case 355:
2031: if ((0x3ff000000000000L & l) != 0L)
2032: jjCheckNAddTwoStates(355, 356);
2033: break;
2034: case 356:
2035: if (curChar == 46)
2036: jjCheckNAdd(158);
2037: break;
2038: case 357:
2039: if ((0x3ff000000000000L & l) != 0L)
2040: jjCheckNAddTwoStates(357, 163);
2041: break;
2042: case 358:
2043: if ((0x3ff000000000000L & l) != 0L)
2044: jjCheckNAddTwoStates(358, 359);
2045: break;
2046: case 359:
2047: if (curChar == 46)
2048: jjCheckNAdd(161);
2049: break;
2050: case 360:
2051: if ((0x3ff000000000000L & l) != 0L)
2052: jjCheckNAddTwoStates(360, 166);
2053: break;
2054: case 361:
2055: if ((0x3ff000000000000L & l) != 0L)
2056: jjCheckNAddTwoStates(361, 362);
2057: break;
2058: case 362:
2059: if (curChar == 46)
2060: jjCheckNAdd(164);
2061: break;
2062: case 363:
2063: if ((0x3ff000000000000L & l) != 0L)
2064: jjCheckNAddTwoStates(363, 170);
2065: break;
2066: case 364:
2067: if ((0x3ff000000000000L & l) != 0L)
2068: jjCheckNAddTwoStates(364, 365);
2069: break;
2070: case 365:
2071: if (curChar == 46)
2072: jjCheckNAdd(167);
2073: break;
2074: case 366:
2075: if ((0x3ff000000000000L & l) != 0L)
2076: jjCheckNAddTwoStates(366, 174);
2077: break;
2078: case 367:
2079: if ((0x3ff000000000000L & l) != 0L)
2080: jjCheckNAddTwoStates(367, 368);
2081: break;
2082: case 368:
2083: if (curChar == 46)
2084: jjCheckNAdd(171);
2085: break;
2086: case 369:
2087: if ((0x3ff000000000000L & l) != 0L)
2088: jjCheckNAddTwoStates(369, 179);
2089: break;
2090: case 370:
2091: if ((0x3ff000000000000L & l) != 0L)
2092: jjCheckNAddTwoStates(370, 371);
2093: break;
2094: case 371:
2095: if (curChar == 46)
2096: jjCheckNAdd(175);
2097: break;
2098: case 372:
2099: if ((0x3ff000000000000L & l) != 0L)
2100: jjCheckNAddTwoStates(372, 182);
2101: break;
2102: case 373:
2103: if ((0x3ff000000000000L & l) != 0L)
2104: jjCheckNAddTwoStates(373, 374);
2105: break;
2106: case 374:
2107: if (curChar == 46)
2108: jjCheckNAdd(180);
2109: break;
2110: case 375:
2111: if ((0x3ff000000000000L & l) != 0L)
2112: jjCheckNAddTwoStates(375, 184);
2113: break;
2114: case 376:
2115: if ((0x3ff000000000000L & l) != 0L)
2116: jjCheckNAddTwoStates(376, 377);
2117: break;
2118: case 377:
2119: if (curChar == 46)
2120: jjCheckNAdd(183);
2121: break;
2122: case 378:
2123: if ((0x3ff000000000000L & l) != 0L)
2124: jjCheckNAddTwoStates(378, 187);
2125: break;
2126: case 379:
2127: if ((0x3ff000000000000L & l) != 0L)
2128: jjCheckNAddTwoStates(379, 380);
2129: break;
2130: case 380:
2131: if (curChar == 46)
2132: jjCheckNAdd(185);
2133: break;
2134: case 381:
2135: if ((0x3ff000000000000L & l) != 0L)
2136: jjCheckNAddTwoStates(381, 191);
2137: break;
2138: case 382:
2139: if ((0x3ff000000000000L & l) != 0L)
2140: jjCheckNAddTwoStates(382, 383);
2141: break;
2142: case 383:
2143: if (curChar == 46)
2144: jjCheckNAdd(188);
2145: break;
2146: case 384:
2147: if ((0x3ff000000000000L & l) != 0L)
2148: jjCheckNAddStates(860, 862);
2149: break;
2150: case 385:
2151: if ((0x3ff000000000000L & l) != 0L)
2152: jjCheckNAddTwoStates(385, 386);
2153: break;
2154: case 386:
2155: if (curChar == 46)
2156: jjCheckNAdd(192);
2157: break;
2158: default : break;
2159: }
2160: } while(i != startsAt);
2161: }
2162: else if (curChar < 128)
2163: {
2164: long l = 1L << (curChar & 077);
2165: MatchLoop: do
2166: {
2167: switch(jjstateSet[--i])
2168: {
2169: case 388:
2170: if ((0x7fffffe87fffffeL & l) != 0L)
2171: jjCheckNAddStates(0, 2);
2172: else if (curChar == 92)
2173: jjCheckNAddTwoStates(80, 81);
2174: else if (curChar == 124)
2175: jjAddStates(863, 864);
2176: if ((0x7fffffe87fffffeL & l) != 0L)
2177: jjCheckNAddStates(3, 5);
2178: else if (curChar == 92)
2179: jjCheckNAddTwoStates(91, 92);
2180: else if (curChar == 124)
2181: {
2182: if (kind > 40)
2183: kind = 40;
2184: }
2185: if ((0x7fffffe87fffffeL & l) != 0L)
2186: jjCheckNAddStates(6, 8);
2187: else if (curChar == 92)
2188: jjCheckNAddTwoStates(120, 121);
2189: if ((0x7fffffe87fffffeL & l) != 0L)
2190: {
2191: if (kind > 36)
2192: kind = 36;
2193: jjCheckNAddTwoStates(78, 79);
2194: }
2195: else if (curChar == 92)
2196: jjCheckNAddTwoStates(131, 132);
2197: break;
2198: case 1:
2199: if ((0x7fffffe87fffffeL & l) != 0L)
2200: {
2201: if (kind > 36)
2202: kind = 36;
2203: jjCheckNAddStates(99, 109);
2204: }
2205: else if (curChar == 92)
2206: jjCheckNAddStates(865, 872);
2207: else if (curChar == 64)
2208: jjAddStates(873, 874);
2209: if ((0x20000000200000L & l) != 0L)
2210: jjAddStates(875, 877);
2211: break;
2212: case 389:
2213: if ((0x7fffffe87fffffeL & l) != 0L)
2214: {
2215: if (kind > 65)
2216: kind = 65;
2217: jjCheckNAddTwoStates(49, 50);
2218: }
2219: else if (curChar == 92)
2220: jjCheckNAddTwoStates(51, 52);
2221: break;
2222: case 48:
2223: if ((0x7fffffe87fffffeL & l) != 0L)
2224: {
2225: if (kind > 65)
2226: kind = 65;
2227: jjCheckNAddTwoStates(49, 50);
2228: }
2229: else if (curChar == 92)
2230: jjCheckNAddTwoStates(51, 60);
2231: break;
2232: case 3:
2233: case 8:
2234: if ((0x7fffffffffffffffL & l) != 0L)
2235: jjCheckNAddStates(114, 117);
2236: break;
2237: case 5:
2238: if (curChar == 92)
2239: jjAddStates(878, 881);
2240: break;
2241: case 7:
2242: if (curChar == 92)
2243: jjAddStates(882, 883);
2244: break;
2245: case 9:
2246: if ((0x7e0000007eL & l) != 0L)
2247: jjCheckNAddStates(121, 126);
2248: break;
2249: case 11:
2250: if ((0x7e0000007eL & l) != 0L)
2251: jjCheckNAddStates(127, 135);
2252: break;
2253: case 12:
2254: if ((0x7e0000007eL & l) != 0L)
2255: jjCheckNAddStates(136, 140);
2256: break;
2257: case 13:
2258: if ((0x7e0000007eL & l) != 0L)
2259: jjCheckNAddStates(141, 146);
2260: break;
2261: case 14:
2262: if ((0x7e0000007eL & l) != 0L)
2263: jjCheckNAddStates(147, 153);
2264: break;
2265: case 15:
2266: if ((0x7e0000007eL & l) != 0L)
2267: jjCheckNAddStates(154, 161);
2268: break;
2269: case 20:
2270: case 25:
2271: if ((0x7fffffffffffffffL & l) != 0L)
2272: jjCheckNAddStates(110, 113);
2273: break;
2274: case 22:
2275: if (curChar == 92)
2276: jjAddStates(884, 887);
2277: break;
2278: case 24:
2279: if (curChar == 92)
2280: jjAddStates(888, 889);
2281: break;
2282: case 26:
2283: if ((0x7e0000007eL & l) != 0L)
2284: jjCheckNAddStates(162, 167);
2285: break;
2286: case 28:
2287: if ((0x7e0000007eL & l) != 0L)
2288: jjCheckNAddStates(168, 176);
2289: break;
2290: case 29:
2291: if ((0x7e0000007eL & l) != 0L)
2292: jjCheckNAddStates(177, 181);
2293: break;
2294: case 30:
2295: if ((0x7e0000007eL & l) != 0L)
2296: jjCheckNAddStates(182, 187);
2297: break;
2298: case 31:
2299: if ((0x7e0000007eL & l) != 0L)
2300: jjCheckNAddStates(188, 194);
2301: break;
2302: case 32:
2303: if ((0x7e0000007eL & l) != 0L)
2304: jjCheckNAddStates(195, 202);
2305: break;
2306: case 37:
2307: if ((0x7fffffe87fffffeL & l) == 0L)
2308: break;
2309: if (kind > 58)
2310: kind = 58;
2311: jjCheckNAddTwoStates(37, 38);
2312: break;
2313: case 38:
2314: if (curChar == 92)
2315: jjAddStates(890, 891);
2316: break;
2317: case 39:
2318: if ((0x7fffffffffffffffL & l) == 0L)
2319: break;
2320: if (kind > 58)
2321: kind = 58;
2322: jjCheckNAddTwoStates(37, 38);
2323: break;
2324: case 40:
2325: if ((0x7e0000007eL & l) == 0L)
2326: break;
2327: if (kind > 58)
2328: kind = 58;
2329: jjCheckNAddStates(203, 206);
2330: break;
2331: case 42:
2332: if ((0x7e0000007eL & l) == 0L)
2333: break;
2334: if (kind > 58)
2335: kind = 58;
2336: jjCheckNAddStates(207, 213);
2337: break;
2338: case 43:
2339: if ((0x7e0000007eL & l) == 0L)
2340: break;
2341: if (kind > 58)
2342: kind = 58;
2343: jjCheckNAddStates(214, 216);
2344: break;
2345: case 44:
2346: if ((0x7e0000007eL & l) == 0L)
2347: break;
2348: if (kind > 58)
2349: kind = 58;
2350: jjCheckNAddStates(217, 220);
2351: break;
2352: case 45:
2353: if ((0x7e0000007eL & l) == 0L)
2354: break;
2355: if (kind > 58)
2356: kind = 58;
2357: jjCheckNAddStates(221, 225);
2358: break;
2359: case 46:
2360: if ((0x7e0000007eL & l) == 0L)
2361: break;
2362: if (kind > 58)
2363: kind = 58;
2364: jjCheckNAddStates(226, 231);
2365: break;
2366: case 47:
2367: if (curChar == 64)
2368: jjAddStates(873, 874);
2369: break;
2370: case 49:
2371: if ((0x7fffffe87fffffeL & l) == 0L)
2372: break;
2373: if (kind > 65)
2374: kind = 65;
2375: jjCheckNAddTwoStates(49, 50);
2376: break;
2377: case 50:
2378: if (curChar == 92)
2379: jjCheckNAddTwoStates(51, 52);
2380: break;
2381: case 51:
2382: if ((0x7fffffffffffffffL & l) == 0L)
2383: break;
2384: if (kind > 65)
2385: kind = 65;
2386: jjCheckNAddTwoStates(49, 50);
2387: break;
2388: case 52:
2389: if ((0x7e0000007eL & l) == 0L)
2390: break;
2391: if (kind > 65)
2392: kind = 65;
2393: jjCheckNAddStates(232, 235);
2394: break;
2395: case 54:
2396: if ((0x7e0000007eL & l) == 0L)
2397: break;
2398: if (kind > 65)
2399: kind = 65;
2400: jjCheckNAddStates(236, 242);
2401: break;
2402: case 55:
2403: if ((0x7e0000007eL & l) == 0L)
2404: break;
2405: if (kind > 65)
2406: kind = 65;
2407: jjCheckNAddStates(243, 245);
2408: break;
2409: case 56:
2410: if ((0x7e0000007eL & l) == 0L)
2411: break;
2412: if (kind > 65)
2413: kind = 65;
2414: jjCheckNAddStates(246, 249);
2415: break;
2416: case 57:
2417: if ((0x7e0000007eL & l) == 0L)
2418: break;
2419: if (kind > 65)
2420: kind = 65;
2421: jjCheckNAddStates(250, 254);
2422: break;
2423: case 58:
2424: if ((0x7e0000007eL & l) == 0L)
2425: break;
2426: if (kind > 65)
2427: kind = 65;
2428: jjCheckNAddStates(255, 260);
2429: break;
2430: case 59:
2431: if (curChar == 92)
2432: jjCheckNAddTwoStates(51, 60);
2433: break;
2434: case 60:
2435: if ((0x7e0000007eL & l) == 0L)
2436: break;
2437: if (kind > 65)
2438: kind = 65;
2439: jjCheckNAddStates(261, 264);
2440: break;
2441: case 61:
2442: if ((0x7e0000007eL & l) == 0L)
2443: break;
2444: if (kind > 65)
2445: kind = 65;
2446: jjCheckNAddStates(265, 271);
2447: break;
2448: case 62:
2449: if ((0x7e0000007eL & l) == 0L)
2450: break;
2451: if (kind > 65)
2452: kind = 65;
2453: jjCheckNAddStates(272, 274);
2454: break;
2455: case 63:
2456: if ((0x7e0000007eL & l) == 0L)
2457: break;
2458: if (kind > 65)
2459: kind = 65;
2460: jjCheckNAddStates(275, 278);
2461: break;
2462: case 64:
2463: if ((0x7e0000007eL & l) == 0L)
2464: break;
2465: if (kind > 65)
2466: kind = 65;
2467: jjCheckNAddStates(279, 283);
2468: break;
2469: case 65:
2470: if ((0x7e0000007eL & l) == 0L)
2471: break;
2472: if (kind > 65)
2473: kind = 65;
2474: jjCheckNAddStates(284, 289);
2475: break;
2476: case 68:
2477: if ((0x10000000100000L & l) != 0L && kind > 66)
2478: kind = 66;
2479: break;
2480: case 69:
2481: if ((0x400000004000L & l) != 0L)
2482: jjstateSet[jjnewStateCnt++] = 68;
2483: break;
2484: case 70:
2485: if ((0x200000002L & l) != 0L)
2486: jjstateSet[jjnewStateCnt++] = 69;
2487: break;
2488: case 71:
2489: if ((0x10000000100000L & l) != 0L)
2490: jjstateSet[jjnewStateCnt++] = 70;
2491: break;
2492: case 72:
2493: if ((0x4000000040000L & l) != 0L)
2494: jjstateSet[jjnewStateCnt++] = 71;
2495: break;
2496: case 73:
2497: if ((0x800000008000L & l) != 0L)
2498: jjstateSet[jjnewStateCnt++] = 72;
2499: break;
2500: case 74:
2501: if ((0x1000000010000L & l) != 0L)
2502: jjstateSet[jjnewStateCnt++] = 73;
2503: break;
2504: case 75:
2505: if ((0x200000002000L & l) != 0L)
2506: jjstateSet[jjnewStateCnt++] = 74;
2507: break;
2508: case 76:
2509: if ((0x20000000200L & l) != 0L)
2510: jjstateSet[jjnewStateCnt++] = 75;
2511: break;
2512: case 77:
2513: if ((0x7fffffe87fffffeL & l) == 0L)
2514: break;
2515: if (kind > 36)
2516: kind = 36;
2517: jjCheckNAddStates(99, 109);
2518: break;
2519: case 78:
2520: if ((0x7fffffe87fffffeL & l) == 0L)
2521: break;
2522: if (kind > 36)
2523: kind = 36;
2524: jjCheckNAddTwoStates(78, 79);
2525: break;
2526: case 79:
2527: if (curChar == 92)
2528: jjCheckNAddTwoStates(80, 81);
2529: break;
2530: case 80:
2531: if ((0x7fffffffffffffffL & l) == 0L)
2532: break;
2533: if (kind > 36)
2534: kind = 36;
2535: jjCheckNAddTwoStates(78, 79);
2536: break;
2537: case 81:
2538: if ((0x7e0000007eL & l) == 0L)
2539: break;
2540: if (kind > 36)
2541: kind = 36;
2542: jjCheckNAddStates(290, 293);
2543: break;
2544: case 83:
2545: if ((0x7e0000007eL & l) == 0L)
2546: break;
2547: if (kind > 36)
2548: kind = 36;
2549: jjCheckNAddStates(294, 300);
2550: break;
2551: case 84:
2552: if ((0x7e0000007eL & l) == 0L)
2553: break;
2554: if (kind > 36)
2555: kind = 36;
2556: jjCheckNAddStates(301, 303);
2557: break;
2558: case 85:
2559: if ((0x7e0000007eL & l) == 0L)
2560: break;
2561: if (kind > 36)
2562: kind = 36;
2563: jjCheckNAddStates(304, 307);
2564: break;
2565: case 86:
2566: if ((0x7e0000007eL & l) == 0L)
2567: break;
2568: if (kind > 36)
2569: kind = 36;
2570: jjCheckNAddStates(308, 312);
2571: break;
2572: case 87:
2573: if ((0x7e0000007eL & l) == 0L)
2574: break;
2575: if (kind > 36)
2576: kind = 36;
2577: jjCheckNAddStates(313, 318);
2578: break;
2579: case 88:
2580: if ((0x7fffffe87fffffeL & l) != 0L)
2581: jjCheckNAddStates(6, 8);
2582: break;
2583: case 89:
2584: if (curChar == 124 && kind > 40)
2585: kind = 40;
2586: break;
2587: case 90:
2588: if (curChar == 92)
2589: jjCheckNAddTwoStates(91, 92);
2590: break;
2591: case 91:
2592: if ((0x7fffffffffffffffL & l) != 0L)
2593: jjCheckNAddStates(6, 8);
2594: break;
2595: case 92:
2596: if ((0x7e0000007eL & l) != 0L)
2597: jjCheckNAddStates(319, 323);
2598: break;
2599: case 94:
2600: if ((0x7e0000007eL & l) != 0L)
2601: jjCheckNAddStates(324, 331);
2602: break;
2603: case 95:
2604: if ((0x7e0000007eL & l) != 0L)
2605: jjCheckNAddStates(332, 335);
2606: break;
2607: case 96:
2608: if ((0x7e0000007eL & l) != 0L)
2609: jjCheckNAddStates(336, 340);
2610: break;
2611: case 97:
2612: if ((0x7e0000007eL & l) != 0L)
2613: jjCheckNAddStates(341, 346);
2614: break;
2615: case 98:
2616: if ((0x7e0000007eL & l) != 0L)
2617: jjCheckNAddStates(347, 353);
2618: break;
2619: case 99:
2620: if ((0x7fffffe87fffffeL & l) != 0L)
2621: jjCheckNAddStates(3, 5);
2622: break;
2623: case 100:
2624: if (curChar == 124)
2625: jjAddStates(863, 864);
2626: break;
2627: case 101:
2628: case 102:
2629: if ((0x7fffffe87fffffeL & l) == 0L)
2630: break;
2631: if (kind > 40)
2632: kind = 40;
2633: jjCheckNAddTwoStates(102, 103);
2634: break;
2635: case 103:
2636: if (curChar == 92)
2637: jjCheckNAddTwoStates(104, 105);
2638: break;
2639: case 104:
2640: if ((0x7fffffffffffffffL & l) == 0L)
2641: break;
2642: if (kind > 40)
2643: kind = 40;
2644: jjCheckNAddTwoStates(102, 103);
2645: break;
2646: case 105:
2647: if ((0x7e0000007eL & l) == 0L)
2648: break;
2649: if (kind > 40)
2650: kind = 40;
2651: jjCheckNAddStates(354, 357);
2652: break;
2653: case 107:
2654: if ((0x7e0000007eL & l) == 0L)
2655: break;
2656: if (kind > 40)
2657: kind = 40;
2658: jjCheckNAddStates(358, 364);
2659: break;
2660: case 108:
2661: if ((0x7e0000007eL & l) == 0L)
2662: break;
2663: if (kind > 40)
2664: kind = 40;
2665: jjCheckNAddStates(365, 367);
2666: break;
2667: case 109:
2668: if ((0x7e0000007eL & l) == 0L)
2669: break;
2670: if (kind > 40)
2671: kind = 40;
2672: jjCheckNAddStates(368, 371);
2673: break;
2674: case 110:
2675: if ((0x7e0000007eL & l) == 0L)
2676: break;
2677: if (kind > 40)
2678: kind = 40;
2679: jjCheckNAddStates(372, 376);
2680: break;
2681: case 111:
2682: if ((0x7e0000007eL & l) == 0L)
2683: break;
2684: if (kind > 40)
2685: kind = 40;
2686: jjCheckNAddStates(377, 382);
2687: break;
2688: case 112:
2689: if (curChar == 92)
2690: jjCheckNAddTwoStates(104, 113);
2691: break;
2692: case 113:
2693: if ((0x7e0000007eL & l) == 0L)
2694: break;
2695: if (kind > 40)
2696: kind = 40;
2697: jjCheckNAddStates(383, 386);
2698: break;
2699: case 114:
2700: if ((0x7e0000007eL & l) == 0L)
2701: break;
2702: if (kind > 40)
2703: kind = 40;
2704: jjCheckNAddStates(387, 393);
2705: break;
2706: case 115:
2707: if ((0x7e0000007eL & l) == 0L)
2708: break;
2709: if (kind > 40)
2710: kind = 40;
2711: jjCheckNAddStates(394, 396);
2712: break;
2713: case 116:
2714: if ((0x7e0000007eL & l) == 0L)
2715: break;
2716: if (kind > 40)
2717: kind = 40;
2718: jjCheckNAddStates(397, 400);
2719: break;
2720: case 117:
2721: if ((0x7e0000007eL & l) == 0L)
2722: break;
2723: if (kind > 40)
2724: kind = 40;
2725: jjCheckNAddStates(401, 405);
2726: break;
2727: case 118:
2728: if ((0x7e0000007eL & l) == 0L)
2729: break;
2730: if (kind > 40)
2731: kind = 40;
2732: jjCheckNAddStates(406, 411);
2733: break;
2734: case 119:
2735: if (curChar == 92)
2736: jjCheckNAddTwoStates(120, 121);
2737: break;
2738: case 120:
2739: if ((0x7fffffffffffffffL & l) != 0L)
2740: jjCheckNAddStates(3, 5);
2741: break;
2742: case 121:
2743: if ((0x7e0000007eL & l) != 0L)
2744: jjCheckNAddStates(412, 416);
2745: break;
2746: case 123:
2747: if ((0x7e0000007eL & l) != 0L)
2748: jjCheckNAddStates(417, 424);
2749: break;
2750: case 124:
2751: if ((0x7e0000007eL & l) != 0L)
2752: jjCheckNAddStates(425, 428);
2753: break;
2754: case 125:
2755: if ((0x7e0000007eL & l) != 0L)
2756: jjCheckNAddStates(429, 433);
2757: break;
2758: case 126:
2759: if ((0x7e0000007eL & l) != 0L)
2760: jjCheckNAddStates(434, 439);
2761: break;
2762: case 127:
2763: if ((0x7e0000007eL & l) != 0L)
2764: jjCheckNAddStates(440, 446);
2765: break;
2766: case 128:
2767: if ((0x7fffffe87fffffeL & l) != 0L)
2768: jjCheckNAddStates(0, 2);
2769: break;
2770: case 130:
2771: if (curChar == 92)
2772: jjCheckNAddTwoStates(131, 132);
2773: break;
2774: case 131:
2775: if ((0x7fffffffffffffffL & l) != 0L)
2776: jjCheckNAddStates(0, 2);
2777: break;
2778: case 132:
2779: if ((0x7e0000007eL & l) != 0L)
2780: jjCheckNAddStates(447, 451);
2781: break;
2782: case 134:
2783: if ((0x7e0000007eL & l) != 0L)
2784: jjCheckNAddStates(452, 459);
2785: break;
2786: case 135:
2787: if ((0x7e0000007eL & l) != 0L)
2788: jjCheckNAddStates(460, 463);
2789: break;
2790: case 136:
2791: if ((0x7e0000007eL & l) != 0L)
2792: jjCheckNAddStates(464, 468);
2793: break;
2794: case 137:
2795: if ((0x7e0000007eL & l) != 0L)
2796: jjCheckNAddStates(469, 474);
2797: break;
2798: case 138:
2799: if ((0x7e0000007eL & l) != 0L)
2800: jjCheckNAddStates(475, 481);
2801: break;
2802: case 144:
2803: if ((0x10000000100000L & l) != 0L && kind > 42)
2804: kind = 42;
2805: break;
2806: case 145:
2807: if ((0x1000000010000L & l) != 0L)
2808: jjstateSet[jjnewStateCnt++] = 144;
2809: break;
2810: case 147:
2811: if ((0x200000002000L & l) != 0L && kind > 43)
2812: kind = 43;
2813: break;
2814: case 148:
2815: if ((0x200000002000L & l) != 0L)
2816: jjstateSet[jjnewStateCnt++] = 147;
2817: break;
2818: case 150:
2819: if ((0x200000002000L & l) != 0L && kind > 44)
2820: kind = 44;
2821: break;
2822: case 151:
2823: if ((0x800000008L & l) != 0L)
2824: jjstateSet[jjnewStateCnt++] = 150;
2825: break;
2826: case 153:
2827: if ((0x800000008L & l) != 0L && kind > 45)
2828: kind = 45;
2829: break;
2830: case 154:
2831: if ((0x1000000010000L & l) != 0L)
2832: jjstateSet[jjnewStateCnt++] = 153;
2833: break;
2834: case 156:
2835: if ((0x400000004000L & l) != 0L && kind > 46)
2836: kind = 46;
2837: break;
2838: case 157:
2839: if ((0x20000000200L & l) != 0L)
2840: jjstateSet[jjnewStateCnt++] = 156;
2841: break;
2842: case 159:
2843: if ((0x100000001000000L & l) != 0L && kind > 47)
2844: kind = 47;
2845: break;
2846: case 160:
2847: if ((0x1000000010000L & l) != 0L)
2848: jjstateSet[jjnewStateCnt++] = 159;
2849: break;
2850: case 162:
2851: if ((0x200000002000L & l) != 0L && kind > 48)
2852: kind = 48;
2853: break;
2854: case 163:
2855: if ((0x2000000020L & l) != 0L)
2856: jjstateSet[jjnewStateCnt++] = 162;
2857: break;
2858: case 165:
2859: if ((0x100000001000000L & l) != 0L && kind > 49)
2860: kind = 49;
2861: break;
2862: case 166:
2863: if ((0x2000000020L & l) != 0L)
2864: jjstateSet[jjnewStateCnt++] = 165;
2865: break;
2866: case 168:
2867: if ((0x8000000080L & l) != 0L && kind > 50)
2868: kind = 50;
2869: break;
2870: case 169:
2871: if ((0x2000000020L & l) != 0L)
2872: jjstateSet[jjnewStateCnt++] = 168;
2873: break;
2874: case 170:
2875: if ((0x1000000010L & l) != 0L)
2876: jjstateSet[jjnewStateCnt++] = 169;
2877: break;
2878: case 172:
2879: if ((0x1000000010L & l) != 0L && kind > 51)
2880: kind = 51;
2881: break;
2882: case 173:
2883: if ((0x200000002L & l) != 0L)
2884: jjstateSet[jjnewStateCnt++] = 172;
2885: break;
2886: case 174:
2887: if ((0x4000000040000L & l) != 0L)
2888: jjstateSet[jjnewStateCnt++] = 173;
2889: break;
2890: case 176:
2891: if ((0x1000000010L & l) != 0L && kind > 52)
2892: kind = 52;
2893: break;
2894: case 177:
2895: if ((0x200000002L & l) != 0L)
2896: jjstateSet[jjnewStateCnt++] = 176;
2897: break;
2898: case 178:
2899: if ((0x4000000040000L & l) != 0L)
2900: jjstateSet[jjnewStateCnt++] = 177;
2901: break;
2902: case 179:
2903: if ((0x8000000080L & l) != 0L)
2904: jjstateSet[jjnewStateCnt++] = 178;
2905: break;
2906: case 181:
2907: if ((0x8000000080000L & l) != 0L && kind > 53)
2908: kind = 53;
2909: break;
2910: case 182:
2911: if ((0x200000002000L & l) != 0L)
2912: jjstateSet[jjnewStateCnt++] = 181;
2913: break;
2914: case 184:
2915: if ((0x8000000080000L & l) != 0L && kind > 54)
2916: kind = 54;
2917: break;
2918: case 186:
2919: if ((0x400000004000000L & l) != 0L && kind > 55)
2920: kind = 55;
2921: break;
2922: case 187:
2923: if ((0x10000000100L & l) != 0L)
2924: jjstateSet[jjnewStateCnt++] = 186;
2925: break;
2926: case 189:
2927: if ((0x400000004000000L & l) != 0L && kind > 56)
2928: kind = 56;
2929: break;
2930: case 190:
2931: if ((0x10000000100L & l) != 0L)
2932: jjstateSet[jjnewStateCnt++] = 189;
2933: break;
2934: case 191:
2935: if ((0x80000000800L & l) != 0L)
2936: jjstateSet[jjnewStateCnt++] = 190;
2937: break;
2938: case 193:
2939: case 194:
2940: if ((0x7fffffe87fffffeL & l) == 0L)
2941: break;
2942: if (kind > 57)
2943: kind = 57;
2944: jjCheckNAddTwoStates(194, 195);
2945: break;
2946: case 195:
2947: if (curChar == 92)
2948: jjCheckNAddTwoStates(196, 197);
2949: break;
2950: case 196:
2951: if ((0x7fffffffffffffffL & l) == 0L)
2952: break;
2953: if (kind > 57)
2954: kind = 57;
2955: jjCheckNAddTwoStates(194, 195);
2956: break;
2957: case 197:
2958: if ((0x7e0000007eL & l) == 0L)
2959: break;
2960: if (kind > 57)
2961: kind = 57;
2962: jjCheckNAddStates(482, 485);
2963: break;
2964: case 199:
2965: if ((0x7e0000007eL & l) == 0L)
2966: break;
2967: if (kind > 57)
2968: kind = 57;
2969: jjCheckNAddStates(486, 492);
2970: break;
2971: case 200:
2972: if ((0x7e0000007eL & l) == 0L)
2973: break;
2974: if (kind > 57)
2975: kind = 57;
2976: jjCheckNAddStates(493, 495);
2977: break;
2978: case 201:
2979: if ((0x7e0000007eL & l) == 0L)
2980: break;
2981: if (kind > 57)
2982: kind = 57;
2983: jjCheckNAddStates(496, 499);
2984: break;
2985: case 202:
2986: if ((0x7e0000007eL & l) == 0L)
2987: break;
2988: if (kind > 57)
2989: kind = 57;
2990: jjCheckNAddStates(500, 504);
2991: break;
2992: case 203:
2993: if ((0x7e0000007eL & l) == 0L)
2994: break;
2995: if (kind > 57)
2996: kind = 57;
2997: jjCheckNAddStates(505, 510);
2998: break;
2999: case 204:
3000: if (curChar == 92)
3001: jjCheckNAddTwoStates(196, 205);
3002: break;
3003: case 205:
3004: if ((0x7e0000007eL & l) == 0L)
3005: break;
3006: if (kind > 57)
3007: kind = 57;
3008: jjCheckNAddStates(511, 514);
3009: break;
3010: case 206:
3011: if ((0x7e0000007eL & l) == 0L)
3012: break;
3013: if (kind > 57)
3014: kind = 57;
3015: jjCheckNAddStates(515, 521);
3016: break;
3017: case 207:
3018: if ((0x7e0000007eL & l) == 0L)
3019: break;
3020: if (kind > 57)
3021: kind = 57;
3022: jjCheckNAddStates(522, 524);
3023: break;
3024: case 208:
3025: if ((0x7e0000007eL & l) == 0L)
3026: break;
3027: if (kind > 57)
3028: kind = 57;
3029: jjCheckNAddStates(525, 528);
3030: break;
3031: case 209:
3032: if ((0x7e0000007eL & l) == 0L)
3033: break;
3034: if (kind > 57)
3035: kind = 57;
3036: jjCheckNAddStates(529, 533);
3037: break;
3038: case 210:
3039: if ((0x7e0000007eL & l) == 0L)
3040: break;
3041: if (kind > 57)
3042: kind = 57;
3043: jjCheckNAddStates(534, 539);
3044: break;
3045: case 211:
3046: if ((0x20000000200000L & l) != 0L)
3047: jjAddStates(875, 877);
3048: break;
3049: case 213:
3050: case 217:
3051: if ((0x7fffffffffffffffL & l) != 0L)
3052: jjCheckNAddStates(546, 549);
3053: break;
3054: case 216:
3055: if (curChar == 92)
3056: jjAddStates(892, 893);
3057: break;
3058: case 218:
3059: if ((0x7e0000007eL & l) != 0L)
3060: jjCheckNAddStates(550, 554);
3061: break;
3062: case 220:
3063: if ((0x7e0000007eL & l) != 0L)
3064: jjCheckNAddStates(555, 562);
3065: break;
3066: case 221:
3067: if ((0x7e0000007eL & l) != 0L)
3068: jjCheckNAddStates(563, 566);
3069: break;
3070: case 222:
3071: if ((0x7e0000007eL & l) != 0L)
3072: jjCheckNAddStates(567, 571);
3073: break;
3074: case 223:
3075: if ((0x7e0000007eL & l) != 0L)
3076: jjCheckNAddStates(572, 577);
3077: break;
3078: case 224:
3079: if ((0x7e0000007eL & l) != 0L)
3080: jjCheckNAddStates(578, 584);
3081: break;
3082: case 226:
3083: case 231:
3084: if ((0x7fffffffffffffffL & l) != 0L)
3085: jjCheckNAddStates(585, 588);
3086: break;
3087: case 228:
3088: if (curChar == 92)
3089: jjAddStates(894, 897);
3090: break;
3091: case 230:
3092: if (curChar == 92)
3093: jjAddStates(898, 899);
3094: break;
3095: case 232:
3096: if ((0x7e0000007eL & l) != 0L)
3097: jjCheckNAddStates(589, 594);
3098: break;
3099: case 234:
3100: if ((0x7e0000007eL & l) != 0L)
3101: jjCheckNAddStates(595, 603);
3102: break;
3103: case 235:
3104: if ((0x7e0000007eL & l) != 0L)
3105: jjCheckNAddStates(604, 608);
3106: break;
3107: case 236:
3108: if ((0x7e0000007eL & l) != 0L)
3109: jjCheckNAddStates(609, 614);
3110: break;
3111: case 237:
3112: if ((0x7e0000007eL & l) != 0L)
3113: jjCheckNAddStates(615, 621);
3114: break;
3115: case 238:
3116: if ((0x7e0000007eL & l) != 0L)
3117: jjCheckNAddStates(622, 629);
3118: break;
3119: case 243:
3120: case 248:
3121: if ((0x7fffffffffffffffL & l) != 0L)
3122: jjCheckNAddStates(630, 633);
3123: break;
3124: case 245:
3125: if (curChar == 92)
3126: jjAddStates(900, 903);
3127: break;
3128: case 247:
3129: if (curChar == 92)
3130: jjAddStates(904, 905);
3131: break;
3132: case 249:
3133: if ((0x7e0000007eL & l) != 0L)
3134: jjCheckNAddStates(634, 639);
3135: break;
3136: case 251:
3137: if ((0x7e0000007eL & l) != 0L)
3138: jjCheckNAddStates(640, 648);
3139: break;
3140: case 252:
3141: if ((0x7e0000007eL & l) != 0L)
3142: jjCheckNAddStates(649, 653);
3143: break;
3144: case 253:
3145: if ((0x7e0000007eL & l) != 0L)
3146: jjCheckNAddStates(654, 659);
3147: break;
3148: case 254:
3149: if ((0x7e0000007eL & l) != 0L)
3150: jjCheckNAddStates(660, 666);
3151: break;
3152: case 255:
3153: if ((0x7e0000007eL & l) != 0L)
3154: jjCheckNAddStates(667, 674);
3155: break;
3156: case 260:
3157: if ((0x100000001000L & l) != 0L)
3158: jjstateSet[jjnewStateCnt++] = 212;
3159: break;
3160: case 261:
3161: if ((0x4000000040000L & l) != 0L)
3162: jjstateSet[jjnewStateCnt++] = 260;
3163: break;
3164: case 269:
3165: if ((0x7e0000007eL & l) == 0L)
3166: break;
3167: if (kind > 76)
3168: kind = 76;
3169: jjAddStates(691, 696);
3170: break;
3171: case 270:
3172: if ((0x7e0000007eL & l) != 0L)
3173: jjstateSet[jjnewStateCnt++] = 271;
3174: break;
3175: case 271:
3176: if ((0x7e0000007eL & l) != 0L)
3177: jjstateSet[jjnewStateCnt++] = 272;
3178: break;
3179: case 272:
3180: if ((0x7e0000007eL & l) != 0L)
3181: jjCheckNAdd(273);
3182: break;
3183: case 273:
3184: if ((0x7e0000007eL & l) != 0L && kind > 76)
3185: kind = 76;
3186: break;
3187: case 274:
3188: if ((0x7e0000007eL & l) != 0L)
3189: jjstateSet[jjnewStateCnt++] = 275;
3190: break;
3191: case 275:
3192: if ((0x7e0000007eL & l) != 0L)
3193: jjstateSet[jjnewStateCnt++] = 276;
3194: break;
3195: case 276:
3196: if ((0x7e0000007eL & l) != 0L)
3197: jjstateSet[jjnewStateCnt++] = 277;
3198: break;
3199: case 277:
3200: if ((0x7e0000007eL & l) == 0L)
3201: break;
3202: if (kind > 76)
3203: kind = 76;
3204: jjstateSet[jjnewStateCnt++] = 265;
3205: break;
3206: case 278:
3207: if ((0x7e0000007eL & l) != 0L)
3208: jjstateSet[jjnewStateCnt++] = 279;
3209: break;
3210: case 279:
3211: if ((0x7e0000007eL & l) != 0L)
3212: jjstateSet[jjnewStateCnt++] = 280;
3213: break;
3214: case 280:
3215: if ((0x7e0000007eL & l) == 0L)
3216: break;
3217: if (kind > 76)
3218: kind = 76;
3219: jjstateSet[jjnewStateCnt++] = 281;
3220: break;
3221: case 282:
3222: if ((0x7e0000007eL & l) != 0L)
3223: jjstateSet[jjnewStateCnt++] = 283;
3224: break;
3225: case 283:
3226: if ((0x7e0000007eL & l) == 0L)
3227: break;
3228: if (kind > 76)
3229: kind = 76;
3230: jjstateSet[jjnewStateCnt++] = 284;
3231: break;
3232: case 286:
3233: if ((0x7e0000007eL & l) == 0L)
3234: break;
3235: if (kind > 76)
3236: kind = 76;
3237: jjstateSet[jjnewStateCnt++] = 287;
3238: break;
3239: case 295:
3240: if ((0x7e0000007eL & l) != 0L)
3241: jjCheckNAddTwoStates(296, 302);
3242: break;
3243: case 297:
3244: if ((0x7e0000007eL & l) == 0L)
3245: break;
3246: if (kind > 76)
3247: kind = 76;
3248: jjstateSet[jjnewStateCnt++] = 298;
3249: break;
3250: case 298:
3251: if ((0x7e0000007eL & l) == 0L)
3252: break;
3253: if (kind > 76)
3254: kind = 76;
3255: jjCheckNAddStates(707, 710);
3256: break;
3257: case 299:
3258: if ((0x7e0000007eL & l) == 0L)
3259: break;
3260: if (kind > 76)
3261: kind = 76;
3262: jjCheckNAdd(273);
3263: break;
3264: case 300:
3265: if ((0x7e0000007eL & l) == 0L)
3266: break;
3267: if (kind > 76)
3268: kind = 76;
3269: jjCheckNAddTwoStates(273, 299);
3270: break;
3271: case 301:
3272: if ((0x7e0000007eL & l) == 0L)
3273: break;
3274: if (kind > 76)
3275: kind = 76;
3276: jjCheckNAddStates(711, 713);
3277: break;
3278: case 302:
3279: if ((0x7e0000007eL & l) != 0L)
3280: jjCheckNAddStates(714, 718);
3281: break;
3282: case 303:
3283: if ((0x7e0000007eL & l) != 0L)
3284: jjCheckNAdd(296);
3285: break;
3286: case 304:
3287: if ((0x7e0000007eL & l) != 0L)
3288: jjCheckNAddTwoStates(303, 296);
3289: break;
3290: case 305:
3291: if ((0x7e0000007eL & l) != 0L)
3292: jjCheckNAddStates(719, 721);
3293: break;
3294: case 306:
3295: if ((0x7e0000007eL & l) != 0L)
3296: jjCheckNAddStates(722, 725);
3297: break;
3298: case 307:
3299: if (curChar == 92)
3300: jjCheckNAddStates(865, 872);
3301: break;
3302: case 308:
3303: if ((0x7e0000007eL & l) == 0L)
3304: break;
3305: if (kind > 36)
3306: kind = 36;
3307: jjCheckNAddStates(726, 729);
3308: break;
3309: case 309:
3310: if ((0x7e0000007eL & l) == 0L)
3311: break;
3312: if (kind > 36)
3313: kind = 36;
3314: jjCheckNAddStates(730, 736);
3315: break;
3316: case 310:
3317: if ((0x7e0000007eL & l) == 0L)
3318: break;
3319: if (kind > 36)
3320: kind = 36;
3321: jjCheckNAddStates(737, 739);
3322: break;
3323: case 311:
3324: if ((0x7e0000007eL & l) == 0L)
3325: break;
3326: if (kind > 36)
3327: kind = 36;
3328: jjCheckNAddStates(740, 743);
3329: break;
3330: case 312:
3331: if ((0x7e0000007eL & l) == 0L)
3332: break;
3333: if (kind > 36)
3334: kind = 36;
3335: jjCheckNAddStates(744, 748);
3336: break;
3337: case 313:
3338: if ((0x7e0000007eL & l) == 0L)
3339: break;
3340: if (kind > 36)
3341: kind = 36;
3342: jjCheckNAddStates(749, 754);
3343: break;
3344: case 314:
3345: if ((0x7e0000007eL & l) != 0L)
3346: jjCheckNAddStates(755, 759);
3347: break;
3348: case 315:
3349: if ((0x7e0000007eL & l) != 0L)
3350: jjCheckNAddStates(760, 767);
3351: break;
3352: case 316:
3353: if ((0x7e0000007eL & l) != 0L)
3354: jjCheckNAddStates(768, 771);
3355: break;
3356: case 317:
3357: if ((0x7e0000007eL & l) != 0L)
3358: jjCheckNAddStates(772, 776);
3359: break;
3360: case 318:
3361: if ((0x7e0000007eL & l) != 0L)
3362: jjCheckNAddStates(777, 782);
3363: break;
3364: case 319:
3365: if ((0x7e0000007eL & l) != 0L)
3366: jjCheckNAddStates(783, 789);
3367: break;
3368: case 320:
3369: if ((0x7e0000007eL & l) != 0L)
3370: jjCheckNAddStates(790, 794);
3371: break;
3372: case 321:
3373: if ((0x7e0000007eL & l) != 0L)
3374: jjCheckNAddStates(795, 802);
3375: break;
3376: case 322:
3377: if ((0x7e0000007eL & l) != 0L)
3378: jjCheckNAddStates(803, 806);
3379: break;
3380: case 323:
3381: if ((0x7e0000007eL & l) != 0L)
3382: jjCheckNAddStates(807, 811);
3383: break;
3384: case 324:
3385: if ((0x7e0000007eL & l) != 0L)
3386: jjCheckNAddStates(812, 817);
3387: break;
3388: case 325:
3389: if ((0x7e0000007eL & l) != 0L)
3390: jjCheckNAddStates(818, 824);
3391: break;
3392: case 326:
3393: if ((0x7e0000007eL & l) != 0L)
3394: jjCheckNAddStates(825, 829);
3395: break;
3396: case 327:
3397: if ((0x7e0000007eL & l) != 0L)
3398: jjCheckNAddStates(830, 837);
3399: break;
3400: case 328:
3401: if ((0x7e0000007eL & l) != 0L)
3402: jjCheckNAddStates(838, 841);
3403: break;
3404: case 329:
3405: if ((0x7e0000007eL & l) != 0L)
3406: jjCheckNAddStates(842, 846);
3407: break;
3408: case 330:
3409: if ((0x7e0000007eL & l) != 0L)
3410: jjCheckNAddStates(847, 852);
3411: break;
3412: case 331:
3413: if ((0x7e0000007eL & l) != 0L)
3414: jjCheckNAddStates(853, 859);
3415: break;
3416: default : break;
3417: }
3418: } while(i != startsAt);
3419: }
3420: else
3421: {
3422: int i2 = (curChar & 0xff) >> 6;
3423: long l2 = 1L << (curChar & 077);
3424: MatchLoop: do
3425: {
3426: switch(jjstateSet[--i])
3427: {
3428: case 388:
3429: if ((jjbitVec0[i2] & l2) != 0L)
3430: {
3431: if (kind > 36)
3432: kind = 36;
3433: jjCheckNAddTwoStates(78, 79);
3434: }
3435: if ((jjbitVec0[i2] & l2) != 0L)
3436: jjCheckNAddStates(6, 8);
3437: if ((jjbitVec0[i2] & l2) != 0L)
3438: jjCheckNAddStates(3, 5);
3439: if ((jjbitVec0[i2] & l2) != 0L)
3440: jjCheckNAddStates(0, 2);
3441: break;
3442: case 1:
3443: if ((jjbitVec0[i2] & l2) != 0L)
3444: {
3445: if (kind > 25)
3446: kind = 25;
3447: }
3448: if ((jjbitVec0[i2] & l2) != 0L)
3449: {
3450: if (kind > 36)
3451: kind = 36;
3452: jjCheckNAddStates(99, 109);
3453: }
3454: break;
3455: case 389:
3456: case 49:
3457: case 51:
3458: if ((jjbitVec0[i2] & l2) == 0L)
3459: break;
3460: if (kind > 65)
3461: kind = 65;
3462: jjCheckNAddTwoStates(49, 50);
3463: break;
3464: case 48:
3465: if ((jjbitVec0[i2] & l2) == 0L)
3466: break;
3467: if (kind > 65)
3468: kind = 65;
3469: jjCheckNAddTwoStates(49, 50);
3470: break;
3471: case 3:
3472: case 8:
3473: if ((jjbitVec0[i2] & l2) != 0L)
3474: jjCheckNAddStates(114, 117);
3475: break;
3476: case 20:
3477: case 25:
3478: if ((jjbitVec0[i2] & l2) != 0L)
3479: jjCheckNAddStates(110, 113);
3480: break;
3481: case 37:
3482: case 39:
3483: if ((jjbitVec0[i2] & l2) == 0L)
3484: break;
3485: if (kind > 58)
3486: kind = 58;
3487: jjCheckNAddTwoStates(37, 38);
3488: break;
3489: case 77:
3490: if ((jjbitVec0[i2] & l2) == 0L)
3491: break;
3492: if (kind > 36)
3493: kind = 36;
3494: jjCheckNAddStates(99, 109);
3495: break;
3496: case 78:
3497: case 80:
3498: if ((jjbitVec0[i2] & l2) == 0L)
3499: break;
3500: if (kind > 36)
3501: kind = 36;
3502: jjCheckNAddTwoStates(78, 79);
3503: break;
3504: case 88:
3505: case 91:
3506: if ((jjbitVec0[i2] & l2) != 0L)
3507: jjCheckNAddStates(6, 8);
3508: break;
3509: case 99:
3510: case 120:
3511: if ((jjbitVec0[i2] & l2) != 0L)
3512: jjCheckNAddStates(3, 5);
3513: break;
3514: case 101:
3515: case 102:
3516: case 104:
3517: if ((jjbitVec0[i2] & l2) == 0L)
3518: break;
3519: if (kind > 40)
3520: kind = 40;
3521: jjCheckNAddTwoStates(102, 103);
3522: break;
3523: case 128:
3524: case 131:
3525: if ((jjbitVec0[i2] & l2) != 0L)
3526: jjCheckNAddStates(0, 2);
3527: break;
3528: case 193:
3529: case 194:
3530: case 196:
3531: if ((jjbitVec0[i2] & l2) == 0L)
3532: break;
3533: if (kind > 57)
3534: kind = 57;
3535: jjCheckNAddTwoStates(194, 195);
3536: break;
3537: case 213:
3538: case 217:
3539: if ((jjbitVec0[i2] & l2) != 0L)
3540: jjCheckNAddStates(546, 549);
3541: break;
3542: case 226:
3543: case 231:
3544: if ((jjbitVec0[i2] & l2) != 0L)
3545: jjCheckNAddStates(585, 588);
3546: break;
3547: case 243:
3548: case 248:
3549: if ((jjbitVec0[i2] & l2) != 0L)
3550: jjCheckNAddStates(630, 633);
3551: break;
3552: default : break;
3553: }
3554: } while(i != startsAt);
3555: }
3556: if (kind != 0x7fffffff)
3557: {
3558: jjmatchedKind = kind;
3559: jjmatchedPos = curPos;
3560: kind = 0x7fffffff;
3561: }
3562: ++curPos;
3563: if ((i = jjnewStateCnt) == (startsAt = 387 - (jjnewStateCnt = startsAt)))
3564: return curPos;
3565: try { curChar = input_stream.readChar(); }
3566: catch(java.io.IOException e) { return curPos; }
3567: }
3568: }
3569: private final int jjMoveStringLiteralDfa0_1()
3570: {
3571: switch(curChar)
3572: {
3573: case 42:
3574: return jjMoveStringLiteralDfa1_1(0x8L);
3575: default :
3576: return 1;
3577: }
3578: }
3579: private final int jjMoveStringLiteralDfa1_1(long active0)
3580: {
3581: try { curChar = input_stream.readChar(); }
3582: catch(java.io.IOException e) {
3583: return 1;
3584: }
3585: switch(curChar)
3586: {
3587: case 47:
3588: if ((active0 & 0x8L) != 0L)
3589: return jjStopAtPos(1, 3);
3590: break;
3591: default :
3592: return 2;
3593: }
3594: return 2;
3595: }
3596: static final int[] jjnextStates = {
3597: 128, 129, 130, 99, 100, 119, 88, 89, 90, 333, 334, 335, 336, 337, 338, 142,
3598: 339, 340, 341, 145, 342, 343, 344, 148, 345, 346, 347, 151, 348, 349, 350, 154,
3599: 351, 352, 353, 157, 354, 355, 356, 160, 357, 358, 359, 163, 360, 361, 362, 166,
3600: 363, 364, 365, 170, 366, 367, 368, 174, 369, 370, 371, 179, 372, 373, 374, 182,
3601: 375, 376, 377, 184, 378, 379, 380, 187, 381, 382, 383, 191, 384, 385, 386, 193,
3602: 204, 140, 141, 143, 146, 149, 152, 155, 158, 161, 164, 167, 171, 175, 180, 183,
3603: 185, 188, 192, 78, 88, 89, 99, 100, 128, 129, 130, 119, 90, 79, 20, 21,
3604: 22, 24, 3, 4, 5, 7, 192, 193, 204, 3, 10, 4, 5, 7, 11, 3,
3605: 12, 10, 4, 5, 7, 13, 14, 15, 3, 10, 4, 5, 7, 3, 12, 10,
3606: 4, 5, 7, 3, 12, 10, 4, 5, 7, 13, 3, 12, 10, 4, 5, 7,
3607: 13, 14, 20, 27, 21, 22, 24, 28, 20, 29, 27, 21, 22, 24, 30, 31,
3608: 32, 20, 27, 21, 22, 24, 20, 29, 27, 21, 22, 24, 20, 29, 27, 21,
3609: 22, 24, 30, 20, 29, 27, 21, 22, 24, 30, 31, 37, 41, 38, 42, 37,
3610: 43, 41, 38, 44, 45, 46, 37, 41, 38, 37, 43, 41, 38, 37, 43, 41,
3611: 38, 44, 37, 43, 41, 38, 44, 45, 49, 53, 50, 54, 49, 55, 53, 50,
3612: 56, 57, 58, 49, 53, 50, 49, 55, 53, 50, 49, 55, 53, 50, 56, 49,
3613: 55, 53, 50, 56, 57, 53, 49, 50, 61, 62, 53, 49, 50, 63, 64, 65,
3614: 53, 49, 50, 62, 53, 49, 50, 62, 53, 49, 50, 63, 62, 53, 49, 50,
3615: 63, 64, 78, 82, 79, 83, 78, 84, 82, 79, 85, 86, 87, 78, 82, 79,
3616: 78, 84, 82, 79, 78, 84, 82, 79, 85, 78, 84, 82, 79, 85, 86, 88,
3617: 93, 89, 90, 94, 88, 95, 93, 89, 90, 96, 97, 98, 88, 93, 89, 90,
3618: 88, 95, 93, 89, 90, 88, 95, 93, 89, 90, 96, 88, 95, 93, 89, 90,
3619: 96, 97, 102, 106, 103, 107, 102, 108, 106, 103, 109, 110, 111, 102, 106, 103,
3620: 102, 108, 106, 103, 102, 108, 106, 103, 109, 102, 108, 106, 103, 109, 110, 106,
3621: 102, 103, 114, 115, 106, 102, 103, 116, 117, 118, 106, 102, 103, 115, 106, 102,
3622: 103, 115, 106, 102, 103, 116, 115, 106, 102, 103, 116, 117, 99, 122, 100, 119,
3623: 123, 99, 124, 122, 100, 119, 125, 126, 127, 99, 122, 100, 119, 99, 124, 122,
3624: 100, 119, 99, 124, 122, 100, 119, 125, 99, 124, 122, 100, 119, 125, 126, 128,
3625: 133, 129, 130, 134, 128, 135, 133, 129, 130, 136, 137, 138, 128, 133, 129, 130,
3626: 128, 135, 133, 129, 130, 128, 135, 133, 129, 130, 136, 128, 135, 133, 129, 130,
3627: 136, 137, 194, 198, 195, 199, 194, 200, 198, 195, 201, 202, 203, 194, 198, 195,
3628: 194, 200, 198, 195, 194, 200, 198, 195, 201, 194, 200, 198, 195, 201, 202, 198,
3629: 194, 195, 206, 207, 198, 194, 195, 208, 209, 210, 198, 194, 195, 207, 198, 194,
3630: 195, 207, 198, 194, 195, 208, 207, 198, 194, 195, 208, 209, 213, 225, 242, 215,
3631: 216, 259, 213, 214, 215, 216, 213, 215, 216, 219, 220, 213, 221, 215, 216, 219,
3632: 222, 223, 224, 213, 215, 216, 219, 213, 221, 215, 216, 219, 213, 221, 215, 216,
3633: 219, 222, 213, 221, 215, 216, 219, 222, 223, 226, 227, 228, 230, 226, 233, 227,
3634: 228, 230, 234, 226, 235, 233, 227, 228, 230, 236, 237, 238, 226, 233, 227, 228,
3635: 230, 226, 235, 233, 227, 228, 230, 226, 235, 233, 227, 228, 230, 236, 226, 235,
3636: 233, 227, 228, 230, 236, 237, 243, 244, 245, 247, 243, 250, 244, 245, 247, 251,
3637: 243, 252, 250, 244, 245, 247, 253, 254, 255, 243, 250, 244, 245, 247, 243, 252,
3638: 250, 244, 245, 247, 243, 252, 250, 244, 245, 247, 253, 243, 252, 250, 244, 245,
3639: 247, 253, 254, 213, 225, 242, 214, 215, 216, 259, 263, 269, 265, 266, 267, 268,
3640: 265, 266, 267, 270, 274, 278, 282, 286, 290, 265, 288, 289, 265, 291, 292, 293,
3641: 265, 291, 292, 273, 299, 300, 301, 273, 299, 300, 303, 296, 304, 305, 306, 303,
3642: 296, 304, 303, 296, 304, 305, 82, 78, 79, 309, 310, 82, 78, 79, 311, 312,
3643: 313, 82, 78, 79, 310, 82, 78, 79, 310, 82, 78, 79, 311, 310, 82, 78,
3644: 79, 311, 312, 93, 88, 89, 90, 315, 316, 93, 88, 89, 90, 317, 318, 319,
3645: 93, 88, 89, 90, 316, 93, 88, 89, 90, 316, 93, 88, 89, 90, 317, 316,
3646: 93, 88, 89, 90, 317, 318, 122, 99, 100, 119, 321, 322, 122, 99, 100, 119,
3647: 323, 324, 325, 122, 99, 100, 119, 322, 122, 99, 100, 119, 322, 122, 99, 100,
3648: 119, 323, 322, 122, 99, 100, 119, 323, 324, 133, 128, 129, 130, 327, 328, 133,
3649: 128, 129, 130, 329, 330, 331, 133, 128, 129, 130, 328, 133, 128, 129, 130, 328,
3650: 133, 128, 129, 130, 329, 328, 133, 128, 129, 130, 329, 330, 384, 193, 204, 101,
3651: 112, 80, 308, 91, 314, 120, 320, 131, 326, 48, 59, 261, 262, 294, 6, 16,
3652: 18, 17, 8, 9, 23, 33, 35, 34, 25, 26, 39, 40, 217, 218, 229, 239,
3653: 241, 240, 231, 232, 246, 256, 258, 257, 248, 249,
3654: };
3655: public static final String[] jjstrLiteralImages = {
3656: "", null, null, null, null, "\74\41\55\55", "\55\55\76", "\173", "\175",
3657: "\174\75", "\176\75", "\75", "\53", "\55", "\54", "\73", "\76", "\57", "\133", "\135",
3658: "\52", "\56", "\51", "\50", "\72", null, null, null, null, null, null, null, null,
3659: null, null, null, null, null, null, null, null, null, null, null, null, null, null,
3660: null, null, null, null, null, null, null, null, null, null, null, null, null, null,
3661: null, null, null, null, null, null, null, null, null, null, null, null, null, null,
3662: null, null, null, null, };
3663: public static final String[] lexStateNames = {
3664: "DEFAULT",
3665: "IN_COMMENT",
3666: };
3667: public static final int[] jjnewLexState = {
3668: -1, -1, 1, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3669: -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,
3670: -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,
3671: -1, -1, -1, -1,
3672: };
3673: static final long[] jjtoToken = {
3674: 0xffffffb803ffffe3L, 0x7007L,
3675: };
3676: static final long[] jjtoSkip = {
3677: 0x8L, 0x0L,
3678: };
3679: static final long[] jjtoMore = {
3680: 0x14L, 0x0L,
3681: };
3682: protected CharStream input_stream;
3683: private final int[] jjrounds = new int[387];
3684: private final int[] jjstateSet = new int[774];
3685: StringBuffer image;
3686: int jjimageLen;
3687: int lengthOfMatch;
3688: protected char curChar;
3689: public ParserTokenManager(CharStream stream){
3690: input_stream = stream;
3691: }
3692: public ParserTokenManager(CharStream stream, int lexState){
3693: this(stream);
3694: SwitchTo(lexState);
3695: }
3696: public void ReInit(CharStream stream)
3697: {
3698: jjmatchedPos = jjnewStateCnt = 0;
3699: curLexState = defaultLexState;
3700: input_stream = stream;
3701: ReInitRounds();
3702: }
3703: private final void ReInitRounds()
3704: {
3705: int i;
3706: jjround = 0x80000001;
3707: for (i = 387; i-- > 0;)
3708: jjrounds[i] = 0x80000000;
3709: }
3710: public void ReInit(CharStream stream, int lexState)
3711: {
3712: ReInit(stream);
3713: SwitchTo(lexState);
3714: }
3715: public void SwitchTo(int lexState)
3716: {
3717: if (lexState >= 2 || lexState < 0)
3718: throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
3719: else
3720: curLexState = lexState;
3721: }
3722:
3723: protected Token jjFillToken()
3724: {
3725: Token t = Token.newToken(jjmatchedKind);
3726: t.kind = jjmatchedKind;
3727: String im = jjstrLiteralImages[jjmatchedKind];
3728: t.image = (im == null) ? input_stream.GetImage() : im;
3729: t.beginLine = input_stream.getBeginLine();
3730: t.beginColumn = input_stream.getBeginColumn();
3731: t.endLine = input_stream.getEndLine();
3732: t.endColumn = input_stream.getEndColumn();
3733: return t;
3734: }
3735:
3736: int curLexState = 0;
3737: int defaultLexState = 0;
3738: int jjnewStateCnt;
3739: int jjround;
3740: int jjmatchedPos;
3741: int jjmatchedKind;
3742:
3743: public Token getNextToken()
3744: {
3745: int kind;
3746: Token specialToken = null;
3747: Token matchedToken;
3748: int curPos = 0;
3749:
3750: EOFLoop :
3751: for (;;)
3752: {
3753: try
3754: {
3755: curChar = input_stream.BeginToken();
3756: }
3757: catch(java.io.IOException e)
3758: {
3759: jjmatchedKind = 0;
3760: matchedToken = jjFillToken();
3761: return matchedToken;
3762: }
3763: image = null;
3764: jjimageLen = 0;
3765:
3766: for (;;)
3767: {
3768: switch(curLexState)
3769: {
3770: case 0:
3771: jjmatchedKind = 0x7fffffff;
3772: jjmatchedPos = 0;
3773: curPos = jjMoveStringLiteralDfa0_0();
3774: if (jjmatchedPos == 0 && jjmatchedKind > 78)
3775: {
3776: jjmatchedKind = 78;
3777: }
3778: break;
3779: case 1:
3780: jjmatchedKind = 0x7fffffff;
3781: jjmatchedPos = 0;
3782: curPos = jjMoveStringLiteralDfa0_1();
3783: if (jjmatchedPos == 0 && jjmatchedKind > 4)
3784: {
3785: jjmatchedKind = 4;
3786: }
3787: break;
3788: }
3789: if (jjmatchedKind != 0x7fffffff)
3790: {
3791: if (jjmatchedPos + 1 < curPos)
3792: input_stream.backup(curPos - jjmatchedPos - 1);
3793: if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
3794: {
3795: matchedToken = jjFillToken();
3796: TokenLexicalActions(matchedToken);
3797: if (jjnewLexState[jjmatchedKind] != -1)
3798: curLexState = jjnewLexState[jjmatchedKind];
3799: return matchedToken;
3800: }
3801: else if ((jjtoSkip[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
3802: {
3803: if (jjnewLexState[jjmatchedKind] != -1)
3804: curLexState = jjnewLexState[jjmatchedKind];
3805: continue EOFLoop;
3806: }
3807: jjimageLen += jjmatchedPos + 1;
3808: if (jjnewLexState[jjmatchedKind] != -1)
3809: curLexState = jjnewLexState[jjmatchedKind];
3810: curPos = 0;
3811: jjmatchedKind = 0x7fffffff;
3812: try {
3813: curChar = input_stream.readChar();
3814: continue;
3815: }
3816: catch (java.io.IOException e1) { }
3817: }
3818: int error_line = input_stream.getEndLine();
3819: int error_column = input_stream.getEndColumn();
3820: String error_after = null;
3821: boolean EOFSeen = false;
3822: try { input_stream.readChar(); input_stream.backup(1); }
3823: catch (java.io.IOException e1) {
3824: EOFSeen = true;
3825: error_after = curPos <= 1 ? "" : input_stream.GetImage();
3826: if (curChar == '\n' || curChar == '\r') {
3827: error_line++;
3828: error_column = 0;
3829: }
3830: else
3831: error_column++;
3832: }
3833: if (!EOFSeen) {
3834: input_stream.backup(1);
3835: error_after = curPos <= 1 ? "" : input_stream.GetImage();
3836: }
3837: throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
3838: }
3839: }
3840: }
3841:
3842: void TokenLexicalActions(Token matchedToken)
3843: {
3844: switch(jjmatchedKind)
3845: {
3846: case 1 :
3847: if (image == null)
3848: image = new StringBuffer();
3849: image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3850: image = Parser.SPACE;
3851: break;
3852: default :
3853: break;
3854: }
3855: }
3856: }