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