001    /* Generated By:JavaCC: Do not edit this line. WirthParserTokenManager.java */
002    package net.hydromatic.clapham.parser.wirth;
003    import java.util.*;
004    import net.hydromatic.clapham.parser.*;
005    
006    /** Token Manager. */
007    public class WirthParserTokenManager implements WirthParserConstants
008    {
009    
010      /** Debug output. */
011      public  java.io.PrintStream debugStream = System.out;
012      /** Set debug output. */
013      public  void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
014    private final int jjStopStringLiteralDfa_0(int pos, long active0)
015    {
016       switch (pos)
017       {
018          default :
019             return -1;
020       }
021    }
022    private final int jjStartNfa_0(int pos, long active0)
023    {
024       return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1);
025    }
026    private int jjStopAtPos(int pos, int kind)
027    {
028       jjmatchedKind = kind;
029       jjmatchedPos = pos;
030       return pos + 1;
031    }
032    private int jjMoveStringLiteralDfa0_0()
033    {
034       switch(curChar)
035       {
036          case 34:
037             return jjStartNfaWithStates_0(0, 14, 5);
038          case 40:
039             return jjStopAtPos(0, 5);
040          case 41:
041             return jjStopAtPos(0, 6);
042          case 46:
043             return jjStopAtPos(0, 11);
044          case 61:
045             return jjStopAtPos(0, 12);
046          case 91:
047             return jjStopAtPos(0, 9);
048          case 93:
049             return jjStopAtPos(0, 10);
050          case 123:
051             return jjStopAtPos(0, 7);
052          case 124:
053             return jjStopAtPos(0, 13);
054          case 125:
055             return jjStopAtPos(0, 8);
056          default :
057             return jjMoveNfa_0(3, 0);
058       }
059    }
060    private int jjStartNfaWithStates_0(int pos, int kind, int state)
061    {
062       jjmatchedKind = kind;
063       jjmatchedPos = pos;
064       try { curChar = input_stream.readChar(); }
065       catch(java.io.IOException e) { return pos + 1; }
066       return jjMoveNfa_0(state, pos + 1);
067    }
068    static final long[] jjbitVec0 = {
069       0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
070    };
071    static final long[] jjbitVec2 = {
072       0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
073    };
074    static final long[] jjbitVec3 = {
075       0x1ff00000fffffffeL, 0xffffffffffffc000L, 0xffffffffL, 0x600000000000000L
076    };
077    static final long[] jjbitVec4 = {
078       0x0L, 0x0L, 0x0L, 0xff7fffffff7fffffL
079    };
080    static final long[] jjbitVec5 = {
081       0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
082    };
083    static final long[] jjbitVec6 = {
084       0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffL, 0x0L
085    };
086    static final long[] jjbitVec7 = {
087       0xffffffffffffffffL, 0xffffffffffffffffL, 0x0L, 0x0L
088    };
089    static final long[] jjbitVec8 = {
090       0x3fffffffffffL, 0x0L, 0x0L, 0x0L
091    };
092    private int jjMoveNfa_0(int startState, int curPos)
093    {
094       int startsAt = 0;
095       jjnewStateCnt = 5;
096       int i = 1;
097       jjstateSet[0] = startState;
098       int kind = 0x7fffffff;
099       for (;;)
100       {
101          if (++jjround == 0x7fffffff)
102             ReInitRounds();
103          if (curChar < 64)
104          {
105             long l = 1L << curChar;
106             do
107             {
108                switch(jjstateSet[--i])
109                {
110                   case 3:
111                      if (curChar == 36)
112                      {
113                         if (kind > 2)
114                            kind = 2;
115                         jjCheckNAdd(4);
116                      }
117                      else if (curChar == 34)
118                         jjCheckNAddTwoStates(1, 2);
119                      break;
120                   case 5:
121                      if ((0xfffffffbffffffffL & l) != 0L)
122                         jjCheckNAddTwoStates(1, 2);
123                      else if (curChar == 34)
124                      {
125                         if (kind > 1)
126                            kind = 1;
127                         jjstateSet[jjnewStateCnt++] = 0;
128                      }
129                      break;
130                   case 0:
131                      if (curChar == 34)
132                         jjCheckNAddTwoStates(1, 2);
133                      break;
134                   case 1:
135                      if ((0xfffffffbffffffffL & l) != 0L)
136                         jjCheckNAddTwoStates(1, 2);
137                      break;
138                   case 2:
139                      if (curChar != 34)
140                         break;
141                      if (kind > 1)
142                         kind = 1;
143                      jjstateSet[jjnewStateCnt++] = 0;
144                      break;
145                   case 4:
146                      if ((0x3ff001000000000L & l) == 0L)
147                         break;
148                      if (kind > 2)
149                         kind = 2;
150                      jjCheckNAdd(4);
151                      break;
152                   default : break;
153                }
154             } while(i != startsAt);
155          }
156          else if (curChar < 128)
157          {
158             long l = 1L << (curChar & 077);
159             do
160             {
161                switch(jjstateSet[--i])
162                {
163                   case 3:
164                   case 4:
165                      if ((0x7fffffe87fffffeL & l) == 0L)
166                         break;
167                      if (kind > 2)
168                         kind = 2;
169                      jjCheckNAdd(4);
170                      break;
171                   case 5:
172                   case 1:
173                      jjCheckNAddTwoStates(1, 2);
174                      break;
175                   default : break;
176                }
177             } while(i != startsAt);
178          }
179          else
180          {
181             int hiByte = (int)(curChar >> 8);
182             int i1 = hiByte >> 6;
183             long l1 = 1L << (hiByte & 077);
184             int i2 = (curChar & 0xff) >> 6;
185             long l2 = 1L << (curChar & 077);
186             do
187             {
188                switch(jjstateSet[--i])
189                {
190                   case 3:
191                   case 4:
192                      if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
193                         break;
194                      if (kind > 2)
195                         kind = 2;
196                      jjCheckNAdd(4);
197                      break;
198                   case 5:
199                   case 1:
200                      if (jjCanMove_0(hiByte, i1, i2, l1, l2))
201                         jjCheckNAddTwoStates(1, 2);
202                      break;
203                   default : break;
204                }
205             } while(i != startsAt);
206          }
207          if (kind != 0x7fffffff)
208          {
209             jjmatchedKind = kind;
210             jjmatchedPos = curPos;
211             kind = 0x7fffffff;
212          }
213          ++curPos;
214          if ((i = jjnewStateCnt) == (startsAt = 5 - (jjnewStateCnt = startsAt)))
215             return curPos;
216          try { curChar = input_stream.readChar(); }
217          catch(java.io.IOException e) { return curPos; }
218       }
219    }
220    static final int[] jjnextStates = {
221    };
222    private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2)
223    {
224       switch(hiByte)
225       {
226          case 0:
227             return ((jjbitVec2[i2] & l2) != 0L);
228          default :
229             if ((jjbitVec0[i1] & l1) != 0L)
230                return true;
231             return false;
232       }
233    }
234    private static final boolean jjCanMove_1(int hiByte, int i1, int i2, long l1, long l2)
235    {
236       switch(hiByte)
237       {
238          case 0:
239             return ((jjbitVec4[i2] & l2) != 0L);
240          case 48:
241             return ((jjbitVec5[i2] & l2) != 0L);
242          case 49:
243             return ((jjbitVec6[i2] & l2) != 0L);
244          case 51:
245             return ((jjbitVec7[i2] & l2) != 0L);
246          case 61:
247             return ((jjbitVec8[i2] & l2) != 0L);
248          default :
249             if ((jjbitVec3[i1] & l1) != 0L)
250                return true;
251             return false;
252       }
253    }
254    
255    /** Token literal values. */
256    public static final String[] jjstrLiteralImages = {
257    "", null, null, null, null, "\50", "\51", "\173", "\175", "\133", "\135", 
258    "\56", "\75", "\174", "\42", null, null, null, null, null, };
259    
260    /** Lexer state names. */
261    public static final String[] lexStateNames = {
262       "DEFAULT",
263    };
264    static final long[] jjtoToken = {
265       0x7fe7L, 
266    };
267    static final long[] jjtoSkip = {
268       0xf8000L, 
269    };
270    protected SimpleCharStream input_stream;
271    private final int[] jjrounds = new int[5];
272    private final int[] jjstateSet = new int[10];
273    protected char curChar;
274    /** Constructor. */
275    public WirthParserTokenManager(SimpleCharStream stream){
276       if (SimpleCharStream.staticFlag)
277          throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
278       input_stream = stream;
279    }
280    
281    /** Constructor. */
282    public WirthParserTokenManager(SimpleCharStream stream, int lexState){
283       this(stream);
284       SwitchTo(lexState);
285    }
286    
287    /** Reinitialise parser. */
288    public void ReInit(SimpleCharStream stream)
289    {
290       jjmatchedPos = jjnewStateCnt = 0;
291       curLexState = defaultLexState;
292       input_stream = stream;
293       ReInitRounds();
294    }
295    private void ReInitRounds()
296    {
297       int i;
298       jjround = 0x80000001;
299       for (i = 5; i-- > 0;)
300          jjrounds[i] = 0x80000000;
301    }
302    
303    /** Reinitialise parser. */
304    public void ReInit(SimpleCharStream stream, int lexState)
305    {
306       ReInit(stream);
307       SwitchTo(lexState);
308    }
309    
310    /** Switch to specified lex state. */
311    public void SwitchTo(int lexState)
312    {
313       if (lexState >= 1 || lexState < 0)
314          throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
315       else
316          curLexState = lexState;
317    }
318    
319    protected Token jjFillToken()
320    {
321       final Token t;
322       final String curTokenImage;
323       final int beginLine;
324       final int endLine;
325       final int beginColumn;
326       final int endColumn;
327       String im = jjstrLiteralImages[jjmatchedKind];
328       curTokenImage = (im == null) ? input_stream.GetImage() : im;
329       beginLine = input_stream.getBeginLine();
330       beginColumn = input_stream.getBeginColumn();
331       endLine = input_stream.getEndLine();
332       endColumn = input_stream.getEndColumn();
333       t = Token.newToken(jjmatchedKind, curTokenImage);
334    
335       t.beginLine = beginLine;
336       t.endLine = endLine;
337       t.beginColumn = beginColumn;
338       t.endColumn = endColumn;
339    
340       return t;
341    }
342    
343    int curLexState = 0;
344    int defaultLexState = 0;
345    int jjnewStateCnt;
346    int jjround;
347    int jjmatchedPos;
348    int jjmatchedKind;
349    
350    /** Get the next Token. */
351    public Token getNextToken() 
352    {
353      Token matchedToken;
354      int curPos = 0;
355    
356      EOFLoop :
357      for (;;)
358      {
359       try
360       {
361          curChar = input_stream.BeginToken();
362       }
363       catch(java.io.IOException e)
364       {
365          jjmatchedKind = 0;
366          matchedToken = jjFillToken();
367          return matchedToken;
368       }
369    
370       try { input_stream.backup(0);
371          while (curChar <= 32 && (0x100003600L & (1L << curChar)) != 0L)
372             curChar = input_stream.BeginToken();
373       }
374       catch (java.io.IOException e1) { continue EOFLoop; }
375       jjmatchedKind = 0x7fffffff;
376       jjmatchedPos = 0;
377       curPos = jjMoveStringLiteralDfa0_0();
378       if (jjmatchedKind != 0x7fffffff)
379       {
380          if (jjmatchedPos + 1 < curPos)
381             input_stream.backup(curPos - jjmatchedPos - 1);
382          if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
383          {
384             matchedToken = jjFillToken();
385             return matchedToken;
386          }
387          else
388          {
389             continue EOFLoop;
390          }
391       }
392       int error_line = input_stream.getEndLine();
393       int error_column = input_stream.getEndColumn();
394       String error_after = null;
395       boolean EOFSeen = false;
396       try { input_stream.readChar(); input_stream.backup(1); }
397       catch (java.io.IOException e1) {
398          EOFSeen = true;
399          error_after = curPos <= 1 ? "" : input_stream.GetImage();
400          if (curChar == '\n' || curChar == '\r') {
401             error_line++;
402             error_column = 0;
403          }
404          else
405             error_column++;
406       }
407       if (!EOFSeen) {
408          input_stream.backup(1);
409          error_after = curPos <= 1 ? "" : input_stream.GetImage();
410       }
411       throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
412      }
413    }
414    
415    private void jjCheckNAdd(int state)
416    {
417       if (jjrounds[state] != jjround)
418       {
419          jjstateSet[jjnewStateCnt++] = state;
420          jjrounds[state] = jjround;
421       }
422    }
423    private void jjAddStates(int start, int end)
424    {
425       do {
426          jjstateSet[jjnewStateCnt++] = jjnextStates[start];
427       } while (start++ != end);
428    }
429    private void jjCheckNAddTwoStates(int state1, int state2)
430    {
431       jjCheckNAdd(state1);
432       jjCheckNAdd(state2);
433    }
434    
435    }