Method: jjCheckNAdd(int)

1: /*
2: * Copyright (c) 2018, 2021 Oracle and/or its affiliates. All rights reserved.
3: *
4: * This program and the accompanying materials are made available under the
5: * terms of the Eclipse Public License v. 2.0, which is available at
6: * http://www.eclipse.org/legal/epl-2.0.
7: *
8: * This Source Code may also be made available under the following Secondary
9: * Licenses when the conditions for such availability set forth in the
10: * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
11: * version 2 with the GNU Classpath Exception, which is available at
12: * https://www.gnu.org/software/classpath/license.html.
13: *
14: * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
15: */
16:
17: /* Generated By:JJTree&JavaCC: Do not edit this line. ELParserTokenManager.java */
18: package com.sun.el.parser;
19:
20: /** Token Manager. */
21: public class ELParserTokenManager implements ELParserConstants
22: {
23: java.util.Stack<Integer> stack = new java.util.Stack<Integer>();
24:
25: /** Debug output. */
26: public java.io.PrintStream debugStream = System.out;
27: /** Set debug output. */
28: public void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
29: private final int jjStopStringLiteralDfa_0(int pos, long active0)
30: {
31: switch (pos)
32: {
33: case 0:
34: if ((active0 & 0x10L) != 0L)
35: return 2;
36: if ((active0 & 0xcL) != 0L)
37: {
38: jjmatchedKind = 1;
39: return 4;
40: }
41: return -1;
42: default :
43: return -1;
44: }
45: }
46: private final int jjStartNfa_0(int pos, long active0)
47: {
48: return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1);
49: }
50: private int jjStopAtPos(int pos, int kind)
51: {
52: jjmatchedKind = kind;
53: jjmatchedPos = pos;
54: return pos + 1;
55: }
56: private int jjMoveStringLiteralDfa0_0()
57: {
58: switch(curChar)
59: {
60: case 35:
61: return jjMoveStringLiteralDfa1_0(0x8L);
62: case 36:
63: return jjMoveStringLiteralDfa1_0(0x4L);
64: case 92:
65: return jjStartNfaWithStates_0(0, 4, 2);
66: default :
67: return jjMoveNfa_0(6, 0);
68: }
69: }
70: private int jjMoveStringLiteralDfa1_0(long active0)
71: {
72: try { curChar = input_stream.readChar(); }
73: catch(java.io.IOException e) {
74: jjStopStringLiteralDfa_0(0, active0);
75: return 1;
76: }
77: switch(curChar)
78: {
79: case 123:
80: if ((active0 & 0x4L) != 0L)
81: return jjStopAtPos(1, 2);
82: else if ((active0 & 0x8L) != 0L)
83: return jjStopAtPos(1, 3);
84: break;
85: default :
86: break;
87: }
88: return jjStartNfa_0(0, active0);
89: }
90: private int jjStartNfaWithStates_0(int pos, int kind, int state)
91: {
92: jjmatchedKind = kind;
93: jjmatchedPos = pos;
94: try { curChar = input_stream.readChar(); }
95: catch(java.io.IOException e) { return pos + 1; }
96: return jjMoveNfa_0(state, pos + 1);
97: }
98: static final long[] jjbitVec0 = {
99: 0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
100: };
101: static final long[] jjbitVec2 = {
102: 0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
103: };
104: private int jjMoveNfa_0(int startState, int curPos)
105: {
106: int startsAt = 0;
107: jjnewStateCnt = 7;
108: int i = 1;
109: jjstateSet[0] = startState;
110: int kind = 0x7fffffff;
111: for (;;)
112: {
113: if (++jjround == 0x7fffffff)
114: ReInitRounds();
115: if (curChar < 64)
116: {
117: long l = 1L << curChar;
118: do
119: {
120: switch(jjstateSet[--i])
121: {
122: case 6:
123: if ((0xffffffe7ffffffffL & l) != 0L)
124: {
125: if (kind > 1)
126: kind = 1;
127: jjCheckNAddStates(0, 3);
128: }
129: else if ((0x1800000000L & l) != 0L)
130: {
131: if (kind > 1)
132: kind = 1;
133: }
134: if (curChar == 35)
135: jjCheckNAdd(4);
136: else if (curChar == 36)
137: jjCheckNAdd(4);
138: break;
139: case 0:
140: case 4:
141: if ((0xffffffe7ffffffffL & l) == 0L)
142: break;
143: if (kind > 1)
144: kind = 1;
145: jjCheckNAddStates(0, 3);
146: break;
147: case 2:
148: if ((0x1800000000L & l) == 0L)
149: break;
150: if (kind > 1)
151: kind = 1;
152: jjCheckNAddStates(0, 3);
153: break;
154: case 3:
155: if (curChar == 36)
156: jjCheckNAdd(4);
157: break;
158: case 5:
159: if (curChar == 35)
160: jjCheckNAdd(4);
161: break;
162: default : break;
163: }
164: } while(i != startsAt);
165: }
166: else if (curChar < 128)
167: {
168: long l = 1L << (curChar & 077);
169: do
170: {
171: switch(jjstateSet[--i])
172: {
173: case 6:
174: if ((0xffffffffefffffffL & l) != 0L)
175: {
176: if (kind > 1)
177: kind = 1;
178: jjCheckNAddStates(0, 3);
179: }
180: else if (curChar == 92)
181: jjstateSet[jjnewStateCnt++] = 2;
182: break;
183: case 0:
184: if ((0xffffffffefffffffL & l) == 0L)
185: break;
186: if (kind > 1)
187: kind = 1;
188: jjCheckNAddStates(0, 3);
189: break;
190: case 1:
191: if (curChar == 92)
192: jjstateSet[jjnewStateCnt++] = 2;
193: break;
194: case 2:
195: if (curChar != 92)
196: break;
197: if (kind > 1)
198: kind = 1;
199: jjCheckNAddStates(0, 3);
200: break;
201: case 4:
202: if ((0xf7ffffffefffffffL & l) == 0L)
203: break;
204: if (kind > 1)
205: kind = 1;
206: jjCheckNAddStates(0, 3);
207: break;
208: default : break;
209: }
210: } while(i != startsAt);
211: }
212: else
213: {
214: int hiByte = (int)(curChar >> 8);
215: int i1 = hiByte >> 6;
216: long l1 = 1L << (hiByte & 077);
217: int i2 = (curChar & 0xff) >> 6;
218: long l2 = 1L << (curChar & 077);
219: do
220: {
221: switch(jjstateSet[--i])
222: {
223: case 6:
224: case 0:
225: case 4:
226: if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
227: break;
228: if (kind > 1)
229: kind = 1;
230: jjCheckNAddStates(0, 3);
231: break;
232: default : break;
233: }
234: } while(i != startsAt);
235: }
236: if (kind != 0x7fffffff)
237: {
238: jjmatchedKind = kind;
239: jjmatchedPos = curPos;
240: kind = 0x7fffffff;
241: }
242: ++curPos;
243: if ((i = jjnewStateCnt) == (startsAt = 7 - (jjnewStateCnt = startsAt)))
244: return curPos;
245: try { curChar = input_stream.readChar(); }
246: catch(java.io.IOException e) { return curPos; }
247: }
248: }
249: private final int jjStopStringLiteralDfa_2(int pos, long active0)
250: {
251: switch (pos)
252: {
253: case 0:
254: if ((active0 & 0x80000L) != 0L)
255: return 1;
256: if ((active0 & 0x50755550070000L) != 0L)
257: {
258: jjmatchedKind = 58;
259: return 6;
260: }
261: return -1;
262: case 1:
263: if ((active0 & 0x105550000000L) != 0L)
264: return 6;
265: if ((active0 & 0x50650000070000L) != 0L)
266: {
267: jjmatchedKind = 58;
268: jjmatchedPos = 1;
269: return 6;
270: }
271: return -1;
272: case 2:
273: if ((active0 & 0x50050000000000L) != 0L)
274: return 6;
275: if ((active0 & 0x600000070000L) != 0L)
276: {
277: jjmatchedKind = 58;
278: jjmatchedPos = 2;
279: return 6;
280: }
281: return -1;
282: case 3:
283: if ((active0 & 0x50000L) != 0L)
284: return 6;
285: if ((active0 & 0x600000020000L) != 0L)
286: {
287: jjmatchedKind = 58;
288: jjmatchedPos = 3;
289: return 6;
290: }
291: return -1;
292: case 4:
293: if ((active0 & 0x400000000000L) != 0L)
294: {
295: jjmatchedKind = 58;
296: jjmatchedPos = 4;
297: return 6;
298: }
299: if ((active0 & 0x200000020000L) != 0L)
300: return 6;
301: return -1;
302: case 5:
303: if ((active0 & 0x400000000000L) != 0L)
304: {
305: jjmatchedKind = 58;
306: jjmatchedPos = 5;
307: return 6;
308: }
309: return -1;
310: case 6:
311: if ((active0 & 0x400000000000L) != 0L)
312: {
313: jjmatchedKind = 58;
314: jjmatchedPos = 6;
315: return 6;
316: }
317: return -1;
318: case 7:
319: if ((active0 & 0x400000000000L) != 0L)
320: {
321: jjmatchedKind = 58;
322: jjmatchedPos = 7;
323: return 6;
324: }
325: return -1;
326: case 8:
327: if ((active0 & 0x400000000000L) != 0L)
328: {
329: jjmatchedKind = 58;
330: jjmatchedPos = 8;
331: return 6;
332: }
333: return -1;
334: default :
335: return -1;
336: }
337: }
338: private final int jjStartNfa_2(int pos, long active0)
339: {
340: return jjMoveNfa_2(jjStopStringLiteralDfa_2(pos, active0), pos + 1);
341: }
342: private int jjMoveStringLiteralDfa0_2()
343: {
344: switch(curChar)
345: {
346: case 33:
347: jjmatchedKind = 39;
348: return jjMoveStringLiteralDfa1_2(0x2000000000L);
349: case 37:
350: return jjStopAtPos(0, 53);
351: case 38:
352: return jjMoveStringLiteralDfa1_2(0x20000000000L);
353: case 40:
354: return jjStopAtPos(0, 20);
355: case 41:
356: return jjStopAtPos(0, 21);
357: case 42:
358: return jjStopAtPos(0, 47);
359: case 43:
360: jjmatchedKind = 48;
361: return jjMoveStringLiteralDfa1_2(0x80000000000000L);
362: case 44:
363: return jjStopAtPos(0, 25);
364: case 45:
365: jjmatchedKind = 49;
366: return jjMoveStringLiteralDfa1_2(0x200000000000000L);
367: case 46:
368: return jjStartNfaWithStates_2(0, 19, 1);
369: case 47:
370: return jjStopAtPos(0, 51);
371: case 58:
372: return jjStopAtPos(0, 24);
373: case 59:
374: return jjStopAtPos(0, 26);
375: case 60:
376: jjmatchedKind = 29;
377: return jjMoveStringLiteralDfa1_2(0x200000000L);
378: case 61:
379: jjmatchedKind = 56;
380: return jjMoveStringLiteralDfa1_2(0x800000000L);
381: case 62:
382: jjmatchedKind = 27;
383: return jjMoveStringLiteralDfa1_2(0x80000000L);
384: case 63:
385: return jjStopAtPos(0, 50);
386: case 91:
387: return jjStopAtPos(0, 22);
388: case 93:
389: return jjStopAtPos(0, 23);
390: case 97:
391: return jjMoveStringLiteralDfa1_2(0x40000000000L);
392: case 100:
393: return jjMoveStringLiteralDfa1_2(0x10000000000000L);
394: case 101:
395: return jjMoveStringLiteralDfa1_2(0x201000000000L);
396: case 102:
397: return jjMoveStringLiteralDfa1_2(0x20000L);
398: case 103:
399: return jjMoveStringLiteralDfa1_2(0x110000000L);
400: case 105:
401: return jjMoveStringLiteralDfa1_2(0x400000000000L);
402: case 108:
403: return jjMoveStringLiteralDfa1_2(0x440000000L);
404: case 109:
405: return jjMoveStringLiteralDfa1_2(0x40000000000000L);
406: case 110:
407: return jjMoveStringLiteralDfa1_2(0x14000040000L);
408: case 111:
409: return jjMoveStringLiteralDfa1_2(0x100000000000L);
410: case 116:
411: return jjMoveStringLiteralDfa1_2(0x10000L);
412: case 123:
413: return jjStopAtPos(0, 9);
414: case 124:
415: return jjMoveStringLiteralDfa1_2(0x80000000000L);
416: case 125:
417: return jjStopAtPos(0, 10);
418: default :
419: return jjMoveNfa_2(0, 0);
420: }
421: }
422: private int jjMoveStringLiteralDfa1_2(long active0)
423: {
424: try { curChar = input_stream.readChar(); }
425: catch(java.io.IOException e) {
426: jjStopStringLiteralDfa_2(0, active0);
427: return 1;
428: }
429: switch(curChar)
430: {
431: case 38:
432: if ((active0 & 0x20000000000L) != 0L)
433: return jjStopAtPos(1, 41);
434: break;
435: case 61:
436: if ((active0 & 0x80000000L) != 0L)
437: return jjStopAtPos(1, 31);
438: else if ((active0 & 0x200000000L) != 0L)
439: return jjStopAtPos(1, 33);
440: else if ((active0 & 0x800000000L) != 0L)
441: return jjStopAtPos(1, 35);
442: else if ((active0 & 0x2000000000L) != 0L)
443: return jjStopAtPos(1, 37);
444: else if ((active0 & 0x80000000000000L) != 0L)
445: return jjStopAtPos(1, 55);
446: break;
447: case 62:
448: if ((active0 & 0x200000000000000L) != 0L)
449: return jjStopAtPos(1, 57);
450: break;
451: case 97:
452: return jjMoveStringLiteralDfa2_2(active0, 0x20000L);
453: case 101:
454: if ((active0 & 0x100000000L) != 0L)
455: return jjStartNfaWithStates_2(1, 32, 6);
456: else if ((active0 & 0x400000000L) != 0L)
457: return jjStartNfaWithStates_2(1, 34, 6);
458: else if ((active0 & 0x4000000000L) != 0L)
459: return jjStartNfaWithStates_2(1, 38, 6);
460: break;
461: case 105:
462: return jjMoveStringLiteralDfa2_2(active0, 0x10000000000000L);
463: case 109:
464: return jjMoveStringLiteralDfa2_2(active0, 0x200000000000L);
465: case 110:
466: return jjMoveStringLiteralDfa2_2(active0, 0x440000000000L);
467: case 111:
468: return jjMoveStringLiteralDfa2_2(active0, 0x40010000000000L);
469: case 113:
470: if ((active0 & 0x1000000000L) != 0L)
471: return jjStartNfaWithStates_2(1, 36, 6);
472: break;
473: case 114:
474: if ((active0 & 0x100000000000L) != 0L)
475: return jjStartNfaWithStates_2(1, 44, 6);
476: return jjMoveStringLiteralDfa2_2(active0, 0x10000L);
477: case 116:
478: if ((active0 & 0x10000000L) != 0L)
479: return jjStartNfaWithStates_2(1, 28, 6);
480: else if ((active0 & 0x40000000L) != 0L)
481: return jjStartNfaWithStates_2(1, 30, 6);
482: break;
483: case 117:
484: return jjMoveStringLiteralDfa2_2(active0, 0x40000L);
485: case 124:
486: if ((active0 & 0x80000000000L) != 0L)
487: return jjStopAtPos(1, 43);
488: break;
489: default :
490: break;
491: }
492: return jjStartNfa_2(0, active0);
493: }
494: private int jjMoveStringLiteralDfa2_2(long old0, long active0)
495: {
496: if (((active0 &= old0)) == 0L)
497: return jjStartNfa_2(0, old0);
498: try { curChar = input_stream.readChar(); }
499: catch(java.io.IOException e) {
500: jjStopStringLiteralDfa_2(1, active0);
501: return 2;
502: }
503: switch(curChar)
504: {
505: case 100:
506: if ((active0 & 0x40000000000L) != 0L)
507: return jjStartNfaWithStates_2(2, 42, 6);
508: else if ((active0 & 0x40000000000000L) != 0L)
509: return jjStartNfaWithStates_2(2, 54, 6);
510: break;
511: case 108:
512: return jjMoveStringLiteralDfa3_2(active0, 0x60000L);
513: case 112:
514: return jjMoveStringLiteralDfa3_2(active0, 0x200000000000L);
515: case 115:
516: return jjMoveStringLiteralDfa3_2(active0, 0x400000000000L);
517: case 116:
518: if ((active0 & 0x10000000000L) != 0L)
519: return jjStartNfaWithStates_2(2, 40, 6);
520: break;
521: case 117:
522: return jjMoveStringLiteralDfa3_2(active0, 0x10000L);
523: case 118:
524: if ((active0 & 0x10000000000000L) != 0L)
525: return jjStartNfaWithStates_2(2, 52, 6);
526: break;
527: default :
528: break;
529: }
530: return jjStartNfa_2(1, active0);
531: }
532: private int jjMoveStringLiteralDfa3_2(long old0, long active0)
533: {
534: if (((active0 &= old0)) == 0L)
535: return jjStartNfa_2(1, old0);
536: try { curChar = input_stream.readChar(); }
537: catch(java.io.IOException e) {
538: jjStopStringLiteralDfa_2(2, active0);
539: return 3;
540: }
541: switch(curChar)
542: {
543: case 101:
544: if ((active0 & 0x10000L) != 0L)
545: return jjStartNfaWithStates_2(3, 16, 6);
546: break;
547: case 108:
548: if ((active0 & 0x40000L) != 0L)
549: return jjStartNfaWithStates_2(3, 18, 6);
550: break;
551: case 115:
552: return jjMoveStringLiteralDfa4_2(active0, 0x20000L);
553: case 116:
554: return jjMoveStringLiteralDfa4_2(active0, 0x600000000000L);
555: default :
556: break;
557: }
558: return jjStartNfa_2(2, active0);
559: }
560: private int jjMoveStringLiteralDfa4_2(long old0, long active0)
561: {
562: if (((active0 &= old0)) == 0L)
563: return jjStartNfa_2(2, old0);
564: try { curChar = input_stream.readChar(); }
565: catch(java.io.IOException e) {
566: jjStopStringLiteralDfa_2(3, active0);
567: return 4;
568: }
569: switch(curChar)
570: {
571: case 97:
572: return jjMoveStringLiteralDfa5_2(active0, 0x400000000000L);
573: case 101:
574: if ((active0 & 0x20000L) != 0L)
575: return jjStartNfaWithStates_2(4, 17, 6);
576: break;
577: case 121:
578: if ((active0 & 0x200000000000L) != 0L)
579: return jjStartNfaWithStates_2(4, 45, 6);
580: break;
581: default :
582: break;
583: }
584: return jjStartNfa_2(3, active0);
585: }
586: private int jjMoveStringLiteralDfa5_2(long old0, long active0)
587: {
588: if (((active0 &= old0)) == 0L)
589: return jjStartNfa_2(3, old0);
590: try { curChar = input_stream.readChar(); }
591: catch(java.io.IOException e) {
592: jjStopStringLiteralDfa_2(4, active0);
593: return 5;
594: }
595: switch(curChar)
596: {
597: case 110:
598: return jjMoveStringLiteralDfa6_2(active0, 0x400000000000L);
599: default :
600: break;
601: }
602: return jjStartNfa_2(4, active0);
603: }
604: private int jjMoveStringLiteralDfa6_2(long old0, long active0)
605: {
606: if (((active0 &= old0)) == 0L)
607: return jjStartNfa_2(4, old0);
608: try { curChar = input_stream.readChar(); }
609: catch(java.io.IOException e) {
610: jjStopStringLiteralDfa_2(5, active0);
611: return 6;
612: }
613: switch(curChar)
614: {
615: case 99:
616: return jjMoveStringLiteralDfa7_2(active0, 0x400000000000L);
617: default :
618: break;
619: }
620: return jjStartNfa_2(5, active0);
621: }
622: private int jjMoveStringLiteralDfa7_2(long old0, long active0)
623: {
624: if (((active0 &= old0)) == 0L)
625: return jjStartNfa_2(5, old0);
626: try { curChar = input_stream.readChar(); }
627: catch(java.io.IOException e) {
628: jjStopStringLiteralDfa_2(6, active0);
629: return 7;
630: }
631: switch(curChar)
632: {
633: case 101:
634: return jjMoveStringLiteralDfa8_2(active0, 0x400000000000L);
635: default :
636: break;
637: }
638: return jjStartNfa_2(6, active0);
639: }
640: private int jjMoveStringLiteralDfa8_2(long old0, long active0)
641: {
642: if (((active0 &= old0)) == 0L)
643: return jjStartNfa_2(6, old0);
644: try { curChar = input_stream.readChar(); }
645: catch(java.io.IOException e) {
646: jjStopStringLiteralDfa_2(7, active0);
647: return 8;
648: }
649: switch(curChar)
650: {
651: case 111:
652: return jjMoveStringLiteralDfa9_2(active0, 0x400000000000L);
653: default :
654: break;
655: }
656: return jjStartNfa_2(7, active0);
657: }
658: private int jjMoveStringLiteralDfa9_2(long old0, long active0)
659: {
660: if (((active0 &= old0)) == 0L)
661: return jjStartNfa_2(7, old0);
662: try { curChar = input_stream.readChar(); }
663: catch(java.io.IOException e) {
664: jjStopStringLiteralDfa_2(8, active0);
665: return 9;
666: }
667: switch(curChar)
668: {
669: case 102:
670: if ((active0 & 0x400000000000L) != 0L)
671: return jjStartNfaWithStates_2(9, 46, 6);
672: break;
673: default :
674: break;
675: }
676: return jjStartNfa_2(8, active0);
677: }
678: private int jjStartNfaWithStates_2(int pos, int kind, int state)
679: {
680: jjmatchedKind = kind;
681: jjmatchedPos = pos;
682: try { curChar = input_stream.readChar(); }
683: catch(java.io.IOException e) { return pos + 1; }
684: return jjMoveNfa_2(state, pos + 1);
685: }
686: static final long[] jjbitVec3 = {
687: 0x1ff00000fffffffeL, 0xffffffffffffc000L, 0xffffffffL, 0x600000000000000L
688: };
689: static final long[] jjbitVec4 = {
690: 0x0L, 0x0L, 0x0L, 0xff7fffffff7fffffL
691: };
692: static final long[] jjbitVec5 = {
693: 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
694: };
695: static final long[] jjbitVec6 = {
696: 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffL, 0x0L
697: };
698: static final long[] jjbitVec7 = {
699: 0xffffffffffffffffL, 0xffffffffffffffffL, 0x0L, 0x0L
700: };
701: static final long[] jjbitVec8 = {
702: 0x3fffffffffffL, 0x0L, 0x0L, 0x0L
703: };
704: private int jjMoveNfa_2(int startState, int curPos)
705: {
706: int startsAt = 0;
707: jjnewStateCnt = 35;
708: int i = 1;
709: jjstateSet[0] = startState;
710: int kind = 0x7fffffff;
711: for (;;)
712: {
713: if (++jjround == 0x7fffffff)
714: ReInitRounds();
715: if (curChar < 64)
716: {
717: long l = 1L << curChar;
718: do
719: {
720: switch(jjstateSet[--i])
721: {
722: case 0:
723: if ((0x3ff000000000000L & l) != 0L)
724: {
725: if (kind > 11)
726: kind = 11;
727: jjCheckNAddStates(4, 8);
728: }
729: else if ((0x1800000000L & l) != 0L)
730: {
731: if (kind > 58)
732: kind = 58;
733: jjCheckNAdd(6);
734: }
735: else if (curChar == 39)
736: jjCheckNAddStates(9, 13);
737: else if (curChar == 34)
738: jjCheckNAddStates(14, 18);
739: else if (curChar == 46)
740: jjCheckNAdd(1);
741: break;
742: case 1:
743: if ((0x3ff000000000000L & l) == 0L)
744: break;
745: if (kind > 12)
746: kind = 12;
747: jjCheckNAddTwoStates(1, 2);
748: break;
749: case 3:
750: if ((0x280000000000L & l) != 0L)
751: jjCheckNAdd(4);
752: break;
753: case 4:
754: if ((0x3ff000000000000L & l) == 0L)
755: break;
756: if (kind > 12)
757: kind = 12;
758: jjCheckNAdd(4);
759: break;
760: case 5:
761: if ((0x1800000000L & l) == 0L)
762: break;
763: if (kind > 58)
764: kind = 58;
765: jjCheckNAdd(6);
766: break;
767: case 6:
768: if ((0x3ff001000000000L & l) == 0L)
769: break;
770: if (kind > 58)
771: kind = 58;
772: jjCheckNAdd(6);
773: break;
774: case 7:
775: if ((0x3ff000000000000L & l) == 0L)
776: break;
777: if (kind > 11)
778: kind = 11;
779: jjCheckNAddStates(4, 8);
780: break;
781: case 8:
782: if ((0x3ff000000000000L & l) == 0L)
783: break;
784: if (kind > 11)
785: kind = 11;
786: jjCheckNAdd(8);
787: break;
788: case 9:
789: if ((0x3ff000000000000L & l) != 0L)
790: jjCheckNAddTwoStates(9, 10);
791: break;
792: case 10:
793: if (curChar != 46)
794: break;
795: if (kind > 12)
796: kind = 12;
797: jjCheckNAddTwoStates(11, 12);
798: break;
799: case 11:
800: if ((0x3ff000000000000L & l) == 0L)
801: break;
802: if (kind > 12)
803: kind = 12;
804: jjCheckNAddTwoStates(11, 12);
805: break;
806: case 13:
807: if ((0x280000000000L & l) != 0L)
808: jjCheckNAdd(14);
809: break;
810: case 14:
811: if ((0x3ff000000000000L & l) == 0L)
812: break;
813: if (kind > 12)
814: kind = 12;
815: jjCheckNAdd(14);
816: break;
817: case 15:
818: if ((0x3ff000000000000L & l) != 0L)
819: jjCheckNAddTwoStates(15, 16);
820: break;
821: case 17:
822: if ((0x280000000000L & l) != 0L)
823: jjCheckNAdd(18);
824: break;
825: case 18:
826: if ((0x3ff000000000000L & l) == 0L)
827: break;
828: if (kind > 12)
829: kind = 12;
830: jjCheckNAdd(18);
831: break;
832: case 19:
833: if (curChar == 34)
834: jjCheckNAddStates(14, 18);
835: break;
836: case 20:
837: if ((0xfffffffbffffffffL & l) != 0L)
838: jjCheckNAddStates(19, 21);
839: break;
840: case 22:
841: if (curChar == 34)
842: jjCheckNAddStates(19, 21);
843: break;
844: case 23:
845: if (curChar == 34 && kind > 14)
846: kind = 14;
847: break;
848: case 24:
849: if ((0xfffffffbffffffffL & l) != 0L)
850: jjCheckNAddTwoStates(24, 25);
851: break;
852: case 26:
853: if ((0xfffffffbffffffffL & l) != 0L && kind > 15)
854: kind = 15;
855: break;
856: case 27:
857: if (curChar == 39)
858: jjCheckNAddStates(9, 13);
859: break;
860: case 28:
861: if ((0xffffff7fffffffffL & l) != 0L)
862: jjCheckNAddStates(22, 24);
863: break;
864: case 30:
865: if (curChar == 39)
866: jjCheckNAddStates(22, 24);
867: break;
868: case 31:
869: if (curChar == 39 && kind > 14)
870: kind = 14;
871: break;
872: case 32:
873: if ((0xffffff7fffffffffL & l) != 0L)
874: jjCheckNAddTwoStates(32, 33);
875: break;
876: case 34:
877: if ((0xffffff7fffffffffL & l) != 0L && kind > 15)
878: kind = 15;
879: break;
880: default : break;
881: }
882: } while(i != startsAt);
883: }
884: else if (curChar < 128)
885: {
886: long l = 1L << (curChar & 077);
887: do
888: {
889: switch(jjstateSet[--i])
890: {
891: case 0:
892: case 6:
893: if ((0x7fffffe87fffffeL & l) == 0L)
894: break;
895: if (kind > 58)
896: kind = 58;
897: jjCheckNAdd(6);
898: break;
899: case 2:
900: if ((0x2000000020L & l) != 0L)
901: jjAddStates(25, 26);
902: break;
903: case 12:
904: if ((0x2000000020L & l) != 0L)
905: jjAddStates(27, 28);
906: break;
907: case 16:
908: if ((0x2000000020L & l) != 0L)
909: jjAddStates(29, 30);
910: break;
911: case 20:
912: if ((0xffffffffefffffffL & l) != 0L)
913: jjCheckNAddStates(19, 21);
914: break;
915: case 21:
916: if (curChar == 92)
917: jjstateSet[jjnewStateCnt++] = 22;
918: break;
919: case 22:
920: if (curChar == 92)
921: jjCheckNAddStates(19, 21);
922: break;
923: case 24:
924: if ((0xffffffffefffffffL & l) != 0L)
925: jjAddStates(31, 32);
926: break;
927: case 25:
928: if (curChar == 92)
929: jjstateSet[jjnewStateCnt++] = 26;
930: break;
931: case 26:
932: case 34:
933: if ((0xffffffffefffffffL & l) != 0L && kind > 15)
934: kind = 15;
935: break;
936: case 28:
937: if ((0xffffffffefffffffL & l) != 0L)
938: jjCheckNAddStates(22, 24);
939: break;
940: case 29:
941: if (curChar == 92)
942: jjstateSet[jjnewStateCnt++] = 30;
943: break;
944: case 30:
945: if (curChar == 92)
946: jjCheckNAddStates(22, 24);
947: break;
948: case 32:
949: if ((0xffffffffefffffffL & l) != 0L)
950: jjAddStates(33, 34);
951: break;
952: case 33:
953: if (curChar == 92)
954: jjstateSet[jjnewStateCnt++] = 34;
955: break;
956: default : break;
957: }
958: } while(i != startsAt);
959: }
960: else
961: {
962: int hiByte = (int)(curChar >> 8);
963: int i1 = hiByte >> 6;
964: long l1 = 1L << (hiByte & 077);
965: int i2 = (curChar & 0xff) >> 6;
966: long l2 = 1L << (curChar & 077);
967: do
968: {
969: switch(jjstateSet[--i])
970: {
971: case 0:
972: case 6:
973: if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
974: break;
975: if (kind > 58)
976: kind = 58;
977: jjCheckNAdd(6);
978: break;
979: case 20:
980: if (jjCanMove_0(hiByte, i1, i2, l1, l2))
981: jjAddStates(19, 21);
982: break;
983: case 24:
984: if (jjCanMove_0(hiByte, i1, i2, l1, l2))
985: jjAddStates(31, 32);
986: break;
987: case 26:
988: case 34:
989: if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 15)
990: kind = 15;
991: break;
992: case 28:
993: if (jjCanMove_0(hiByte, i1, i2, l1, l2))
994: jjAddStates(22, 24);
995: break;
996: case 32:
997: if (jjCanMove_0(hiByte, i1, i2, l1, l2))
998: jjAddStates(33, 34);
999: break;
1000: default : break;
1001: }
1002: } while(i != startsAt);
1003: }
1004: if (kind != 0x7fffffff)
1005: {
1006: jjmatchedKind = kind;
1007: jjmatchedPos = curPos;
1008: kind = 0x7fffffff;
1009: }
1010: ++curPos;
1011: if ((i = jjnewStateCnt) == (startsAt = 35 - (jjnewStateCnt = startsAt)))
1012: return curPos;
1013: try { curChar = input_stream.readChar(); }
1014: catch(java.io.IOException e) { return curPos; }
1015: }
1016: }
1017: private final int jjStopStringLiteralDfa_1(int pos, long active0)
1018: {
1019: switch (pos)
1020: {
1021: case 0:
1022: if ((active0 & 0x80000L) != 0L)
1023: return 1;
1024: if ((active0 & 0x50755550070000L) != 0L)
1025: {
1026: jjmatchedKind = 58;
1027: return 6;
1028: }
1029: return -1;
1030: case 1:
1031: if ((active0 & 0x105550000000L) != 0L)
1032: return 6;
1033: if ((active0 & 0x50650000070000L) != 0L)
1034: {
1035: jjmatchedKind = 58;
1036: jjmatchedPos = 1;
1037: return 6;
1038: }
1039: return -1;
1040: case 2:
1041: if ((active0 & 0x50050000000000L) != 0L)
1042: return 6;
1043: if ((active0 & 0x600000070000L) != 0L)
1044: {
1045: jjmatchedKind = 58;
1046: jjmatchedPos = 2;
1047: return 6;
1048: }
1049: return -1;
1050: case 3:
1051: if ((active0 & 0x50000L) != 0L)
1052: return 6;
1053: if ((active0 & 0x600000020000L) != 0L)
1054: {
1055: jjmatchedKind = 58;
1056: jjmatchedPos = 3;
1057: return 6;
1058: }
1059: return -1;
1060: case 4:
1061: if ((active0 & 0x400000000000L) != 0L)
1062: {
1063: jjmatchedKind = 58;
1064: jjmatchedPos = 4;
1065: return 6;
1066: }
1067: if ((active0 & 0x200000020000L) != 0L)
1068: return 6;
1069: return -1;
1070: case 5:
1071: if ((active0 & 0x400000000000L) != 0L)
1072: {
1073: jjmatchedKind = 58;
1074: jjmatchedPos = 5;
1075: return 6;
1076: }
1077: return -1;
1078: case 6:
1079: if ((active0 & 0x400000000000L) != 0L)
1080: {
1081: jjmatchedKind = 58;
1082: jjmatchedPos = 6;
1083: return 6;
1084: }
1085: return -1;
1086: case 7:
1087: if ((active0 & 0x400000000000L) != 0L)
1088: {
1089: jjmatchedKind = 58;
1090: jjmatchedPos = 7;
1091: return 6;
1092: }
1093: return -1;
1094: case 8:
1095: if ((active0 & 0x400000000000L) != 0L)
1096: {
1097: jjmatchedKind = 58;
1098: jjmatchedPos = 8;
1099: return 6;
1100: }
1101: return -1;
1102: default :
1103: return -1;
1104: }
1105: }
1106: private final int jjStartNfa_1(int pos, long active0)
1107: {
1108: return jjMoveNfa_1(jjStopStringLiteralDfa_1(pos, active0), pos + 1);
1109: }
1110: private int jjMoveStringLiteralDfa0_1()
1111: {
1112: switch(curChar)
1113: {
1114: case 33:
1115: jjmatchedKind = 39;
1116: return jjMoveStringLiteralDfa1_1(0x2000000000L);
1117: case 37:
1118: return jjStopAtPos(0, 53);
1119: case 38:
1120: return jjMoveStringLiteralDfa1_1(0x20000000000L);
1121: case 40:
1122: return jjStopAtPos(0, 20);
1123: case 41:
1124: return jjStopAtPos(0, 21);
1125: case 42:
1126: return jjStopAtPos(0, 47);
1127: case 43:
1128: jjmatchedKind = 48;
1129: return jjMoveStringLiteralDfa1_1(0x80000000000000L);
1130: case 44:
1131: return jjStopAtPos(0, 25);
1132: case 45:
1133: jjmatchedKind = 49;
1134: return jjMoveStringLiteralDfa1_1(0x200000000000000L);
1135: case 46:
1136: return jjStartNfaWithStates_1(0, 19, 1);
1137: case 47:
1138: return jjStopAtPos(0, 51);
1139: case 58:
1140: return jjStopAtPos(0, 24);
1141: case 59:
1142: return jjStopAtPos(0, 26);
1143: case 60:
1144: jjmatchedKind = 29;
1145: return jjMoveStringLiteralDfa1_1(0x200000000L);
1146: case 61:
1147: jjmatchedKind = 56;
1148: return jjMoveStringLiteralDfa1_1(0x800000000L);
1149: case 62:
1150: jjmatchedKind = 27;
1151: return jjMoveStringLiteralDfa1_1(0x80000000L);
1152: case 63:
1153: return jjStopAtPos(0, 50);
1154: case 91:
1155: return jjStopAtPos(0, 22);
1156: case 93:
1157: return jjStopAtPos(0, 23);
1158: case 97:
1159: return jjMoveStringLiteralDfa1_1(0x40000000000L);
1160: case 100:
1161: return jjMoveStringLiteralDfa1_1(0x10000000000000L);
1162: case 101:
1163: return jjMoveStringLiteralDfa1_1(0x201000000000L);
1164: case 102:
1165: return jjMoveStringLiteralDfa1_1(0x20000L);
1166: case 103:
1167: return jjMoveStringLiteralDfa1_1(0x110000000L);
1168: case 105:
1169: return jjMoveStringLiteralDfa1_1(0x400000000000L);
1170: case 108:
1171: return jjMoveStringLiteralDfa1_1(0x440000000L);
1172: case 109:
1173: return jjMoveStringLiteralDfa1_1(0x40000000000000L);
1174: case 110:
1175: return jjMoveStringLiteralDfa1_1(0x14000040000L);
1176: case 111:
1177: return jjMoveStringLiteralDfa1_1(0x100000000000L);
1178: case 116:
1179: return jjMoveStringLiteralDfa1_1(0x10000L);
1180: case 123:
1181: return jjStopAtPos(0, 9);
1182: case 124:
1183: return jjMoveStringLiteralDfa1_1(0x80000000000L);
1184: case 125:
1185: return jjStopAtPos(0, 10);
1186: default :
1187: return jjMoveNfa_1(0, 0);
1188: }
1189: }
1190: private int jjMoveStringLiteralDfa1_1(long active0)
1191: {
1192: try { curChar = input_stream.readChar(); }
1193: catch(java.io.IOException e) {
1194: jjStopStringLiteralDfa_1(0, active0);
1195: return 1;
1196: }
1197: switch(curChar)
1198: {
1199: case 38:
1200: if ((active0 & 0x20000000000L) != 0L)
1201: return jjStopAtPos(1, 41);
1202: break;
1203: case 61:
1204: if ((active0 & 0x80000000L) != 0L)
1205: return jjStopAtPos(1, 31);
1206: else if ((active0 & 0x200000000L) != 0L)
1207: return jjStopAtPos(1, 33);
1208: else if ((active0 & 0x800000000L) != 0L)
1209: return jjStopAtPos(1, 35);
1210: else if ((active0 & 0x2000000000L) != 0L)
1211: return jjStopAtPos(1, 37);
1212: else if ((active0 & 0x80000000000000L) != 0L)
1213: return jjStopAtPos(1, 55);
1214: break;
1215: case 62:
1216: if ((active0 & 0x200000000000000L) != 0L)
1217: return jjStopAtPos(1, 57);
1218: break;
1219: case 97:
1220: return jjMoveStringLiteralDfa2_1(active0, 0x20000L);
1221: case 101:
1222: if ((active0 & 0x100000000L) != 0L)
1223: return jjStartNfaWithStates_1(1, 32, 6);
1224: else if ((active0 & 0x400000000L) != 0L)
1225: return jjStartNfaWithStates_1(1, 34, 6);
1226: else if ((active0 & 0x4000000000L) != 0L)
1227: return jjStartNfaWithStates_1(1, 38, 6);
1228: break;
1229: case 105:
1230: return jjMoveStringLiteralDfa2_1(active0, 0x10000000000000L);
1231: case 109:
1232: return jjMoveStringLiteralDfa2_1(active0, 0x200000000000L);
1233: case 110:
1234: return jjMoveStringLiteralDfa2_1(active0, 0x440000000000L);
1235: case 111:
1236: return jjMoveStringLiteralDfa2_1(active0, 0x40010000000000L);
1237: case 113:
1238: if ((active0 & 0x1000000000L) != 0L)
1239: return jjStartNfaWithStates_1(1, 36, 6);
1240: break;
1241: case 114:
1242: if ((active0 & 0x100000000000L) != 0L)
1243: return jjStartNfaWithStates_1(1, 44, 6);
1244: return jjMoveStringLiteralDfa2_1(active0, 0x10000L);
1245: case 116:
1246: if ((active0 & 0x10000000L) != 0L)
1247: return jjStartNfaWithStates_1(1, 28, 6);
1248: else if ((active0 & 0x40000000L) != 0L)
1249: return jjStartNfaWithStates_1(1, 30, 6);
1250: break;
1251: case 117:
1252: return jjMoveStringLiteralDfa2_1(active0, 0x40000L);
1253: case 124:
1254: if ((active0 & 0x80000000000L) != 0L)
1255: return jjStopAtPos(1, 43);
1256: break;
1257: default :
1258: break;
1259: }
1260: return jjStartNfa_1(0, active0);
1261: }
1262: private int jjMoveStringLiteralDfa2_1(long old0, long active0)
1263: {
1264: if (((active0 &= old0)) == 0L)
1265: return jjStartNfa_1(0, old0);
1266: try { curChar = input_stream.readChar(); }
1267: catch(java.io.IOException e) {
1268: jjStopStringLiteralDfa_1(1, active0);
1269: return 2;
1270: }
1271: switch(curChar)
1272: {
1273: case 100:
1274: if ((active0 & 0x40000000000L) != 0L)
1275: return jjStartNfaWithStates_1(2, 42, 6);
1276: else if ((active0 & 0x40000000000000L) != 0L)
1277: return jjStartNfaWithStates_1(2, 54, 6);
1278: break;
1279: case 108:
1280: return jjMoveStringLiteralDfa3_1(active0, 0x60000L);
1281: case 112:
1282: return jjMoveStringLiteralDfa3_1(active0, 0x200000000000L);
1283: case 115:
1284: return jjMoveStringLiteralDfa3_1(active0, 0x400000000000L);
1285: case 116:
1286: if ((active0 & 0x10000000000L) != 0L)
1287: return jjStartNfaWithStates_1(2, 40, 6);
1288: break;
1289: case 117:
1290: return jjMoveStringLiteralDfa3_1(active0, 0x10000L);
1291: case 118:
1292: if ((active0 & 0x10000000000000L) != 0L)
1293: return jjStartNfaWithStates_1(2, 52, 6);
1294: break;
1295: default :
1296: break;
1297: }
1298: return jjStartNfa_1(1, active0);
1299: }
1300: private int jjMoveStringLiteralDfa3_1(long old0, long active0)
1301: {
1302: if (((active0 &= old0)) == 0L)
1303: return jjStartNfa_1(1, old0);
1304: try { curChar = input_stream.readChar(); }
1305: catch(java.io.IOException e) {
1306: jjStopStringLiteralDfa_1(2, active0);
1307: return 3;
1308: }
1309: switch(curChar)
1310: {
1311: case 101:
1312: if ((active0 & 0x10000L) != 0L)
1313: return jjStartNfaWithStates_1(3, 16, 6);
1314: break;
1315: case 108:
1316: if ((active0 & 0x40000L) != 0L)
1317: return jjStartNfaWithStates_1(3, 18, 6);
1318: break;
1319: case 115:
1320: return jjMoveStringLiteralDfa4_1(active0, 0x20000L);
1321: case 116:
1322: return jjMoveStringLiteralDfa4_1(active0, 0x600000000000L);
1323: default :
1324: break;
1325: }
1326: return jjStartNfa_1(2, active0);
1327: }
1328: private int jjMoveStringLiteralDfa4_1(long old0, long active0)
1329: {
1330: if (((active0 &= old0)) == 0L)
1331: return jjStartNfa_1(2, old0);
1332: try { curChar = input_stream.readChar(); }
1333: catch(java.io.IOException e) {
1334: jjStopStringLiteralDfa_1(3, active0);
1335: return 4;
1336: }
1337: switch(curChar)
1338: {
1339: case 97:
1340: return jjMoveStringLiteralDfa5_1(active0, 0x400000000000L);
1341: case 101:
1342: if ((active0 & 0x20000L) != 0L)
1343: return jjStartNfaWithStates_1(4, 17, 6);
1344: break;
1345: case 121:
1346: if ((active0 & 0x200000000000L) != 0L)
1347: return jjStartNfaWithStates_1(4, 45, 6);
1348: break;
1349: default :
1350: break;
1351: }
1352: return jjStartNfa_1(3, active0);
1353: }
1354: private int jjMoveStringLiteralDfa5_1(long old0, long active0)
1355: {
1356: if (((active0 &= old0)) == 0L)
1357: return jjStartNfa_1(3, old0);
1358: try { curChar = input_stream.readChar(); }
1359: catch(java.io.IOException e) {
1360: jjStopStringLiteralDfa_1(4, active0);
1361: return 5;
1362: }
1363: switch(curChar)
1364: {
1365: case 110:
1366: return jjMoveStringLiteralDfa6_1(active0, 0x400000000000L);
1367: default :
1368: break;
1369: }
1370: return jjStartNfa_1(4, active0);
1371: }
1372: private int jjMoveStringLiteralDfa6_1(long old0, long active0)
1373: {
1374: if (((active0 &= old0)) == 0L)
1375: return jjStartNfa_1(4, old0);
1376: try { curChar = input_stream.readChar(); }
1377: catch(java.io.IOException e) {
1378: jjStopStringLiteralDfa_1(5, active0);
1379: return 6;
1380: }
1381: switch(curChar)
1382: {
1383: case 99:
1384: return jjMoveStringLiteralDfa7_1(active0, 0x400000000000L);
1385: default :
1386: break;
1387: }
1388: return jjStartNfa_1(5, active0);
1389: }
1390: private int jjMoveStringLiteralDfa7_1(long old0, long active0)
1391: {
1392: if (((active0 &= old0)) == 0L)
1393: return jjStartNfa_1(5, old0);
1394: try { curChar = input_stream.readChar(); }
1395: catch(java.io.IOException e) {
1396: jjStopStringLiteralDfa_1(6, active0);
1397: return 7;
1398: }
1399: switch(curChar)
1400: {
1401: case 101:
1402: return jjMoveStringLiteralDfa8_1(active0, 0x400000000000L);
1403: default :
1404: break;
1405: }
1406: return jjStartNfa_1(6, active0);
1407: }
1408: private int jjMoveStringLiteralDfa8_1(long old0, long active0)
1409: {
1410: if (((active0 &= old0)) == 0L)
1411: return jjStartNfa_1(6, old0);
1412: try { curChar = input_stream.readChar(); }
1413: catch(java.io.IOException e) {
1414: jjStopStringLiteralDfa_1(7, active0);
1415: return 8;
1416: }
1417: switch(curChar)
1418: {
1419: case 111:
1420: return jjMoveStringLiteralDfa9_1(active0, 0x400000000000L);
1421: default :
1422: break;
1423: }
1424: return jjStartNfa_1(7, active0);
1425: }
1426: private int jjMoveStringLiteralDfa9_1(long old0, long active0)
1427: {
1428: if (((active0 &= old0)) == 0L)
1429: return jjStartNfa_1(7, old0);
1430: try { curChar = input_stream.readChar(); }
1431: catch(java.io.IOException e) {
1432: jjStopStringLiteralDfa_1(8, active0);
1433: return 9;
1434: }
1435: switch(curChar)
1436: {
1437: case 102:
1438: if ((active0 & 0x400000000000L) != 0L)
1439: return jjStartNfaWithStates_1(9, 46, 6);
1440: break;
1441: default :
1442: break;
1443: }
1444: return jjStartNfa_1(8, active0);
1445: }
1446: private int jjStartNfaWithStates_1(int pos, int kind, int state)
1447: {
1448: jjmatchedKind = kind;
1449: jjmatchedPos = pos;
1450: try { curChar = input_stream.readChar(); }
1451: catch(java.io.IOException e) { return pos + 1; }
1452: return jjMoveNfa_1(state, pos + 1);
1453: }
1454: private int jjMoveNfa_1(int startState, int curPos)
1455: {
1456: int startsAt = 0;
1457: jjnewStateCnt = 35;
1458: int i = 1;
1459: jjstateSet[0] = startState;
1460: int kind = 0x7fffffff;
1461: for (;;)
1462: {
1463: if (++jjround == 0x7fffffff)
1464: ReInitRounds();
1465: if (curChar < 64)
1466: {
1467: long l = 1L << curChar;
1468: do
1469: {
1470: switch(jjstateSet[--i])
1471: {
1472: case 0:
1473: if ((0x3ff000000000000L & l) != 0L)
1474: {
1475: if (kind > 11)
1476: kind = 11;
1477: jjCheckNAddStates(4, 8);
1478: }
1479: else if ((0x1800000000L & l) != 0L)
1480: {
1481: if (kind > 58)
1482: kind = 58;
1483: jjCheckNAdd(6);
1484: }
1485: else if (curChar == 39)
1486: jjCheckNAddStates(9, 13);
1487: else if (curChar == 34)
1488: jjCheckNAddStates(14, 18);
1489: else if (curChar == 46)
1490: jjCheckNAdd(1);
1491: break;
1492: case 1:
1493: if ((0x3ff000000000000L & l) == 0L)
1494: break;
1495: if (kind > 12)
1496: kind = 12;
1497: jjCheckNAddTwoStates(1, 2);
1498: break;
1499: case 3:
1500: if ((0x280000000000L & l) != 0L)
1501: jjCheckNAdd(4);
1502: break;
1503: case 4:
1504: if ((0x3ff000000000000L & l) == 0L)
1505: break;
1506: if (kind > 12)
1507: kind = 12;
1508: jjCheckNAdd(4);
1509: break;
1510: case 5:
1511: if ((0x1800000000L & l) == 0L)
1512: break;
1513: if (kind > 58)
1514: kind = 58;
1515: jjCheckNAdd(6);
1516: break;
1517: case 6:
1518: if ((0x3ff001000000000L & l) == 0L)
1519: break;
1520: if (kind > 58)
1521: kind = 58;
1522: jjCheckNAdd(6);
1523: break;
1524: case 7:
1525: if ((0x3ff000000000000L & l) == 0L)
1526: break;
1527: if (kind > 11)
1528: kind = 11;
1529: jjCheckNAddStates(4, 8);
1530: break;
1531: case 8:
1532: if ((0x3ff000000000000L & l) == 0L)
1533: break;
1534: if (kind > 11)
1535: kind = 11;
1536: jjCheckNAdd(8);
1537: break;
1538: case 9:
1539: if ((0x3ff000000000000L & l) != 0L)
1540: jjCheckNAddTwoStates(9, 10);
1541: break;
1542: case 10:
1543: if (curChar != 46)
1544: break;
1545: if (kind > 12)
1546: kind = 12;
1547: jjCheckNAddTwoStates(11, 12);
1548: break;
1549: case 11:
1550: if ((0x3ff000000000000L & l) == 0L)
1551: break;
1552: if (kind > 12)
1553: kind = 12;
1554: jjCheckNAddTwoStates(11, 12);
1555: break;
1556: case 13:
1557: if ((0x280000000000L & l) != 0L)
1558: jjCheckNAdd(14);
1559: break;
1560: case 14:
1561: if ((0x3ff000000000000L & l) == 0L)
1562: break;
1563: if (kind > 12)
1564: kind = 12;
1565: jjCheckNAdd(14);
1566: break;
1567: case 15:
1568: if ((0x3ff000000000000L & l) != 0L)
1569: jjCheckNAddTwoStates(15, 16);
1570: break;
1571: case 17:
1572: if ((0x280000000000L & l) != 0L)
1573: jjCheckNAdd(18);
1574: break;
1575: case 18:
1576: if ((0x3ff000000000000L & l) == 0L)
1577: break;
1578: if (kind > 12)
1579: kind = 12;
1580: jjCheckNAdd(18);
1581: break;
1582: case 19:
1583: if (curChar == 34)
1584: jjCheckNAddStates(14, 18);
1585: break;
1586: case 20:
1587: if ((0xfffffffbffffffffL & l) != 0L)
1588: jjCheckNAddStates(19, 21);
1589: break;
1590: case 22:
1591: if (curChar == 34)
1592: jjCheckNAddStates(19, 21);
1593: break;
1594: case 23:
1595: if (curChar == 34 && kind > 14)
1596: kind = 14;
1597: break;
1598: case 24:
1599: if ((0xfffffffbffffffffL & l) != 0L)
1600: jjCheckNAddTwoStates(24, 25);
1601: break;
1602: case 26:
1603: if ((0xfffffffbffffffffL & l) != 0L && kind > 15)
1604: kind = 15;
1605: break;
1606: case 27:
1607: if (curChar == 39)
1608: jjCheckNAddStates(9, 13);
1609: break;
1610: case 28:
1611: if ((0xffffff7fffffffffL & l) != 0L)
1612: jjCheckNAddStates(22, 24);
1613: break;
1614: case 30:
1615: if (curChar == 39)
1616: jjCheckNAddStates(22, 24);
1617: break;
1618: case 31:
1619: if (curChar == 39 && kind > 14)
1620: kind = 14;
1621: break;
1622: case 32:
1623: if ((0xffffff7fffffffffL & l) != 0L)
1624: jjCheckNAddTwoStates(32, 33);
1625: break;
1626: case 34:
1627: if ((0xffffff7fffffffffL & l) != 0L && kind > 15)
1628: kind = 15;
1629: break;
1630: default : break;
1631: }
1632: } while(i != startsAt);
1633: }
1634: else if (curChar < 128)
1635: {
1636: long l = 1L << (curChar & 077);
1637: do
1638: {
1639: switch(jjstateSet[--i])
1640: {
1641: case 0:
1642: case 6:
1643: if ((0x7fffffe87fffffeL & l) == 0L)
1644: break;
1645: if (kind > 58)
1646: kind = 58;
1647: jjCheckNAdd(6);
1648: break;
1649: case 2:
1650: if ((0x2000000020L & l) != 0L)
1651: jjAddStates(25, 26);
1652: break;
1653: case 12:
1654: if ((0x2000000020L & l) != 0L)
1655: jjAddStates(27, 28);
1656: break;
1657: case 16:
1658: if ((0x2000000020L & l) != 0L)
1659: jjAddStates(29, 30);
1660: break;
1661: case 20:
1662: if ((0xffffffffefffffffL & l) != 0L)
1663: jjCheckNAddStates(19, 21);
1664: break;
1665: case 21:
1666: if (curChar == 92)
1667: jjstateSet[jjnewStateCnt++] = 22;
1668: break;
1669: case 22:
1670: if (curChar == 92)
1671: jjCheckNAddStates(19, 21);
1672: break;
1673: case 24:
1674: if ((0xffffffffefffffffL & l) != 0L)
1675: jjAddStates(31, 32);
1676: break;
1677: case 25:
1678: if (curChar == 92)
1679: jjstateSet[jjnewStateCnt++] = 26;
1680: break;
1681: case 26:
1682: case 34:
1683: if ((0xffffffffefffffffL & l) != 0L && kind > 15)
1684: kind = 15;
1685: break;
1686: case 28:
1687: if ((0xffffffffefffffffL & l) != 0L)
1688: jjCheckNAddStates(22, 24);
1689: break;
1690: case 29:
1691: if (curChar == 92)
1692: jjstateSet[jjnewStateCnt++] = 30;
1693: break;
1694: case 30:
1695: if (curChar == 92)
1696: jjCheckNAddStates(22, 24);
1697: break;
1698: case 32:
1699: if ((0xffffffffefffffffL & l) != 0L)
1700: jjAddStates(33, 34);
1701: break;
1702: case 33:
1703: if (curChar == 92)
1704: jjstateSet[jjnewStateCnt++] = 34;
1705: break;
1706: default : break;
1707: }
1708: } while(i != startsAt);
1709: }
1710: else
1711: {
1712: int hiByte = (int)(curChar >> 8);
1713: int i1 = hiByte >> 6;
1714: long l1 = 1L << (hiByte & 077);
1715: int i2 = (curChar & 0xff) >> 6;
1716: long l2 = 1L << (curChar & 077);
1717: do
1718: {
1719: switch(jjstateSet[--i])
1720: {
1721: case 0:
1722: case 6:
1723: if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
1724: break;
1725: if (kind > 58)
1726: kind = 58;
1727: jjCheckNAdd(6);
1728: break;
1729: case 20:
1730: if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1731: jjAddStates(19, 21);
1732: break;
1733: case 24:
1734: if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1735: jjAddStates(31, 32);
1736: break;
1737: case 26:
1738: case 34:
1739: if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 15)
1740: kind = 15;
1741: break;
1742: case 28:
1743: if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1744: jjAddStates(22, 24);
1745: break;
1746: case 32:
1747: if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1748: jjAddStates(33, 34);
1749: break;
1750: default : break;
1751: }
1752: } while(i != startsAt);
1753: }
1754: if (kind != 0x7fffffff)
1755: {
1756: jjmatchedKind = kind;
1757: jjmatchedPos = curPos;
1758: kind = 0x7fffffff;
1759: }
1760: ++curPos;
1761: if ((i = jjnewStateCnt) == (startsAt = 35 - (jjnewStateCnt = startsAt)))
1762: return curPos;
1763: try { curChar = input_stream.readChar(); }
1764: catch(java.io.IOException e) { return curPos; }
1765: }
1766: }
1767: static final int[] jjnextStates = {
1768: 0, 1, 3, 5, 8, 9, 10, 15, 16, 28, 29, 31, 32, 33, 20, 21,
1769: 23, 24, 25, 20, 21, 23, 28, 29, 31, 3, 4, 13, 14, 17, 18, 24,
1770: 25, 32, 33,
1771: };
1772: private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2)
1773: {
1774: switch(hiByte)
1775: {
1776: case 0:
1777: return ((jjbitVec2[i2] & l2) != 0L);
1778: default :
1779: if ((jjbitVec0[i1] & l1) != 0L)
1780: return true;
1781: return false;
1782: }
1783: }
1784: private static final boolean jjCanMove_1(int hiByte, int i1, int i2, long l1, long l2)
1785: {
1786: switch(hiByte)
1787: {
1788: case 0:
1789: return ((jjbitVec4[i2] & l2) != 0L);
1790: case 48:
1791: return ((jjbitVec5[i2] & l2) != 0L);
1792: case 49:
1793: return ((jjbitVec6[i2] & l2) != 0L);
1794: case 51:
1795: return ((jjbitVec7[i2] & l2) != 0L);
1796: case 61:
1797: return ((jjbitVec8[i2] & l2) != 0L);
1798: default :
1799: if ((jjbitVec3[i1] & l1) != 0L)
1800: return true;
1801: return false;
1802: }
1803: }
1804:
1805: /** Token literal values. */
1806: public static final String[] jjstrLiteralImages = {
1807: "", null, "\44\173", "\43\173", null, null, null, null, null, "\173", "\175",
1808: null, null, null, null, null, "\164\162\165\145", "\146\141\154\163\145",
1809: "\156\165\154\154", "\56", "\50", "\51", "\133", "\135", "\72", "\54", "\73", "\76", "\147\164",
1810: "\74", "\154\164", "\76\75", "\147\145", "\74\75", "\154\145", "\75\75", "\145\161",
1811: "\41\75", "\156\145", "\41", "\156\157\164", "\46\46", "\141\156\144", "\174\174",
1812: "\157\162", "\145\155\160\164\171", "\151\156\163\164\141\156\143\145\157\146", "\52",
1813: "\53", "\55", "\77", "\57", "\144\151\166", "\45", "\155\157\144", "\53\75", "\75",
1814: "\55\76", null, null, null, null, null, };
1815:
1816: /** Lexer state names. */
1817: public static final String[] lexStateNames = {
1818: "DEFAULT",
1819: "IN_EXPRESSION",
1820: "IN_MAP",
1821: };
1822:
1823: /** Lex State array. */
1824: public static final int[] jjnewLexState = {
1825: -1, -1, 1, 1, -1, -1, -1, -1, -1, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1826: -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,
1827: -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1828: };
1829: static final long[] jjtoToken = {
1830: 0x47ffffffffffde0fL,
1831: };
1832: static final long[] jjtoSkip = {
1833: 0x1f0L,
1834: };
1835: protected SimpleCharStream input_stream;
1836: private final int[] jjrounds = new int[35];
1837: private final int[] jjstateSet = new int[70];
1838: private final StringBuilder jjimage = new StringBuilder();
1839: private StringBuilder image = jjimage;
1840: private int jjimageLen;
1841: private int lengthOfMatch;
1842: protected char curChar;
1843: /** Constructor. */
1844: public ELParserTokenManager(SimpleCharStream stream){
1845: if (SimpleCharStream.staticFlag)
1846: throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
1847: input_stream = stream;
1848: }
1849:
1850: /** Constructor. */
1851: public ELParserTokenManager(SimpleCharStream stream, int lexState){
1852: this(stream);
1853: SwitchTo(lexState);
1854: }
1855:
1856: /** Reinitialise parser. */
1857: public void ReInit(SimpleCharStream stream)
1858: {
1859: jjmatchedPos = jjnewStateCnt = 0;
1860: curLexState = defaultLexState;
1861: input_stream = stream;
1862: ReInitRounds();
1863: }
1864: private void ReInitRounds()
1865: {
1866: int i;
1867: jjround = 0x80000001;
1868: for (i = 35; i-- > 0;)
1869: jjrounds[i] = 0x80000000;
1870: }
1871:
1872: /** Reinitialise parser. */
1873: public void ReInit(SimpleCharStream stream, int lexState)
1874: {
1875: ReInit(stream);
1876: SwitchTo(lexState);
1877: }
1878:
1879: /** Switch to specified lex state. */
1880: public void SwitchTo(int lexState)
1881: {
1882: if (lexState >= 3 || lexState < 0)
1883: throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
1884: else
1885: curLexState = lexState;
1886: }
1887:
1888: protected Token jjFillToken()
1889: {
1890: final Token t;
1891: final String curTokenImage;
1892: final int beginLine;
1893: final int endLine;
1894: final int beginColumn;
1895: final int endColumn;
1896: String im = jjstrLiteralImages[jjmatchedKind];
1897: curTokenImage = (im == null) ? input_stream.GetImage() : im;
1898: beginLine = input_stream.getBeginLine();
1899: beginColumn = input_stream.getBeginColumn();
1900: endLine = input_stream.getEndLine();
1901: endColumn = input_stream.getEndColumn();
1902: t = Token.newToken(jjmatchedKind);
1903: t.kind = jjmatchedKind;
1904: t.image = curTokenImage;
1905:
1906: t.beginLine = beginLine;
1907: t.endLine = endLine;
1908: t.beginColumn = beginColumn;
1909: t.endColumn = endColumn;
1910:
1911: return t;
1912: }
1913:
1914: int curLexState = 0;
1915: int defaultLexState = 0;
1916: int jjnewStateCnt;
1917: int jjround;
1918: int jjmatchedPos;
1919: int jjmatchedKind;
1920:
1921: /** Get the next Token. */
1922: public Token getNextToken()
1923: {
1924: Token matchedToken;
1925: int curPos = 0;
1926:
1927: EOFLoop :
1928: for (;;)
1929: {
1930: try
1931: {
1932: curChar = input_stream.BeginToken();
1933: }
1934: catch(java.io.IOException e)
1935: {
1936: jjmatchedKind = 0;
1937: matchedToken = jjFillToken();
1938: return matchedToken;
1939: }
1940: image = jjimage;
1941: image.setLength(0);
1942: jjimageLen = 0;
1943:
1944: switch(curLexState)
1945: {
1946: case 0:
1947: jjmatchedKind = 0x7fffffff;
1948: jjmatchedPos = 0;
1949: curPos = jjMoveStringLiteralDfa0_0();
1950: break;
1951: case 1:
1952: try { input_stream.backup(0);
1953: while (curChar <= 32 && (0x100002600L & (1L << curChar)) != 0L)
1954: curChar = input_stream.BeginToken();
1955: }
1956: catch (java.io.IOException e1) { continue EOFLoop; }
1957: jjmatchedKind = 0x7fffffff;
1958: jjmatchedPos = 0;
1959: curPos = jjMoveStringLiteralDfa0_1();
1960: if (jjmatchedPos == 0 && jjmatchedKind > 62)
1961: {
1962: jjmatchedKind = 62;
1963: }
1964: break;
1965: case 2:
1966: try { input_stream.backup(0);
1967: while (curChar <= 32 && (0x100002600L & (1L << curChar)) != 0L)
1968: curChar = input_stream.BeginToken();
1969: }
1970: catch (java.io.IOException e1) { continue EOFLoop; }
1971: jjmatchedKind = 0x7fffffff;
1972: jjmatchedPos = 0;
1973: curPos = jjMoveStringLiteralDfa0_2();
1974: if (jjmatchedPos == 0 && jjmatchedKind > 62)
1975: {
1976: jjmatchedKind = 62;
1977: }
1978: break;
1979: }
1980: if (jjmatchedKind != 0x7fffffff)
1981: {
1982: if (jjmatchedPos + 1 < curPos)
1983: input_stream.backup(curPos - jjmatchedPos - 1);
1984: if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
1985: {
1986: matchedToken = jjFillToken();
1987: TokenLexicalActions(matchedToken);
1988: if (jjnewLexState[jjmatchedKind] != -1)
1989: curLexState = jjnewLexState[jjmatchedKind];
1990: return matchedToken;
1991: }
1992: else
1993: {
1994: if (jjnewLexState[jjmatchedKind] != -1)
1995: curLexState = jjnewLexState[jjmatchedKind];
1996: continue EOFLoop;
1997: }
1998: }
1999: int error_line = input_stream.getEndLine();
2000: int error_column = input_stream.getEndColumn();
2001: String error_after = null;
2002: boolean EOFSeen = false;
2003: try { input_stream.readChar(); input_stream.backup(1); }
2004: catch (java.io.IOException e1) {
2005: EOFSeen = true;
2006: error_after = curPos <= 1 ? "" : input_stream.GetImage();
2007: if (curChar == '\n' || curChar == '\r') {
2008: error_line++;
2009: error_column = 0;
2010: }
2011: else
2012: error_column++;
2013: }
2014: if (!EOFSeen) {
2015: input_stream.backup(1);
2016: error_after = curPos <= 1 ? "" : input_stream.GetImage();
2017: }
2018: throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
2019: }
2020: }
2021:
2022: void TokenLexicalActions(Token matchedToken)
2023: {
2024: switch(jjmatchedKind)
2025: {
2026: case 2 :
2027: image.append(jjstrLiteralImages[2]);
2028: lengthOfMatch = jjstrLiteralImages[2].length();
2029: stack.push(DEFAULT);
2030: break;
2031: case 3 :
2032: image.append(jjstrLiteralImages[3]);
2033: lengthOfMatch = jjstrLiteralImages[3].length();
2034: stack.push(DEFAULT);
2035: break;
2036: case 9 :
2037: image.append(jjstrLiteralImages[9]);
2038: lengthOfMatch = jjstrLiteralImages[9].length();
2039: stack.push(curLexState);
2040: break;
2041: case 10 :
2042: image.append(jjstrLiteralImages[10]);
2043: lengthOfMatch = jjstrLiteralImages[10].length();
2044: SwitchTo(stack.pop());
2045: break;
2046: default :
2047: break;
2048: }
2049: }
2050: private void jjCheckNAdd(int state)
2051: {
2052:• if (jjrounds[state] != jjround)
2053: {
2054: jjstateSet[jjnewStateCnt++] = state;
2055: jjrounds[state] = jjround;
2056: }
2057: }
2058: private void jjAddStates(int start, int end)
2059: {
2060: do {
2061: jjstateSet[jjnewStateCnt++] = jjnextStates[start];
2062: } while (start++ != end);
2063: }
2064: private void jjCheckNAddTwoStates(int state1, int state2)
2065: {
2066: jjCheckNAdd(state1);
2067: jjCheckNAdd(state2);
2068: }
2069:
2070: private void jjCheckNAddStates(int start, int end)
2071: {
2072: do {
2073: jjCheckNAdd(jjnextStates[start]);
2074: } while (start++ != end);
2075: }
2076:
2077: }