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