001: /* Generated By:JavaCC: Do not edit this line. ArchiveParserTokenManager.java */
002: package org.apache.commons.jrcs.rcs;
003:
004: public class ArchiveParserTokenManager implements
005: ArchiveParserConstants {
006: public java.io.PrintStream debugStream = System.out;
007:
008: public void setDebugStream(java.io.PrintStream ds) {
009: debugStream = ds;
010: }
011:
012: private final int jjStopStringLiteralDfa_0(int pos, long active0) {
013: switch (pos) {
014: case 0:
015: if ((active0 & 0x40000000L) != 0L)
016: return 1;
017: if ((active0 & 0x3fffc0L) != 0L) {
018: jjmatchedKind = 22;
019: return 14;
020: }
021: return -1;
022: case 1:
023: if ((active0 & 0x3fffc0L) != 0L) {
024: jjmatchedKind = 22;
025: jjmatchedPos = 1;
026: return 14;
027: }
028: return -1;
029: case 2:
030: if ((active0 & 0x3effc0L) != 0L) {
031: jjmatchedKind = 22;
032: jjmatchedPos = 2;
033: return 14;
034: }
035: if ((active0 & 0x10000L) != 0L)
036: return 14;
037: return -1;
038: case 3:
039: if ((active0 & 0x1ca7c0L) != 0L) {
040: jjmatchedKind = 22;
041: jjmatchedPos = 3;
042: return 14;
043: }
044: if ((active0 & 0x225800L) != 0L)
045: return 14;
046: return -1;
047: case 4:
048: if ((active0 & 0x1827c0L) != 0L) {
049: jjmatchedKind = 22;
050: jjmatchedPos = 4;
051: return 14;
052: }
053: if ((active0 & 0x48000L) != 0L)
054: return 14;
055: return -1;
056: case 5:
057: if ((active0 & 0x823c0L) != 0L)
058: return 14;
059: if ((active0 & 0x100400L) != 0L) {
060: if (jjmatchedPos != 5) {
061: jjmatchedKind = 22;
062: jjmatchedPos = 5;
063: }
064: return 14;
065: }
066: return -1;
067: case 6:
068: if ((active0 & 0x200L) != 0L) {
069: jjmatchedKind = 22;
070: jjmatchedPos = 6;
071: return 14;
072: }
073: if ((active0 & 0x100400L) != 0L)
074: return 14;
075: return -1;
076: default:
077: return -1;
078: }
079: }
080:
081: private final int jjStartNfa_0(int pos, long active0) {
082: return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0),
083: pos + 1);
084: }
085:
086: private final int jjStopAtPos(int pos, int kind) {
087: jjmatchedKind = kind;
088: jjmatchedPos = pos;
089: return pos + 1;
090: }
091:
092: private final int jjStartNfaWithStates_0(int pos, int kind,
093: int state) {
094: jjmatchedKind = kind;
095: jjmatchedPos = pos;
096: try {
097: curChar = input_stream.readChar();
098: } catch (java.io.IOException e) {
099: return pos + 1;
100: }
101: return jjMoveNfa_0(state, pos + 1);
102: }
103:
104: private final int jjMoveStringLiteralDfa0_0() {
105: switch (curChar) {
106: case 46:
107: return jjStartNfaWithStates_0(0, 30, 1);
108: case 58:
109: return jjStopAtPos(0, 29);
110: case 59:
111: return jjStopAtPos(0, 28);
112: case 97:
113: return jjMoveStringLiteralDfa1_0(0xc0L);
114: case 98:
115: return jjMoveStringLiteralDfa1_0(0x300L);
116: case 99:
117: return jjMoveStringLiteralDfa1_0(0x400L);
118: case 100:
119: return jjMoveStringLiteralDfa1_0(0x1800L);
120: case 101:
121: return jjMoveStringLiteralDfa1_0(0x2000L);
122: case 104:
123: return jjMoveStringLiteralDfa1_0(0x4000L);
124: case 108:
125: return jjMoveStringLiteralDfa1_0(0x18000L);
126: case 110:
127: return jjMoveStringLiteralDfa1_0(0x20000L);
128: case 115:
129: return jjMoveStringLiteralDfa1_0(0x1c0000L);
130: case 116:
131: return jjMoveStringLiteralDfa1_0(0x200000L);
132: default:
133: return jjMoveNfa_0(0, 0);
134: }
135: }
136:
137: private final int jjMoveStringLiteralDfa1_0(long active0) {
138: try {
139: curChar = input_stream.readChar();
140: } catch (java.io.IOException e) {
141: jjStopStringLiteralDfa_0(0, active0);
142: return 1;
143: }
144: switch (curChar) {
145: case 97:
146: return jjMoveStringLiteralDfa2_0(active0, 0x800L);
147: case 99:
148: return jjMoveStringLiteralDfa2_0(active0, 0x40L);
149: case 101:
150: return jjMoveStringLiteralDfa2_0(active0, 0x225000L);
151: case 111:
152: return jjMoveStringLiteralDfa2_0(active0, 0x18400L);
153: case 114:
154: return jjMoveStringLiteralDfa2_0(active0, 0x300L);
155: case 116:
156: return jjMoveStringLiteralDfa2_0(active0, 0xc0000L);
157: case 117:
158: return jjMoveStringLiteralDfa2_0(active0, 0x80L);
159: case 120:
160: return jjMoveStringLiteralDfa2_0(active0, 0x2000L);
161: case 121:
162: return jjMoveStringLiteralDfa2_0(active0, 0x100000L);
163: default:
164: break;
165: }
166: return jjStartNfa_0(0, active0);
167: }
168:
169: private final int jjMoveStringLiteralDfa2_0(long old0, long active0) {
170: if (((active0 &= old0)) == 0L)
171: return jjStartNfa_0(0, old0);
172: try {
173: curChar = input_stream.readChar();
174: } catch (java.io.IOException e) {
175: jjStopStringLiteralDfa_0(1, active0);
176: return 2;
177: }
178: switch (curChar) {
179: case 97:
180: return jjMoveStringLiteralDfa3_0(active0, 0x44300L);
181: case 99:
182: return jjMoveStringLiteralDfa3_0(active0, 0x8040L);
183: case 103:
184: if ((active0 & 0x10000L) != 0L)
185: return jjStartNfaWithStates_0(2, 16, 14);
186: break;
187: case 109:
188: return jjMoveStringLiteralDfa3_0(active0, 0x100400L);
189: case 112:
190: return jjMoveStringLiteralDfa3_0(active0, 0x2000L);
191: case 114:
192: return jjMoveStringLiteralDfa3_0(active0, 0x80000L);
193: case 115:
194: return jjMoveStringLiteralDfa3_0(active0, 0x1000L);
195: case 116:
196: return jjMoveStringLiteralDfa3_0(active0, 0x880L);
197: case 120:
198: return jjMoveStringLiteralDfa3_0(active0, 0x220000L);
199: default:
200: break;
201: }
202: return jjStartNfa_0(1, active0);
203: }
204:
205: private final int jjMoveStringLiteralDfa3_0(long old0, long active0) {
206: if (((active0 &= old0)) == 0L)
207: return jjStartNfa_0(1, old0);
208: try {
209: curChar = input_stream.readChar();
210: } catch (java.io.IOException e) {
211: jjStopStringLiteralDfa_0(2, active0);
212: return 3;
213: }
214: switch (curChar) {
215: case 97:
216: return jjMoveStringLiteralDfa4_0(active0, 0x2000L);
217: case 98:
218: return jjMoveStringLiteralDfa4_0(active0, 0x100000L);
219: case 99:
220: if ((active0 & 0x1000L) != 0L)
221: return jjStartNfaWithStates_0(3, 12, 14);
222: break;
223: case 100:
224: if ((active0 & 0x4000L) != 0L)
225: return jjStartNfaWithStates_0(3, 14, 14);
226: break;
227: case 101:
228: if ((active0 & 0x800L) != 0L)
229: return jjStartNfaWithStates_0(3, 11, 14);
230: return jjMoveStringLiteralDfa4_0(active0, 0x40L);
231: case 104:
232: return jjMoveStringLiteralDfa4_0(active0, 0x80L);
233: case 105:
234: return jjMoveStringLiteralDfa4_0(active0, 0x80000L);
235: case 107:
236: return jjMoveStringLiteralDfa4_0(active0, 0x8000L);
237: case 109:
238: return jjMoveStringLiteralDfa4_0(active0, 0x400L);
239: case 110:
240: return jjMoveStringLiteralDfa4_0(active0, 0x300L);
241: case 116:
242: if ((active0 & 0x20000L) != 0L)
243: return jjStartNfaWithStates_0(3, 17, 14);
244: else if ((active0 & 0x200000L) != 0L)
245: return jjStartNfaWithStates_0(3, 21, 14);
246: return jjMoveStringLiteralDfa4_0(active0, 0x40000L);
247: default:
248: break;
249: }
250: return jjStartNfa_0(2, active0);
251: }
252:
253: private final int jjMoveStringLiteralDfa4_0(long old0, long active0) {
254: if (((active0 &= old0)) == 0L)
255: return jjStartNfa_0(2, old0);
256: try {
257: curChar = input_stream.readChar();
258: } catch (java.io.IOException e) {
259: jjStopStringLiteralDfa_0(3, active0);
260: return 4;
261: }
262: switch (curChar) {
263: case 99:
264: return jjMoveStringLiteralDfa5_0(active0, 0x80300L);
265: case 101:
266: if ((active0 & 0x40000L) != 0L)
267: return jjStartNfaWithStates_0(4, 18, 14);
268: return jjMoveStringLiteralDfa5_0(active0, 0x400L);
269: case 110:
270: return jjMoveStringLiteralDfa5_0(active0, 0x2000L);
271: case 111:
272: return jjMoveStringLiteralDfa5_0(active0, 0x100080L);
273: case 115:
274: if ((active0 & 0x8000L) != 0L)
275: return jjStartNfaWithStates_0(4, 15, 14);
276: return jjMoveStringLiteralDfa5_0(active0, 0x40L);
277: default:
278: break;
279: }
280: return jjStartNfa_0(3, active0);
281: }
282:
283: private final int jjMoveStringLiteralDfa5_0(long old0, long active0) {
284: if (((active0 &= old0)) == 0L)
285: return jjStartNfa_0(3, old0);
286: try {
287: curChar = input_stream.readChar();
288: } catch (java.io.IOException e) {
289: jjStopStringLiteralDfa_0(4, active0);
290: return 5;
291: }
292: switch (curChar) {
293: case 100:
294: if ((active0 & 0x2000L) != 0L)
295: return jjStartNfaWithStates_0(5, 13, 14);
296: break;
297: case 104:
298: if ((active0 & 0x100L) != 0L) {
299: jjmatchedKind = 8;
300: jjmatchedPos = 5;
301: }
302: return jjMoveStringLiteralDfa6_0(active0, 0x200L);
303: case 108:
304: return jjMoveStringLiteralDfa6_0(active0, 0x100000L);
305: case 110:
306: return jjMoveStringLiteralDfa6_0(active0, 0x400L);
307: case 114:
308: if ((active0 & 0x80L) != 0L)
309: return jjStartNfaWithStates_0(5, 7, 14);
310: break;
311: case 115:
312: if ((active0 & 0x40L) != 0L)
313: return jjStartNfaWithStates_0(5, 6, 14);
314: break;
315: case 116:
316: if ((active0 & 0x80000L) != 0L)
317: return jjStartNfaWithStates_0(5, 19, 14);
318: break;
319: default:
320: break;
321: }
322: return jjStartNfa_0(4, active0);
323: }
324:
325: private final int jjMoveStringLiteralDfa6_0(long old0, long active0) {
326: if (((active0 &= old0)) == 0L)
327: return jjStartNfa_0(4, old0);
328: try {
329: curChar = input_stream.readChar();
330: } catch (java.io.IOException e) {
331: jjStopStringLiteralDfa_0(5, active0);
332: return 6;
333: }
334: switch (curChar) {
335: case 101:
336: return jjMoveStringLiteralDfa7_0(active0, 0x200L);
337: case 115:
338: if ((active0 & 0x100000L) != 0L)
339: return jjStartNfaWithStates_0(6, 20, 14);
340: break;
341: case 116:
342: if ((active0 & 0x400L) != 0L)
343: return jjStartNfaWithStates_0(6, 10, 14);
344: break;
345: default:
346: break;
347: }
348: return jjStartNfa_0(5, active0);
349: }
350:
351: private final int jjMoveStringLiteralDfa7_0(long old0, long active0) {
352: if (((active0 &= old0)) == 0L)
353: return jjStartNfa_0(5, old0);
354: try {
355: curChar = input_stream.readChar();
356: } catch (java.io.IOException e) {
357: jjStopStringLiteralDfa_0(6, active0);
358: return 7;
359: }
360: switch (curChar) {
361: case 115:
362: if ((active0 & 0x200L) != 0L)
363: return jjStartNfaWithStates_0(7, 9, 14);
364: break;
365: default:
366: break;
367: }
368: return jjStartNfa_0(6, active0);
369: }
370:
371: private final void jjCheckNAdd(int state) {
372: if (jjrounds[state] != jjround) {
373: jjstateSet[jjnewStateCnt++] = state;
374: jjrounds[state] = jjround;
375: }
376: }
377:
378: private final void jjAddStates(int start, int end) {
379: do {
380: jjstateSet[jjnewStateCnt++] = jjnextStates[start];
381: } while (start++ != end);
382: }
383:
384: private final void jjCheckNAddTwoStates(int state1, int state2) {
385: jjCheckNAdd(state1);
386: jjCheckNAdd(state2);
387: }
388:
389: private final void jjCheckNAddStates(int start, int end) {
390: do {
391: jjCheckNAdd(jjnextStates[start]);
392: } while (start++ != end);
393: }
394:
395: private final void jjCheckNAddStates(int start) {
396: jjCheckNAdd(jjnextStates[start]);
397: jjCheckNAdd(jjnextStates[start + 1]);
398: }
399:
400: static final long[] jjbitVec0 = { 0x0L, 0x0L, 0xffffffffffffffffL,
401: 0xffffffffffffffffL };
402:
403: private final int jjMoveNfa_0(int startState, int curPos) {
404: int[] nextStates;
405: int startsAt = 0;
406: jjnewStateCnt = 14;
407: int i = 1;
408: jjstateSet[0] = startState;
409: int j, kind = 0x7fffffff;
410: for (;;) {
411: if (++jjround == 0x7fffffff)
412: ReInitRounds();
413: if (curChar < 64) {
414: long l = 1L << curChar;
415: MatchLoop: do {
416: switch (jjstateSet[--i]) {
417: case 14:
418: if ((0x3ff600000000000L & l) != 0L) {
419: if (kind > 22)
420: kind = 22;
421: jjCheckNAdd(2);
422: }
423: if ((0x3ff200000000000L & l) != 0L) {
424: if (kind > 23)
425: kind = 23;
426: jjCheckNAdd(9);
427: }
428: break;
429: case 0:
430: if ((0x3ff400000000000L & l) != 0L)
431: jjstateSet[jjnewStateCnt++] = 1;
432: else if (curChar == 45) {
433: if (kind > 22)
434: kind = 22;
435: jjCheckNAddTwoStates(2, 9);
436: }
437: if ((0x3ff000000000000L & l) != 0L) {
438: if (kind > 27)
439: kind = 27;
440: jjCheckNAddStates(0, 2);
441: }
442: break;
443: case 1:
444: if (curChar != 45)
445: break;
446: if (kind > 22)
447: kind = 22;
448: jjCheckNAdd(2);
449: break;
450: case 2:
451: if ((0x3ff600000000000L & l) == 0L)
452: break;
453: if (kind > 22)
454: kind = 22;
455: jjCheckNAdd(2);
456: break;
457: case 4:
458: jjAddStates(3, 5);
459: break;
460: case 8:
461: if (curChar != 45)
462: break;
463: if (kind > 22)
464: kind = 22;
465: jjCheckNAddTwoStates(2, 9);
466: break;
467: case 9:
468: if ((0x3ff200000000000L & l) == 0L)
469: break;
470: if (kind > 23)
471: kind = 23;
472: jjCheckNAdd(9);
473: break;
474: case 10:
475: if ((0x3ff000000000000L & l) == 0L)
476: break;
477: if (kind > 27)
478: kind = 27;
479: jjCheckNAddStates(0, 2);
480: break;
481: case 11:
482: if ((0x3ff000000000000L & l) != 0L)
483: jjCheckNAddTwoStates(11, 12);
484: break;
485: case 12:
486: if (curChar != 45)
487: break;
488: if (kind > 23)
489: kind = 23;
490: jjCheckNAdd(9);
491: break;
492: case 13:
493: if ((0x3ff000000000000L & l) == 0L)
494: break;
495: if (kind > 27)
496: kind = 27;
497: jjCheckNAdd(13);
498: break;
499: default:
500: break;
501: }
502: } while (i != startsAt);
503: } else if (curChar < 128) {
504: long l = 1L << (curChar & 077);
505: MatchLoop: do {
506: switch (jjstateSet[--i]) {
507: case 14:
508: if ((0x7fffffe87fffffeL & l) != 0L) {
509: if (kind > 23)
510: kind = 23;
511: jjCheckNAdd(9);
512: }
513: if ((0x7fffffe87fffffeL & l) != 0L) {
514: if (kind > 22)
515: kind = 22;
516: jjCheckNAdd(2);
517: }
518: break;
519: case 0:
520: if ((0x7fffffe87fffffeL & l) != 0L) {
521: if (kind > 22)
522: kind = 22;
523: jjCheckNAddTwoStates(2, 9);
524: } else if (curChar == 64)
525: jjCheckNAddStates(3, 5);
526: break;
527: case 1:
528: if ((0x7fffffe87fffffeL & l) == 0L)
529: break;
530: if (kind > 22)
531: kind = 22;
532: jjCheckNAdd(2);
533: break;
534: case 2:
535: if ((0x7fffffe87fffffeL & l) == 0L)
536: break;
537: if (kind > 22)
538: kind = 22;
539: jjCheckNAdd(2);
540: break;
541: case 3:
542: case 5:
543: if (curChar == 64)
544: jjCheckNAddStates(3, 5);
545: break;
546: case 4:
547: if ((0xfffffffffffffffeL & l) != 0L)
548: jjCheckNAddStates(3, 5);
549: break;
550: case 6:
551: if (curChar == 64)
552: jjstateSet[jjnewStateCnt++] = 5;
553: break;
554: case 7:
555: if (curChar == 64 && kind > 24)
556: kind = 24;
557: break;
558: case 8:
559: if ((0x7fffffe87fffffeL & l) == 0L)
560: break;
561: if (kind > 22)
562: kind = 22;
563: jjCheckNAddTwoStates(2, 9);
564: break;
565: case 9:
566: case 12:
567: if ((0x7fffffe87fffffeL & l) == 0L)
568: break;
569: if (kind > 23)
570: kind = 23;
571: jjCheckNAdd(9);
572: break;
573: default:
574: break;
575: }
576: } while (i != startsAt);
577: } else {
578: int i2 = (curChar & 0xff) >> 6;
579: long l2 = 1L << (curChar & 077);
580: MatchLoop: do {
581: switch (jjstateSet[--i]) {
582: case 4:
583: if ((jjbitVec0[i2] & l2) != 0L)
584: jjAddStates(3, 5);
585: break;
586: default:
587: break;
588: }
589: } while (i != startsAt);
590: }
591: if (kind != 0x7fffffff) {
592: jjmatchedKind = kind;
593: jjmatchedPos = curPos;
594: kind = 0x7fffffff;
595: }
596: ++curPos;
597: if ((i = jjnewStateCnt) == (startsAt = 14 - (jjnewStateCnt = startsAt)))
598: return curPos;
599: try {
600: curChar = input_stream.readChar();
601: } catch (java.io.IOException e) {
602: return curPos;
603: }
604: }
605: }
606:
607: private final int jjMoveStringLiteralDfa0_1() {
608: switch (curChar) {
609: default:
610: return 1;
611: }
612: }
613:
614: static final int[] jjnextStates = { 11, 12, 13, 4, 6, 7, };
615: public static final String[] jjstrLiteralImages = { "", null, null,
616: null, null, null, "\141\143\143\145\163\163",
617: "\141\165\164\150\157\162", "\142\162\141\156\143\150",
618: "\142\162\141\156\143\150\145\163",
619: "\143\157\155\155\145\156\164", "\144\141\164\145",
620: "\144\145\163\143", "\145\170\160\141\156\144",
621: "\150\145\141\144", "\154\157\143\153\163", "\154\157\147",
622: "\156\145\170\164", "\163\164\141\164\145",
623: "\163\164\162\151\143\164", "\163\171\155\142\157\154\163",
624: "\164\145\170\164", null, null, null, null, null, null,
625: "\73", "\72", "\56", };
626: public static final String[] lexStateNames = { "DEFAULT",
627: "PRE_DELTA", };
628: public static final int[] jjnewLexState = { -1, -1, -1, -1, -1, -1,
629: -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
630: -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, };
631: static final long[] jjtoToken = { 0x79ffffc1L, };
632: static final long[] jjtoSkip = { 0x3eL, };
633: private SimpleCharStream input_stream;
634: private final int[] jjrounds = new int[14];
635: private final int[] jjstateSet = new int[28];
636: protected char curChar;
637:
638: public ArchiveParserTokenManager(SimpleCharStream stream) {
639: if (SimpleCharStream.staticFlag)
640: throw new Error(
641: "ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
642: input_stream = stream;
643: }
644:
645: public ArchiveParserTokenManager(SimpleCharStream stream,
646: int lexState) {
647: this (stream);
648: SwitchTo(lexState);
649: }
650:
651: public void ReInit(SimpleCharStream stream) {
652: jjmatchedPos = jjnewStateCnt = 0;
653: curLexState = defaultLexState;
654: input_stream = stream;
655: ReInitRounds();
656: }
657:
658: private final void ReInitRounds() {
659: int i;
660: jjround = 0x80000001;
661: for (i = 14; i-- > 0;)
662: jjrounds[i] = 0x80000000;
663: }
664:
665: public void ReInit(SimpleCharStream stream, int lexState) {
666: ReInit(stream);
667: SwitchTo(lexState);
668: }
669:
670: public void SwitchTo(int lexState) {
671: if (lexState >= 2 || lexState < 0)
672: throw new TokenMgrError(
673: "Error: Ignoring invalid lexical state : "
674: + lexState + ". State unchanged.",
675: TokenMgrError.INVALID_LEXICAL_STATE);
676: else
677: curLexState = lexState;
678: }
679:
680: private final Token jjFillToken() {
681: Token t = Token.newToken(jjmatchedKind);
682: t.kind = jjmatchedKind;
683: String im = jjstrLiteralImages[jjmatchedKind];
684: t.image = (im == null) ? input_stream.GetImage() : im;
685: t.beginLine = input_stream.getBeginLine();
686: t.beginColumn = input_stream.getBeginColumn();
687: t.endLine = input_stream.getEndLine();
688: t.endColumn = input_stream.getEndColumn();
689: return t;
690: }
691:
692: int curLexState = 0;
693: int defaultLexState = 0;
694: int jjnewStateCnt;
695: int jjround;
696: int jjmatchedPos;
697: int jjmatchedKind;
698:
699: public final Token getNextToken() {
700: int kind;
701: Token specialToken = null;
702: Token matchedToken;
703: int curPos = 0;
704:
705: EOFLoop: for (;;) {
706: try {
707: curChar = input_stream.BeginToken();
708: } catch (java.io.IOException e) {
709: jjmatchedKind = 0;
710: matchedToken = jjFillToken();
711: return matchedToken;
712: }
713:
714: switch (curLexState) {
715: case 0:
716: try {
717: input_stream.backup(0);
718: while (curChar <= 32
719: && (0x100003600L & (1L << curChar)) != 0L)
720: curChar = input_stream.BeginToken();
721: } catch (java.io.IOException e1) {
722: continue EOFLoop;
723: }
724: jjmatchedKind = 0x7fffffff;
725: jjmatchedPos = 0;
726: curPos = jjMoveStringLiteralDfa0_0();
727: break;
728: case 1:
729: try {
730: input_stream.backup(0);
731: while (curChar <= 32
732: && (0x100003600L & (1L << curChar)) != 0L)
733: curChar = input_stream.BeginToken();
734: } catch (java.io.IOException e1) {
735: continue EOFLoop;
736: }
737: jjmatchedKind = 0x7fffffff;
738: jjmatchedPos = 0;
739: curPos = jjMoveStringLiteralDfa0_1();
740: break;
741: }
742: if (jjmatchedKind != 0x7fffffff) {
743: if (jjmatchedPos + 1 < curPos)
744: input_stream.backup(curPos - jjmatchedPos - 1);
745: if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) {
746: matchedToken = jjFillToken();
747: if (jjnewLexState[jjmatchedKind] != -1)
748: curLexState = jjnewLexState[jjmatchedKind];
749: return matchedToken;
750: } else {
751: if (jjnewLexState[jjmatchedKind] != -1)
752: curLexState = jjnewLexState[jjmatchedKind];
753: continue EOFLoop;
754: }
755: }
756: int error_line = input_stream.getEndLine();
757: int error_column = input_stream.getEndColumn();
758: String error_after = null;
759: boolean EOFSeen = false;
760: try {
761: input_stream.readChar();
762: input_stream.backup(1);
763: } catch (java.io.IOException e1) {
764: EOFSeen = true;
765: error_after = curPos <= 1 ? "" : input_stream
766: .GetImage();
767: if (curChar == '\n' || curChar == '\r') {
768: error_line++;
769: error_column = 0;
770: } else
771: error_column++;
772: }
773: if (!EOFSeen) {
774: input_stream.backup(1);
775: error_after = curPos <= 1 ? "" : input_stream
776: .GetImage();
777: }
778: throw new TokenMgrError(EOFSeen, curLexState, error_line,
779: error_column, error_after, curChar,
780: TokenMgrError.LEXICAL_ERROR);
781: }
782: }
783:
784: }
|