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