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