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