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