00001 package edu.ksu.cis.bandera.abstraction.predicate.parser;
00002
00003
00004 import java.util.*;
00005 import java.io.*;
00006
00007 public class PredicateParserTokenManager implements PredicateParserConstants
00008 {
00009 static final long[] jjbitVec0 = {
00010 0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
00011 };
00012 static final long[] jjbitVec2 = {
00013 0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
00014 };
00015 static final long[] jjbitVec3 = {
00016 0x1ff00000fffffffeL, 0xffffffffffffc000L, 0xffffffffL, 0x600000000000000L
00017 };
00018 static final long[] jjbitVec4 = {
00019 0x0L, 0x0L, 0x0L, 0xff7fffffff7fffffL
00020 };
00021 static final long[] jjbitVec5 = {
00022 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
00023 };
00024 static final long[] jjbitVec6 = {
00025 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffL, 0x0L
00026 };
00027 static final long[] jjbitVec7 = {
00028 0xffffffffffffffffL, 0xffffffffffffffffL, 0x0L, 0x0L
00029 };
00030 static final long[] jjbitVec8 = {
00031 0x3fffffffffffL, 0x0L, 0x0L, 0x0L
00032 };
00033 static final int[] jjnextStates = {
00034 25, 26, 31, 32, 35, 36, 12, 14, 15, 17, 40, 42, 6, 8, 9, 12,
00035 14, 15, 19, 17, 27, 28, 12, 35, 36, 12, 10, 11, 16, 18, 20, 29,
00036 30, 33, 34, 37, 38,
00037 };
00038 public static final String[] jjstrLiteralImages = {
00039 null, null, null, null, null, null, null, null, null, null, null, null, null,
00040 null, null, null, null, null, null, null, null, null, null, null, null, null, null,
00041 null, null, null, null, null, null, null, null, null, null, null, null, null, null,
00042 null, null, null, null, null, null, null, null, null, null, null, null, null, null,
00043 null, null, null, null, null, null, null, null, null, null, null, null, null, null,
00044 null, null, null, null, null, null, null, null, null, null, null, null, null, null,
00045 null, };
00046 public static final String[] lexStateNames = {
00047 "DEFAULT",
00048 "IN_SINGLE_LINE_COMMENT",
00049 "IN_FORMAL_COMMENT",
00050 "IN_MULTI_LINE_COMMENT",
00051 "CHAR_LIT",
00052 "ESCAPED_CHAR_LIT",
00053 "CHAR_LIT_CLOSE",
00054 };
00055 public static final int[] jjnewLexState = {
00056 -1, -1, -1, -1, -1, -1, 1, 2, 3, 0, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
00057 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 4, -1, 5, 6, 6, 6, 6, 0, -1, -1, -1, -1,
00058 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
00059 -1, -1, -1, -1, -1, -1, -1, -1, -1,
00060 };
00061 static final long[] jjtoToken = {
00062 0xfffe40d1ffffe001L, 0xfffffL,
00063 };
00064 static final long[] jjtoSkip = {
00065 0xe3eL, 0x0L,
00066 };
00067 static final long[] jjtoSpecial = {
00068 0xe3eL, 0x0L,
00069 };
00070 static final long[] jjtoMore = {
00071 0x3f00000011c0L, 0x0L,
00072 };
00073 private ASCII_UCodeESC_CharStream input_stream;
00074 private final int[] jjrounds = new int[43];
00075 private final int[] jjstateSet = new int[86];
00076 StringBuffer image;
00077 int jjimageLen;
00078 int lengthOfMatch;
00079 protected char curChar;
00080 int curLexState = 0;
00081 int defaultLexState = 0;
00082 int jjnewStateCnt;
00083 int jjround;
00084 int jjmatchedPos;
00085 int jjmatchedKind;
00086
00087 public PredicateParserTokenManager(ASCII_UCodeESC_CharStream stream)
00088 {
00089 if (ASCII_UCodeESC_CharStream.staticFlag)
00090 throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
00091 input_stream = stream;
00092 }
00093 public PredicateParserTokenManager(ASCII_UCodeESC_CharStream stream, int lexState)
00094 {
00095 this(stream);
00096 SwitchTo(lexState);
00097 }
00098 public final Token getNextToken()
00099 {
00100 int kind;
00101 Token specialToken = null;
00102 Token matchedToken;
00103 int curPos = 0;
00104
00105 EOFLoop :
00106 for (;;)
00107 {
00108 try
00109 {
00110 curChar = input_stream.BeginToken();
00111 }
00112 catch(java.io.IOException e)
00113 {
00114 jjmatchedKind = 0;
00115 matchedToken = jjFillToken();
00116 matchedToken.specialToken = specialToken;
00117 return matchedToken;
00118 }
00119 image = null;
00120 jjimageLen = 0;
00121
00122 for (;;)
00123 {
00124 switch(curLexState)
00125 {
00126 case 0:
00127 jjmatchedKind = 0x7fffffff;
00128 jjmatchedPos = 0;
00129 curPos = jjMoveStringLiteralDfa0_0();
00130 break;
00131 case 1:
00132 jjmatchedKind = 0x7fffffff;
00133 jjmatchedPos = 0;
00134 curPos = jjMoveStringLiteralDfa0_1();
00135 if (jjmatchedPos == 0 && jjmatchedKind > 12)
00136 {
00137 jjmatchedKind = 12;
00138 }
00139 break;
00140 case 2:
00141 jjmatchedKind = 0x7fffffff;
00142 jjmatchedPos = 0;
00143 curPos = jjMoveStringLiteralDfa0_2();
00144 if (jjmatchedPos == 0 && jjmatchedKind > 12)
00145 {
00146 jjmatchedKind = 12;
00147 }
00148 break;
00149 case 3:
00150 jjmatchedKind = 0x7fffffff;
00151 jjmatchedPos = 0;
00152 curPos = jjMoveStringLiteralDfa0_3();
00153 if (jjmatchedPos == 0 && jjmatchedKind > 12)
00154 {
00155 jjmatchedKind = 12;
00156 }
00157 break;
00158 case 4:
00159 jjmatchedKind = 0x7fffffff;
00160 jjmatchedPos = 0;
00161 curPos = jjMoveStringLiteralDfa0_4();
00162 break;
00163 case 5:
00164 jjmatchedKind = 0x7fffffff;
00165 jjmatchedPos = 0;
00166 curPos = jjMoveStringLiteralDfa0_5();
00167 break;
00168 case 6:
00169 jjmatchedKind = 0x7fffffff;
00170 jjmatchedPos = 0;
00171 curPos = jjMoveStringLiteralDfa0_6();
00172 break;
00173 }
00174 if (jjmatchedKind != 0x7fffffff)
00175 {
00176 if (jjmatchedPos + 1 < curPos)
00177 input_stream.backup(curPos - jjmatchedPos - 1);
00178 if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
00179 {
00180 matchedToken = jjFillToken();
00181 matchedToken.specialToken = specialToken;
00182 if (jjnewLexState[jjmatchedKind] != -1)
00183 curLexState = jjnewLexState[jjmatchedKind];
00184 return matchedToken;
00185 }
00186 else if ((jjtoSkip[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
00187 {
00188 if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
00189 {
00190 matchedToken = jjFillToken();
00191 if (specialToken == null)
00192 specialToken = matchedToken;
00193 else
00194 {
00195 matchedToken.specialToken = specialToken;
00196 specialToken = (specialToken.next = matchedToken);
00197 }
00198 SkipLexicalActions(matchedToken);
00199 }
00200 else
00201 SkipLexicalActions(null);
00202 if (jjnewLexState[jjmatchedKind] != -1)
00203 curLexState = jjnewLexState[jjmatchedKind];
00204 continue EOFLoop;
00205 }
00206 MoreLexicalActions();
00207 if (jjnewLexState[jjmatchedKind] != -1)
00208 curLexState = jjnewLexState[jjmatchedKind];
00209 curPos = 0;
00210 jjmatchedKind = 0x7fffffff;
00211 try {
00212 curChar = input_stream.readChar();
00213 continue;
00214 }
00215 catch (java.io.IOException e1) { }
00216 }
00217 int error_line = input_stream.getEndLine();
00218 int error_column = input_stream.getEndColumn();
00219 String error_after = null;
00220 boolean EOFSeen = false;
00221 try { input_stream.readChar(); input_stream.backup(1); }
00222 catch (java.io.IOException e1) {
00223 EOFSeen = true;
00224 error_after = curPos <= 1 ? "" : input_stream.GetImage();
00225 if (curChar == '\n' || curChar == '\r') {
00226 error_line++;
00227 error_column = 0;
00228 }
00229 else
00230 error_column++;
00231 }
00232 if (!EOFSeen) {
00233 input_stream.backup(1);
00234 error_after = curPos <= 1 ? "" : input_stream.GetImage();
00235 }
00236 throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
00237 }
00238 }
00239 }
00240 private final void jjAddStates(int start, int end)
00241 {
00242 do {
00243 jjstateSet[jjnewStateCnt++] = jjnextStates[start];
00244 } while (start++ != end);
00245 }
00246 private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2)
00247 {
00248 switch(hiByte)
00249 {
00250 case 0:
00251 return ((jjbitVec2[i2] & l2) != 0L);
00252 default :
00253 if ((jjbitVec0[i1] & l1) != 0L)
00254 return true;
00255 return false;
00256 }
00257 }
00258 private static final boolean jjCanMove_1(int hiByte, int i1, int i2, long l1, long l2)
00259 {
00260 switch(hiByte)
00261 {
00262 case 0:
00263 return ((jjbitVec4[i2] & l2) != 0L);
00264 case 48:
00265 return ((jjbitVec5[i2] & l2) != 0L);
00266 case 49:
00267 return ((jjbitVec6[i2] & l2) != 0L);
00268 case 51:
00269 return ((jjbitVec7[i2] & l2) != 0L);
00270 case 61:
00271 return ((jjbitVec8[i2] & l2) != 0L);
00272 default :
00273 if ((jjbitVec3[i1] & l1) != 0L)
00274 return true;
00275 return false;
00276 }
00277 }
00278 private final void jjCheckNAdd(int state)
00279 {
00280 if (jjrounds[state] != jjround)
00281 {
00282 jjstateSet[jjnewStateCnt++] = state;
00283 jjrounds[state] = jjround;
00284 }
00285 }
00286 private final void jjCheckNAddStates(int start)
00287 {
00288 jjCheckNAdd(jjnextStates[start]);
00289 jjCheckNAdd(jjnextStates[start + 1]);
00290 }
00291 private final void jjCheckNAddStates(int start, int end)
00292 {
00293 do {
00294 jjCheckNAdd(jjnextStates[start]);
00295 } while (start++ != end);
00296 }
00297 private final void jjCheckNAddTwoStates(int state1, int state2)
00298 {
00299 jjCheckNAdd(state1);
00300 jjCheckNAdd(state2);
00301 }
00302 private final Token jjFillToken()
00303 {
00304 Token t = Token.newToken(jjmatchedKind);
00305 t.kind = jjmatchedKind;
00306 String im = jjstrLiteralImages[jjmatchedKind];
00307 t.image = (im == null) ? input_stream.GetImage() : im;
00308 t.beginLine = input_stream.getBeginLine();
00309 t.beginColumn = input_stream.getBeginColumn();
00310 t.endLine = input_stream.getEndLine();
00311 t.endColumn = input_stream.getEndColumn();
00312 return t;
00313 }
00314 private final int jjMoveNfa_0(int startState, int curPos)
00315 {
00316 int[] nextStates;
00317 int startsAt = 0;
00318 jjnewStateCnt = 43;
00319 int i = 1;
00320 jjstateSet[0] = startState;
00321 int j, kind = 0x7fffffff;
00322 for (;;)
00323 {
00324 if (++jjround == 0x7fffffff)
00325 ReInitRounds();
00326 if (curChar < 64)
00327 {
00328 long l = 1L << curChar;
00329 MatchLoop: do
00330 {
00331 switch(jjstateSet[--i])
00332 {
00333 case 3:
00334 if ((0x3ff000000000000L & l) != 0L)
00335 jjCheckNAddStates(0, 6);
00336 else if (curChar == 36)
00337 {
00338 if (kind > 46)
00339 kind = 46;
00340 jjCheckNAdd(23);
00341 }
00342 else if (curChar == 34)
00343 jjCheckNAddStates(7, 9);
00344 else if (curChar == 46)
00345 jjCheckNAdd(8);
00346 else if (curChar == 47)
00347 jjstateSet[jjnewStateCnt++] = 2;
00348 if ((0x3fe000000000000L & l) != 0L)
00349 {
00350 if (kind > 32)
00351 kind = 32;
00352 jjCheckNAddTwoStates(5, 6);
00353 }
00354 else if (curChar == 48)
00355 {
00356 if (kind > 32)
00357 kind = 32;
00358 jjCheckNAddStates(10, 12);
00359 }
00360 break;
00361 case 0:
00362 if (curChar == 42)
00363 jjstateSet[jjnewStateCnt++] = 1;
00364 break;
00365 case 1:
00366 if ((0xffff7fffffffffffL & l) != 0L && kind > 7)
00367 kind = 7;
00368 break;
00369 case 2:
00370 if (curChar == 42)
00371 jjstateSet[jjnewStateCnt++] = 0;
00372 break;
00373 case 4:
00374 if ((0x3fe000000000000L & l) == 0L)
00375 break;
00376 if (kind > 32)
00377 kind = 32;
00378 jjCheckNAddTwoStates(5, 6);
00379 break;
00380 case 5:
00381 if ((0x3ff000000000000L & l) == 0L)
00382 break;
00383 if (kind > 32)
00384 kind = 32;
00385 jjCheckNAddTwoStates(5, 6);
00386 break;
00387 case 7:
00388 if (curChar == 46)
00389 jjCheckNAdd(8);
00390 break;
00391 case 8:
00392 if ((0x3ff000000000000L & l) == 0L)
00393 break;
00394 if (kind > 36)
00395 kind = 36;
00396 jjCheckNAddStates(13, 15);
00397 break;
00398 case 10:
00399 if ((0x280000000000L & l) != 0L)
00400 jjCheckNAdd(11);
00401 break;
00402 case 11:
00403 if ((0x3ff000000000000L & l) == 0L)
00404 break;
00405 if (kind > 36)
00406 kind = 36;
00407 jjCheckNAddTwoStates(11, 12);
00408 break;
00409 case 13:
00410 if (curChar == 34)
00411 jjCheckNAddStates(7, 9);
00412 break;
00413 case 14:
00414 if ((0xfffffffbffffdbffL & l) != 0L)
00415 jjCheckNAddStates(7, 9);
00416 break;
00417 case 16:
00418 if ((0x8400000000L & l) != 0L)
00419 jjCheckNAddStates(7, 9);
00420 break;
00421 case 17:
00422 if (curChar == 34 && kind > 39)
00423 kind = 39;
00424 break;
00425 case 18:
00426 if ((0xff000000000000L & l) != 0L)
00427 jjCheckNAddStates(16, 19);
00428 break;
00429 case 19:
00430 if ((0xff000000000000L & l) != 0L)
00431 jjCheckNAddStates(7, 9);
00432 break;
00433 case 20:
00434 if ((0xf000000000000L & l) != 0L)
00435 jjstateSet[jjnewStateCnt++] = 21;
00436 break;
00437 case 21:
00438 if ((0xff000000000000L & l) != 0L)
00439 jjCheckNAdd(19);
00440 break;
00441 case 22:
00442 if (curChar != 36)
00443 break;
00444 if (kind > 46)
00445 kind = 46;
00446 jjCheckNAdd(23);
00447 break;
00448 case 23:
00449 if ((0x3ff001000000000L & l) == 0L)
00450 break;
00451 if (kind > 46)
00452 kind = 46;
00453 jjCheckNAdd(23);
00454 break;
00455 case 24:
00456 if ((0x3ff000000000000L & l) != 0L)
00457 jjCheckNAddStates(0, 6);
00458 break;
00459 case 25:
00460 if ((0x3ff000000000000L & l) != 0L)
00461 jjCheckNAddTwoStates(25, 26);
00462 break;
00463 case 26:
00464 if (curChar != 46)
00465 break;
00466 if (kind > 36)
00467 kind = 36;
00468 jjCheckNAddStates(20, 22);
00469 break;
00470 case 27:
00471 if ((0x3ff000000000000L & l) == 0L)
00472 break;
00473 if (kind > 36)
00474 kind = 36;
00475 jjCheckNAddStates(20, 22);
00476 break;
00477 case 29:
00478 if ((0x280000000000L & l) != 0L)
00479 jjCheckNAdd(30);
00480 break;
00481 case 30:
00482 if ((0x3ff000000000000L & l) == 0L)
00483 break;
00484 if (kind > 36)
00485 kind = 36;
00486 jjCheckNAddTwoStates(30, 12);
00487 break;
00488 case 31:
00489 if ((0x3ff000000000000L & l) != 0L)
00490 jjCheckNAddTwoStates(31, 32);
00491 break;
00492 case 33:
00493 if ((0x280000000000L & l) != 0L)
00494 jjCheckNAdd(34);
00495 break;
00496 case 34:
00497 if ((0x3ff000000000000L & l) == 0L)
00498 break;
00499 if (kind > 36)
00500 kind = 36;
00501 jjCheckNAddTwoStates(34, 12);
00502 break;
00503 case 35:
00504 if ((0x3ff000000000000L & l) != 0L)
00505 jjCheckNAddStates(23, 25);
00506 break;
00507 case 37:
00508 if ((0x280000000000L & l) != 0L)
00509 jjCheckNAdd(38);
00510 break;
00511 case 38:
00512 if ((0x3ff000000000000L & l) != 0L)
00513 jjCheckNAddTwoStates(38, 12);
00514 break;
00515 case 39:
00516 if (curChar != 48)
00517 break;
00518 if (kind > 32)
00519 kind = 32;
00520 jjCheckNAddStates(10, 12);
00521 break;
00522 case 41:
00523 if ((0x3ff000000000000L & l) == 0L)
00524 break;
00525 if (kind > 32)
00526 kind = 32;
00527 jjCheckNAddTwoStates(41, 6);
00528 break;
00529 case 42:
00530 if ((0xff000000000000L & l) == 0L)
00531 break;
00532 if (kind > 32)
00533 kind = 32;
00534 jjCheckNAddTwoStates(42, 6);
00535 break;
00536 default : break;
00537 }
00538 } while(i != startsAt);
00539 }
00540 else if (curChar < 128)
00541 {
00542 long l = 1L << (curChar & 077);
00543 MatchLoop: do
00544 {
00545 switch(jjstateSet[--i])
00546 {
00547 case 3:
00548 case 23:
00549 if ((0x7fffffe87fffffeL & l) == 0L)
00550 break;
00551 if (kind > 46)
00552 kind = 46;
00553 jjCheckNAdd(23);
00554 break;
00555 case 1:
00556 if (kind > 7)
00557 kind = 7;
00558 break;
00559 case 6:
00560 if ((0x100000001000L & l) != 0L && kind > 32)
00561 kind = 32;
00562 break;
00563 case 9:
00564 if ((0x2000000020L & l) != 0L)
00565 jjAddStates(26, 27);
00566 break;
00567 case 12:
00568 if ((0x5000000050L & l) != 0L && kind > 36)
00569 kind = 36;
00570 break;
00571 case 14:
00572 if ((0xffffffffefffffffL & l) != 0L)
00573 jjCheckNAddStates(7, 9);
00574 break;
00575 case 15:
00576 if (curChar == 92)
00577 jjAddStates(28, 30);
00578 break;
00579 case 16:
00580 if ((0x14404410000000L & l) != 0L)
00581 jjCheckNAddStates(7, 9);
00582 break;
00583 case 28:
00584 if ((0x2000000020L & l) != 0L)
00585 jjAddStates(31, 32);
00586 break;
00587 case 32:
00588 if ((0x2000000020L & l) != 0L)
00589 jjAddStates(33, 34);
00590 break;
00591 case 36:
00592 if ((0x2000000020L & l) != 0L)
00593 jjAddStates(35, 36);
00594 break;
00595 case 40:
00596 if ((0x100000001000000L & l) != 0L)
00597 jjCheckNAdd(41);
00598 break;
00599 case 41:
00600 if ((0x7e0000007eL & l) == 0L)
00601 break;
00602 if (kind > 32)
00603 kind = 32;
00604 jjCheckNAddTwoStates(41, 6);
00605 break;
00606 default : break;
00607 }
00608 } while(i != startsAt);
00609 }
00610 else
00611 {
00612 int hiByte = (int)(curChar >> 8);
00613 int i1 = hiByte >> 6;
00614 long l1 = 1L << (hiByte & 077);
00615 int i2 = (curChar & 0xff) >> 6;
00616 long l2 = 1L << (curChar & 077);
00617 MatchLoop: do
00618 {
00619 switch(jjstateSet[--i])
00620 {
00621 case 3:
00622 case 23:
00623 if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
00624 break;
00625 if (kind > 46)
00626 kind = 46;
00627 jjCheckNAdd(23);
00628 break;
00629 case 1:
00630 if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 7)
00631 kind = 7;
00632 break;
00633 case 14:
00634 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
00635 jjAddStates(7, 9);
00636 break;
00637 default : break;
00638 }
00639 } while(i != startsAt);
00640 }
00641 if (kind != 0x7fffffff)
00642 {
00643 jjmatchedKind = kind;
00644 jjmatchedPos = curPos;
00645 kind = 0x7fffffff;
00646 }
00647 ++curPos;
00648 if ((i = jjnewStateCnt) == (startsAt = 43 - (jjnewStateCnt = startsAt)))
00649 return curPos;
00650 try { curChar = input_stream.readChar(); }
00651 catch(java.io.IOException e) { return curPos; }
00652 }
00653 }
00654 private final int jjMoveNfa_1(int startState, int curPos)
00655 {
00656 int[] nextStates;
00657 int startsAt = 0;
00658 jjnewStateCnt = 3;
00659 int i = 1;
00660 jjstateSet[0] = startState;
00661 int j, kind = 0x7fffffff;
00662 for (;;)
00663 {
00664 if (++jjround == 0x7fffffff)
00665 ReInitRounds();
00666 if (curChar < 64)
00667 {
00668 long l = 1L << curChar;
00669 MatchLoop: do
00670 {
00671 switch(jjstateSet[--i])
00672 {
00673 case 0:
00674 if ((0x2400L & l) != 0L)
00675 {
00676 if (kind > 9)
00677 kind = 9;
00678 }
00679 if (curChar == 13)
00680 jjstateSet[jjnewStateCnt++] = 1;
00681 break;
00682 case 1:
00683 if (curChar == 10 && kind > 9)
00684 kind = 9;
00685 break;
00686 case 2:
00687 if (curChar == 13)
00688 jjstateSet[jjnewStateCnt++] = 1;
00689 break;
00690 default : break;
00691 }
00692 } while(i != startsAt);
00693 }
00694 else if (curChar < 128)
00695 {
00696 long l = 1L << (curChar & 077);
00697 MatchLoop: do
00698 {
00699 switch(jjstateSet[--i])
00700 {
00701 default : break;
00702 }
00703 } while(i != startsAt);
00704 }
00705 else
00706 {
00707 int hiByte = (int)(curChar >> 8);
00708 int i1 = hiByte >> 6;
00709 long l1 = 1L << (hiByte & 077);
00710 int i2 = (curChar & 0xff) >> 6;
00711 long l2 = 1L << (curChar & 077);
00712 MatchLoop: do
00713 {
00714 switch(jjstateSet[--i])
00715 {
00716 default : break;
00717 }
00718 } while(i != startsAt);
00719 }
00720 if (kind != 0x7fffffff)
00721 {
00722 jjmatchedKind = kind;
00723 jjmatchedPos = curPos;
00724 kind = 0x7fffffff;
00725 }
00726 ++curPos;
00727 if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
00728 return curPos;
00729 try { curChar = input_stream.readChar(); }
00730 catch(java.io.IOException e) { return curPos; }
00731 }
00732 }
00733 private final int jjMoveNfa_4(int startState, int curPos)
00734 {
00735 int[] nextStates;
00736 int startsAt = 0;
00737 jjnewStateCnt = 1;
00738 int i = 1;
00739 jjstateSet[0] = startState;
00740 int j, kind = 0x7fffffff;
00741 for (;;)
00742 {
00743 if (++jjround == 0x7fffffff)
00744 ReInitRounds();
00745 if (curChar < 64)
00746 {
00747 long l = 1L << curChar;
00748 MatchLoop: do
00749 {
00750 switch(jjstateSet[--i])
00751 {
00752 case 0:
00753 if ((0xffffff7fffffdbffL & l) != 0L)
00754 kind = 41;
00755 break;
00756 default : break;
00757 }
00758 } while(i != startsAt);
00759 }
00760 else if (curChar < 128)
00761 {
00762 long l = 1L << (curChar & 077);
00763 MatchLoop: do
00764 {
00765 switch(jjstateSet[--i])
00766 {
00767 case 0:
00768 if ((0xffffffffefffffffL & l) != 0L)
00769 kind = 41;
00770 break;
00771 default : break;
00772 }
00773 } while(i != startsAt);
00774 }
00775 else
00776 {
00777 int hiByte = (int)(curChar >> 8);
00778 int i1 = hiByte >> 6;
00779 long l1 = 1L << (hiByte & 077);
00780 int i2 = (curChar & 0xff) >> 6;
00781 long l2 = 1L << (curChar & 077);
00782 MatchLoop: do
00783 {
00784 switch(jjstateSet[--i])
00785 {
00786 case 0:
00787 if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 41)
00788 kind = 41;
00789 break;
00790 default : break;
00791 }
00792 } while(i != startsAt);
00793 }
00794 if (kind != 0x7fffffff)
00795 {
00796 jjmatchedKind = kind;
00797 jjmatchedPos = curPos;
00798 kind = 0x7fffffff;
00799 }
00800 ++curPos;
00801 if ((i = jjnewStateCnt) == (startsAt = 1 - (jjnewStateCnt = startsAt)))
00802 return curPos;
00803 try { curChar = input_stream.readChar(); }
00804 catch(java.io.IOException e) { return curPos; }
00805 }
00806 }
00807 private final int jjMoveNfa_5(int startState, int curPos)
00808 {
00809 int[] nextStates;
00810 int startsAt = 0;
00811 jjnewStateCnt = 10;
00812 int i = 1;
00813 jjstateSet[0] = startState;
00814 int j, kind = 0x7fffffff;
00815 for (;;)
00816 {
00817 if (++jjround == 0x7fffffff)
00818 ReInitRounds();
00819 if (curChar < 64)
00820 {
00821 long l = 1L << curChar;
00822 MatchLoop: do
00823 {
00824 switch(jjstateSet[--i])
00825 {
00826 case 0:
00827 if ((0xff000000000000L & l) != 0L)
00828 {
00829 if (kind > 43)
00830 kind = 43;
00831 jjCheckNAdd(2);
00832 }
00833 else if ((0x8400000000L & l) != 0L)
00834 {
00835 if (kind > 42)
00836 kind = 42;
00837 }
00838 if ((0xf000000000000L & l) != 0L)
00839 jjstateSet[jjnewStateCnt++] = 4;
00840 break;
00841 case 1:
00842 if ((0xff000000000000L & l) == 0L)
00843 break;
00844 if (kind > 43)
00845 kind = 43;
00846 jjCheckNAdd(2);
00847 break;
00848 case 2:
00849 if ((0xff000000000000L & l) != 0L && kind > 43)
00850 kind = 43;
00851 break;
00852 case 3:
00853 if ((0xf000000000000L & l) != 0L)
00854 jjstateSet[jjnewStateCnt++] = 4;
00855 break;
00856 case 4:
00857 if ((0xff000000000000L & l) != 0L)
00858 jjCheckNAdd(2);
00859 break;
00860 case 6:
00861 if ((0x3ff000000000000L & l) != 0L)
00862 jjstateSet[jjnewStateCnt++] = 7;
00863 break;
00864 case 7:
00865 if ((0x3ff000000000000L & l) != 0L)
00866 jjstateSet[jjnewStateCnt++] = 8;
00867 break;
00868 case 8:
00869 if ((0x3ff000000000000L & l) != 0L)
00870 jjstateSet[jjnewStateCnt++] = 9;
00871 break;
00872 case 9:
00873 if ((0x3ff000000000000L & l) != 0L && kind > 44)
00874 kind = 44;
00875 break;
00876 default : break;
00877 }
00878 } while(i != startsAt);
00879 }
00880 else if (curChar < 128)
00881 {
00882 long l = 1L << (curChar & 077);
00883 MatchLoop: do
00884 {
00885 switch(jjstateSet[--i])
00886 {
00887 case 0:
00888 if ((0x14404410000000L & l) != 0L)
00889 {
00890 if (kind > 42)
00891 kind = 42;
00892 }
00893 else if (curChar == 117)
00894 jjstateSet[jjnewStateCnt++] = 6;
00895 break;
00896 case 5:
00897 if (curChar == 117)
00898 jjstateSet[jjnewStateCnt++] = 6;
00899 break;
00900 case 6:
00901 if ((0x7e0000007eL & l) != 0L)
00902 jjstateSet[jjnewStateCnt++] = 7;
00903 break;
00904 case 7:
00905 if ((0x7e0000007eL & l) != 0L)
00906 jjstateSet[jjnewStateCnt++] = 8;
00907 break;
00908 case 8:
00909 if ((0x7e0000007eL & l) != 0L)
00910 jjstateSet[jjnewStateCnt++] = 9;
00911 break;
00912 case 9:
00913 if ((0x7e0000007eL & l) != 0L && kind > 44)
00914 kind = 44;
00915 break;
00916 default : break;
00917 }
00918 } while(i != startsAt);
00919 }
00920 else
00921 {
00922 int hiByte = (int)(curChar >> 8);
00923 int i1 = hiByte >> 6;
00924 long l1 = 1L << (hiByte & 077);
00925 int i2 = (curChar & 0xff) >> 6;
00926 long l2 = 1L << (curChar & 077);
00927 MatchLoop: do
00928 {
00929 switch(jjstateSet[--i])
00930 {
00931 default : break;
00932 }
00933 } while(i != startsAt);
00934 }
00935 if (kind != 0x7fffffff)
00936 {
00937 jjmatchedKind = kind;
00938 jjmatchedPos = curPos;
00939 kind = 0x7fffffff;
00940 }
00941 ++curPos;
00942 if ((i = jjnewStateCnt) == (startsAt = 10 - (jjnewStateCnt = startsAt)))
00943 return curPos;
00944 try { curChar = input_stream.readChar(); }
00945 catch(java.io.IOException e) { return curPos; }
00946 }
00947 }
00948 private final int jjMoveStringLiteralDfa0_0()
00949 {
00950 switch(curChar)
00951 {
00952 case 9:
00953 return jjStopAtPos(0, 2);
00954 case 10:
00955 return jjStopAtPos(0, 3);
00956 case 12:
00957 return jjStopAtPos(0, 5);
00958 case 13:
00959 return jjStopAtPos(0, 4);
00960 case 32:
00961 return jjStopAtPos(0, 1);
00962 case 33:
00963 jjmatchedKind = 61;
00964 return jjMoveStringLiteralDfa1_0(0x0L, 0x4L);
00965 case 37:
00966 return jjStopAtPos(0, 78);
00967 case 38:
00968 jjmatchedKind = 75;
00969 return jjMoveStringLiteralDfa1_0(0x0L, 0x10L);
00970 case 39:
00971 return jjStopAtPos(0, 38);
00972 case 40:
00973 return jjStopAtPos(0, 49);
00974 case 41:
00975 return jjStopAtPos(0, 50);
00976 case 42:
00977 return jjStopAtPos(0, 73);
00978 case 43:
00979 jjmatchedKind = 71;
00980 return jjMoveStringLiteralDfa1_0(0x0L, 0x20L);
00981 case 44:
00982 return jjStopAtPos(0, 56);
00983 case 45:
00984 jjmatchedKind = 72;
00985 return jjMoveStringLiteralDfa1_0(0x0L, 0x40L);
00986 case 46:
00987 return jjStartNfaWithStates_0(0, 57, 8);
00988 case 47:
00989 jjmatchedKind = 74;
00990 return jjMoveStringLiteralDfa1_0(0x140L, 0x0L);
00991 case 58:
00992 return jjStopAtPos(0, 83);
00993 case 59:
00994 return jjStopAtPos(0, 55);
00995 case 60:
00996 jjmatchedKind = 60;
00997 return jjMoveStringLiteralDfa1_0(0x0L, 0x8001L);
00998 case 61:
00999 jjmatchedKind = 58;
01000 return jjMoveStringLiteralDfa1_0(0x8000000000000000L, 0x0L);
01001 case 62:
01002 jjmatchedKind = 59;
01003 return jjMoveStringLiteralDfa1_0(0x0L, 0x30002L);
01004 case 63:
01005 return jjStopAtPos(0, 82);
01006 case 91:
01007 return jjStopAtPos(0, 53);
01008 case 93:
01009 return jjStopAtPos(0, 54);
01010 case 94:
01011 return jjStopAtPos(0, 77);
01012 case 98:
01013 return jjMoveStringLiteralDfa1_0(0x6000L, 0x0L);
01014 case 99:
01015 return jjMoveStringLiteralDfa1_0(0x18000L, 0x0L);
01016 case 100:
01017 return jjMoveStringLiteralDfa1_0(0x20000L, 0x0L);
01018 case 101:
01019 return jjMoveStringLiteralDfa1_0(0x40000000L, 0x0L);
01020 case 102:
01021 return jjMoveStringLiteralDfa1_0(0xc0000L, 0x0L);
01022 case 103:
01023 return jjMoveStringLiteralDfa1_0(0x80000000L, 0x0L);
01024 case 105:
01025 return jjMoveStringLiteralDfa1_0(0x300000L, 0x0L);
01026 case 108:
01027 return jjMoveStringLiteralDfa1_0(0x400000L, 0x0L);
01028 case 109:
01029 return jjMoveStringLiteralDfa1_0(0x20000000L, 0x0L);
01030 case 110:
01031 return jjMoveStringLiteralDfa1_0(0x800000L, 0x0L);
01032 case 112:
01033 return jjMoveStringLiteralDfa1_0(0x10000000L, 0x0L);
01034 case 115:
01035 return jjMoveStringLiteralDfa1_0(0x3000000L, 0x0L);
01036 case 116:
01037 return jjMoveStringLiteralDfa1_0(0xc000000L, 0x0L);
01038 case 123:
01039 return jjStopAtPos(0, 51);
01040 case 124:
01041 jjmatchedKind = 76;
01042 return jjMoveStringLiteralDfa1_0(0x0L, 0x8L);
01043 case 125:
01044 return jjStopAtPos(0, 52);
01045 case 126:
01046 return jjStopAtPos(0, 62);
01047 default :
01048 return jjMoveNfa_0(3, 0);
01049 }
01050 }
01051 private final int jjMoveStringLiteralDfa0_1()
01052 {
01053 return jjMoveNfa_1(0, 0);
01054 }
01055 private final int jjMoveStringLiteralDfa0_2()
01056 {
01057 switch(curChar)
01058 {
01059 case 42:
01060 return jjMoveStringLiteralDfa1_2(0x400L);
01061 default :
01062 return 1;
01063 }
01064 }
01065 private final int jjMoveStringLiteralDfa0_3()
01066 {
01067 switch(curChar)
01068 {
01069 case 42:
01070 return jjMoveStringLiteralDfa1_3(0x800L);
01071 default :
01072 return 1;
01073 }
01074 }
01075 private final int jjMoveStringLiteralDfa0_4()
01076 {
01077 switch(curChar)
01078 {
01079 case 92:
01080 return jjStopAtPos(0, 40);
01081 default :
01082 return jjMoveNfa_4(0, 0);
01083 }
01084 }
01085 private final int jjMoveStringLiteralDfa0_5()
01086 {
01087 return jjMoveNfa_5(0, 0);
01088 }
01089 private final int jjMoveStringLiteralDfa0_6()
01090 {
01091 switch(curChar)
01092 {
01093 case 39:
01094 return jjStopAtPos(0, 45);
01095 default :
01096 return 1;
01097 }
01098 }
01099 private final int jjMoveStringLiteralDfa1_0(long active0, long active1)
01100 {
01101 try { curChar = input_stream.readChar(); }
01102 catch(java.io.IOException e) {
01103 jjStopStringLiteralDfa_0(0, active0, active1);
01104 return 1;
01105 }
01106 switch(curChar)
01107 {
01108 case 38:
01109 if ((active1 & 0x10L) != 0L)
01110 return jjStopAtPos(1, 68);
01111 break;
01112 case 42:
01113 if ((active0 & 0x100L) != 0L)
01114 return jjStartNfaWithStates_0(1, 8, 0);
01115 break;
01116 case 43:
01117 if ((active1 & 0x20L) != 0L)
01118 return jjStopAtPos(1, 69);
01119 break;
01120 case 45:
01121 if ((active1 & 0x40L) != 0L)
01122 return jjStopAtPos(1, 70);
01123 break;
01124 case 47:
01125 if ((active0 & 0x40L) != 0L)
01126 return jjStopAtPos(1, 6);
01127 break;
01128 case 60:
01129 if ((active1 & 0x8000L) != 0L)
01130 return jjStopAtPos(1, 79);
01131 break;
01132 case 61:
01133 if ((active0 & 0x8000000000000000L) != 0L)
01134 return jjStopAtPos(1, 63);
01135 else if ((active1 & 0x1L) != 0L)
01136 return jjStopAtPos(1, 64);
01137 else if ((active1 & 0x2L) != 0L)
01138 return jjStopAtPos(1, 65);
01139 else if ((active1 & 0x4L) != 0L)
01140 return jjStopAtPos(1, 66);
01141 break;
01142 case 62:
01143 if ((active1 & 0x10000L) != 0L)
01144 {
01145 jjmatchedKind = 80;
01146 jjmatchedPos = 1;
01147 }
01148 return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x20000L);
01149 case 97:
01150 return jjMoveStringLiteralDfa2_0(active0, 0x40000L, active1, 0L);
01151 case 101:
01152 return jjMoveStringLiteralDfa2_0(active0, 0x20000000L, active1, 0L);
01153 case 104:
01154 return jjMoveStringLiteralDfa2_0(active0, 0x6008000L, active1, 0L);
01155 case 108:
01156 return jjMoveStringLiteralDfa2_0(active0, 0x80090000L, active1, 0L);
01157 case 110:
01158 return jjMoveStringLiteralDfa2_0(active0, 0x300000L, active1, 0L);
01159 case 111:
01160 return jjMoveStringLiteralDfa2_0(active0, 0x422000L, active1, 0L);
01161 case 114:
01162 return jjMoveStringLiteralDfa2_0(active0, 0x18000000L, active1, 0L);
01163 case 117:
01164 return jjMoveStringLiteralDfa2_0(active0, 0x1800000L, active1, 0L);
01165 case 120:
01166 return jjMoveStringLiteralDfa2_0(active0, 0x40000000L, active1, 0L);
01167 case 121:
01168 return jjMoveStringLiteralDfa2_0(active0, 0x4000L, active1, 0L);
01169 case 124:
01170 if ((active1 & 0x8L) != 0L)
01171 return jjStopAtPos(1, 67);
01172 break;
01173 default :
01174 break;
01175 }
01176 return jjStartNfa_0(0, active0, active1);
01177 }
01178 private final int jjMoveStringLiteralDfa1_2(long active0)
01179 {
01180 try { curChar = input_stream.readChar(); }
01181 catch(java.io.IOException e) {
01182 return 1;
01183 }
01184 switch(curChar)
01185 {
01186 case 47:
01187 if ((active0 & 0x400L) != 0L)
01188 return jjStopAtPos(1, 10);
01189 break;
01190 default :
01191 return 2;
01192 }
01193 return 2;
01194 }
01195 private final int jjMoveStringLiteralDfa1_3(long active0)
01196 {
01197 try { curChar = input_stream.readChar(); }
01198 catch(java.io.IOException e) {
01199 return 1;
01200 }
01201 switch(curChar)
01202 {
01203 case 47:
01204 if ((active0 & 0x800L) != 0L)
01205 return jjStopAtPos(1, 11);
01206 break;
01207 default :
01208 return 2;
01209 }
01210 return 2;
01211 }
01212 private final int jjMoveStringLiteralDfa2_0(long old0, long active0, long old1, long active1)
01213 {
01214 if (((active0 &= old0) | (active1 &= old1)) == 0L)
01215 return jjStartNfa_0(0, old0, old1);
01216 try { curChar = input_stream.readChar(); }
01217 catch(java.io.IOException e) {
01218 jjStopStringLiteralDfa_0(1, active0, active1);
01219 return 2;
01220 }
01221 switch(curChar)
01222 {
01223 case 62:
01224 if ((active1 & 0x20000L) != 0L)
01225 return jjStopAtPos(2, 81);
01226 break;
01227 case 97:
01228 return jjMoveStringLiteralDfa3_0(active0, 0x18000L, active1, 0L);
01229 case 101:
01230 return jjMoveStringLiteralDfa3_0(active0, 0x10000000L, active1, 0L);
01231 case 105:
01232 return jjMoveStringLiteralDfa3_0(active0, 0x4000000L, active1, 0L);
01233 case 108:
01234 return jjMoveStringLiteralDfa3_0(active0, 0x840000L, active1, 0L);
01235 case 110:
01236 return jjMoveStringLiteralDfa3_0(active0, 0x400000L, active1, 0L);
01237 case 111:
01238 return jjMoveStringLiteralDfa3_0(active0, 0x82082000L, active1, 0L);
01239 case 112:
01240 return jjMoveStringLiteralDfa3_0(active0, 0x41000000L, active1, 0L);
01241 case 115:
01242 return jjMoveStringLiteralDfa3_0(active0, 0x100000L, active1, 0L);
01243 case 116:
01244 if ((active0 & 0x200000L) != 0L)
01245 return jjStartNfaWithStates_0(2, 21, 23);
01246 return jjMoveStringLiteralDfa3_0(active0, 0x20004000L, active1, 0L);
01247 case 117:
01248 return jjMoveStringLiteralDfa3_0(active0, 0x8020000L, active1, 0L);
01249 default :
01250 break;
01251 }
01252 return jjStartNfa_0(1, active0, active1);
01253 }
01254 private final int jjMoveStringLiteralDfa3_0(long old0, long active0, long old1, long active1)
01255 {
01256 if (((active0 &= old0) | (active1 &= old1)) == 0L)
01257 return jjStartNfa_0(1, old0, old1);
01258 try { curChar = input_stream.readChar(); }
01259 catch(java.io.IOException e) {
01260 jjStopStringLiteralDfa_0(2, active0, 0L);
01261 return 3;
01262 }
01263 switch(curChar)
01264 {
01265 case 97:
01266 return jjMoveStringLiteralDfa4_0(active0, 0x80000L);
01267 case 98:
01268 return jjMoveStringLiteralDfa4_0(active0, 0x80020000L);
01269 case 100:
01270 return jjMoveStringLiteralDfa4_0(active0, 0x10000000L);
01271 case 101:
01272 if ((active0 & 0x4000L) != 0L)
01273 return jjStartNfaWithStates_0(3, 14, 23);
01274 else if ((active0 & 0x8000000L) != 0L)
01275 return jjStartNfaWithStates_0(3, 27, 23);
01276 return jjMoveStringLiteralDfa4_0(active0, 0x1000000L);
01277 case 103:
01278 if ((active0 & 0x400000L) != 0L)
01279 return jjStartNfaWithStates_0(3, 22, 23);
01280 break;
01281 case 104:
01282 return jjMoveStringLiteralDfa4_0(active0, 0x20000000L);
01283 case 108:
01284 if ((active0 & 0x800000L) != 0L)
01285 return jjStartNfaWithStates_0(3, 23, 23);
01286 return jjMoveStringLiteralDfa4_0(active0, 0x2000L);
01287 case 114:
01288 if ((active0 & 0x8000L) != 0L)
01289 return jjStartNfaWithStates_0(3, 15, 23);
01290 else if ((active0 & 0x40000000L) != 0L)
01291 return jjStartNfaWithStates_0(3, 30, 23);
01292 return jjMoveStringLiteralDfa4_0(active0, 0x2000000L);
01293 case 115:
01294 if ((active0 & 0x4000000L) != 0L)
01295 return jjStartNfaWithStates_0(3, 26, 23);
01296 return jjMoveStringLiteralDfa4_0(active0, 0x50000L);
01297 case 116:
01298 return jjMoveStringLiteralDfa4_0(active0, 0x100000L);
01299 default :
01300 break;
01301 }
01302 return jjStartNfa_0(2, active0, 0L);
01303 }
01304 private final int jjMoveStringLiteralDfa4_0(long old0, long active0)
01305 {
01306 if (((active0 &= old0)) == 0L)
01307 return jjStartNfa_0(2, old0, 0L);
01308 try { curChar = input_stream.readChar(); }
01309 catch(java.io.IOException e) {
01310 jjStopStringLiteralDfa_0(3, active0, 0L);
01311 return 4;
01312 }
01313 switch(curChar)
01314 {
01315 case 97:
01316 return jjMoveStringLiteralDfa5_0(active0, 0x80100000L);
01317 case 101:
01318 if ((active0 & 0x40000L) != 0L)
01319 return jjStartNfaWithStates_0(4, 18, 23);
01320 return jjMoveStringLiteralDfa5_0(active0, 0x2000L);
01321 case 105:
01322 return jjMoveStringLiteralDfa5_0(active0, 0x10000000L);
01323 case 108:
01324 return jjMoveStringLiteralDfa5_0(active0, 0x20000L);
01325 case 111:
01326 return jjMoveStringLiteralDfa5_0(active0, 0x20000000L);
01327 case 114:
01328 if ((active0 & 0x1000000L) != 0L)
01329 return jjStartNfaWithStates_0(4, 24, 23);
01330 break;
01331 case 115:
01332 if ((active0 & 0x10000L) != 0L)
01333 return jjStartNfaWithStates_0(4, 16, 23);
01334 break;
01335 case 116:
01336 if ((active0 & 0x80000L) != 0L)
01337 return jjStartNfaWithStates_0(4, 19, 23);
01338 else if ((active0 & 0x2000000L) != 0L)
01339 return jjStartNfaWithStates_0(4, 25, 23);
01340 break;
01341 default :
01342 break;
01343 }
01344 return jjStartNfa_0(3, active0, 0L);
01345 }
01346 private final int jjMoveStringLiteralDfa5_0(long old0, long active0)
01347 {
01348 if (((active0 &= old0)) == 0L)
01349 return jjStartNfa_0(3, old0, 0L);
01350 try { curChar = input_stream.readChar(); }
01351 catch(java.io.IOException e) {
01352 jjStopStringLiteralDfa_0(4, active0, 0L);
01353 return 5;
01354 }
01355 switch(curChar)
01356 {
01357 case 97:
01358 return jjMoveStringLiteralDfa6_0(active0, 0x2000L);
01359 case 99:
01360 return jjMoveStringLiteralDfa6_0(active0, 0x10000000L);
01361 case 100:
01362 if ((active0 & 0x20000000L) != 0L)
01363 return jjStartNfaWithStates_0(5, 29, 23);
01364 break;
01365 case 101:
01366 if ((active0 & 0x20000L) != 0L)
01367 return jjStartNfaWithStates_0(5, 17, 23);
01368 break;
01369 case 108:
01370 if ((active0 & 0x80000000L) != 0L)
01371 return jjStartNfaWithStates_0(5, 31, 23);
01372 break;
01373 case 110:
01374 return jjMoveStringLiteralDfa6_0(active0, 0x100000L);
01375 default :
01376 break;
01377 }
01378 return jjStartNfa_0(4, active0, 0L);
01379 }
01380 private final int jjMoveStringLiteralDfa6_0(long old0, long active0)
01381 {
01382 if (((active0 &= old0)) == 0L)
01383 return jjStartNfa_0(4, old0, 0L);
01384 try { curChar = input_stream.readChar(); }
01385 catch(java.io.IOException e) {
01386 jjStopStringLiteralDfa_0(5, active0, 0L);
01387 return 6;
01388 }
01389 switch(curChar)
01390 {
01391 case 97:
01392 return jjMoveStringLiteralDfa7_0(active0, 0x10000000L);
01393 case 99:
01394 return jjMoveStringLiteralDfa7_0(active0, 0x100000L);
01395 case 110:
01396 if ((active0 & 0x2000L) != 0L)
01397 return jjStartNfaWithStates_0(6, 13, 23);
01398 break;
01399 default :
01400 break;
01401 }
01402 return jjStartNfa_0(5, active0, 0L);
01403 }
01404 private final int jjMoveStringLiteralDfa7_0(long old0, long active0)
01405 {
01406 if (((active0 &= old0)) == 0L)
01407 return jjStartNfa_0(5, old0, 0L);
01408 try { curChar = input_stream.readChar(); }
01409 catch(java.io.IOException e) {
01410 jjStopStringLiteralDfa_0(6, active0, 0L);
01411 return 7;
01412 }
01413 switch(curChar)
01414 {
01415 case 101:
01416 return jjMoveStringLiteralDfa8_0(active0, 0x100000L);
01417 case 116:
01418 return jjMoveStringLiteralDfa8_0(active0, 0x10000000L);
01419 default :
01420 break;
01421 }
01422 return jjStartNfa_0(6, active0, 0L);
01423 }
01424 private final int jjMoveStringLiteralDfa8_0(long old0, long active0)
01425 {
01426 if (((active0 &= old0)) == 0L)
01427 return jjStartNfa_0(6, old0, 0L);
01428 try { curChar = input_stream.readChar(); }
01429 catch(java.io.IOException e) {
01430 jjStopStringLiteralDfa_0(7, active0, 0L);
01431 return 8;
01432 }
01433 switch(curChar)
01434 {
01435 case 101:
01436 if ((active0 & 0x10000000L) != 0L)
01437 return jjStartNfaWithStates_0(8, 28, 23);
01438 break;
01439 case 111:
01440 return jjMoveStringLiteralDfa9_0(active0, 0x100000L);
01441 default :
01442 break;
01443 }
01444 return jjStartNfa_0(7, active0, 0L);
01445 }
01446 private final int jjMoveStringLiteralDfa9_0(long old0, long active0)
01447 {
01448 if (((active0 &= old0)) == 0L)
01449 return jjStartNfa_0(7, old0, 0L);
01450 try { curChar = input_stream.readChar(); }
01451 catch(java.io.IOException e) {
01452 jjStopStringLiteralDfa_0(8, active0, 0L);
01453 return 9;
01454 }
01455 switch(curChar)
01456 {
01457 case 102:
01458 if ((active0 & 0x100000L) != 0L)
01459 return jjStartNfaWithStates_0(9, 20, 23);
01460 break;
01461 default :
01462 break;
01463 }
01464 return jjStartNfa_0(8, active0, 0L);
01465 }
01466 private final int jjStartNfa_0(int pos, long active0, long active1)
01467 {
01468 return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0, active1), pos + 1);
01469 }
01470 private final int jjStartNfa_4(int pos, long active0)
01471 {
01472 return jjMoveNfa_4(jjStopStringLiteralDfa_4(pos, active0), pos + 1);
01473 }
01474 private final int jjStartNfaWithStates_0(int pos, int kind, int state)
01475 {
01476 jjmatchedKind = kind;
01477 jjmatchedPos = pos;
01478 try { curChar = input_stream.readChar(); }
01479 catch(java.io.IOException e) { return pos + 1; }
01480 return jjMoveNfa_0(state, pos + 1);
01481 }
01482 private final int jjStartNfaWithStates_4(int pos, int kind, int state)
01483 {
01484 jjmatchedKind = kind;
01485 jjmatchedPos = pos;
01486 try { curChar = input_stream.readChar(); }
01487 catch(java.io.IOException e) { return pos + 1; }
01488 return jjMoveNfa_4(state, pos + 1);
01489 }
01490 private final int jjStopAtPos(int pos, int kind)
01491 {
01492 jjmatchedKind = kind;
01493 jjmatchedPos = pos;
01494 return pos + 1;
01495 }
01496 private final int jjStopStringLiteralDfa_0(int pos, long active0, long active1)
01497 {
01498 switch (pos)
01499 {
01500 case 0:
01501 if ((active0 & 0x140L) != 0L || (active1 & 0x400L) != 0L)
01502 return 2;
01503 if ((active0 & 0x200000000000000L) != 0L)
01504 return 8;
01505 if ((active0 & 0xffffe000L) != 0L)
01506 {
01507 jjmatchedKind = 46;
01508 return 23;
01509 }
01510 return -1;
01511 case 1:
01512 if ((active0 & 0x100L) != 0L)
01513 return 0;
01514 if ((active0 & 0xffffe000L) != 0L)
01515 {
01516 if (jjmatchedPos != 1)
01517 {
01518 jjmatchedKind = 46;
01519 jjmatchedPos = 1;
01520 }
01521 return 23;
01522 }
01523 return -1;
01524 case 2:
01525 if ((active0 & 0x200000L) != 0L)
01526 return 23;
01527 if ((active0 & 0xffdfe000L) != 0L)
01528 {
01529 jjmatchedKind = 46;
01530 jjmatchedPos = 2;
01531 return 23;
01532 }
01533 return -1;
01534 case 3:
01535 if ((active0 & 0xb31f2000L) != 0L)
01536 {
01537 jjmatchedKind = 46;
01538 jjmatchedPos = 3;
01539 return 23;
01540 }
01541 if ((active0 & 0x4cc0c000L) != 0L)
01542 return 23;
01543 return -1;
01544 case 4:
01545 if ((active0 & 0xb0122000L) != 0L)
01546 {
01547 jjmatchedKind = 46;
01548 jjmatchedPos = 4;
01549 return 23;
01550 }
01551 if ((active0 & 0x30d0000L) != 0L)
01552 return 23;
01553 return -1;
01554 case 5:
01555 if ((active0 & 0xa0020000L) != 0L)
01556 return 23;
01557 if ((active0 & 0x10102000L) != 0L)
01558 {
01559 jjmatchedKind = 46;
01560 jjmatchedPos = 5;
01561 return 23;
01562 }
01563 return -1;
01564 case 6:
01565 if ((active0 & 0x10100000L) != 0L)
01566 {
01567 jjmatchedKind = 46;
01568 jjmatchedPos = 6;
01569 return 23;
01570 }
01571 if ((active0 & 0x2000L) != 0L)
01572 return 23;
01573 return -1;
01574 case 7:
01575 if ((active0 & 0x10100000L) != 0L)
01576 {
01577 jjmatchedKind = 46;
01578 jjmatchedPos = 7;
01579 return 23;
01580 }
01581 return -1;
01582 case 8:
01583 if ((active0 & 0x10000000L) != 0L)
01584 return 23;
01585 if ((active0 & 0x100000L) != 0L)
01586 {
01587 jjmatchedKind = 46;
01588 jjmatchedPos = 8;
01589 return 23;
01590 }
01591 return -1;
01592 default :
01593 return -1;
01594 }
01595 }
01596 private final int jjStopStringLiteralDfa_4(int pos, long active0)
01597 {
01598 switch (pos)
01599 {
01600 default :
01601 return -1;
01602 }
01603 }
01604 final void MoreLexicalActions()
01605 {
01606 jjimageLen += (lengthOfMatch = jjmatchedPos + 1);
01607 switch(jjmatchedKind)
01608 {
01609 case 7 :
01610 if (image == null)
01611 image = new StringBuffer(new String(input_stream.GetSuffix(jjimageLen)));
01612 else
01613 image.append(input_stream.GetSuffix(jjimageLen));
01614 jjimageLen = 0;
01615 input_stream.backup(1);
01616 break;
01617 case 42 :
01618 if (image == null)
01619 image = new StringBuffer(new String(input_stream.GetSuffix(jjimageLen)));
01620 else
01621 image.append(input_stream.GetSuffix(jjimageLen));
01622 jjimageLen = 0;
01623 char ch = image.charAt(image.length()-1);
01624 switch (ch)
01625 {
01626 case 'n' : image = new StringBuffer("\n"); break;
01627 case 't' : image = new StringBuffer("\t"); break;
01628 case 'b' : image = new StringBuffer("\b"); break;
01629 case 'r' : image = new StringBuffer("\r"); break;
01630 case 'f' : image = new StringBuffer("\f"); break;
01631 case '\\': image = new StringBuffer("\\"); break;
01632 case '\'': image = new StringBuffer("'"); break;
01633 case '\"': image = new StringBuffer("\""); break;
01634 default: System.out.println("Warning: Unknown token parsed on '"+image.toString()+"'");
01635 }
01636 break;
01637 case 43 :
01638 if (image == null)
01639 image = new StringBuffer(new String(input_stream.GetSuffix(jjimageLen)));
01640 else
01641 image.append(input_stream.GetSuffix(jjimageLen));
01642 jjimageLen = 0;
01643 char ch_octal = (char) Integer.parseInt(image.substring(1),8);
01644 image = new StringBuffer(String.valueOf(ch_octal));
01645 break;
01646 case 44 :
01647 if (image == null)
01648 image = new StringBuffer(new String(input_stream.GetSuffix(jjimageLen)));
01649 else
01650 image.append(input_stream.GetSuffix(jjimageLen));
01651 jjimageLen = 0;
01652 char ch_uni = (char) Integer.parseInt(image.substring(1),16);
01653 image = new StringBuffer(String.valueOf(ch_uni));
01654 break;
01655 default :
01656 break;
01657 }
01658 }
01659 public void ReInit(ASCII_UCodeESC_CharStream stream)
01660 {
01661 jjmatchedPos = jjnewStateCnt = 0;
01662 curLexState = defaultLexState;
01663 input_stream = stream;
01664 ReInitRounds();
01665 }
01666 public void ReInit(ASCII_UCodeESC_CharStream stream, int lexState)
01667 {
01668 ReInit(stream);
01669 SwitchTo(lexState);
01670 }
01671 private final void ReInitRounds()
01672 {
01673 int i;
01674 jjround = 0x80000001;
01675 for (i = 43; i-- > 0;)
01676 jjrounds[i] = 0x80000000;
01677 }
01678 final void SkipLexicalActions(Token matchedToken)
01679 {
01680 switch(jjmatchedKind)
01681 {
01682 default :
01683 break;
01684 }
01685 }
01686 public void SwitchTo(int lexState)
01687 {
01688 if (lexState >= 7 || lexState < 0)
01689 throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
01690 else
01691 curLexState = lexState;
01692 }
01693 }
