00001
00002 package plp.expressions2.parser;
00003 import plp.expressions2.*;
00004 import plp.expressions2.memory.*;
00005 import plp.expressions2.declaration.*;
00006 import plp.expressions2.expression.*;
00007 import java.util.List;
00008 import java.util.LinkedList;
00009
00010 public class Exp2ParserTokenManager implements Exp2ParserConstants
00011 {
00012 public static java.io.PrintStream debugStream = System.out;
00013 public static void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
00014 private static final int jjStopStringLiteralDfa_0(int pos, long active0)
00015 {
00016 switch (pos)
00017 {
00018 case 0:
00019 if ((active0 & 0x10000000000000L) != 0L)
00020 return 19;
00021 if ((active0 & 0x3fe00L) != 0L)
00022 {
00023 jjmatchedKind = 23;
00024 return 13;
00025 }
00026 return -1;
00027 case 1:
00028 if ((active0 & 0x1fa00L) != 0L)
00029 {
00030 jjmatchedKind = 23;
00031 jjmatchedPos = 1;
00032 return 13;
00033 }
00034 if ((active0 & 0x20400L) != 0L)
00035 return 13;
00036 return -1;
00037 case 2:
00038 if ((active0 & 0x18a00L) != 0L)
00039 return 13;
00040 if ((active0 & 0x7000L) != 0L)
00041 {
00042 jjmatchedKind = 23;
00043 jjmatchedPos = 2;
00044 return 13;
00045 }
00046 return -1;
00047 case 3:
00048 if ((active0 & 0x5000L) != 0L)
00049 {
00050 jjmatchedKind = 23;
00051 jjmatchedPos = 3;
00052 return 13;
00053 }
00054 if ((active0 & 0x2000L) != 0L)
00055 return 13;
00056 return -1;
00057 case 4:
00058 if ((active0 & 0x1000L) != 0L)
00059 {
00060 jjmatchedKind = 23;
00061 jjmatchedPos = 4;
00062 return 13;
00063 }
00064 if ((active0 & 0x4000L) != 0L)
00065 return 13;
00066 return -1;
00067 default :
00068 return -1;
00069 }
00070 }
00071 private static final int jjStartNfa_0(int pos, long active0)
00072 {
00073 return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1);
00074 }
00075 static private final int jjStopAtPos(int pos, int kind)
00076 {
00077 jjmatchedKind = kind;
00078 jjmatchedPos = pos;
00079 return pos + 1;
00080 }
00081 static private final int jjStartNfaWithStates_0(int pos, int kind, int state)
00082 {
00083 jjmatchedKind = kind;
00084 jjmatchedPos = pos;
00085 try { curChar = input_stream.readChar(); }
00086 catch(java.io.IOException e) { return pos + 1; }
00087 return jjMoveNfa_0(state, pos + 1);
00088 }
00089 static private final int jjMoveStringLiteralDfa0_0()
00090 {
00091 switch(curChar)
00092 {
00093 case 33:
00094 jjmatchedKind = 38;
00095 return jjMoveStringLiteralDfa1_0(0x200000000000L);
00096 case 37:
00097 return jjStopAtPos(0, 56);
00098 case 38:
00099 jjmatchedKind = 53;
00100 return jjMoveStringLiteralDfa1_0(0x800000000000L);
00101 case 40:
00102 return jjStopAtPos(0, 26);
00103 case 41:
00104 return jjStopAtPos(0, 27);
00105 case 42:
00106 return jjStopAtPos(0, 51);
00107 case 43:
00108 jjmatchedKind = 49;
00109 return jjMoveStringLiteralDfa1_0(0x1000000000000L);
00110 case 44:
00111 return jjStopAtPos(0, 33);
00112 case 45:
00113 return jjStopAtPos(0, 50);
00114 case 46:
00115 return jjStopAtPos(0, 34);
00116 case 47:
00117 return jjStartNfaWithStates_0(0, 52, 19);
00118 case 58:
00119 return jjStopAtPos(0, 41);
00120 case 59:
00121 return jjStopAtPos(0, 32);
00122 case 60:
00123 jjmatchedKind = 37;
00124 return jjMoveStringLiteralDfa1_0(0x80000000000L);
00125 case 61:
00126 jjmatchedKind = 35;
00127 return jjMoveStringLiteralDfa1_0(0x40000000000L);
00128 case 62:
00129 jjmatchedKind = 36;
00130 return jjMoveStringLiteralDfa1_0(0x100000000000L);
00131 case 63:
00132 return jjStopAtPos(0, 40);
00133 case 91:
00134 return jjStopAtPos(0, 30);
00135 case 93:
00136 return jjStopAtPos(0, 31);
00137 case 94:
00138 return jjStopAtPos(0, 55);
00139 case 97:
00140 return jjMoveStringLiteralDfa1_0(0x200L);
00141 case 102:
00142 return jjMoveStringLiteralDfa1_0(0x4000L);
00143 case 105:
00144 return jjMoveStringLiteralDfa1_0(0x20000L);
00145 case 108:
00146 return jjMoveStringLiteralDfa1_0(0x9000L);
00147 case 110:
00148 return jjMoveStringLiteralDfa1_0(0x800L);
00149 case 111:
00150 return jjMoveStringLiteralDfa1_0(0x400L);
00151 case 116:
00152 return jjMoveStringLiteralDfa1_0(0x2000L);
00153 case 118:
00154 return jjMoveStringLiteralDfa1_0(0x10000L);
00155 case 123:
00156 return jjStopAtPos(0, 28);
00157 case 124:
00158 jjmatchedKind = 54;
00159 return jjMoveStringLiteralDfa1_0(0x400000000000L);
00160 case 125:
00161 return jjStopAtPos(0, 29);
00162 case 126:
00163 return jjStopAtPos(0, 39);
00164 default :
00165 return jjMoveNfa_0(0, 0);
00166 }
00167 }
00168 static private final int jjMoveStringLiteralDfa1_0(long active0)
00169 {
00170 try { curChar = input_stream.readChar(); }
00171 catch(java.io.IOException e) {
00172 jjStopStringLiteralDfa_0(0, active0);
00173 return 1;
00174 }
00175 switch(curChar)
00176 {
00177 case 38:
00178 if ((active0 & 0x800000000000L) != 0L)
00179 return jjStopAtPos(1, 47);
00180 break;
00181 case 43:
00182 if ((active0 & 0x1000000000000L) != 0L)
00183 return jjStopAtPos(1, 48);
00184 break;
00185 case 61:
00186 if ((active0 & 0x40000000000L) != 0L)
00187 return jjStopAtPos(1, 42);
00188 else if ((active0 & 0x80000000000L) != 0L)
00189 return jjStopAtPos(1, 43);
00190 else if ((active0 & 0x100000000000L) != 0L)
00191 return jjStopAtPos(1, 44);
00192 else if ((active0 & 0x200000000000L) != 0L)
00193 return jjStopAtPos(1, 45);
00194 break;
00195 case 97:
00196 return jjMoveStringLiteralDfa2_0(active0, 0x14000L);
00197 case 101:
00198 return jjMoveStringLiteralDfa2_0(active0, 0x9000L);
00199 case 110:
00200 if ((active0 & 0x20000L) != 0L)
00201 return jjStartNfaWithStates_0(1, 17, 13);
00202 return jjMoveStringLiteralDfa2_0(active0, 0x200L);
00203 case 111:
00204 return jjMoveStringLiteralDfa2_0(active0, 0x800L);
00205 case 114:
00206 if ((active0 & 0x400L) != 0L)
00207 return jjStartNfaWithStates_0(1, 10, 13);
00208 return jjMoveStringLiteralDfa2_0(active0, 0x2000L);
00209 case 124:
00210 if ((active0 & 0x400000000000L) != 0L)
00211 return jjStopAtPos(1, 46);
00212 break;
00213 default :
00214 break;
00215 }
00216 return jjStartNfa_0(0, active0);
00217 }
00218 static private final int jjMoveStringLiteralDfa2_0(long old0, long active0)
00219 {
00220 if (((active0 &= old0)) == 0L)
00221 return jjStartNfa_0(0, old0);
00222 try { curChar = input_stream.readChar(); }
00223 catch(java.io.IOException e) {
00224 jjStopStringLiteralDfa_0(1, active0);
00225 return 2;
00226 }
00227 switch(curChar)
00228 {
00229 case 100:
00230 if ((active0 & 0x200L) != 0L)
00231 return jjStartNfaWithStates_0(2, 9, 13);
00232 break;
00233 case 108:
00234 return jjMoveStringLiteralDfa3_0(active0, 0x4000L);
00235 case 110:
00236 return jjMoveStringLiteralDfa3_0(active0, 0x1000L);
00237 case 114:
00238 if ((active0 & 0x10000L) != 0L)
00239 return jjStartNfaWithStates_0(2, 16, 13);
00240 break;
00241 case 116:
00242 if ((active0 & 0x800L) != 0L)
00243 return jjStartNfaWithStates_0(2, 11, 13);
00244 else if ((active0 & 0x8000L) != 0L)
00245 return jjStartNfaWithStates_0(2, 15, 13);
00246 break;
00247 case 117:
00248 return jjMoveStringLiteralDfa3_0(active0, 0x2000L);
00249 default :
00250 break;
00251 }
00252 return jjStartNfa_0(1, active0);
00253 }
00254 static private final int jjMoveStringLiteralDfa3_0(long old0, long active0)
00255 {
00256 if (((active0 &= old0)) == 0L)
00257 return jjStartNfa_0(1, old0);
00258 try { curChar = input_stream.readChar(); }
00259 catch(java.io.IOException e) {
00260 jjStopStringLiteralDfa_0(2, active0);
00261 return 3;
00262 }
00263 switch(curChar)
00264 {
00265 case 101:
00266 if ((active0 & 0x2000L) != 0L)
00267 return jjStartNfaWithStates_0(3, 13, 13);
00268 break;
00269 case 103:
00270 return jjMoveStringLiteralDfa4_0(active0, 0x1000L);
00271 case 115:
00272 return jjMoveStringLiteralDfa4_0(active0, 0x4000L);
00273 default :
00274 break;
00275 }
00276 return jjStartNfa_0(2, active0);
00277 }
00278 static private final int jjMoveStringLiteralDfa4_0(long old0, long active0)
00279 {
00280 if (((active0 &= old0)) == 0L)
00281 return jjStartNfa_0(2, old0);
00282 try { curChar = input_stream.readChar(); }
00283 catch(java.io.IOException e) {
00284 jjStopStringLiteralDfa_0(3, active0);
00285 return 4;
00286 }
00287 switch(curChar)
00288 {
00289 case 101:
00290 if ((active0 & 0x4000L) != 0L)
00291 return jjStartNfaWithStates_0(4, 14, 13);
00292 break;
00293 case 116:
00294 return jjMoveStringLiteralDfa5_0(active0, 0x1000L);
00295 default :
00296 break;
00297 }
00298 return jjStartNfa_0(3, active0);
00299 }
00300 static private final int jjMoveStringLiteralDfa5_0(long old0, long active0)
00301 {
00302 if (((active0 &= old0)) == 0L)
00303 return jjStartNfa_0(3, old0);
00304 try { curChar = input_stream.readChar(); }
00305 catch(java.io.IOException e) {
00306 jjStopStringLiteralDfa_0(4, active0);
00307 return 5;
00308 }
00309 switch(curChar)
00310 {
00311 case 104:
00312 if ((active0 & 0x1000L) != 0L)
00313 return jjStartNfaWithStates_0(5, 12, 13);
00314 break;
00315 default :
00316 break;
00317 }
00318 return jjStartNfa_0(4, active0);
00319 }
00320 static private final void jjCheckNAdd(int state)
00321 {
00322 if (jjrounds[state] != jjround)
00323 {
00324 jjstateSet[jjnewStateCnt++] = state;
00325 jjrounds[state] = jjround;
00326 }
00327 }
00328 static private final void jjAddStates(int start, int end)
00329 {
00330 do {
00331 jjstateSet[jjnewStateCnt++] = jjnextStates[start];
00332 } while (start++ != end);
00333 }
00334 static private final void jjCheckNAddTwoStates(int state1, int state2)
00335 {
00336 jjCheckNAdd(state1);
00337 jjCheckNAdd(state2);
00338 }
00339 static private final void jjCheckNAddStates(int start, int end)
00340 {
00341 do {
00342 jjCheckNAdd(jjnextStates[start]);
00343 } while (start++ != end);
00344 }
00345 static private final void jjCheckNAddStates(int start)
00346 {
00347 jjCheckNAdd(jjnextStates[start]);
00348 jjCheckNAdd(jjnextStates[start + 1]);
00349 }
00350 static final long[] jjbitVec0 = {
00351 0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
00352 };
00353 static final long[] jjbitVec2 = {
00354 0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
00355 };
00356 static final long[] jjbitVec3 = {
00357 0x1ff00000fffffffeL, 0xffffffffffffc000L, 0xffffffffL, 0x600000000000000L
00358 };
00359 static final long[] jjbitVec4 = {
00360 0x0L, 0x0L, 0x0L, 0xff7fffffff7fffffL
00361 };
00362 static final long[] jjbitVec5 = {
00363 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
00364 };
00365 static final long[] jjbitVec6 = {
00366 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffL, 0x0L
00367 };
00368 static final long[] jjbitVec7 = {
00369 0xffffffffffffffffL, 0xffffffffffffffffL, 0x0L, 0x0L
00370 };
00371 static final long[] jjbitVec8 = {
00372 0x3fffffffffffL, 0x0L, 0x0L, 0x0L
00373 };
00374 static private final int jjMoveNfa_0(int startState, int curPos)
00375 {
00376 int[] nextStates;
00377 int startsAt = 0;
00378 jjnewStateCnt = 37;
00379 int i = 1;
00380 jjstateSet[0] = startState;
00381 int j, kind = 0x7fffffff;
00382 for (;;)
00383 {
00384 if (++jjround == 0x7fffffff)
00385 ReInitRounds();
00386 if (curChar < 64)
00387 {
00388 long l = 1L << curChar;
00389 MatchLoop: do
00390 {
00391 switch(jjstateSet[--i])
00392 {
00393 case 19:
00394 if (curChar == 42)
00395 jjCheckNAddTwoStates(32, 33);
00396 else if (curChar == 47)
00397 jjCheckNAddStates(0, 2);
00398 if (curChar == 42)
00399 jjstateSet[jjnewStateCnt++] = 24;
00400 break;
00401 case 0:
00402 if ((0x3fe000000000000L & l) != 0L)
00403 {
00404 if (kind > 18)
00405 kind = 18;
00406 jjCheckNAddTwoStates(1, 2);
00407 }
00408 else if (curChar == 47)
00409 jjAddStates(3, 5);
00410 else if (curChar == 48)
00411 {
00412 if (kind > 18)
00413 kind = 18;
00414 jjCheckNAddStates(6, 8);
00415 }
00416 else if (curChar == 36)
00417 {
00418 if (kind > 23)
00419 kind = 23;
00420 jjCheckNAdd(13);
00421 }
00422 else if (curChar == 34)
00423 jjCheckNAddStates(9, 11);
00424 break;
00425 case 1:
00426 if ((0x3ff000000000000L & l) == 0L)
00427 break;
00428 if (kind > 18)
00429 kind = 18;
00430 jjCheckNAddTwoStates(1, 2);
00431 break;
00432 case 3:
00433 if (curChar == 34)
00434 jjCheckNAddStates(9, 11);
00435 break;
00436 case 4:
00437 if ((0xfffffffbffffdbffL & l) != 0L)
00438 jjCheckNAddStates(9, 11);
00439 break;
00440 case 6:
00441 if ((0x8400000000L & l) != 0L)
00442 jjCheckNAddStates(9, 11);
00443 break;
00444 case 7:
00445 if (curChar == 34 && kind > 22)
00446 kind = 22;
00447 break;
00448 case 8:
00449 if ((0xff000000000000L & l) != 0L)
00450 jjCheckNAddStates(12, 15);
00451 break;
00452 case 9:
00453 if ((0xff000000000000L & l) != 0L)
00454 jjCheckNAddStates(9, 11);
00455 break;
00456 case 10:
00457 if ((0xf000000000000L & l) != 0L)
00458 jjstateSet[jjnewStateCnt++] = 11;
00459 break;
00460 case 11:
00461 if ((0xff000000000000L & l) != 0L)
00462 jjCheckNAdd(9);
00463 break;
00464 case 12:
00465 if (curChar != 36)
00466 break;
00467 if (kind > 23)
00468 kind = 23;
00469 jjCheckNAdd(13);
00470 break;
00471 case 13:
00472 if ((0x3ff001000000000L & l) == 0L)
00473 break;
00474 if (kind > 23)
00475 kind = 23;
00476 jjCheckNAdd(13);
00477 break;
00478 case 14:
00479 if (curChar != 48)
00480 break;
00481 if (kind > 18)
00482 kind = 18;
00483 jjCheckNAddStates(6, 8);
00484 break;
00485 case 16:
00486 if ((0x3ff000000000000L & l) == 0L)
00487 break;
00488 if (kind > 18)
00489 kind = 18;
00490 jjCheckNAddTwoStates(16, 2);
00491 break;
00492 case 17:
00493 if ((0xff000000000000L & l) == 0L)
00494 break;
00495 if (kind > 18)
00496 kind = 18;
00497 jjCheckNAddTwoStates(17, 2);
00498 break;
00499 case 18:
00500 if (curChar == 47)
00501 jjAddStates(3, 5);
00502 break;
00503 case 20:
00504 if ((0xffffffffffffdbffL & l) != 0L)
00505 jjCheckNAddStates(0, 2);
00506 break;
00507 case 21:
00508 if ((0x2400L & l) != 0L && kind > 6)
00509 kind = 6;
00510 break;
00511 case 22:
00512 if (curChar == 10 && kind > 6)
00513 kind = 6;
00514 break;
00515 case 23:
00516 if (curChar == 13)
00517 jjstateSet[jjnewStateCnt++] = 22;
00518 break;
00519 case 24:
00520 if (curChar == 42)
00521 jjCheckNAddTwoStates(25, 26);
00522 break;
00523 case 25:
00524 if ((0xfffffbffffffffffL & l) != 0L)
00525 jjCheckNAddTwoStates(25, 26);
00526 break;
00527 case 26:
00528 if (curChar == 42)
00529 jjCheckNAddStates(16, 18);
00530 break;
00531 case 27:
00532 if ((0xffff7bffffffffffL & l) != 0L)
00533 jjCheckNAddTwoStates(28, 26);
00534 break;
00535 case 28:
00536 if ((0xfffffbffffffffffL & l) != 0L)
00537 jjCheckNAddTwoStates(28, 26);
00538 break;
00539 case 29:
00540 if (curChar == 47 && kind > 7)
00541 kind = 7;
00542 break;
00543 case 30:
00544 if (curChar == 42)
00545 jjstateSet[jjnewStateCnt++] = 24;
00546 break;
00547 case 31:
00548 if (curChar == 42)
00549 jjCheckNAddTwoStates(32, 33);
00550 break;
00551 case 32:
00552 if ((0xfffffbffffffffffL & l) != 0L)
00553 jjCheckNAddTwoStates(32, 33);
00554 break;
00555 case 33:
00556 if (curChar == 42)
00557 jjCheckNAddStates(19, 21);
00558 break;
00559 case 34:
00560 if ((0xffff7bffffffffffL & l) != 0L)
00561 jjCheckNAddTwoStates(35, 33);
00562 break;
00563 case 35:
00564 if ((0xfffffbffffffffffL & l) != 0L)
00565 jjCheckNAddTwoStates(35, 33);
00566 break;
00567 case 36:
00568 if (curChar == 47 && kind > 8)
00569 kind = 8;
00570 break;
00571 default : break;
00572 }
00573 } while(i != startsAt);
00574 }
00575 else if (curChar < 128)
00576 {
00577 long l = 1L << (curChar & 077);
00578 MatchLoop: do
00579 {
00580 switch(jjstateSet[--i])
00581 {
00582 case 0:
00583 case 13:
00584 if ((0x7fffffe87fffffeL & l) == 0L)
00585 break;
00586 if (kind > 23)
00587 kind = 23;
00588 jjCheckNAdd(13);
00589 break;
00590 case 2:
00591 if ((0x100000001000L & l) != 0L && kind > 18)
00592 kind = 18;
00593 break;
00594 case 4:
00595 if ((0xffffffffefffffffL & l) != 0L)
00596 jjCheckNAddStates(9, 11);
00597 break;
00598 case 5:
00599 if (curChar == 92)
00600 jjAddStates(22, 24);
00601 break;
00602 case 6:
00603 if ((0x14404410000000L & l) != 0L)
00604 jjCheckNAddStates(9, 11);
00605 break;
00606 case 15:
00607 if ((0x100000001000000L & l) != 0L)
00608 jjCheckNAdd(16);
00609 break;
00610 case 16:
00611 if ((0x7e0000007eL & l) == 0L)
00612 break;
00613 if (kind > 18)
00614 kind = 18;
00615 jjCheckNAddTwoStates(16, 2);
00616 break;
00617 case 20:
00618 jjAddStates(0, 2);
00619 break;
00620 case 25:
00621 jjCheckNAddTwoStates(25, 26);
00622 break;
00623 case 27:
00624 case 28:
00625 jjCheckNAddTwoStates(28, 26);
00626 break;
00627 case 32:
00628 jjCheckNAddTwoStates(32, 33);
00629 break;
00630 case 34:
00631 case 35:
00632 jjCheckNAddTwoStates(35, 33);
00633 break;
00634 default : break;
00635 }
00636 } while(i != startsAt);
00637 }
00638 else
00639 {
00640 int hiByte = (int)(curChar >> 8);
00641 int i1 = hiByte >> 6;
00642 long l1 = 1L << (hiByte & 077);
00643 int i2 = (curChar & 0xff) >> 6;
00644 long l2 = 1L << (curChar & 077);
00645 MatchLoop: do
00646 {
00647 switch(jjstateSet[--i])
00648 {
00649 case 0:
00650 case 13:
00651 if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
00652 break;
00653 if (kind > 23)
00654 kind = 23;
00655 jjCheckNAdd(13);
00656 break;
00657 case 4:
00658 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
00659 jjAddStates(9, 11);
00660 break;
00661 case 20:
00662 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
00663 jjAddStates(0, 2);
00664 break;
00665 case 25:
00666 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
00667 jjCheckNAddTwoStates(25, 26);
00668 break;
00669 case 27:
00670 case 28:
00671 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
00672 jjCheckNAddTwoStates(28, 26);
00673 break;
00674 case 32:
00675 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
00676 jjCheckNAddTwoStates(32, 33);
00677 break;
00678 case 34:
00679 case 35:
00680 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
00681 jjCheckNAddTwoStates(35, 33);
00682 break;
00683 default : break;
00684 }
00685 } while(i != startsAt);
00686 }
00687 if (kind != 0x7fffffff)
00688 {
00689 jjmatchedKind = kind;
00690 jjmatchedPos = curPos;
00691 kind = 0x7fffffff;
00692 }
00693 ++curPos;
00694 if ((i = jjnewStateCnt) == (startsAt = 37 - (jjnewStateCnt = startsAt)))
00695 return curPos;
00696 try { curChar = input_stream.readChar(); }
00697 catch(java.io.IOException e) { return curPos; }
00698 }
00699 }
00700 static final int[] jjnextStates = {
00701 20, 21, 23, 19, 30, 31, 15, 17, 2, 4, 5, 7, 4, 5, 9, 7,
00702 26, 27, 29, 33, 34, 36, 6, 8, 10,
00703 };
00704 private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2)
00705 {
00706 switch(hiByte)
00707 {
00708 case 0:
00709 return ((jjbitVec2[i2] & l2) != 0L);
00710 default :
00711 if ((jjbitVec0[i1] & l1) != 0L)
00712 return true;
00713 return false;
00714 }
00715 }
00716 private static final boolean jjCanMove_1(int hiByte, int i1, int i2, long l1, long l2)
00717 {
00718 switch(hiByte)
00719 {
00720 case 0:
00721 return ((jjbitVec4[i2] & l2) != 0L);
00722 case 48:
00723 return ((jjbitVec5[i2] & l2) != 0L);
00724 case 49:
00725 return ((jjbitVec6[i2] & l2) != 0L);
00726 case 51:
00727 return ((jjbitVec7[i2] & l2) != 0L);
00728 case 61:
00729 return ((jjbitVec8[i2] & l2) != 0L);
00730 default :
00731 if ((jjbitVec3[i1] & l1) != 0L)
00732 return true;
00733 return false;
00734 }
00735 }
00736 public static final String[] jjstrLiteralImages = {
00737 "", null, null, null, null, null, null, null, null, "\141\156\144",
00738 "\157\162", "\156\157\164", "\154\145\156\147\164\150", "\164\162\165\145",
00739 "\146\141\154\163\145", "\154\145\164", "\166\141\162", "\151\156", null, null, null, null, null, null,
00740 null, null, "\50", "\51", "\173", "\175", "\133", "\135", "\73", "\54", "\56",
00741 "\75", "\76", "\74", "\41", "\176", "\77", "\72", "\75\75", "\74\75", "\76\75",
00742 "\41\75", "\174\174", "\46\46", "\53\53", "\53", "\55", "\52", "\57", "\46", "\174",
00743 "\136", "\45", };
00744 public static final String[] lexStateNames = {
00745 "DEFAULT",
00746 };
00747 static final long[] jjtoToken = {
00748 0x1fffffffcc7fe01L,
00749 };
00750 static final long[] jjtoSkip = {
00751 0x1feL,
00752 };
00753 static final long[] jjtoSpecial = {
00754 0x1c0L,
00755 };
00756 static protected JavaCharStream input_stream;
00757 static private final int[] jjrounds = new int[37];
00758 static private final int[] jjstateSet = new int[74];
00759 static protected char curChar;
00760 public Exp2ParserTokenManager(JavaCharStream stream){
00761 if (input_stream != null)
00762 throw new TokenMgrError("ERROR: Second call to constructor of static lexer. You must use ReInit() to initialize the static variables.", TokenMgrError.STATIC_LEXER_ERROR);
00763 input_stream = stream;
00764 }
00765 public Exp2ParserTokenManager(JavaCharStream stream, int lexState){
00766 this(stream);
00767 SwitchTo(lexState);
00768 }
00769 static public void ReInit(JavaCharStream stream)
00770 {
00771 jjmatchedPos = jjnewStateCnt = 0;
00772 curLexState = defaultLexState;
00773 input_stream = stream;
00774 ReInitRounds();
00775 }
00776 static private final void ReInitRounds()
00777 {
00778 int i;
00779 jjround = 0x80000001;
00780 for (i = 37; i-- > 0;)
00781 jjrounds[i] = 0x80000000;
00782 }
00783 static public void ReInit(JavaCharStream stream, int lexState)
00784 {
00785 ReInit(stream);
00786 SwitchTo(lexState);
00787 }
00788 static public void SwitchTo(int lexState)
00789 {
00790 if (lexState >= 1 || lexState < 0)
00791 throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
00792 else
00793 curLexState = lexState;
00794 }
00795
00796 static protected Token jjFillToken()
00797 {
00798 Token t = Token.newToken(jjmatchedKind);
00799 t.kind = jjmatchedKind;
00800 String im = jjstrLiteralImages[jjmatchedKind];
00801 t.image = (im == null) ? input_stream.GetImage() : im;
00802 t.beginLine = input_stream.getBeginLine();
00803 t.beginColumn = input_stream.getBeginColumn();
00804 t.endLine = input_stream.getEndLine();
00805 t.endColumn = input_stream.getEndColumn();
00806 return t;
00807 }
00808
00809 static int curLexState = 0;
00810 static int defaultLexState = 0;
00811 static int jjnewStateCnt;
00812 static int jjround;
00813 static int jjmatchedPos;
00814 static int jjmatchedKind;
00815
00816 public static Token getNextToken()
00817 {
00818 int kind;
00819 Token specialToken = null;
00820 Token matchedToken;
00821 int curPos = 0;
00822
00823 EOFLoop :
00824 for (;;)
00825 {
00826 try
00827 {
00828 curChar = input_stream.BeginToken();
00829 }
00830 catch(java.io.IOException e)
00831 {
00832 jjmatchedKind = 0;
00833 matchedToken = jjFillToken();
00834 matchedToken.specialToken = specialToken;
00835 return matchedToken;
00836 }
00837
00838 try { input_stream.backup(0);
00839 while (curChar <= 32 && (0x100003600L & (1L << curChar)) != 0L)
00840 curChar = input_stream.BeginToken();
00841 }
00842 catch (java.io.IOException e1) { continue EOFLoop; }
00843 jjmatchedKind = 0x7fffffff;
00844 jjmatchedPos = 0;
00845 curPos = jjMoveStringLiteralDfa0_0();
00846 if (jjmatchedKind != 0x7fffffff)
00847 {
00848 if (jjmatchedPos + 1 < curPos)
00849 input_stream.backup(curPos - jjmatchedPos - 1);
00850 if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
00851 {
00852 matchedToken = jjFillToken();
00853 matchedToken.specialToken = specialToken;
00854 return matchedToken;
00855 }
00856 else
00857 {
00858 if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
00859 {
00860 matchedToken = jjFillToken();
00861 if (specialToken == null)
00862 specialToken = matchedToken;
00863 else
00864 {
00865 matchedToken.specialToken = specialToken;
00866 specialToken = (specialToken.next = matchedToken);
00867 }
00868 }
00869 continue EOFLoop;
00870 }
00871 }
00872 int error_line = input_stream.getEndLine();
00873 int error_column = input_stream.getEndColumn();
00874 String error_after = null;
00875 boolean EOFSeen = false;
00876 try { input_stream.readChar(); input_stream.backup(1); }
00877 catch (java.io.IOException e1) {
00878 EOFSeen = true;
00879 error_after = curPos <= 1 ? "" : input_stream.GetImage();
00880 if (curChar == '\n' || curChar == '\r') {
00881 error_line++;
00882 error_column = 0;
00883 }
00884 else
00885 error_column++;
00886 }
00887 if (!EOFSeen) {
00888 input_stream.backup(1);
00889 error_after = curPos <= 1 ? "" : input_stream.GetImage();
00890 }
00891 throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
00892 }
00893 }
00894
00895 }
