001/* Generated By:JJTree&JavaCC: Do not edit this line. AddressListParserTokenManager.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,   *
014 * software distributed under the License is distributed on an  *
015 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY       *
016 * KIND, either express or implied.  See the License for the    *
017 * specific language governing permissions and limitations      *
018 * under the License.                                           *
019 ****************************************************************/
020package org.apache.james.mime4j.field.address;
021
022/** Token Manager. */
023public class AddressListParserTokenManager implements AddressListParserConstants
024{
025        // Keeps track of how many levels of comment nesting
026        // we've encountered.  This is only used when the 2nd
027        // level is reached, for example ((this)), not (this).
028        // This is because the outermost level must be treated
029        // specially anyway, because the outermost ")" has a 
030        // different token type than inner ")" instances.
031        static int commentNest;
032
033  /** Debug output. */
034  public  java.io.PrintStream debugStream = System.out;
035  /** Set debug output. */
036  public  void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
037private final int jjStopStringLiteralDfa_0(int pos, long active0)
038{
039   switch (pos)
040   {
041      default :
042         return -1;
043   }
044}
045private final int jjStartNfa_0(int pos, long active0)
046{
047   return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1);
048}
049private int jjStopAtPos(int pos, int kind)
050{
051   jjmatchedKind = kind;
052   jjmatchedPos = pos;
053   return pos + 1;
054}
055private int jjMoveStringLiteralDfa0_0()
056{
057   switch(curChar)
058   {
059      case 10:
060         return jjStopAtPos(0, 2);
061      case 13:
062         return jjStopAtPos(0, 1);
063      case 34:
064         return jjStopAtPos(0, 28);
065      case 40:
066         return jjStopAtPos(0, 19);
067      case 44:
068         return jjStopAtPos(0, 3);
069      case 46:
070         return jjStopAtPos(0, 9);
071      case 58:
072         return jjStopAtPos(0, 4);
073      case 59:
074         return jjStopAtPos(0, 5);
075      case 60:
076         return jjStopAtPos(0, 6);
077      case 62:
078         return jjStopAtPos(0, 7);
079      case 64:
080         return jjStopAtPos(0, 8);
081      case 91:
082         return jjStopAtPos(0, 15);
083      default :
084         return jjMoveNfa_0(1, 0);
085   }
086}
087private int jjMoveNfa_0(int startState, int curPos)
088{
089   int startsAt = 0;
090   jjnewStateCnt = 3;
091   int i = 1;
092   jjstateSet[0] = startState;
093   int kind = 0x7fffffff;
094   for (;;)
095   {
096      if (++jjround == 0x7fffffff)
097         ReInitRounds();
098      if (curChar < 64)
099      {
100         long l = 1L << curChar;
101         do
102         {
103            switch(jjstateSet[--i])
104            {
105               case 1:
106                  if ((0xa3ffacfa00000000L & l) != 0L)
107                  {
108                     if (kind > 14)
109                        kind = 14;
110                     jjCheckNAdd(2);
111                  }
112                  else if ((0x100000200L & l) != 0L)
113                  {
114                     if (kind > 10)
115                        kind = 10;
116                     jjCheckNAdd(0);
117                  }
118                  break;
119               case 0:
120                  if ((0x100000200L & l) == 0L)
121                     break;
122                  kind = 10;
123                  jjCheckNAdd(0);
124                  break;
125               case 2:
126                  if ((0xa3ffecfa00000000L & l) == 0L)
127                     break;
128                  if (kind > 14)
129                     kind = 14;
130                  jjCheckNAdd(2);
131                  break;
132               default : break;
133            }
134         } while(i != startsAt);
135      }
136      else if (curChar < 128)
137      {
138         long l = 1L << (curChar & 077);
139         do
140         {
141            switch(jjstateSet[--i])
142            {
143               case 1:
144               case 2:
145                  if ((0x7fffffffc7fffffeL & l) == 0L)
146                     break;
147                  if (kind > 14)
148                     kind = 14;
149                  jjCheckNAdd(2);
150                  break;
151               default : break;
152            }
153         } while(i != startsAt);
154      }
155      else
156      {
157         int i2 = (curChar & 0xff) >> 6;
158         long l2 = 1L << (curChar & 077);
159         do
160         {
161            switch(jjstateSet[--i])
162            {
163               default : break;
164            }
165         } while(i != startsAt);
166      }
167      if (kind != 0x7fffffff)
168      {
169         jjmatchedKind = kind;
170         jjmatchedPos = curPos;
171         kind = 0x7fffffff;
172      }
173      ++curPos;
174      if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
175         return curPos;
176      try { curChar = input_stream.readChar(); }
177      catch(java.io.IOException e) { return curPos; }
178   }
179}
180private final int jjStopStringLiteralDfa_2(int pos, long active0)
181{
182   switch (pos)
183   {
184      default :
185         return -1;
186   }
187}
188private final int jjStartNfa_2(int pos, long active0)
189{
190   return jjMoveNfa_2(jjStopStringLiteralDfa_2(pos, active0), pos + 1);
191}
192private int jjMoveStringLiteralDfa0_2()
193{
194   switch(curChar)
195   {
196      case 40:
197         return jjStopAtPos(0, 22);
198      case 41:
199         return jjStopAtPos(0, 20);
200      default :
201         return jjMoveNfa_2(0, 0);
202   }
203}
204static final long[] jjbitVec0 = {
205   0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
206};
207private int jjMoveNfa_2(int startState, int curPos)
208{
209   int startsAt = 0;
210   jjnewStateCnt = 3;
211   int i = 1;
212   jjstateSet[0] = startState;
213   int kind = 0x7fffffff;
214   for (;;)
215   {
216      if (++jjround == 0x7fffffff)
217         ReInitRounds();
218      if (curChar < 64)
219      {
220         long l = 1L << curChar;
221         do
222         {
223            switch(jjstateSet[--i])
224            {
225               case 0:
226                  if (kind > 23)
227                     kind = 23;
228                  break;
229               case 1:
230                  if (kind > 21)
231                     kind = 21;
232                  break;
233               default : break;
234            }
235         } while(i != startsAt);
236      }
237      else if (curChar < 128)
238      {
239         long l = 1L << (curChar & 077);
240         do
241         {
242            switch(jjstateSet[--i])
243            {
244               case 0:
245                  if (kind > 23)
246                     kind = 23;
247                  if (curChar == 92)
248                     jjstateSet[jjnewStateCnt++] = 1;
249                  break;
250               case 1:
251                  if (kind > 21)
252                     kind = 21;
253                  break;
254               case 2:
255                  if (kind > 23)
256                     kind = 23;
257                  break;
258               default : break;
259            }
260         } while(i != startsAt);
261      }
262      else
263      {
264         int i2 = (curChar & 0xff) >> 6;
265         long l2 = 1L << (curChar & 077);
266         do
267         {
268            switch(jjstateSet[--i])
269            {
270               case 0:
271                  if ((jjbitVec0[i2] & l2) != 0L && kind > 23)
272                     kind = 23;
273                  break;
274               case 1:
275                  if ((jjbitVec0[i2] & l2) != 0L && kind > 21)
276                     kind = 21;
277                  break;
278               default : break;
279            }
280         } while(i != startsAt);
281      }
282      if (kind != 0x7fffffff)
283      {
284         jjmatchedKind = kind;
285         jjmatchedPos = curPos;
286         kind = 0x7fffffff;
287      }
288      ++curPos;
289      if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
290         return curPos;
291      try { curChar = input_stream.readChar(); }
292      catch(java.io.IOException e) { return curPos; }
293   }
294}
295private final int jjStopStringLiteralDfa_4(int pos, long active0)
296{
297   switch (pos)
298   {
299      default :
300         return -1;
301   }
302}
303private final int jjStartNfa_4(int pos, long active0)
304{
305   return jjMoveNfa_4(jjStopStringLiteralDfa_4(pos, active0), pos + 1);
306}
307private int jjMoveStringLiteralDfa0_4()
308{
309   switch(curChar)
310   {
311      case 34:
312         return jjStopAtPos(0, 31);
313      default :
314         return jjMoveNfa_4(0, 0);
315   }
316}
317private int jjMoveNfa_4(int startState, int curPos)
318{
319   int startsAt = 0;
320   jjnewStateCnt = 3;
321   int i = 1;
322   jjstateSet[0] = startState;
323   int kind = 0x7fffffff;
324   for (;;)
325   {
326      if (++jjround == 0x7fffffff)
327         ReInitRounds();
328      if (curChar < 64)
329      {
330         long l = 1L << curChar;
331         do
332         {
333            switch(jjstateSet[--i])
334            {
335               case 0:
336               case 2:
337                  if ((0xfffffffbffffffffL & l) == 0L)
338                     break;
339                  if (kind > 30)
340                     kind = 30;
341                  jjCheckNAdd(2);
342                  break;
343               case 1:
344                  if (kind > 29)
345                     kind = 29;
346                  break;
347               default : break;
348            }
349         } while(i != startsAt);
350      }
351      else if (curChar < 128)
352      {
353         long l = 1L << (curChar & 077);
354         do
355         {
356            switch(jjstateSet[--i])
357            {
358               case 0:
359                  if ((0xffffffffefffffffL & l) != 0L)
360                  {
361                     if (kind > 30)
362                        kind = 30;
363                     jjCheckNAdd(2);
364                  }
365                  else if (curChar == 92)
366                     jjstateSet[jjnewStateCnt++] = 1;
367                  break;
368               case 1:
369                  if (kind > 29)
370                     kind = 29;
371                  break;
372               case 2:
373                  if ((0xffffffffefffffffL & l) == 0L)
374                     break;
375                  if (kind > 30)
376                     kind = 30;
377                  jjCheckNAdd(2);
378                  break;
379               default : break;
380            }
381         } while(i != startsAt);
382      }
383      else
384      {
385         int i2 = (curChar & 0xff) >> 6;
386         long l2 = 1L << (curChar & 077);
387         do
388         {
389            switch(jjstateSet[--i])
390            {
391               case 0:
392               case 2:
393                  if ((jjbitVec0[i2] & l2) == 0L)
394                     break;
395                  if (kind > 30)
396                     kind = 30;
397                  jjCheckNAdd(2);
398                  break;
399               case 1:
400                  if ((jjbitVec0[i2] & l2) != 0L && kind > 29)
401                     kind = 29;
402                  break;
403               default : break;
404            }
405         } while(i != startsAt);
406      }
407      if (kind != 0x7fffffff)
408      {
409         jjmatchedKind = kind;
410         jjmatchedPos = curPos;
411         kind = 0x7fffffff;
412      }
413      ++curPos;
414      if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
415         return curPos;
416      try { curChar = input_stream.readChar(); }
417      catch(java.io.IOException e) { return curPos; }
418   }
419}
420private final int jjStopStringLiteralDfa_3(int pos, long active0)
421{
422   switch (pos)
423   {
424      default :
425         return -1;
426   }
427}
428private final int jjStartNfa_3(int pos, long active0)
429{
430   return jjMoveNfa_3(jjStopStringLiteralDfa_3(pos, active0), pos + 1);
431}
432private int jjMoveStringLiteralDfa0_3()
433{
434   switch(curChar)
435   {
436      case 40:
437         return jjStopAtPos(0, 25);
438      case 41:
439         return jjStopAtPos(0, 26);
440      default :
441         return jjMoveNfa_3(0, 0);
442   }
443}
444private int jjMoveNfa_3(int startState, int curPos)
445{
446   int startsAt = 0;
447   jjnewStateCnt = 3;
448   int i = 1;
449   jjstateSet[0] = startState;
450   int kind = 0x7fffffff;
451   for (;;)
452   {
453      if (++jjround == 0x7fffffff)
454         ReInitRounds();
455      if (curChar < 64)
456      {
457         long l = 1L << curChar;
458         do
459         {
460            switch(jjstateSet[--i])
461            {
462               case 0:
463                  if (kind > 27)
464                     kind = 27;
465                  break;
466               case 1:
467                  if (kind > 24)
468                     kind = 24;
469                  break;
470               default : break;
471            }
472         } while(i != startsAt);
473      }
474      else if (curChar < 128)
475      {
476         long l = 1L << (curChar & 077);
477         do
478         {
479            switch(jjstateSet[--i])
480            {
481               case 0:
482                  if (kind > 27)
483                     kind = 27;
484                  if (curChar == 92)
485                     jjstateSet[jjnewStateCnt++] = 1;
486                  break;
487               case 1:
488                  if (kind > 24)
489                     kind = 24;
490                  break;
491               case 2:
492                  if (kind > 27)
493                     kind = 27;
494                  break;
495               default : break;
496            }
497         } while(i != startsAt);
498      }
499      else
500      {
501         int i2 = (curChar & 0xff) >> 6;
502         long l2 = 1L << (curChar & 077);
503         do
504         {
505            switch(jjstateSet[--i])
506            {
507               case 0:
508                  if ((jjbitVec0[i2] & l2) != 0L && kind > 27)
509                     kind = 27;
510                  break;
511               case 1:
512                  if ((jjbitVec0[i2] & l2) != 0L && kind > 24)
513                     kind = 24;
514                  break;
515               default : break;
516            }
517         } while(i != startsAt);
518      }
519      if (kind != 0x7fffffff)
520      {
521         jjmatchedKind = kind;
522         jjmatchedPos = curPos;
523         kind = 0x7fffffff;
524      }
525      ++curPos;
526      if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
527         return curPos;
528      try { curChar = input_stream.readChar(); }
529      catch(java.io.IOException e) { return curPos; }
530   }
531}
532private final int jjStopStringLiteralDfa_1(int pos, long active0)
533{
534   switch (pos)
535   {
536      default :
537         return -1;
538   }
539}
540private final int jjStartNfa_1(int pos, long active0)
541{
542   return jjMoveNfa_1(jjStopStringLiteralDfa_1(pos, active0), pos + 1);
543}
544private int jjMoveStringLiteralDfa0_1()
545{
546   switch(curChar)
547   {
548      case 93:
549         return jjStopAtPos(0, 18);
550      default :
551         return jjMoveNfa_1(0, 0);
552   }
553}
554private int jjMoveNfa_1(int startState, int curPos)
555{
556   int startsAt = 0;
557   jjnewStateCnt = 3;
558   int i = 1;
559   jjstateSet[0] = startState;
560   int kind = 0x7fffffff;
561   for (;;)
562   {
563      if (++jjround == 0x7fffffff)
564         ReInitRounds();
565      if (curChar < 64)
566      {
567         long l = 1L << curChar;
568         do
569         {
570            switch(jjstateSet[--i])
571            {
572               case 0:
573                  if (kind > 17)
574                     kind = 17;
575                  break;
576               case 1:
577                  if (kind > 16)
578                     kind = 16;
579                  break;
580               default : break;
581            }
582         } while(i != startsAt);
583      }
584      else if (curChar < 128)
585      {
586         long l = 1L << (curChar & 077);
587         do
588         {
589            switch(jjstateSet[--i])
590            {
591               case 0:
592                  if ((0xffffffffc7ffffffL & l) != 0L)
593                  {
594                     if (kind > 17)
595                        kind = 17;
596                  }
597                  else if (curChar == 92)
598                     jjstateSet[jjnewStateCnt++] = 1;
599                  break;
600               case 1:
601                  if (kind > 16)
602                     kind = 16;
603                  break;
604               case 2:
605                  if ((0xffffffffc7ffffffL & l) != 0L && kind > 17)
606                     kind = 17;
607                  break;
608               default : break;
609            }
610         } while(i != startsAt);
611      }
612      else
613      {
614         int i2 = (curChar & 0xff) >> 6;
615         long l2 = 1L << (curChar & 077);
616         do
617         {
618            switch(jjstateSet[--i])
619            {
620               case 0:
621                  if ((jjbitVec0[i2] & l2) != 0L && kind > 17)
622                     kind = 17;
623                  break;
624               case 1:
625                  if ((jjbitVec0[i2] & l2) != 0L && kind > 16)
626                     kind = 16;
627                  break;
628               default : break;
629            }
630         } while(i != startsAt);
631      }
632      if (kind != 0x7fffffff)
633      {
634         jjmatchedKind = kind;
635         jjmatchedPos = curPos;
636         kind = 0x7fffffff;
637      }
638      ++curPos;
639      if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
640         return curPos;
641      try { curChar = input_stream.readChar(); }
642      catch(java.io.IOException e) { return curPos; }
643   }
644}
645static final int[] jjnextStates = {
646};
647
648/** Token literal values. */
649public static final String[] jjstrLiteralImages = {
650"", "\15", "\12", "\54", "\72", "\73", "\74", "\76", "\100", "\56", null, null, 
651null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
652null, null, null, null, null, null, null, null, };
653
654/** Lexer state names. */
655public static final String[] lexStateNames = {
656   "DEFAULT",
657   "INDOMAINLITERAL",
658   "INCOMMENT",
659   "NESTED_COMMENT",
660   "INQUOTEDSTRING",
661};
662
663/** Lex State array. */
664public static final int[] jjnewLexState = {
665   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, -1, -1, 0, 2, 0, -1, 3, -1, -1, 
666   -1, -1, -1, 4, -1, -1, 0, -1, -1, 
667};
668static final long[] jjtoToken = {
669   0x800443ffL, 
670};
671static final long[] jjtoSkip = {
672   0x100400L, 
673};
674static final long[] jjtoSpecial = {
675   0x400L, 
676};
677static final long[] jjtoMore = {
678   0x7feb8000L, 
679};
680protected SimpleCharStream input_stream;
681private final int[] jjrounds = new int[3];
682private final int[] jjstateSet = new int[6];
683private final StringBuilder jjimage = new StringBuilder();
684private StringBuilder image = jjimage;
685private int jjimageLen;
686private int lengthOfMatch;
687protected char curChar;
688/** Constructor. */
689public AddressListParserTokenManager(SimpleCharStream stream){
690   if (SimpleCharStream.staticFlag)
691      throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
692   input_stream = stream;
693}
694
695/** Constructor. */
696public AddressListParserTokenManager(SimpleCharStream stream, int lexState){
697   this(stream);
698   SwitchTo(lexState);
699}
700
701/** Reinitialise parser. */
702public void ReInit(SimpleCharStream stream)
703{
704   jjmatchedPos = jjnewStateCnt = 0;
705   curLexState = defaultLexState;
706   input_stream = stream;
707   ReInitRounds();
708}
709private void ReInitRounds()
710{
711   int i;
712   jjround = 0x80000001;
713   for (i = 3; i-- > 0;)
714      jjrounds[i] = 0x80000000;
715}
716
717/** Reinitialise parser. */
718public void ReInit(SimpleCharStream stream, int lexState)
719{
720   ReInit(stream);
721   SwitchTo(lexState);
722}
723
724/** Switch to specified lex state. */
725public void SwitchTo(int lexState)
726{
727   if (lexState >= 5 || lexState < 0)
728      throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
729   else
730      curLexState = lexState;
731}
732
733protected Token jjFillToken()
734{
735   final Token t;
736   final String curTokenImage;
737   final int beginLine;
738   final int endLine;
739   final int beginColumn;
740   final int endColumn;
741   String im = jjstrLiteralImages[jjmatchedKind];
742   curTokenImage = (im == null) ? input_stream.GetImage() : im;
743   beginLine = input_stream.getBeginLine();
744   beginColumn = input_stream.getBeginColumn();
745   endLine = input_stream.getEndLine();
746   endColumn = input_stream.getEndColumn();
747   t = Token.newToken(jjmatchedKind, curTokenImage);
748
749   t.beginLine = beginLine;
750   t.endLine = endLine;
751   t.beginColumn = beginColumn;
752   t.endColumn = endColumn;
753
754   return t;
755}
756
757int curLexState = 0;
758int defaultLexState = 0;
759int jjnewStateCnt;
760int jjround;
761int jjmatchedPos;
762int jjmatchedKind;
763
764/** Get the next Token. */
765public Token getNextToken() 
766{
767  Token specialToken = null;
768  Token matchedToken;
769  int curPos = 0;
770
771  EOFLoop :
772  for (;;)
773  {
774   try
775   {
776      curChar = input_stream.BeginToken();
777   }
778   catch(java.io.IOException e)
779   {
780      jjmatchedKind = 0;
781      matchedToken = jjFillToken();
782      matchedToken.specialToken = specialToken;
783      return matchedToken;
784   }
785   image = jjimage;
786   image.setLength(0);
787   jjimageLen = 0;
788
789   for (;;)
790   {
791     switch(curLexState)
792     {
793       case 0:
794         jjmatchedKind = 0x7fffffff;
795         jjmatchedPos = 0;
796         curPos = jjMoveStringLiteralDfa0_0();
797         break;
798       case 1:
799         jjmatchedKind = 0x7fffffff;
800         jjmatchedPos = 0;
801         curPos = jjMoveStringLiteralDfa0_1();
802         break;
803       case 2:
804         jjmatchedKind = 0x7fffffff;
805         jjmatchedPos = 0;
806         curPos = jjMoveStringLiteralDfa0_2();
807         break;
808       case 3:
809         jjmatchedKind = 0x7fffffff;
810         jjmatchedPos = 0;
811         curPos = jjMoveStringLiteralDfa0_3();
812         break;
813       case 4:
814         jjmatchedKind = 0x7fffffff;
815         jjmatchedPos = 0;
816         curPos = jjMoveStringLiteralDfa0_4();
817         break;
818     }
819     if (jjmatchedKind != 0x7fffffff)
820     {
821        if (jjmatchedPos + 1 < curPos)
822           input_stream.backup(curPos - jjmatchedPos - 1);
823        if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
824        {
825           matchedToken = jjFillToken();
826           matchedToken.specialToken = specialToken;
827           TokenLexicalActions(matchedToken);
828       if (jjnewLexState[jjmatchedKind] != -1)
829         curLexState = jjnewLexState[jjmatchedKind];
830           return matchedToken;
831        }
832        else if ((jjtoSkip[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
833        {
834           if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
835           {
836              matchedToken = jjFillToken();
837              if (specialToken == null)
838                 specialToken = matchedToken;
839              else
840              {
841                 matchedToken.specialToken = specialToken;
842                 specialToken = (specialToken.next = matchedToken);
843              }
844           }
845         if (jjnewLexState[jjmatchedKind] != -1)
846           curLexState = jjnewLexState[jjmatchedKind];
847           continue EOFLoop;
848        }
849        MoreLexicalActions();
850      if (jjnewLexState[jjmatchedKind] != -1)
851        curLexState = jjnewLexState[jjmatchedKind];
852        curPos = 0;
853        jjmatchedKind = 0x7fffffff;
854        try {
855           curChar = input_stream.readChar();
856           continue;
857        }
858        catch (java.io.IOException e1) { }
859     }
860     int error_line = input_stream.getEndLine();
861     int error_column = input_stream.getEndColumn();
862     String error_after = null;
863     boolean EOFSeen = false;
864     try { input_stream.readChar(); input_stream.backup(1); }
865     catch (java.io.IOException e1) {
866        EOFSeen = true;
867        error_after = curPos <= 1 ? "" : input_stream.GetImage();
868        if (curChar == '\n' || curChar == '\r') {
869           error_line++;
870           error_column = 0;
871        }
872        else
873           error_column++;
874     }
875     if (!EOFSeen) {
876        input_stream.backup(1);
877        error_after = curPos <= 1 ? "" : input_stream.GetImage();
878     }
879     throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
880   }
881  }
882}
883
884void MoreLexicalActions()
885{
886   jjimageLen += (lengthOfMatch = jjmatchedPos + 1);
887   switch(jjmatchedKind)
888   {
889      case 16 :
890         image.append(input_stream.GetSuffix(jjimageLen));
891         jjimageLen = 0;
892                          image.deleteCharAt(image.length() - 2);
893         break;
894      case 21 :
895         image.append(input_stream.GetSuffix(jjimageLen));
896         jjimageLen = 0;
897                          image.deleteCharAt(image.length() - 2);
898         break;
899      case 22 :
900         image.append(input_stream.GetSuffix(jjimageLen));
901         jjimageLen = 0;
902              commentNest = 1;
903         break;
904      case 24 :
905         image.append(input_stream.GetSuffix(jjimageLen));
906         jjimageLen = 0;
907                          image.deleteCharAt(image.length() - 2);
908         break;
909      case 25 :
910         image.append(input_stream.GetSuffix(jjimageLen));
911         jjimageLen = 0;
912              ++commentNest;
913         break;
914      case 26 :
915         image.append(input_stream.GetSuffix(jjimageLen));
916         jjimageLen = 0;
917              --commentNest; if (commentNest == 0) SwitchTo(INCOMMENT);
918         break;
919      case 28 :
920         image.append(input_stream.GetSuffix(jjimageLen));
921         jjimageLen = 0;
922               image.deleteCharAt(image.length() - 1);
923         break;
924      case 29 :
925         image.append(input_stream.GetSuffix(jjimageLen));
926         jjimageLen = 0;
927                          image.deleteCharAt(image.length() - 2);
928         break;
929      default :
930         break;
931   }
932}
933void TokenLexicalActions(Token matchedToken)
934{
935   switch(jjmatchedKind)
936   {
937      case 18 :
938        image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
939                                 matchedToken.image = image.toString();
940         break;
941      case 31 :
942        image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
943                                 matchedToken.image = image.substring(0, image.length() - 1);
944         break;
945      default :
946         break;
947   }
948}
949private void jjCheckNAdd(int state)
950{
951   if (jjrounds[state] != jjround)
952   {
953      jjstateSet[jjnewStateCnt++] = state;
954      jjrounds[state] = jjround;
955   }
956}
957private void jjAddStates(int start, int end)
958{
959   do {
960      jjstateSet[jjnewStateCnt++] = jjnextStates[start];
961   } while (start++ != end);
962}
963private void jjCheckNAddTwoStates(int state1, int state2)
964{
965   jjCheckNAdd(state1);
966   jjCheckNAdd(state2);
967}
968
969}