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