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}