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:
20:
21: public class GeneratedFormulaParserTokenManager implements GeneratedFormulaParserConstants
22: {
23:
24:
25: public java.io.PrintStream debugStream = System.out;
26:
27: public void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
28: private int jjStopAtPos(int pos, int kind)
29: {
30: jjmatchedKind = kind;
31: jjmatchedPos = pos;
32: return pos + 1;
33: }
34: private int jjMoveStringLiteralDfa0_0()
35: {
36: switch(curChar)
37: {
38: case 37:
39: jjmatchedKind = 39;
40: return jjMoveNfa_0(0, 0);
41: case 38:
42: jjmatchedKind = 38;
43: return jjMoveNfa_0(0, 0);
44: case 40:
45: jjmatchedKind = 19;
46: return jjMoveNfa_0(0, 0);
47: case 41:
48: jjmatchedKind = 20;
49: return jjMoveNfa_0(0, 0);
50: case 42:
51: jjmatchedKind = 29;
52: return jjMoveNfa_0(0, 0);
53: case 43:
54: jjmatchedKind = 27;
55: return jjMoveNfa_0(0, 0);
56: case 44:
57: jjmatchedKind = 13;
58: return jjMoveNfa_0(0, 0);
59: case 45:
60: jjmatchedKind = 28;
61: return jjMoveNfa_0(0, 0);
62: case 47:
63: jjmatchedKind = 30;
64: return jjMoveNfa_0(0, 0);
65: case 59:
66: jjmatchedKind = 18;
67: return jjMoveNfa_0(0, 0);
68: case 60:
69: jjmatchedKind = 36;
70: return jjMoveStringLiteralDfa1_0(0x600000000L);
71: case 61:
72: jjmatchedKind = 32;
73: return jjMoveNfa_0(0, 0);
74: case 62:
75: jjmatchedKind = 37;
76: return jjMoveStringLiteralDfa1_0(0x800000000L);
77: case 63:
78: jjmatchedKind = 23;
79: return jjMoveNfa_0(0, 0);
80: case 78:
81: return jjMoveStringLiteralDfa1_0(0x1000000000000L);
82: case 91:
83: jjmatchedKind = 21;
84: return jjMoveNfa_0(0, 0);
85: case 93:
86: jjmatchedKind = 22;
87: return jjMoveNfa_0(0, 0);
88: case 94:
89: jjmatchedKind = 31;
90: return jjMoveNfa_0(0, 0);
91: case 110:
92: return jjMoveStringLiteralDfa1_0(0x1000000000000L);
93: case 123:
94: jjmatchedKind = 24;
95: return jjMoveNfa_0(0, 0);
96: case 124:
97: jjmatchedKind = 26;
98: return jjMoveNfa_0(0, 0);
99: case 125:
100: jjmatchedKind = 25;
101: return jjMoveNfa_0(0, 0);
102: default :
103: return jjMoveNfa_0(0, 0);
104: }
105: }
106: private int jjMoveStringLiteralDfa1_0(long active0)
107: {
108: try { curChar = input_stream.readChar(); }
109: catch(java.io.IOException e) {
110: return jjMoveNfa_0(0, 0);
111: }
112: switch(curChar)
113: {
114: case 61:
115: if ((active0 & 0x400000000L) != 0L)
116: {
117: jjmatchedKind = 34;
118: jjmatchedPos = 1;
119: }
120: else if ((active0 & 0x800000000L) != 0L)
121: {
122: jjmatchedKind = 35;
123: jjmatchedPos = 1;
124: }
125: break;
126: case 62:
127: if ((active0 & 0x200000000L) != 0L)
128: {
129: jjmatchedKind = 33;
130: jjmatchedPos = 1;
131: }
132: break;
133: case 85:
134: return jjMoveStringLiteralDfa2_0(active0, 0x1000000000000L);
135: case 117:
136: return jjMoveStringLiteralDfa2_0(active0, 0x1000000000000L);
137: default :
138: break;
139: }
140: return jjMoveNfa_0(0, 1);
141: }
142: private int jjMoveStringLiteralDfa2_0(long old0, long active0)
143: {
144: if (((active0 &= old0)) == 0L)
145: return jjMoveNfa_0(0, 1);
146: try { curChar = input_stream.readChar(); }
147: catch(java.io.IOException e) {
148: return jjMoveNfa_0(0, 1);
149: }
150: switch(curChar)
151: {
152: case 76:
153: return jjMoveStringLiteralDfa3_0(active0, 0x1000000000000L);
154: case 108:
155: return jjMoveStringLiteralDfa3_0(active0, 0x1000000000000L);
156: default :
157: break;
158: }
159: return jjMoveNfa_0(0, 2);
160: }
161: private int jjMoveStringLiteralDfa3_0(long old0, long active0)
162: {
163: if (((active0 &= old0)) == 0L)
164: return jjMoveNfa_0(0, 2);
165: try { curChar = input_stream.readChar(); }
166: catch(java.io.IOException e) {
167: return jjMoveNfa_0(0, 2);
168: }
169: switch(curChar)
170: {
171: case 76:
172: if ((active0 & 0x1000000000000L) != 0L)
173: {
174: jjmatchedKind = 48;
175: jjmatchedPos = 3;
176: }
177: break;
178: case 108:
179: if ((active0 & 0x1000000000000L) != 0L)
180: {
181: jjmatchedKind = 48;
182: jjmatchedPos = 3;
183: }
184: break;
185: default :
186: break;
187: }
188: return jjMoveNfa_0(0, 3);
189: }
190: static final long[] jjbitVec0 = {
191: 0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
192: };
193: static final long[] jjbitVec2 = {
194: 0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
195: };
196: private int jjMoveNfa_0(int startState, int curPos)
197: {
198: int strKind = jjmatchedKind;
199: int strPos = jjmatchedPos;
200: int seenUpto;
201: input_stream.backup(seenUpto = curPos + 1);
202: try { curChar = input_stream.readChar(); }
203: catch(java.io.IOException e) { throw new Error("Internal Error"); }
204: curPos = 0;
205: int startsAt = 0;
206: jjnewStateCnt = 45;
207: int i = 1;
208: jjstateSet[0] = startState;
209: int kind = 0x7fffffff;
210: for (;;)
211: {
212: if (++jjround == 0x7fffffff)
213: ReInitRounds();
214: if (curChar < 64)
215: {
216: long l = 1L << curChar;
217: do
218: {
219: switch(jjstateSet[--i])
220: {
221: case 0:
222: if ((0x1ffffffffL & l) != 0L)
223: {
224: if (kind > 1)
225: kind = 1;
226: }
227: else if ((0x3fe000000000000L & l) != 0L)
228: {
229: if (kind > 8)
230: kind = 8;
231: jjCheckNAddStates(0, 5);
232: }
233: else if (curChar == 48)
234: {
235: if (kind > 8)
236: kind = 8;
237: jjCheckNAddStates(6, 8);
238: }
239: else if (curChar == 46)
240: jjCheckNAddStates(9, 12);
241: else if (curChar == 34)
242: jjCheckNAddStates(13, 16);
243: else if (curChar == 36)
244: {
245: if (kind > 40)
246: kind = 40;
247: jjCheckNAddTwoStates(8, 9);
248: }
249: else if (curChar == 45)
250: jjstateSet[jjnewStateCnt++] = 1;
251: break;
252: case 1:
253: if (curChar == 45)
254: jjCheckNAddStates(17, 19);
255: break;
256: case 2:
257: if ((0xffffffffffffdbffL & l) != 0L)
258: jjCheckNAddStates(17, 19);
259: break;
260: case 3:
261: if ((0x2400L & l) != 0L && kind > 2)
262: kind = 2;
263: break;
264: case 4:
265: if (curChar == 10 && kind > 2)
266: kind = 2;
267: break;
268: case 5:
269: if (curChar == 13)
270: jjstateSet[jjnewStateCnt++] = 4;
271: break;
272: case 6:
273: if (curChar == 45)
274: jjstateSet[jjnewStateCnt++] = 1;
275: break;
276: case 7:
277: if (curChar != 36)
278: break;
279: if (kind > 40)
280: kind = 40;
281: jjCheckNAddTwoStates(8, 9);
282: break;
283: case 8:
284: if ((0x3ff001000000000L & l) == 0L)
285: break;
286: if (kind > 40)
287: kind = 40;
288: jjCheckNAddTwoStates(8, 9);
289: break;
290: case 9:
291: if (curChar != 46)
292: break;
293: if (kind > 40)
294: kind = 40;
295: jjCheckNAdd(10);
296: break;
297: case 10:
298: if ((0x3ff001000000000L & l) == 0L)
299: break;
300: if (kind > 40)
301: kind = 40;
302: jjCheckNAdd(10);
303: break;
304: case 13:
305: if (curChar == 34)
306: jjCheckNAddStates(20, 22);
307: break;
308: case 14:
309: jjCheckNAddStates(20, 22);
310: break;
311: case 16:
312: case 17:
313: case 20:
314: if (curChar == 34)
315: jjCheckNAddStates(13, 16);
316: break;
317: case 18:
318: if (curChar == 34)
319: jjstateSet[jjnewStateCnt++] = 17;
320: break;
321: case 21:
322: if ((0xfffffffbffffffffL & l) != 0L)
323: jjCheckNAddStates(13, 16);
324: break;
325: case 22:
326: if (curChar == 34 && kind > 42)
327: kind = 42;
328: break;
329: case 23:
330: if (curChar == 46)
331: jjCheckNAddStates(9, 12);
332: break;
333: case 24:
334: if (curChar == 48)
335: jjCheckNAdd(25);
336: break;
337: case 26:
338: if ((0x280000000000L & l) != 0L)
339: jjCheckNAddTwoStates(27, 28);
340: break;
341: case 27:
342: if (curChar == 48 && kind > 43)
343: kind = 43;
344: break;
345: case 28:
346: if ((0x3fe000000000000L & l) == 0L)
347: break;
348: if (kind > 43)
349: kind = 43;
350: jjCheckNAdd(29);
351: break;
352: case 29:
353: if ((0x3ff000000000000L & l) == 0L)
354: break;
355: if (kind > 43)
356: kind = 43;
357: jjCheckNAdd(29);
358: break;
359: case 30:
360: if ((0x3fe000000000000L & l) != 0L)
361: jjCheckNAddTwoStates(31, 25);
362: break;
363: case 31:
364: if ((0x3ff000000000000L & l) != 0L)
365: jjCheckNAddTwoStates(31, 25);
366: break;
367: case 32:
368: if ((0x3fe000000000000L & l) == 0L)
369: break;
370: if (kind > 43)
371: kind = 43;
372: jjCheckNAdd(33);
373: break;
374: case 33:
375: if ((0x3ff000000000000L & l) == 0L)
376: break;
377: if (kind > 43)
378: kind = 43;
379: jjCheckNAdd(33);
380: break;
381: case 34:
382: if (curChar != 48)
383: break;
384: if (kind > 8)
385: kind = 8;
386: jjCheckNAddStates(6, 8);
387: break;
388: case 35:
389: if (curChar == 46)
390: jjCheckNAddTwoStates(24, 36);
391: break;
392: case 36:
393: if ((0x3fe000000000000L & l) != 0L)
394: jjCheckNAddTwoStates(37, 25);
395: break;
396: case 37:
397: if ((0x3ff000000000000L & l) != 0L)
398: jjCheckNAddTwoStates(37, 25);
399: break;
400: case 38:
401: if (curChar == 46)
402: jjCheckNAddTwoStates(27, 39);
403: break;
404: case 39:
405: if ((0x3fe000000000000L & l) == 0L)
406: break;
407: if (kind > 43)
408: kind = 43;
409: jjCheckNAdd(40);
410: break;
411: case 40:
412: if ((0x3ff000000000000L & l) == 0L)
413: break;
414: if (kind > 43)
415: kind = 43;
416: jjCheckNAdd(40);
417: break;
418: case 41:
419: if ((0x3fe000000000000L & l) == 0L)
420: break;
421: if (kind > 8)
422: kind = 8;
423: jjCheckNAddStates(0, 5);
424: break;
425: case 42:
426: if ((0x3ff000000000000L & l) == 0L)
427: break;
428: if (kind > 8)
429: kind = 8;
430: jjCheckNAdd(42);
431: break;
432: case 43:
433: if ((0x3ff000000000000L & l) != 0L)
434: jjCheckNAddStates(23, 25);
435: break;
436: case 44:
437: if ((0x3ff000000000000L & l) == 0L)
438: break;
439: if (kind > 43)
440: kind = 43;
441: jjCheckNAddTwoStates(44, 38);
442: break;
443: default : break;
444: }
445: } while(i != startsAt);
446: }
447: else if (curChar < 128)
448: {
449: long l = 1L << (curChar & 077);
450: do
451: {
452: switch(jjstateSet[--i])
453: {
454: case 0:
455: if ((0x7fffffe87fffffeL & l) != 0L)
456: {
457: if (kind > 40)
458: kind = 40;
459: jjCheckNAddTwoStates(8, 9);
460: }
461: else if (curChar == 91)
462: jjCheckNAddStates(20, 22);
463: break;
464: case 2:
465: jjAddStates(17, 19);
466: break;
467: case 7:
468: case 8:
469: if ((0x7fffffe87fffffeL & l) == 0L)
470: break;
471: if (kind > 40)
472: kind = 40;
473: jjCheckNAddTwoStates(8, 9);
474: break;
475: case 10:
476: if ((0x7fffffe87fffffeL & l) == 0L)
477: break;
478: if (kind > 40)
479: kind = 40;
480: jjstateSet[jjnewStateCnt++] = 10;
481: break;
482: case 11:
483: if (curChar == 91)
484: jjCheckNAddStates(20, 22);
485: break;
486: case 12:
487: if (curChar == 92)
488: jjstateSet[jjnewStateCnt++] = 13;
489: break;
490: case 13:
491: if ((0x7fffffe37fffffeL & l) != 0L)
492: jjCheckNAddStates(20, 22);
493: break;
494: case 14:
495: if ((0xffffffffdfffffffL & l) != 0L)
496: jjCheckNAddStates(20, 22);
497: break;
498: case 15:
499: if (curChar == 93 && kind > 41)
500: kind = 41;
501: break;
502: case 19:
503: if (curChar == 92)
504: jjstateSet[jjnewStateCnt++] = 20;
505: break;
506: case 20:
507: if ((0x7fffffe17fffffeL & l) != 0L)
508: jjCheckNAddStates(13, 16);
509: break;
510: case 21:
511: jjCheckNAddStates(13, 16);
512: break;
513: case 25:
514: if ((0x2000000020L & l) != 0L)
515: jjAddStates(26, 28);
516: break;
517: default : break;
518: }
519: } while(i != startsAt);
520: }
521: else
522: {
523: int hiByte = (int)(curChar >> 8);
524: int i1 = hiByte >> 6;
525: long l1 = 1L << (hiByte & 077);
526: int i2 = (curChar & 0xff) >> 6;
527: long l2 = 1L << (curChar & 077);
528: do
529: {
530: switch(jjstateSet[--i])
531: {
532: case 2:
533: if (jjCanMove_0(hiByte, i1, i2, l1, l2))
534: jjAddStates(17, 19);
535: break;
536: case 14:
537: if (jjCanMove_0(hiByte, i1, i2, l1, l2))
538: jjAddStates(20, 22);
539: break;
540: case 21:
541: if (jjCanMove_0(hiByte, i1, i2, l1, l2))
542: jjAddStates(13, 16);
543: break;
544: default : break;
545: }
546: } while(i != startsAt);
547: }
548: if (kind != 0x7fffffff)
549: {
550: jjmatchedKind = kind;
551: jjmatchedPos = curPos;
552: kind = 0x7fffffff;
553: }
554: ++curPos;
555: if ((i = jjnewStateCnt) == (startsAt = 45 - (jjnewStateCnt = startsAt)))
556: break;
557: try { curChar = input_stream.readChar(); }
558: catch(java.io.IOException e) { break; }
559: }
560: if (jjmatchedPos > strPos)
561: return curPos;
562:
563: int toRet = Math.max(curPos, seenUpto);
564:
565: if (curPos < toRet)
566: for (i = toRet - Math.min(curPos, seenUpto); i-- > 0; )
567: try { curChar = input_stream.readChar(); }
568: catch(java.io.IOException e) { throw new Error("Internal Error : Please send a bug report."); }
569:
570: if (jjmatchedPos < strPos)
571: {
572: jjmatchedKind = strKind;
573: jjmatchedPos = strPos;
574: }
575: else if (jjmatchedPos == strPos && jjmatchedKind > strKind)
576: jjmatchedKind = strKind;
577:
578: return toRet;
579: }
580: static final int[] jjnextStates = {
581: 42, 43, 35, 25, 44, 38, 35, 25, 38, 24, 30, 27, 32, 18, 19, 21,
582: 22, 2, 3, 5, 12, 14, 15, 43, 35, 25, 26, 27, 28,
583: };
584: private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2)
585: {
586: switch(hiByte)
587: {
588: case 0:
589: return ((jjbitVec2[i2] & l2) != 0L);
590: default :
591: if ((jjbitVec0[i1] & l1) != 0L)
592: return true;
593: return false;
594: }
595: }
596:
597:
598: public static final String[] jjstrLiteralImages = {
599: "", null, null, null, null, null, null, null, null, null, null, null, null,
600: "\54", null, null, null, null, "\73", "\50", "\51", "\133", "\135", "\77", "\173",
601: "\175", "\174", "\53", "\55", "\52", "\57", "\136", "\75", "\74\76", "\74\75",
602: "\76\75", "\74", "\76", "\46", "\45", null, null, null, null, null, null, null, null,
603: null, };
604:
605:
606: public static final String[] lexStateNames = {
607: "DEFAULT",
608: };
609: static final long[] jjtoToken = {
610: 0x10ffffffc2101L,
611: };
612: static final long[] jjtoSkip = {
613: 0x6L,
614: };
615: protected JavaCharStream input_stream;
616: private final int[] jjrounds = new int[45];
617: private final int[] jjstateSet = new int[90];
618: protected char curChar;
619:
620: public GeneratedFormulaParserTokenManager(JavaCharStream stream){
621: if (JavaCharStream.staticFlag)
622: throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
623: input_stream = stream;
624: }
625:
626:
627: public GeneratedFormulaParserTokenManager(JavaCharStream stream, int lexState){
628: this(stream);
629: SwitchTo(lexState);
630: }
631:
632:
633: public void ReInit(JavaCharStream stream)
634: {
635: jjmatchedPos = jjnewStateCnt = 0;
636: curLexState = defaultLexState;
637: input_stream = stream;
638: ReInitRounds();
639: }
640: private void ReInitRounds()
641: {
642: int i;
643: jjround = 0x80000001;
644: for (i = 45; i-- > 0;)
645: jjrounds[i] = 0x80000000;
646: }
647:
648:
649: public void ReInit(JavaCharStream stream, int lexState)
650: {
651: ReInit(stream);
652: SwitchTo(lexState);
653: }
654:
655:
656: public void SwitchTo(int lexState)
657: {
658: if (lexState >= 1 || lexState < 0)
659: throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
660: else
661: curLexState = lexState;
662: }
663:
664: protected Token jjFillToken()
665: {
666: final Token t;
667: final String curTokenImage;
668: final int beginLine;
669: final int endLine;
670: final int beginColumn;
671: final int endColumn;
672: String im = jjstrLiteralImages[jjmatchedKind];
673: curTokenImage = (im == null) ? input_stream.GetImage() : im;
674: beginLine = input_stream.getBeginLine();
675: beginColumn = input_stream.getBeginColumn();
676: endLine = input_stream.getEndLine();
677: endColumn = input_stream.getEndColumn();
678: t = Token.newToken(jjmatchedKind, curTokenImage);
679:
680: t.beginLine = beginLine;
681: t.endLine = endLine;
682: t.beginColumn = beginColumn;
683: t.endColumn = endColumn;
684:
685: return t;
686: }
687:
688: int curLexState = 0;
689: int defaultLexState = 0;
690: int jjnewStateCnt;
691: int jjround;
692: int jjmatchedPos;
693: int jjmatchedKind;
694:
695:
696: public Token getNextToken()
697: {
698: Token matchedToken;
699: int curPos = 0;
700:
701: EOFLoop :
702: for (;;)
703: {
704: try
705: {
706: curChar = input_stream.BeginToken();
707: }
708: catch(java.io.IOException e)
709: {
710: jjmatchedKind = 0;
711: matchedToken = jjFillToken();
712: return matchedToken;
713: }
714:
715: jjmatchedKind = 0x7fffffff;
716: jjmatchedPos = 0;
717: curPos = jjMoveStringLiteralDfa0_0();
718: if (jjmatchedKind != 0x7fffffff)
719: {
720: if (jjmatchedPos + 1 < curPos)
721: input_stream.backup(curPos - jjmatchedPos - 1);
722: if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
723: {
724: matchedToken = jjFillToken();
725: return matchedToken;
726: }
727: else
728: {
729: continue EOFLoop;
730: }
731: }
732: int error_line = input_stream.getEndLine();
733: int error_column = input_stream.getEndColumn();
734: String error_after = null;
735: boolean EOFSeen = false;
736: try { input_stream.readChar(); input_stream.backup(1); }
737: catch (java.io.IOException e1) {
738: EOFSeen = true;
739: error_after = curPos <= 1 ? "" : input_stream.GetImage();
740: if (curChar == '\n' || curChar == '\r') {
741: error_line++;
742: error_column = 0;
743: }
744: else
745: error_column++;
746: }
747: if (!EOFSeen) {
748: input_stream.backup(1);
749: error_after = curPos <= 1 ? "" : input_stream.GetImage();
750: }
751: throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
752: }
753: }
754:
755: private void jjCheckNAdd(int state)
756: {
757: if (jjrounds[state] != jjround)
758: {
759: jjstateSet[jjnewStateCnt++] = state;
760: jjrounds[state] = jjround;
761: }
762: }
763: private void jjAddStates(int start, int end)
764: {
765: do {
766: jjstateSet[jjnewStateCnt++] = jjnextStates[start];
767: } while (start++ != end);
768: }
769: private void jjCheckNAddTwoStates(int state1, int state2)
770: {
771: jjCheckNAdd(state1);
772: jjCheckNAdd(state2);
773: }
774:
775: private void jjCheckNAddStates(int start, int end)
776: {
777: do {
778: jjCheckNAdd(jjnextStates[start]);
779: } while (start++ != end);
780: }
781:
782: }