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