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 }