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 }