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