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