001 /* Generated By:JJTree&JavaCC: Do not edit this line. ParserTokenManager.java */ 002 package org.apache.commons.jexl2.parser; 003 import java.io.Reader; 004 import org.apache.commons.jexl2.JexlInfo; 005 006 /** Token Manager. */ 007 public class ParserTokenManager implements ParserConstants 008 { 009 010 /** Debug output. */ 011 public java.io.PrintStream debugStream = System.out; 012 /** Set debug output. */ 013 public void setDebugStream(java.io.PrintStream ds) { debugStream = ds; } 014 private final int jjStopStringLiteralDfa_1(int pos, long active0, long active1) 015 { 016 switch (pos) 017 { 018 case 0: 019 if ((active0 & 0x502aa850003ff800L) != 0L || (active1 & 0x2L) != 0L) 020 { 021 jjmatchedKind = 67; 022 return 7; 023 } 024 if ((active0 & 0x800000000000000L) != 0L) 025 return 19; 026 return -1; 027 case 1: 028 if ((active0 & 0x50000040003ef000L) != 0L || (active1 & 0x2L) != 0L) 029 { 030 if (jjmatchedPos != 1) 031 { 032 jjmatchedKind = 67; 033 jjmatchedPos = 1; 034 } 035 return 7; 036 } 037 if ((active0 & 0x2aa81000010800L) != 0L) 038 return 7; 039 return -1; 040 case 2: 041 if ((active0 & 0x3e9000L) != 0L) 042 { 043 if (jjmatchedPos != 2) 044 { 045 jjmatchedKind = 67; 046 jjmatchedPos = 2; 047 } 048 return 7; 049 } 050 if ((active0 & 0x5000004000016000L) != 0L || (active1 & 0x2L) != 0L) 051 return 7; 052 return -1; 053 case 3: 054 if ((active0 & 0x22c000L) != 0L) 055 { 056 jjmatchedKind = 67; 057 jjmatchedPos = 3; 058 return 7; 059 } 060 if ((active0 & 0x1c1000L) != 0L) 061 return 7; 062 return -1; 063 case 4: 064 if ((active0 & 0x228000L) != 0L) 065 return 7; 066 if ((active0 & 0x4000L) != 0L) 067 { 068 jjmatchedKind = 67; 069 jjmatchedPos = 4; 070 return 7; 071 } 072 return -1; 073 case 5: 074 if ((active0 & 0x4000L) != 0L) 075 { 076 jjmatchedKind = 67; 077 jjmatchedPos = 5; 078 return 7; 079 } 080 return -1; 081 default : 082 return -1; 083 } 084 } 085 private final int jjStartNfa_1(int pos, long active0, long active1) 086 { 087 return jjMoveNfa_1(jjStopStringLiteralDfa_1(pos, active0, active1), pos + 1); 088 } 089 private int jjStopAtPos(int pos, int kind) 090 { 091 jjmatchedKind = kind; 092 jjmatchedPos = pos; 093 return pos + 1; 094 } 095 private int jjMoveStringLiteralDfa0_1() 096 { 097 switch(curChar) 098 { 099 case 33: 100 jjmatchedKind = 64; 101 return jjMoveStringLiteralDfa1_1(0x80100000000000L, 0x0L); 102 case 37: 103 return jjStopAtPos(0, 61); 104 case 38: 105 jjmatchedKind = 41; 106 return jjMoveStringLiteralDfa1_1(0x2000000000L, 0x0L); 107 case 40: 108 return jjStopAtPos(0, 22); 109 case 41: 110 return jjStopAtPos(0, 23); 111 case 42: 112 return jjStopAtPos(0, 58); 113 case 43: 114 return jjStopAtPos(0, 56); 115 case 44: 116 return jjStopAtPos(0, 30); 117 case 45: 118 return jjStopAtPos(0, 57); 119 case 46: 120 return jjStopAtPos(0, 66); 121 case 47: 122 return jjStartNfaWithStates_1(0, 59, 19); 123 case 58: 124 return jjStopAtPos(0, 29); 125 case 59: 126 return jjStopAtPos(0, 28); 127 case 60: 128 jjmatchedKind = 46; 129 return jjMoveStringLiteralDfa1_1(0x4000000000000L, 0x0L); 130 case 61: 131 jjmatchedKind = 32; 132 return jjMoveStringLiteralDfa1_1(0x40040000000000L, 0x0L); 133 case 62: 134 jjmatchedKind = 48; 135 return jjMoveStringLiteralDfa1_1(0x10000000000000L, 0x0L); 136 case 63: 137 jjmatchedKind = 33; 138 return jjMoveStringLiteralDfa1_1(0x400000000L, 0x0L); 139 case 91: 140 return jjStopAtPos(0, 26); 141 case 93: 142 return jjStopAtPos(0, 27); 143 case 94: 144 return jjStopAtPos(0, 40); 145 case 97: 146 return jjMoveStringLiteralDfa1_1(0x4000000000L, 0x0L); 147 case 100: 148 return jjMoveStringLiteralDfa1_1(0x1000000000000000L, 0x0L); 149 case 101: 150 return jjMoveStringLiteralDfa1_1(0x80000021000L, 0x0L); 151 case 102: 152 return jjMoveStringLiteralDfa1_1(0x206000L, 0x0L); 153 case 103: 154 return jjMoveStringLiteralDfa1_1(0x22000000000000L, 0x0L); 155 case 105: 156 return jjMoveStringLiteralDfa1_1(0x800L, 0x0L); 157 case 108: 158 return jjMoveStringLiteralDfa1_1(0x8800000000000L, 0x0L); 159 case 109: 160 return jjMoveStringLiteralDfa1_1(0x4000000000000000L, 0x0L); 161 case 110: 162 return jjMoveStringLiteralDfa1_1(0x200000090000L, 0x2L); 163 case 111: 164 return jjMoveStringLiteralDfa1_1(0x1000000000L, 0x0L); 165 case 115: 166 return jjMoveStringLiteralDfa1_1(0x40000L, 0x0L); 167 case 116: 168 return jjMoveStringLiteralDfa1_1(0x100000L, 0x0L); 169 case 119: 170 return jjMoveStringLiteralDfa1_1(0x8000L, 0x0L); 171 case 123: 172 return jjStopAtPos(0, 24); 173 case 124: 174 jjmatchedKind = 39; 175 return jjMoveStringLiteralDfa1_1(0x800000000L, 0x0L); 176 case 125: 177 return jjStopAtPos(0, 25); 178 case 126: 179 return jjStopAtPos(0, 63); 180 default : 181 return jjMoveNfa_1(5, 0); 182 } 183 } 184 private int jjMoveStringLiteralDfa1_1(long active0, long active1) 185 { 186 try { curChar = input_stream.readChar(); } 187 catch(java.io.IOException e) { 188 jjStopStringLiteralDfa_1(0, active0, active1); 189 return 1; 190 } 191 switch(curChar) 192 { 193 case 38: 194 if ((active0 & 0x2000000000L) != 0L) 195 return jjStopAtPos(1, 37); 196 break; 197 case 58: 198 if ((active0 & 0x400000000L) != 0L) 199 return jjStopAtPos(1, 34); 200 break; 201 case 61: 202 if ((active0 & 0x40000000000L) != 0L) 203 return jjStopAtPos(1, 42); 204 else if ((active0 & 0x100000000000L) != 0L) 205 return jjStopAtPos(1, 44); 206 else if ((active0 & 0x4000000000000L) != 0L) 207 return jjStopAtPos(1, 50); 208 else if ((active0 & 0x10000000000000L) != 0L) 209 return jjStopAtPos(1, 52); 210 break; 211 case 97: 212 return jjMoveStringLiteralDfa2_1(active0, 0x200000L, active1, 0L); 213 case 101: 214 if ((active0 & 0x200000000000L) != 0L) 215 { 216 jjmatchedKind = 45; 217 jjmatchedPos = 1; 218 } 219 else if ((active0 & 0x8000000000000L) != 0L) 220 return jjStartNfaWithStates_1(1, 51, 7); 221 else if ((active0 & 0x20000000000000L) != 0L) 222 return jjStartNfaWithStates_1(1, 53, 7); 223 return jjMoveStringLiteralDfa2_1(active0, 0x10000L, active1, 0L); 224 case 102: 225 if ((active0 & 0x800L) != 0L) 226 return jjStartNfaWithStates_1(1, 11, 7); 227 break; 228 case 104: 229 return jjMoveStringLiteralDfa2_1(active0, 0x8000L, active1, 0L); 230 case 105: 231 return jjMoveStringLiteralDfa2_1(active0, 0x1000000000040000L, active1, 0L); 232 case 108: 233 return jjMoveStringLiteralDfa2_1(active0, 0x1000L, active1, 0L); 234 case 109: 235 return jjMoveStringLiteralDfa2_1(active0, 0x20000L, active1, 0L); 236 case 110: 237 return jjMoveStringLiteralDfa2_1(active0, 0x4000000000L, active1, 0L); 238 case 111: 239 return jjMoveStringLiteralDfa2_1(active0, 0x4000000000006000L, active1, 0x2L); 240 case 113: 241 if ((active0 & 0x80000000000L) != 0L) 242 return jjStartNfaWithStates_1(1, 43, 7); 243 break; 244 case 114: 245 if ((active0 & 0x1000000000L) != 0L) 246 return jjStartNfaWithStates_1(1, 36, 7); 247 return jjMoveStringLiteralDfa2_1(active0, 0x100000L, active1, 0L); 248 case 116: 249 if ((active0 & 0x800000000000L) != 0L) 250 return jjStartNfaWithStates_1(1, 47, 7); 251 else if ((active0 & 0x2000000000000L) != 0L) 252 return jjStartNfaWithStates_1(1, 49, 7); 253 break; 254 case 117: 255 return jjMoveStringLiteralDfa2_1(active0, 0x80000L, active1, 0L); 256 case 124: 257 if ((active0 & 0x800000000L) != 0L) 258 return jjStopAtPos(1, 35); 259 break; 260 case 126: 261 if ((active0 & 0x40000000000000L) != 0L) 262 return jjStopAtPos(1, 54); 263 else if ((active0 & 0x80000000000000L) != 0L) 264 return jjStopAtPos(1, 55); 265 break; 266 default : 267 break; 268 } 269 return jjStartNfa_1(0, active0, active1); 270 } 271 private int jjMoveStringLiteralDfa2_1(long old0, long active0, long old1, long active1) 272 { 273 if (((active0 &= old0) | (active1 &= old1)) == 0L) 274 return jjStartNfa_1(0, old0, old1); 275 try { curChar = input_stream.readChar(); } 276 catch(java.io.IOException e) { 277 jjStopStringLiteralDfa_1(1, active0, active1); 278 return 2; 279 } 280 switch(curChar) 281 { 282 case 100: 283 if ((active0 & 0x4000000000L) != 0L) 284 return jjStartNfaWithStates_1(2, 38, 7); 285 else if ((active0 & 0x4000000000000000L) != 0L) 286 return jjStartNfaWithStates_1(2, 62, 7); 287 break; 288 case 105: 289 return jjMoveStringLiteralDfa3_1(active0, 0x8000L, active1, 0L); 290 case 108: 291 return jjMoveStringLiteralDfa3_1(active0, 0x280000L, active1, 0L); 292 case 112: 293 return jjMoveStringLiteralDfa3_1(active0, 0x20000L, active1, 0L); 294 case 114: 295 if ((active0 & 0x2000L) != 0L) 296 { 297 jjmatchedKind = 13; 298 jjmatchedPos = 2; 299 } 300 return jjMoveStringLiteralDfa3_1(active0, 0x4000L, active1, 0L); 301 case 115: 302 return jjMoveStringLiteralDfa3_1(active0, 0x1000L, active1, 0L); 303 case 116: 304 if ((active1 & 0x2L) != 0L) 305 return jjStartNfaWithStates_1(2, 65, 7); 306 break; 307 case 117: 308 return jjMoveStringLiteralDfa3_1(active0, 0x100000L, active1, 0L); 309 case 118: 310 if ((active0 & 0x1000000000000000L) != 0L) 311 return jjStartNfaWithStates_1(2, 60, 7); 312 break; 313 case 119: 314 if ((active0 & 0x10000L) != 0L) 315 return jjStartNfaWithStates_1(2, 16, 7); 316 break; 317 case 122: 318 return jjMoveStringLiteralDfa3_1(active0, 0x40000L, active1, 0L); 319 default : 320 break; 321 } 322 return jjStartNfa_1(1, active0, active1); 323 } 324 private int jjMoveStringLiteralDfa3_1(long old0, long active0, long old1, long active1) 325 { 326 if (((active0 &= old0) | (active1 &= old1)) == 0L) 327 return jjStartNfa_1(1, old0, old1); 328 try { curChar = input_stream.readChar(); } 329 catch(java.io.IOException e) { 330 jjStopStringLiteralDfa_1(2, active0, 0L); 331 return 3; 332 } 333 switch(curChar) 334 { 335 case 101: 336 if ((active0 & 0x1000L) != 0L) 337 return jjStartNfaWithStates_1(3, 12, 7); 338 else if ((active0 & 0x40000L) != 0L) 339 return jjStartNfaWithStates_1(3, 18, 7); 340 else if ((active0 & 0x100000L) != 0L) 341 return jjStartNfaWithStates_1(3, 20, 7); 342 return jjMoveStringLiteralDfa4_1(active0, 0x4000L); 343 case 108: 344 if ((active0 & 0x80000L) != 0L) 345 return jjStartNfaWithStates_1(3, 19, 7); 346 return jjMoveStringLiteralDfa4_1(active0, 0x8000L); 347 case 115: 348 return jjMoveStringLiteralDfa4_1(active0, 0x200000L); 349 case 116: 350 return jjMoveStringLiteralDfa4_1(active0, 0x20000L); 351 default : 352 break; 353 } 354 return jjStartNfa_1(2, active0, 0L); 355 } 356 private int jjMoveStringLiteralDfa4_1(long old0, long active0) 357 { 358 if (((active0 &= old0)) == 0L) 359 return jjStartNfa_1(2, old0, 0L); 360 try { curChar = input_stream.readChar(); } 361 catch(java.io.IOException e) { 362 jjStopStringLiteralDfa_1(3, active0, 0L); 363 return 4; 364 } 365 switch(curChar) 366 { 367 case 97: 368 return jjMoveStringLiteralDfa5_1(active0, 0x4000L); 369 case 101: 370 if ((active0 & 0x8000L) != 0L) 371 return jjStartNfaWithStates_1(4, 15, 7); 372 else if ((active0 & 0x200000L) != 0L) 373 return jjStartNfaWithStates_1(4, 21, 7); 374 break; 375 case 121: 376 if ((active0 & 0x20000L) != 0L) 377 return jjStartNfaWithStates_1(4, 17, 7); 378 break; 379 default : 380 break; 381 } 382 return jjStartNfa_1(3, active0, 0L); 383 } 384 private int jjMoveStringLiteralDfa5_1(long old0, long active0) 385 { 386 if (((active0 &= old0)) == 0L) 387 return jjStartNfa_1(3, old0, 0L); 388 try { curChar = input_stream.readChar(); } 389 catch(java.io.IOException e) { 390 jjStopStringLiteralDfa_1(4, active0, 0L); 391 return 5; 392 } 393 switch(curChar) 394 { 395 case 99: 396 return jjMoveStringLiteralDfa6_1(active0, 0x4000L); 397 default : 398 break; 399 } 400 return jjStartNfa_1(4, active0, 0L); 401 } 402 private int jjMoveStringLiteralDfa6_1(long old0, long active0) 403 { 404 if (((active0 &= old0)) == 0L) 405 return jjStartNfa_1(4, old0, 0L); 406 try { curChar = input_stream.readChar(); } 407 catch(java.io.IOException e) { 408 jjStopStringLiteralDfa_1(5, active0, 0L); 409 return 6; 410 } 411 switch(curChar) 412 { 413 case 104: 414 if ((active0 & 0x4000L) != 0L) 415 return jjStartNfaWithStates_1(6, 14, 7); 416 break; 417 default : 418 break; 419 } 420 return jjStartNfa_1(5, active0, 0L); 421 } 422 private int jjStartNfaWithStates_1(int pos, int kind, int state) 423 { 424 jjmatchedKind = kind; 425 jjmatchedPos = pos; 426 try { curChar = input_stream.readChar(); } 427 catch(java.io.IOException e) { return pos + 1; } 428 return jjMoveNfa_1(state, pos + 1); 429 } 430 static final long[] jjbitVec0 = { 431 0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL 432 }; 433 static final long[] jjbitVec2 = { 434 0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL 435 }; 436 private int jjMoveNfa_1(int startState, int curPos) 437 { 438 int startsAt = 0; 439 jjnewStateCnt = 35; 440 int i = 1; 441 jjstateSet[0] = startState; 442 int kind = 0x7fffffff; 443 for (;;) 444 { 445 if (++jjround == 0x7fffffff) 446 ReInitRounds(); 447 if (curChar < 64) 448 { 449 long l = 1L << curChar; 450 do 451 { 452 switch(jjstateSet[--i]) 453 { 454 case 5: 455 if ((0x3ff000000000000L & l) != 0L) 456 { 457 if (kind > 9) 458 kind = 9; 459 jjCheckNAddStates(0, 2); 460 } 461 else if (curChar == 47) 462 jjAddStates(3, 4); 463 else if (curChar == 39) 464 jjCheckNAddStates(5, 7); 465 else if (curChar == 34) 466 jjCheckNAddStates(8, 10); 467 else if (curChar == 36) 468 { 469 if (kind > 67) 470 kind = 67; 471 jjCheckNAdd(7); 472 } 473 else if (curChar == 35) 474 jjstateSet[jjnewStateCnt++] = 0; 475 break; 476 case 19: 477 if (curChar == 47) 478 { 479 if (kind > 3) 480 kind = 3; 481 jjCheckNAddStates(11, 13); 482 } 483 else if (curChar == 42) 484 jjCheckNAddTwoStates(20, 21); 485 break; 486 case 0: 487 if (curChar != 35) 488 break; 489 if (kind > 1) 490 kind = 1; 491 jjCheckNAddStates(14, 16); 492 break; 493 case 1: 494 if ((0xffffffffffffdbffL & l) == 0L) 495 break; 496 if (kind > 1) 497 kind = 1; 498 jjCheckNAddStates(14, 16); 499 break; 500 case 2: 501 if ((0x2400L & l) != 0L && kind > 1) 502 kind = 1; 503 break; 504 case 3: 505 if (curChar == 10 && kind > 1) 506 kind = 1; 507 break; 508 case 4: 509 if (curChar == 13) 510 jjstateSet[jjnewStateCnt++] = 3; 511 break; 512 case 6: 513 if (curChar != 36) 514 break; 515 if (kind > 67) 516 kind = 67; 517 jjCheckNAdd(7); 518 break; 519 case 7: 520 if ((0x3ff001000000000L & l) == 0L) 521 break; 522 if (kind > 67) 523 kind = 67; 524 jjCheckNAdd(7); 525 break; 526 case 8: 527 case 11: 528 if (curChar == 34) 529 jjCheckNAddStates(8, 10); 530 break; 531 case 9: 532 if ((0xfffffffbffffdbffL & l) != 0L) 533 jjCheckNAddStates(8, 10); 534 break; 535 case 12: 536 if (curChar == 34 && kind > 70) 537 kind = 70; 538 break; 539 case 13: 540 case 16: 541 if (curChar == 39) 542 jjCheckNAddStates(5, 7); 543 break; 544 case 14: 545 if ((0xffffff7fffffdbffL & l) != 0L) 546 jjCheckNAddStates(5, 7); 547 break; 548 case 17: 549 if (curChar == 39 && kind > 70) 550 kind = 70; 551 break; 552 case 18: 553 if (curChar == 47) 554 jjAddStates(3, 4); 555 break; 556 case 20: 557 if ((0xfffffbffffffffffL & l) != 0L) 558 jjCheckNAddTwoStates(20, 21); 559 break; 560 case 21: 561 if (curChar == 42) 562 jjCheckNAddStates(17, 19); 563 break; 564 case 22: 565 if ((0xffff7bffffffffffL & l) != 0L) 566 jjCheckNAddTwoStates(23, 21); 567 break; 568 case 23: 569 if ((0xfffffbffffffffffL & l) != 0L) 570 jjCheckNAddTwoStates(23, 21); 571 break; 572 case 24: 573 if (curChar == 47 && kind > 2) 574 kind = 2; 575 break; 576 case 25: 577 if (curChar != 47) 578 break; 579 if (kind > 3) 580 kind = 3; 581 jjCheckNAddStates(11, 13); 582 break; 583 case 26: 584 if ((0xffffffffffffdbffL & l) == 0L) 585 break; 586 if (kind > 3) 587 kind = 3; 588 jjCheckNAddStates(11, 13); 589 break; 590 case 27: 591 if ((0x2400L & l) != 0L && kind > 3) 592 kind = 3; 593 break; 594 case 28: 595 if (curChar == 10 && kind > 3) 596 kind = 3; 597 break; 598 case 29: 599 if (curChar == 13) 600 jjstateSet[jjnewStateCnt++] = 28; 601 break; 602 case 30: 603 if ((0x3ff000000000000L & l) == 0L) 604 break; 605 if (kind > 9) 606 kind = 9; 607 jjCheckNAddStates(0, 2); 608 break; 609 case 31: 610 if ((0x3ff000000000000L & l) == 0L) 611 break; 612 if (kind > 9) 613 kind = 9; 614 jjCheckNAdd(31); 615 break; 616 case 32: 617 if ((0x3ff000000000000L & l) != 0L) 618 jjCheckNAddTwoStates(32, 33); 619 break; 620 case 33: 621 if (curChar == 46) 622 jjCheckNAdd(34); 623 break; 624 case 34: 625 if ((0x3ff000000000000L & l) == 0L) 626 break; 627 if (kind > 10) 628 kind = 10; 629 jjCheckNAdd(34); 630 break; 631 default : break; 632 } 633 } while(i != startsAt); 634 } 635 else if (curChar < 128) 636 { 637 long l = 1L << (curChar & 077); 638 do 639 { 640 switch(jjstateSet[--i]) 641 { 642 case 5: 643 case 7: 644 if ((0x7fffffe87fffffeL & l) == 0L) 645 break; 646 if (kind > 67) 647 kind = 67; 648 jjCheckNAdd(7); 649 break; 650 case 1: 651 if (kind > 1) 652 kind = 1; 653 jjAddStates(14, 16); 654 break; 655 case 9: 656 jjCheckNAddStates(8, 10); 657 break; 658 case 10: 659 if (curChar == 92) 660 jjstateSet[jjnewStateCnt++] = 11; 661 break; 662 case 11: 663 if ((0x34404410000000L & l) != 0L) 664 jjCheckNAddStates(8, 10); 665 break; 666 case 14: 667 jjCheckNAddStates(5, 7); 668 break; 669 case 15: 670 if (curChar == 92) 671 jjstateSet[jjnewStateCnt++] = 16; 672 break; 673 case 16: 674 if ((0x34404410000000L & l) != 0L) 675 jjCheckNAddStates(5, 7); 676 break; 677 case 20: 678 jjCheckNAddTwoStates(20, 21); 679 break; 680 case 22: 681 case 23: 682 jjCheckNAddTwoStates(23, 21); 683 break; 684 case 26: 685 if (kind > 3) 686 kind = 3; 687 jjAddStates(11, 13); 688 break; 689 default : break; 690 } 691 } while(i != startsAt); 692 } 693 else 694 { 695 int hiByte = (int)(curChar >> 8); 696 int i1 = hiByte >> 6; 697 long l1 = 1L << (hiByte & 077); 698 int i2 = (curChar & 0xff) >> 6; 699 long l2 = 1L << (curChar & 077); 700 do 701 { 702 switch(jjstateSet[--i]) 703 { 704 case 1: 705 if (!jjCanMove_0(hiByte, i1, i2, l1, l2)) 706 break; 707 if (kind > 1) 708 kind = 1; 709 jjAddStates(14, 16); 710 break; 711 case 9: 712 if (jjCanMove_0(hiByte, i1, i2, l1, l2)) 713 jjAddStates(8, 10); 714 break; 715 case 14: 716 if (jjCanMove_0(hiByte, i1, i2, l1, l2)) 717 jjAddStates(5, 7); 718 break; 719 case 20: 720 if (jjCanMove_0(hiByte, i1, i2, l1, l2)) 721 jjCheckNAddTwoStates(20, 21); 722 break; 723 case 22: 724 case 23: 725 if (jjCanMove_0(hiByte, i1, i2, l1, l2)) 726 jjCheckNAddTwoStates(23, 21); 727 break; 728 case 26: 729 if (!jjCanMove_0(hiByte, i1, i2, l1, l2)) 730 break; 731 if (kind > 3) 732 kind = 3; 733 jjAddStates(11, 13); 734 break; 735 default : break; 736 } 737 } while(i != startsAt); 738 } 739 if (kind != 0x7fffffff) 740 { 741 jjmatchedKind = kind; 742 jjmatchedPos = curPos; 743 kind = 0x7fffffff; 744 } 745 ++curPos; 746 if ((i = jjnewStateCnt) == (startsAt = 35 - (jjnewStateCnt = startsAt))) 747 return curPos; 748 try { curChar = input_stream.readChar(); } 749 catch(java.io.IOException e) { return curPos; } 750 } 751 } 752 private final int jjStopStringLiteralDfa_0(int pos, long active0) 753 { 754 switch (pos) 755 { 756 case 0: 757 if ((active0 & 0x803ff800L) != 0L) 758 { 759 jjmatchedKind = 67; 760 return 7; 761 } 762 return -1; 763 case 1: 764 if ((active0 & 0x3ff000L) != 0L) 765 { 766 jjmatchedKind = 67; 767 jjmatchedPos = 1; 768 return 7; 769 } 770 if ((active0 & 0x80000800L) != 0L) 771 return 7; 772 return -1; 773 case 2: 774 if ((active0 & 0x3e9000L) != 0L) 775 { 776 if (jjmatchedPos != 2) 777 { 778 jjmatchedKind = 67; 779 jjmatchedPos = 2; 780 } 781 return 7; 782 } 783 if ((active0 & 0x16000L) != 0L) 784 return 7; 785 return -1; 786 case 3: 787 if ((active0 & 0x22c000L) != 0L) 788 { 789 jjmatchedKind = 67; 790 jjmatchedPos = 3; 791 return 7; 792 } 793 if ((active0 & 0x1c1000L) != 0L) 794 return 7; 795 return -1; 796 case 4: 797 if ((active0 & 0x228000L) != 0L) 798 return 7; 799 if ((active0 & 0x4000L) != 0L) 800 { 801 jjmatchedKind = 67; 802 jjmatchedPos = 4; 803 return 7; 804 } 805 return -1; 806 case 5: 807 if ((active0 & 0x4000L) != 0L) 808 { 809 jjmatchedKind = 67; 810 jjmatchedPos = 5; 811 return 7; 812 } 813 return -1; 814 default : 815 return -1; 816 } 817 } 818 private final int jjStartNfa_0(int pos, long active0) 819 { 820 return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1); 821 } 822 private int jjMoveStringLiteralDfa0_0() 823 { 824 switch(curChar) 825 { 826 case 40: 827 return jjStopAtPos(0, 22); 828 case 41: 829 return jjStopAtPos(0, 23); 830 case 44: 831 return jjStopAtPos(0, 30); 832 case 58: 833 return jjStopAtPos(0, 29); 834 case 59: 835 return jjStopAtPos(0, 28); 836 case 91: 837 return jjStopAtPos(0, 26); 838 case 93: 839 return jjStopAtPos(0, 27); 840 case 101: 841 return jjMoveStringLiteralDfa1_0(0x21000L); 842 case 102: 843 return jjMoveStringLiteralDfa1_0(0x206000L); 844 case 105: 845 return jjMoveStringLiteralDfa1_0(0x80000800L); 846 case 110: 847 return jjMoveStringLiteralDfa1_0(0x90000L); 848 case 115: 849 return jjMoveStringLiteralDfa1_0(0x40000L); 850 case 116: 851 return jjMoveStringLiteralDfa1_0(0x100000L); 852 case 119: 853 return jjMoveStringLiteralDfa1_0(0x8000L); 854 case 123: 855 return jjStopAtPos(0, 24); 856 case 125: 857 return jjStopAtPos(0, 25); 858 default : 859 return jjMoveNfa_0(5, 0); 860 } 861 } 862 private int jjMoveStringLiteralDfa1_0(long active0) 863 { 864 try { curChar = input_stream.readChar(); } 865 catch(java.io.IOException e) { 866 jjStopStringLiteralDfa_0(0, active0); 867 return 1; 868 } 869 switch(curChar) 870 { 871 case 97: 872 return jjMoveStringLiteralDfa2_0(active0, 0x200000L); 873 case 101: 874 return jjMoveStringLiteralDfa2_0(active0, 0x10000L); 875 case 102: 876 if ((active0 & 0x800L) != 0L) 877 return jjStartNfaWithStates_0(1, 11, 7); 878 break; 879 case 104: 880 return jjMoveStringLiteralDfa2_0(active0, 0x8000L); 881 case 105: 882 return jjMoveStringLiteralDfa2_0(active0, 0x40000L); 883 case 108: 884 return jjMoveStringLiteralDfa2_0(active0, 0x1000L); 885 case 109: 886 return jjMoveStringLiteralDfa2_0(active0, 0x20000L); 887 case 110: 888 if ((active0 & 0x80000000L) != 0L) 889 return jjStartNfaWithStates_0(1, 31, 7); 890 break; 891 case 111: 892 return jjMoveStringLiteralDfa2_0(active0, 0x6000L); 893 case 114: 894 return jjMoveStringLiteralDfa2_0(active0, 0x100000L); 895 case 117: 896 return jjMoveStringLiteralDfa2_0(active0, 0x80000L); 897 default : 898 break; 899 } 900 return jjStartNfa_0(0, active0); 901 } 902 private int jjMoveStringLiteralDfa2_0(long old0, long active0) 903 { 904 if (((active0 &= old0)) == 0L) 905 return jjStartNfa_0(0, old0); 906 try { curChar = input_stream.readChar(); } 907 catch(java.io.IOException e) { 908 jjStopStringLiteralDfa_0(1, active0); 909 return 2; 910 } 911 switch(curChar) 912 { 913 case 105: 914 return jjMoveStringLiteralDfa3_0(active0, 0x8000L); 915 case 108: 916 return jjMoveStringLiteralDfa3_0(active0, 0x280000L); 917 case 112: 918 return jjMoveStringLiteralDfa3_0(active0, 0x20000L); 919 case 114: 920 if ((active0 & 0x2000L) != 0L) 921 { 922 jjmatchedKind = 13; 923 jjmatchedPos = 2; 924 } 925 return jjMoveStringLiteralDfa3_0(active0, 0x4000L); 926 case 115: 927 return jjMoveStringLiteralDfa3_0(active0, 0x1000L); 928 case 117: 929 return jjMoveStringLiteralDfa3_0(active0, 0x100000L); 930 case 119: 931 if ((active0 & 0x10000L) != 0L) 932 return jjStartNfaWithStates_0(2, 16, 7); 933 break; 934 case 122: 935 return jjMoveStringLiteralDfa3_0(active0, 0x40000L); 936 default : 937 break; 938 } 939 return jjStartNfa_0(1, active0); 940 } 941 private int jjMoveStringLiteralDfa3_0(long old0, long active0) 942 { 943 if (((active0 &= old0)) == 0L) 944 return jjStartNfa_0(1, old0); 945 try { curChar = input_stream.readChar(); } 946 catch(java.io.IOException e) { 947 jjStopStringLiteralDfa_0(2, active0); 948 return 3; 949 } 950 switch(curChar) 951 { 952 case 101: 953 if ((active0 & 0x1000L) != 0L) 954 return jjStartNfaWithStates_0(3, 12, 7); 955 else if ((active0 & 0x40000L) != 0L) 956 return jjStartNfaWithStates_0(3, 18, 7); 957 else if ((active0 & 0x100000L) != 0L) 958 return jjStartNfaWithStates_0(3, 20, 7); 959 return jjMoveStringLiteralDfa4_0(active0, 0x4000L); 960 case 108: 961 if ((active0 & 0x80000L) != 0L) 962 return jjStartNfaWithStates_0(3, 19, 7); 963 return jjMoveStringLiteralDfa4_0(active0, 0x8000L); 964 case 115: 965 return jjMoveStringLiteralDfa4_0(active0, 0x200000L); 966 case 116: 967 return jjMoveStringLiteralDfa4_0(active0, 0x20000L); 968 default : 969 break; 970 } 971 return jjStartNfa_0(2, active0); 972 } 973 private int jjMoveStringLiteralDfa4_0(long old0, long active0) 974 { 975 if (((active0 &= old0)) == 0L) 976 return jjStartNfa_0(2, old0); 977 try { curChar = input_stream.readChar(); } 978 catch(java.io.IOException e) { 979 jjStopStringLiteralDfa_0(3, active0); 980 return 4; 981 } 982 switch(curChar) 983 { 984 case 97: 985 return jjMoveStringLiteralDfa5_0(active0, 0x4000L); 986 case 101: 987 if ((active0 & 0x8000L) != 0L) 988 return jjStartNfaWithStates_0(4, 15, 7); 989 else if ((active0 & 0x200000L) != 0L) 990 return jjStartNfaWithStates_0(4, 21, 7); 991 break; 992 case 121: 993 if ((active0 & 0x20000L) != 0L) 994 return jjStartNfaWithStates_0(4, 17, 7); 995 break; 996 default : 997 break; 998 } 999 return jjStartNfa_0(3, active0); 1000 } 1001 private int jjMoveStringLiteralDfa5_0(long old0, long active0) 1002 { 1003 if (((active0 &= old0)) == 0L) 1004 return jjStartNfa_0(3, old0); 1005 try { curChar = input_stream.readChar(); } 1006 catch(java.io.IOException e) { 1007 jjStopStringLiteralDfa_0(4, active0); 1008 return 5; 1009 } 1010 switch(curChar) 1011 { 1012 case 99: 1013 return jjMoveStringLiteralDfa6_0(active0, 0x4000L); 1014 default : 1015 break; 1016 } 1017 return jjStartNfa_0(4, active0); 1018 } 1019 private int jjMoveStringLiteralDfa6_0(long old0, long active0) 1020 { 1021 if (((active0 &= old0)) == 0L) 1022 return jjStartNfa_0(4, old0); 1023 try { curChar = input_stream.readChar(); } 1024 catch(java.io.IOException e) { 1025 jjStopStringLiteralDfa_0(5, active0); 1026 return 6; 1027 } 1028 switch(curChar) 1029 { 1030 case 104: 1031 if ((active0 & 0x4000L) != 0L) 1032 return jjStartNfaWithStates_0(6, 14, 7); 1033 break; 1034 default : 1035 break; 1036 } 1037 return jjStartNfa_0(5, active0); 1038 } 1039 private int jjStartNfaWithStates_0(int pos, int kind, int state) 1040 { 1041 jjmatchedKind = kind; 1042 jjmatchedPos = pos; 1043 try { curChar = input_stream.readChar(); } 1044 catch(java.io.IOException e) { return pos + 1; } 1045 return jjMoveNfa_0(state, pos + 1); 1046 } 1047 private int jjMoveNfa_0(int startState, int curPos) 1048 { 1049 int startsAt = 0; 1050 jjnewStateCnt = 35; 1051 int i = 1; 1052 jjstateSet[0] = startState; 1053 int kind = 0x7fffffff; 1054 for (;;) 1055 { 1056 if (++jjround == 0x7fffffff) 1057 ReInitRounds(); 1058 if (curChar < 64) 1059 { 1060 long l = 1L << curChar; 1061 do 1062 { 1063 switch(jjstateSet[--i]) 1064 { 1065 case 5: 1066 if ((0x3ff000000000000L & l) != 0L) 1067 { 1068 if (kind > 9) 1069 kind = 9; 1070 jjCheckNAddStates(0, 2); 1071 } 1072 else if (curChar == 47) 1073 jjAddStates(3, 4); 1074 else if (curChar == 39) 1075 jjCheckNAddStates(5, 7); 1076 else if (curChar == 34) 1077 jjCheckNAddStates(8, 10); 1078 else if (curChar == 36) 1079 { 1080 if (kind > 67) 1081 kind = 67; 1082 jjCheckNAdd(7); 1083 } 1084 else if (curChar == 35) 1085 jjstateSet[jjnewStateCnt++] = 0; 1086 break; 1087 case 0: 1088 if (curChar != 35) 1089 break; 1090 if (kind > 1) 1091 kind = 1; 1092 jjCheckNAddStates(14, 16); 1093 break; 1094 case 1: 1095 if ((0xffffffffffffdbffL & l) == 0L) 1096 break; 1097 if (kind > 1) 1098 kind = 1; 1099 jjCheckNAddStates(14, 16); 1100 break; 1101 case 2: 1102 if ((0x2400L & l) != 0L && kind > 1) 1103 kind = 1; 1104 break; 1105 case 3: 1106 if (curChar == 10 && kind > 1) 1107 kind = 1; 1108 break; 1109 case 4: 1110 if (curChar == 13) 1111 jjstateSet[jjnewStateCnt++] = 3; 1112 break; 1113 case 6: 1114 if (curChar != 36) 1115 break; 1116 if (kind > 67) 1117 kind = 67; 1118 jjCheckNAdd(7); 1119 break; 1120 case 7: 1121 if ((0x3ff001000000000L & l) == 0L) 1122 break; 1123 if (kind > 67) 1124 kind = 67; 1125 jjCheckNAdd(7); 1126 break; 1127 case 8: 1128 case 11: 1129 if (curChar == 34) 1130 jjCheckNAddStates(8, 10); 1131 break; 1132 case 9: 1133 if ((0xfffffffbffffdbffL & l) != 0L) 1134 jjCheckNAddStates(8, 10); 1135 break; 1136 case 12: 1137 if (curChar == 34 && kind > 70) 1138 kind = 70; 1139 break; 1140 case 13: 1141 case 16: 1142 if (curChar == 39) 1143 jjCheckNAddStates(5, 7); 1144 break; 1145 case 14: 1146 if ((0xffffff7fffffdbffL & l) != 0L) 1147 jjCheckNAddStates(5, 7); 1148 break; 1149 case 17: 1150 if (curChar == 39 && kind > 70) 1151 kind = 70; 1152 break; 1153 case 18: 1154 if (curChar == 47) 1155 jjAddStates(3, 4); 1156 break; 1157 case 19: 1158 if (curChar == 42) 1159 jjCheckNAddTwoStates(20, 21); 1160 break; 1161 case 20: 1162 if ((0xfffffbffffffffffL & l) != 0L) 1163 jjCheckNAddTwoStates(20, 21); 1164 break; 1165 case 21: 1166 if (curChar == 42) 1167 jjCheckNAddStates(17, 19); 1168 break; 1169 case 22: 1170 if ((0xffff7bffffffffffL & l) != 0L) 1171 jjCheckNAddTwoStates(23, 21); 1172 break; 1173 case 23: 1174 if ((0xfffffbffffffffffL & l) != 0L) 1175 jjCheckNAddTwoStates(23, 21); 1176 break; 1177 case 24: 1178 if (curChar == 47 && kind > 2) 1179 kind = 2; 1180 break; 1181 case 25: 1182 if (curChar != 47) 1183 break; 1184 if (kind > 3) 1185 kind = 3; 1186 jjCheckNAddStates(11, 13); 1187 break; 1188 case 26: 1189 if ((0xffffffffffffdbffL & l) == 0L) 1190 break; 1191 if (kind > 3) 1192 kind = 3; 1193 jjCheckNAddStates(11, 13); 1194 break; 1195 case 27: 1196 if ((0x2400L & l) != 0L && kind > 3) 1197 kind = 3; 1198 break; 1199 case 28: 1200 if (curChar == 10 && kind > 3) 1201 kind = 3; 1202 break; 1203 case 29: 1204 if (curChar == 13) 1205 jjstateSet[jjnewStateCnt++] = 28; 1206 break; 1207 case 30: 1208 if ((0x3ff000000000000L & l) == 0L) 1209 break; 1210 if (kind > 9) 1211 kind = 9; 1212 jjCheckNAddStates(0, 2); 1213 break; 1214 case 31: 1215 if ((0x3ff000000000000L & l) == 0L) 1216 break; 1217 if (kind > 9) 1218 kind = 9; 1219 jjCheckNAdd(31); 1220 break; 1221 case 32: 1222 if ((0x3ff000000000000L & l) != 0L) 1223 jjCheckNAddTwoStates(32, 33); 1224 break; 1225 case 33: 1226 if (curChar == 46) 1227 jjCheckNAdd(34); 1228 break; 1229 case 34: 1230 if ((0x3ff000000000000L & l) == 0L) 1231 break; 1232 if (kind > 10) 1233 kind = 10; 1234 jjCheckNAdd(34); 1235 break; 1236 default : break; 1237 } 1238 } while(i != startsAt); 1239 } 1240 else if (curChar < 128) 1241 { 1242 long l = 1L << (curChar & 077); 1243 do 1244 { 1245 switch(jjstateSet[--i]) 1246 { 1247 case 5: 1248 case 7: 1249 if ((0x7fffffe87fffffeL & l) == 0L) 1250 break; 1251 if (kind > 67) 1252 kind = 67; 1253 jjCheckNAdd(7); 1254 break; 1255 case 1: 1256 if (kind > 1) 1257 kind = 1; 1258 jjAddStates(14, 16); 1259 break; 1260 case 9: 1261 jjCheckNAddStates(8, 10); 1262 break; 1263 case 10: 1264 if (curChar == 92) 1265 jjstateSet[jjnewStateCnt++] = 11; 1266 break; 1267 case 11: 1268 if ((0x34404410000000L & l) != 0L) 1269 jjCheckNAddStates(8, 10); 1270 break; 1271 case 14: 1272 jjCheckNAddStates(5, 7); 1273 break; 1274 case 15: 1275 if (curChar == 92) 1276 jjstateSet[jjnewStateCnt++] = 16; 1277 break; 1278 case 16: 1279 if ((0x34404410000000L & l) != 0L) 1280 jjCheckNAddStates(5, 7); 1281 break; 1282 case 20: 1283 jjCheckNAddTwoStates(20, 21); 1284 break; 1285 case 22: 1286 case 23: 1287 jjCheckNAddTwoStates(23, 21); 1288 break; 1289 case 26: 1290 if (kind > 3) 1291 kind = 3; 1292 jjAddStates(11, 13); 1293 break; 1294 default : break; 1295 } 1296 } while(i != startsAt); 1297 } 1298 else 1299 { 1300 int hiByte = (int)(curChar >> 8); 1301 int i1 = hiByte >> 6; 1302 long l1 = 1L << (hiByte & 077); 1303 int i2 = (curChar & 0xff) >> 6; 1304 long l2 = 1L << (curChar & 077); 1305 do 1306 { 1307 switch(jjstateSet[--i]) 1308 { 1309 case 1: 1310 if (!jjCanMove_0(hiByte, i1, i2, l1, l2)) 1311 break; 1312 if (kind > 1) 1313 kind = 1; 1314 jjAddStates(14, 16); 1315 break; 1316 case 9: 1317 if (jjCanMove_0(hiByte, i1, i2, l1, l2)) 1318 jjAddStates(8, 10); 1319 break; 1320 case 14: 1321 if (jjCanMove_0(hiByte, i1, i2, l1, l2)) 1322 jjAddStates(5, 7); 1323 break; 1324 case 20: 1325 if (jjCanMove_0(hiByte, i1, i2, l1, l2)) 1326 jjCheckNAddTwoStates(20, 21); 1327 break; 1328 case 22: 1329 case 23: 1330 if (jjCanMove_0(hiByte, i1, i2, l1, l2)) 1331 jjCheckNAddTwoStates(23, 21); 1332 break; 1333 case 26: 1334 if (!jjCanMove_0(hiByte, i1, i2, l1, l2)) 1335 break; 1336 if (kind > 3) 1337 kind = 3; 1338 jjAddStates(11, 13); 1339 break; 1340 default : break; 1341 } 1342 } while(i != startsAt); 1343 } 1344 if (kind != 0x7fffffff) 1345 { 1346 jjmatchedKind = kind; 1347 jjmatchedPos = curPos; 1348 kind = 0x7fffffff; 1349 } 1350 ++curPos; 1351 if ((i = jjnewStateCnt) == (startsAt = 35 - (jjnewStateCnt = startsAt))) 1352 return curPos; 1353 try { curChar = input_stream.readChar(); } 1354 catch(java.io.IOException e) { return curPos; } 1355 } 1356 } 1357 static final int[] jjnextStates = { 1358 31, 32, 33, 19, 25, 14, 15, 17, 9, 10, 12, 26, 27, 29, 1, 2, 1359 4, 21, 22, 24, 1360 }; 1361 private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2) 1362 { 1363 switch(hiByte) 1364 { 1365 case 0: 1366 return ((jjbitVec2[i2] & l2) != 0L); 1367 default : 1368 if ((jjbitVec0[i1] & l1) != 0L) 1369 return true; 1370 return false; 1371 } 1372 } 1373 1374 /** Token literal values. */ 1375 public static final String[] jjstrLiteralImages = { 1376 "", null, null, null, null, null, null, null, null, null, null, "\151\146", 1377 "\145\154\163\145", "\146\157\162", "\146\157\162\145\141\143\150", "\167\150\151\154\145", 1378 "\156\145\167", "\145\155\160\164\171", "\163\151\172\145", "\156\165\154\154", 1379 "\164\162\165\145", "\146\141\154\163\145", "\50", "\51", "\173", "\175", "\133", "\135", "\73", 1380 "\72", "\54", "\151\156", "\75", "\77", "\77\72", "\174\174", "\157\162", "\46\46", 1381 "\141\156\144", "\174", "\136", "\46", "\75\75", "\145\161", "\41\75", "\156\145", "\74", 1382 "\154\164", "\76", "\147\164", "\74\75", "\154\145", "\76\75", "\147\145", "\75\176", 1383 "\41\176", "\53", "\55", "\52", "\57", "\144\151\166", "\45", "\155\157\144", "\176", 1384 "\41", "\156\157\164", "\56", null, null, null, null, }; 1385 1386 /** Lexer state names. */ 1387 public static final String[] lexStateNames = { 1388 "FOR_EACH_IN", 1389 "DEFAULT", 1390 }; 1391 1392 /** Lex State array. */ 1393 public static final int[] jjnewLexState = { 1394 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1395 -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, 1396 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1397 }; 1398 static final long[] jjtoToken = { 1399 0xfffffffffffffe01L, 0x4fL, 1400 }; 1401 static final long[] jjtoSkip = { 1402 0x1feL, 0x0L, 1403 }; 1404 protected SimpleCharStream input_stream; 1405 private final int[] jjrounds = new int[35]; 1406 private final int[] jjstateSet = new int[70]; 1407 protected char curChar; 1408 /** Constructor. */ 1409 public ParserTokenManager(SimpleCharStream stream){ 1410 if (SimpleCharStream.staticFlag) 1411 throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer."); 1412 input_stream = stream; 1413 } 1414 1415 /** Constructor. */ 1416 public ParserTokenManager(SimpleCharStream stream, int lexState){ 1417 this(stream); 1418 SwitchTo(lexState); 1419 } 1420 1421 /** Reinitialise parser. */ 1422 public void ReInit(SimpleCharStream stream) 1423 { 1424 jjmatchedPos = jjnewStateCnt = 0; 1425 curLexState = defaultLexState; 1426 input_stream = stream; 1427 ReInitRounds(); 1428 } 1429 private void ReInitRounds() 1430 { 1431 int i; 1432 jjround = 0x80000001; 1433 for (i = 35; i-- > 0;) 1434 jjrounds[i] = 0x80000000; 1435 } 1436 1437 /** Reinitialise parser. */ 1438 public void ReInit(SimpleCharStream stream, int lexState) 1439 { 1440 ReInit(stream); 1441 SwitchTo(lexState); 1442 } 1443 1444 /** Switch to specified lex state. */ 1445 public void SwitchTo(int lexState) 1446 { 1447 if (lexState >= 2 || lexState < 0) 1448 throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE); 1449 else 1450 curLexState = lexState; 1451 } 1452 1453 protected Token jjFillToken() 1454 { 1455 final Token t; 1456 final String curTokenImage; 1457 final int beginLine; 1458 final int endLine; 1459 final int beginColumn; 1460 final int endColumn; 1461 String im = jjstrLiteralImages[jjmatchedKind]; 1462 curTokenImage = (im == null) ? input_stream.GetImage() : im; 1463 beginLine = input_stream.getBeginLine(); 1464 beginColumn = input_stream.getBeginColumn(); 1465 endLine = input_stream.getEndLine(); 1466 endColumn = input_stream.getEndColumn(); 1467 t = Token.newToken(jjmatchedKind, curTokenImage); 1468 1469 t.beginLine = beginLine; 1470 t.endLine = endLine; 1471 t.beginColumn = beginColumn; 1472 t.endColumn = endColumn; 1473 1474 return t; 1475 } 1476 1477 int curLexState = 1; 1478 int defaultLexState = 1; 1479 int jjnewStateCnt; 1480 int jjround; 1481 int jjmatchedPos; 1482 int jjmatchedKind; 1483 1484 /** Get the next Token. */ 1485 public Token getNextToken() 1486 { 1487 Token matchedToken; 1488 int curPos = 0; 1489 1490 EOFLoop : 1491 for (;;) 1492 { 1493 try 1494 { 1495 curChar = input_stream.BeginToken(); 1496 } 1497 catch(java.io.IOException e) 1498 { 1499 jjmatchedKind = 0; 1500 matchedToken = jjFillToken(); 1501 return matchedToken; 1502 } 1503 1504 switch(curLexState) 1505 { 1506 case 0: 1507 try { input_stream.backup(0); 1508 while (curChar <= 32 && (0x100003600L & (1L << curChar)) != 0L) 1509 curChar = input_stream.BeginToken(); 1510 } 1511 catch (java.io.IOException e1) { continue EOFLoop; } 1512 jjmatchedKind = 0x7fffffff; 1513 jjmatchedPos = 0; 1514 curPos = jjMoveStringLiteralDfa0_0(); 1515 break; 1516 case 1: 1517 try { input_stream.backup(0); 1518 while (curChar <= 32 && (0x100003600L & (1L << curChar)) != 0L) 1519 curChar = input_stream.BeginToken(); 1520 } 1521 catch (java.io.IOException e1) { continue EOFLoop; } 1522 jjmatchedKind = 0x7fffffff; 1523 jjmatchedPos = 0; 1524 curPos = jjMoveStringLiteralDfa0_1(); 1525 break; 1526 } 1527 if (jjmatchedKind != 0x7fffffff) 1528 { 1529 if (jjmatchedPos + 1 < curPos) 1530 input_stream.backup(curPos - jjmatchedPos - 1); 1531 if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) 1532 { 1533 matchedToken = jjFillToken(); 1534 if (jjnewLexState[jjmatchedKind] != -1) 1535 curLexState = jjnewLexState[jjmatchedKind]; 1536 return matchedToken; 1537 } 1538 else 1539 { 1540 if (jjnewLexState[jjmatchedKind] != -1) 1541 curLexState = jjnewLexState[jjmatchedKind]; 1542 continue EOFLoop; 1543 } 1544 } 1545 int error_line = input_stream.getEndLine(); 1546 int error_column = input_stream.getEndColumn(); 1547 String error_after = null; 1548 boolean EOFSeen = false; 1549 try { input_stream.readChar(); input_stream.backup(1); } 1550 catch (java.io.IOException e1) { 1551 EOFSeen = true; 1552 error_after = curPos <= 1 ? "" : input_stream.GetImage(); 1553 if (curChar == '\n' || curChar == '\r') { 1554 error_line++; 1555 error_column = 0; 1556 } 1557 else 1558 error_column++; 1559 } 1560 if (!EOFSeen) { 1561 input_stream.backup(1); 1562 error_after = curPos <= 1 ? "" : input_stream.GetImage(); 1563 } 1564 throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR); 1565 } 1566 } 1567 1568 private void jjCheckNAdd(int state) 1569 { 1570 if (jjrounds[state] != jjround) 1571 { 1572 jjstateSet[jjnewStateCnt++] = state; 1573 jjrounds[state] = jjround; 1574 } 1575 } 1576 private void jjAddStates(int start, int end) 1577 { 1578 do { 1579 jjstateSet[jjnewStateCnt++] = jjnextStates[start]; 1580 } while (start++ != end); 1581 } 1582 private void jjCheckNAddTwoStates(int state1, int state2) 1583 { 1584 jjCheckNAdd(state1); 1585 jjCheckNAdd(state2); 1586 } 1587 1588 private void jjCheckNAddStates(int start, int end) 1589 { 1590 do { 1591 jjCheckNAdd(jjnextStates[start]); 1592 } while (start++ != end); 1593 } 1594 1595 }