001/* WirthParserTokenManager.java */ 002/* Generated By:JavaCC: Do not edit this line. WirthParserTokenManager.java */ 003package net.hydromatic.clapham.parser.wirth; 004import java.util.*; 005import net.hydromatic.clapham.parser.*; 006 007/** Token Manager. */ 008public class WirthParserTokenManager implements WirthParserConstants { 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 switch (pos) 016 { 017 default : 018 return -1; 019 } 020} 021private final int jjStartNfa_0(int pos, long active0){ 022 return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1); 023} 024private int jjStopAtPos(int pos, int kind) 025{ 026 jjmatchedKind = kind; 027 jjmatchedPos = pos; 028 return pos + 1; 029} 030private int jjMoveStringLiteralDfa0_0(){ 031 switch(curChar) 032 { 033 case 34: 034 return jjStartNfaWithStates_0(0, 14, 5); 035 case 40: 036 return jjStopAtPos(0, 5); 037 case 41: 038 return jjStopAtPos(0, 6); 039 case 46: 040 return jjStopAtPos(0, 11); 041 case 61: 042 return jjStopAtPos(0, 12); 043 case 91: 044 return jjStopAtPos(0, 9); 045 case 93: 046 return jjStopAtPos(0, 10); 047 case 123: 048 return jjStopAtPos(0, 7); 049 case 124: 050 return jjStopAtPos(0, 13); 051 case 125: 052 return jjStopAtPos(0, 8); 053 default : 054 return jjMoveNfa_0(3, 0); 055 } 056} 057private int jjStartNfaWithStates_0(int pos, int kind, int state) 058{ 059 jjmatchedKind = kind; 060 jjmatchedPos = pos; 061 try { curChar = input_stream.readChar(); } 062 catch(java.io.IOException e) { return pos + 1; } 063 return jjMoveNfa_0(state, pos + 1); 064} 065static final long[] jjbitVec0 = { 066 0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL 067}; 068static final long[] jjbitVec2 = { 069 0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL 070}; 071static final long[] jjbitVec3 = { 072 0x1ff00000fffffffeL, 0xffffffffffffc000L, 0xffffffffL, 0x600000000000000L 073}; 074static final long[] jjbitVec4 = { 075 0x0L, 0x0L, 0x0L, 0xff7fffffff7fffffL 076}; 077static final long[] jjbitVec5 = { 078 0x3fffffffffL, 0x0L, 0x0L, 0x0L 079}; 080static final long[] jjbitVec6 = { 081 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL 082}; 083static final long[] jjbitVec7 = { 084 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffL, 0x0L 085}; 086static final long[] jjbitVec8 = { 087 0xffffffffffffffffL, 0xffffffffffffffffL, 0x0L, 0x0L 088}; 089static final long[] jjbitVec9 = { 090 0x3fffffffffffL, 0x0L, 0x0L, 0x0L 091}; 092private 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 = (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 : if (i1 == 0 || l1 == 0 || i2 == 0 || l2 == 0) break; else 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 221/** Token literal values. */ 222public static final String[] jjstrLiteralImages = { 223"", null, null, null, null, "\50", "\51", "\173", "\175", "\133", "\135", 224"\56", "\75", "\174", "\42", null, null, null, null, null, }; 225protected Token jjFillToken() 226{ 227 final Token t; 228 final String curTokenImage; 229 final int beginLine; 230 final int endLine; 231 final int beginColumn; 232 final int endColumn; 233 String im = jjstrLiteralImages[jjmatchedKind]; 234 curTokenImage = (im == null) ? input_stream.GetImage() : im; 235 beginLine = input_stream.getBeginLine(); 236 beginColumn = input_stream.getBeginColumn(); 237 endLine = input_stream.getEndLine(); 238 endColumn = input_stream.getEndColumn(); 239 t = Token.newToken(jjmatchedKind); 240 t.kind = jjmatchedKind; 241 t.image = curTokenImage; 242 243 t.beginLine = beginLine; 244 t.endLine = endLine; 245 t.beginColumn = beginColumn; 246 t.endColumn = endColumn; 247 248 return t; 249} 250static final int[] jjnextStates = {0 251}; 252private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2) 253{ 254 switch(hiByte) 255 { 256 case 0: 257 return ((jjbitVec2[i2] & l2) != 0L); 258 default : 259 if ((jjbitVec0[i1] & l1) != 0L) 260 return true; 261 return false; 262 } 263} 264private static final boolean jjCanMove_1(int hiByte, int i1, int i2, long l1, long l2) 265{ 266 switch(hiByte) 267 { 268 case 0: 269 return ((jjbitVec4[i2] & l2) != 0L); 270 case 45: 271 return ((jjbitVec5[i2] & l2) != 0L); 272 case 48: 273 return ((jjbitVec6[i2] & l2) != 0L); 274 case 49: 275 return ((jjbitVec7[i2] & l2) != 0L); 276 case 51: 277 return ((jjbitVec8[i2] & l2) != 0L); 278 case 61: 279 return ((jjbitVec9[i2] & l2) != 0L); 280 default : 281 if ((jjbitVec3[i1] & l1) != 0L) 282 return true; 283 return false; 284 } 285} 286 287int curLexState = 0; 288int defaultLexState = 0; 289int jjnewStateCnt; 290int jjround; 291int jjmatchedPos; 292int jjmatchedKind; 293 294/** Get the next Token. */ 295public Token getNextToken() 296{ 297 Token matchedToken; 298 int curPos = 0; 299 300 EOFLoop : 301 for (;;) 302 { 303 try 304 { 305 curChar = input_stream.BeginToken(); 306 } 307 catch(Exception e) 308 { 309 jjmatchedKind = 0; 310 jjmatchedPos = -1; 311 matchedToken = jjFillToken(); 312 return matchedToken; 313 } 314 315 try { input_stream.backup(0); 316 while (curChar <= 32 && (0x100003600L & (1L << curChar)) != 0L) 317 curChar = input_stream.BeginToken(); 318 } 319 catch (java.io.IOException e1) { continue EOFLoop; } 320 jjmatchedKind = 0x7fffffff; 321 jjmatchedPos = 0; 322 curPos = jjMoveStringLiteralDfa0_0(); 323 if (jjmatchedKind != 0x7fffffff) 324 { 325 if (jjmatchedPos + 1 < curPos) 326 input_stream.backup(curPos - jjmatchedPos - 1); 327 if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) 328 { 329 matchedToken = jjFillToken(); 330 return matchedToken; 331 } 332 else 333 { 334 continue EOFLoop; 335 } 336 } 337 int error_line = input_stream.getEndLine(); 338 int error_column = input_stream.getEndColumn(); 339 String error_after = null; 340 boolean EOFSeen = false; 341 try { input_stream.readChar(); input_stream.backup(1); } 342 catch (java.io.IOException e1) { 343 EOFSeen = true; 344 error_after = curPos <= 1 ? "" : input_stream.GetImage(); 345 if (curChar == '\n' || curChar == '\r') { 346 error_line++; 347 error_column = 0; 348 } 349 else 350 error_column++; 351 } 352 if (!EOFSeen) { 353 input_stream.backup(1); 354 error_after = curPos <= 1 ? "" : input_stream.GetImage(); 355 } 356 throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR); 357 } 358} 359 360void SkipLexicalActions(Token matchedToken) 361{ 362 switch(jjmatchedKind) 363 { 364 default : 365 break; 366 } 367} 368void MoreLexicalActions() 369{ 370 jjimageLen += (lengthOfMatch = jjmatchedPos + 1); 371 switch(jjmatchedKind) 372 { 373 default : 374 break; 375 } 376} 377void TokenLexicalActions(Token matchedToken) 378{ 379 switch(jjmatchedKind) 380 { 381 default : 382 break; 383 } 384} 385private void jjCheckNAdd(int state) 386{ 387 if (jjrounds[state] != jjround) 388 { 389 jjstateSet[jjnewStateCnt++] = state; 390 jjrounds[state] = jjround; 391 } 392} 393private void jjAddStates(int start, int end) 394{ 395 do { 396 jjstateSet[jjnewStateCnt++] = jjnextStates[start]; 397 } while (start++ != end); 398} 399private void jjCheckNAddTwoStates(int state1, int state2) 400{ 401 jjCheckNAdd(state1); 402 jjCheckNAdd(state2); 403} 404 405 /** Constructor. */ 406 public WirthParserTokenManager(SimpleCharStream stream){ 407 408 if (SimpleCharStream.staticFlag) 409 throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer."); 410 411 input_stream = stream; 412 } 413 414 /** Constructor. */ 415 public WirthParserTokenManager (SimpleCharStream stream, int lexState){ 416 ReInit(stream); 417 SwitchTo(lexState); 418 } 419 420 /** Reinitialise parser. */ 421 422 public void ReInit(SimpleCharStream stream) 423 { 424 425 426 jjmatchedPos = 427 jjnewStateCnt = 428 0; 429 curLexState = defaultLexState; 430 input_stream = stream; 431 ReInitRounds(); 432 } 433 434 private void ReInitRounds() 435 { 436 int i; 437 jjround = 0x80000001; 438 for (i = 5; i-- > 0;) 439 jjrounds[i] = 0x80000000; 440 } 441 442 /** Reinitialise parser. */ 443 public void ReInit(SimpleCharStream stream, int lexState) 444 445 { 446 ReInit(stream); 447 SwitchTo(lexState); 448 } 449 450 /** Switch to specified lex state. */ 451 public void SwitchTo(int lexState) 452 { 453 if (lexState >= 1 || lexState < 0) 454 throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE); 455 else 456 curLexState = lexState; 457 } 458 459 460/** Lexer state names. */ 461public static final String[] lexStateNames = { 462 "DEFAULT", 463}; 464 465/** Lex State array. */ 466public static final int[] jjnewLexState = { 467 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 468}; 469static final long[] jjtoToken = { 470 0x7fe7L, 471}; 472static final long[] jjtoSkip = { 473 0xf8000L, 474}; 475static final long[] jjtoSpecial = { 476 0x0L, 477}; 478static final long[] jjtoMore = { 479 0x0L, 480}; 481 protected SimpleCharStream input_stream; 482 483 private final int[] jjrounds = new int[5]; 484 private final int[] jjstateSet = new int[2 * 5]; 485 private final StringBuilder jjimage = new StringBuilder(); 486 private StringBuilder image = jjimage; 487 private int jjimageLen; 488 private int lengthOfMatch; 489 protected int curChar; 490}