1 2 package org.ejen.ext.parsers.java_1_2; 3 4 public class JavaParserTokenManager implements JavaParserConstants { 5 public static java.io.PrintStream debugStream = System.out; 6 public static void setDebugStream(java.io.PrintStream ds) { 7 debugStream = ds; 8 } 9 10 private static final int jjStopStringLiteralDfa_0(int pos, long active0, long active1) { 11 switch (pos) { 12 case 0: 13 if ((active0 & 0x140L) != 0L || (active1 & 0x2004000000000L) != 0L) { 14 return 2; 15 } 16 if ((active1 & 0x80000L) != 0L) { 17 return 8; 18 } 19 if ((active0 & 0xffffffffffffe000L) != 0L) { 20 jjmatchedKind = 72; 21 return 32; 22 } 23 return -1; 24 25 case 1: 26 if ((active0 & 0x100L) != 0L) { 27 return 0; 28 } 29 if ((active0 & 0xfffffffbfcffe000L) != 0L) { 30 if (jjmatchedPos != 1) { 31 jjmatchedKind = 72; 32 jjmatchedPos = 1; 33 } 34 return 32; 35 } 36 if ((active0 & 0x403000000L) != 0L) { 37 return 32; 38 } 39 return -1; 40 41 case 2: 42 if ((active0 & 0xf7fffb3afeffe000L) != 0L) { 43 if (jjmatchedPos != 2) { 44 jjmatchedKind = 72; 45 jjmatchedPos = 2; 46 } 47 return 32; 48 } 49 if ((active0 & 0x80004c100000000L) != 0L) { 50 return 32; 51 } 52 return -1; 53 54 case 3: 55 if ((active0 & 0xe3bff2b8faf4e000L) != 0L) { 56 jjmatchedKind = 72; 57 jjmatchedPos = 3; 58 return 32; 59 } 60 if ((active0 & 0x14400902040b0000L) != 0L) { 61 return 32; 62 } 63 return -1; 64 65 case 4: 66 if ((active0 & 0xa235f2b80ac06000L) != 0L) { 67 if (jjmatchedPos != 4) { 68 jjmatchedKind = 72; 69 jjmatchedPos = 4; 70 } 71 return 32; 72 } 73 if ((active0 & 0x418a0000f0348000L) != 0L) { 74 return 32; 75 } 76 return -1; 77 78 case 5: 79 if ((active0 & 0xa22070a848c06000L) != 0L) { 80 jjmatchedKind = 72; 81 jjmatchedPos = 5; 82 return 32; 83 } 84 if ((active0 & 0x115821002000000L) != 0L) { 85 return 32; 86 } 87 return -1; 88 89 case 6: 90 if ((active0 & 0xa22040a800402000L) != 0L) { 91 jjmatchedKind = 72; 92 jjmatchedPos = 6; 93 return 32; 94 } 95 if ((active0 & 0x300048804000L) != 0L) { 96 return 32; 97 } 98 return -1; 99 100 case 7: 101 if ((active0 & 0x22040a800000000L) != 0L) { 102 jjmatchedKind = 72; 103 jjmatchedPos = 7; 104 return 32; 105 } 106 if ((active0 & 0xa000000000402000L) != 0L) { 107 return 32; 108 } 109 return -1; 110 111 case 8: 112 if ((active0 & 0x20002800000000L) != 0L) { 113 jjmatchedKind = 72; 114 jjmatchedPos = 8; 115 return 32; 116 } 117 if ((active0 & 0x200408000000000L) != 0L) { 118 return 32; 119 } 120 return -1; 121 122 case 9: 123 if ((active0 & 0x20000000000000L) != 0L) { 124 jjmatchedKind = 72; 125 jjmatchedPos = 9; 126 return 32; 127 } 128 if ((active0 & 0x2800000000L) != 0L) { 129 return 32; 130 } 131 return -1; 132 133 case 10: 134 if ((active0 & 0x20000000000000L) != 0L) { 135 jjmatchedKind = 72; 136 jjmatchedPos = 10; 137 return 32; 138 } 139 return -1; 140 141 default: 142 return -1; 143 } 144 } 145 146 private static final int jjStartNfa_0(int pos, long active0, long active1) { 147 return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0, active1), 148 pos + 1); 149 } 150 151 static private final int jjStopAtPos(int pos, int kind) { 152 jjmatchedKind = kind; 153 jjmatchedPos = pos; 154 return pos + 1; 155 } 156 157 static private final int jjStartNfaWithStates_0(int pos, int kind, int state) { 158 jjmatchedKind = kind; 159 jjmatchedPos = pos; 160 try { 161 curChar = input_stream.readChar(); 162 } catch (java.io.IOException e) { 163 return pos + 1; 164 } 165 return jjMoveNfa_0(state, pos + 1); 166 } 167 168 static private final int jjMoveStringLiteralDfa0_0() { 169 switch (curChar) { 170 case 9: 171 return jjStopAtPos(0, 2); 172 173 case 10: 174 return jjStopAtPos(0, 3); 175 176 case 12: 177 return jjStopAtPos(0, 5); 178 179 case 13: 180 return jjStopAtPos(0, 4); 181 182 case 32: 183 return jjStopAtPos(0, 1); 184 185 case 33: 186 jjmatchedKind = 87; 187 return jjMoveStringLiteralDfa1_0(0x0L, 0x40000000L); 188 189 case 37: 190 jjmatchedKind = 106; 191 return jjMoveStringLiteralDfa1_0(0x0L, 0x20000000000000L); 192 193 case 38: 194 jjmatchedKind = 103; 195 return jjMoveStringLiteralDfa1_0(0x0L, 0x4000100000000L); 196 197 case 40: 198 return jjStopAtPos(0, 75); 199 200 case 41: 201 return jjStopAtPos(0, 76); 202 203 case 42: 204 jjmatchedKind = 101; 205 return jjMoveStringLiteralDfa1_0(0x0L, 0x1000000000000L); 206 207 case 43: 208 jjmatchedKind = 99; 209 return jjMoveStringLiteralDfa1_0(0x0L, 0x400200000000L); 210 211 case 44: 212 return jjStopAtPos(0, 82); 213 214 case 45: 215 jjmatchedKind = 100; 216 return jjMoveStringLiteralDfa1_0(0x0L, 0x800400000000L); 217 218 case 46: 219 return jjStartNfaWithStates_0(0, 83, 8); 220 221 case 47: 222 jjmatchedKind = 102; 223 return jjMoveStringLiteralDfa1_0(0x140L, 0x2000000000000L); 224 225 case 58: 226 return jjStopAtPos(0, 90); 227 228 case 59: 229 return jjStopAtPos(0, 81); 230 231 case 60: 232 jjmatchedKind = 86; 233 return jjMoveStringLiteralDfa1_0(0x0L, 0x40080010000000L); 234 235 case 61: 236 jjmatchedKind = 84; 237 return jjMoveStringLiteralDfa1_0(0x0L, 0x8000000L); 238 239 case 62: 240 jjmatchedKind = 85; 241 return jjMoveStringLiteralDfa1_0(0x0L, 0x180300020000000L); 242 243 case 63: 244 return jjStopAtPos(0, 89); 245 246 case 91: 247 return jjStopAtPos(0, 79); 248 249 case 93: 250 return jjStopAtPos(0, 80); 251 252 case 94: 253 jjmatchedKind = 105; 254 return jjMoveStringLiteralDfa1_0(0x0L, 0x10000000000000L); 255 256 case 97: 257 return jjMoveStringLiteralDfa1_0(0x2000L, 0x0L); 258 259 case 98: 260 return jjMoveStringLiteralDfa1_0(0x1c000L, 0x0L); 261 262 case 99: 263 return jjMoveStringLiteralDfa1_0(0x7e0000L, 0x0L); 264 265 case 100: 266 return jjMoveStringLiteralDfa1_0(0x3800000L, 0x0L); 267 268 case 101: 269 return jjMoveStringLiteralDfa1_0(0xc000000L, 0x0L); 270 271 case 102: 272 return jjMoveStringLiteralDfa1_0(0x1f0000000L, 0x0L); 273 274 case 103: 275 return jjMoveStringLiteralDfa1_0(0x200000000L, 0x0L); 276 277 case 105: 278 return jjMoveStringLiteralDfa1_0(0xfc00000000L, 0x0L); 279 280 case 108: 281 return jjMoveStringLiteralDfa1_0(0x10000000000L, 0x0L); 282 283 case 110: 284 return jjMoveStringLiteralDfa1_0(0xe0000000000L, 0x0L); 285 286 case 112: 287 return jjMoveStringLiteralDfa1_0(0xf00000000000L, 0x0L); 288 289 case 114: 290 return jjMoveStringLiteralDfa1_0(0x1000000000000L, 0x0L); 291 292 case 115: 293 return jjMoveStringLiteralDfa1_0(0x803e000000000000L, 0x0L); 294 295 case 116: 296 return jjMoveStringLiteralDfa1_0(0xfc0000000000000L, 0x0L); 297 298 case 118: 299 return jjMoveStringLiteralDfa1_0(0x3000000000000000L, 0x0L); 300 301 case 119: 302 return jjMoveStringLiteralDfa1_0(0x4000000000000000L, 0x0L); 303 304 case 123: 305 return jjStopAtPos(0, 77); 306 307 case 124: 308 jjmatchedKind = 104; 309 return jjMoveStringLiteralDfa1_0(0x0L, 0x8000080000000L); 310 311 case 125: 312 return jjStopAtPos(0, 78); 313 314 case 126: 315 return jjStopAtPos(0, 88); 316 317 default: 318 return jjMoveNfa_0(3, 0); 319 } 320 } 321 322 static private final int jjMoveStringLiteralDfa1_0(long active0, long active1) { 323 try { 324 curChar = input_stream.readChar(); 325 } catch (java.io.IOException e) { 326 jjStopStringLiteralDfa_0(0, active0, active1); 327 return 1; 328 } 329 switch (curChar) { 330 case 38: 331 if ((active1 & 0x100000000L) != 0L) { 332 return jjStopAtPos(1, 96); 333 } 334 break; 335 336 case 42: 337 if ((active0 & 0x100L) != 0L) { 338 return jjStartNfaWithStates_0(1, 8, 0); 339 } 340 break; 341 342 case 43: 343 if ((active1 & 0x200000000L) != 0L) { 344 return jjStopAtPos(1, 97); 345 } 346 break; 347 348 case 45: 349 if ((active1 & 0x400000000L) != 0L) { 350 return jjStopAtPos(1, 98); 351 } 352 break; 353 354 case 47: 355 if ((active0 & 0x40L) != 0L) { 356 return jjStopAtPos(1, 6); 357 } 358 break; 359 360 case 60: 361 if ((active1 & 0x80000000000L) != 0L) { 362 jjmatchedKind = 107; 363 jjmatchedPos = 1; 364 } 365 return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 366 0x40000000000000L); 367 368 case 61: 369 if ((active1 & 0x8000000L) != 0L) { 370 return jjStopAtPos(1, 91); 371 } else if ((active1 & 0x10000000L) != 0L) { 372 return jjStopAtPos(1, 92); 373 } else if ((active1 & 0x20000000L) != 0L) { 374 return jjStopAtPos(1, 93); 375 } else if ((active1 & 0x40000000L) != 0L) { 376 return jjStopAtPos(1, 94); 377 } else if ((active1 & 0x400000000000L) != 0L) { 378 return jjStopAtPos(1, 110); 379 } else if ((active1 & 0x800000000000L) != 0L) { 380 return jjStopAtPos(1, 111); 381 } else if ((active1 & 0x1000000000000L) != 0L) { 382 return jjStopAtPos(1, 112); 383 } else if ((active1 & 0x2000000000000L) != 0L) { 384 return jjStopAtPos(1, 113); 385 } else if ((active1 & 0x4000000000000L) != 0L) { 386 return jjStopAtPos(1, 114); 387 } else if ((active1 & 0x8000000000000L) != 0L) { 388 return jjStopAtPos(1, 115); 389 } else if ((active1 & 0x10000000000000L) != 0L) { 390 return jjStopAtPos(1, 116); 391 } else if ((active1 & 0x20000000000000L) != 0L) { 392 return jjStopAtPos(1, 117); 393 } 394 break; 395 396 case 62: 397 if ((active1 & 0x100000000000L) != 0L) { 398 jjmatchedKind = 108; 399 jjmatchedPos = 1; 400 } 401 return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 402 0x180200000000000L); 403 404 case 97: 405 return jjMoveStringLiteralDfa2_0(active0, 0x120010060000L, active1, 406 0L); 407 408 case 98: 409 return jjMoveStringLiteralDfa2_0(active0, 0x2000L, active1, 0L); 410 411 case 101: 412 return jjMoveStringLiteralDfa2_0(active0, 0x1040000800000L, active1, 413 0L); 414 415 case 102: 416 if ((active0 & 0x400000000L) != 0L) { 417 return jjStartNfaWithStates_0(1, 34, 32); 418 } 419 break; 420 421 case 104: 422 return jjMoveStringLiteralDfa2_0(active0, 0x41c2000000080000L, 423 active1, 0L); 424 425 case 105: 426 return jjMoveStringLiteralDfa2_0(active0, 0x60000000L, active1, 0L); 427 428 case 108: 429 return jjMoveStringLiteralDfa2_0(active0, 0x84100000L, active1, 0L); 430 431 case 109: 432 return jjMoveStringLiteralDfa2_0(active0, 0x1800000000L, active1, 0L); 433 434 case 110: 435 return jjMoveStringLiteralDfa2_0(active0, 0xe000000000L, active1, 0L); 436 437 case 111: 438 if ((active0 & 0x1000000L) != 0L) { 439 jjmatchedKind = 24; 440 jjmatchedPos = 1; 441 } 442 return jjMoveStringLiteralDfa2_0(active0, 0x3000010302604000L, 443 active1, 0L); 444 445 case 114: 446 return jjMoveStringLiteralDfa2_0(active0, 0xe00600000008000L, 447 active1, 0L); 448 449 case 116: 450 return jjMoveStringLiteralDfa2_0(active0, 0x8004000000000000L, 451 active1, 0L); 452 453 case 117: 454 return jjMoveStringLiteralDfa2_0(active0, 0x8880000000000L, active1, 455 0L); 456 457 case 119: 458 return jjMoveStringLiteralDfa2_0(active0, 0x10000000000000L, active1, 459 0L); 460 461 case 120: 462 return jjMoveStringLiteralDfa2_0(active0, 0x8000000L, active1, 0L); 463 464 case 121: 465 return jjMoveStringLiteralDfa2_0(active0, 0x20000000010000L, active1, 466 0L); 467 468 case 124: 469 if ((active1 & 0x80000000L) != 0L) { 470 return jjStopAtPos(1, 95); 471 } 472 break; 473 474 default: 475 break; 476 } 477 return jjStartNfa_0(0, active0, active1); 478 } 479 480 static private final int jjMoveStringLiteralDfa2_0(long old0, long active0, long old1, long active1) { 481 if (((active0 &= old0) | (active1 &= old1)) == 0L) { 482 return jjStartNfa_0(0, old0, old1); 483 } 484 try { 485 curChar = input_stream.readChar(); 486 } catch (java.io.IOException e) { 487 jjStopStringLiteralDfa_0(1, active0, active1); 488 return 2; 489 } 490 switch (curChar) { 491 case 61: 492 if ((active1 & 0x40000000000000L) != 0L) { 493 return jjStopAtPos(2, 118); 494 } else if ((active1 & 0x80000000000000L) != 0L) { 495 return jjStopAtPos(2, 119); 496 } 497 break; 498 499 case 62: 500 if ((active1 & 0x200000000000L) != 0L) { 501 jjmatchedKind = 109; 502 jjmatchedPos = 2; 503 } 504 return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 505 0x100000000000000L); 506 507 case 97: 508 return jjMoveStringLiteralDfa3_0(active0, 0x204000000180000L, 509 active1, 0L); 510 511 case 98: 512 return jjMoveStringLiteralDfa3_0(active0, 0x800000000000L, active1, 513 0L); 514 515 case 99: 516 return jjMoveStringLiteralDfa3_0(active0, 0x100000000000L, active1, 517 0L); 518 519 case 101: 520 return jjMoveStringLiteralDfa3_0(active0, 0x8000L, active1, 0L); 521 522 case 102: 523 return jjMoveStringLiteralDfa3_0(active0, 0x800000L, active1, 0L); 524 525 case 105: 526 return jjMoveStringLiteralDfa3_0(active0, 0x5050200000000000L, 527 active1, 0L); 528 529 case 108: 530 return jjMoveStringLiteralDfa3_0(active0, 0x2000080010000000L, 531 active1, 0L); 532 533 case 110: 534 return jjMoveStringLiteralDfa3_0(active0, 0x20010060600000L, active1, 535 0L); 536 537 case 111: 538 return jjMoveStringLiteralDfa3_0(active0, 0x2400080004000L, active1, 539 0L); 540 541 case 112: 542 return jjMoveStringLiteralDfa3_0(active0, 0x8001800000000L, active1, 543 0L); 544 545 case 114: 546 if ((active0 & 0x100000000L) != 0L) { 547 return jjStartNfaWithStates_0(2, 32, 32); 548 } 549 return jjMoveStringLiteralDfa3_0(active0, 0x8180000000000000L, 550 active1, 0L); 551 552 case 115: 553 return jjMoveStringLiteralDfa3_0(active0, 0x2004022000L, active1, 0L); 554 555 case 116: 556 if ((active0 & 0x4000000000L) != 0L) { 557 jjmatchedKind = 38; 558 jjmatchedPos = 2; 559 } 560 return jjMoveStringLiteralDfa3_0(active0, 0x1028208050000L, active1, 561 0L); 562 563 case 117: 564 return jjMoveStringLiteralDfa3_0(active0, 0x400000002000000L, 565 active1, 0L); 566 567 case 119: 568 if ((active0 & 0x40000000000L) != 0L) { 569 return jjStartNfaWithStates_0(2, 42, 32); 570 } 571 break; 572 573 case 121: 574 if ((active0 & 0x800000000000000L) != 0L) { 575 return jjStartNfaWithStates_0(2, 59, 32); 576 } 577 break; 578 579 default: 580 break; 581 } 582 return jjStartNfa_0(1, active0, active1); 583 } 584 585 static private final int jjMoveStringLiteralDfa3_0(long old0, long active0, long old1, long active1) { 586 if (((active0 &= old0) | (active1 &= old1)) == 0L) { 587 return jjStartNfa_0(1, old0, old1); 588 } 589 try { 590 curChar = input_stream.readChar(); 591 } catch (java.io.IOException e) { 592 jjStopStringLiteralDfa_0(2, active0, active1); 593 return 3; 594 } 595 switch (curChar) { 596 case 61: 597 if ((active1 & 0x100000000000000L) != 0L) { 598 return jjStopAtPos(3, 120); 599 } 600 break; 601 602 case 97: 603 return jjMoveStringLiteralDfa4_0(active0, 0x20000000e0808000L, 604 active1, 0L); 605 606 case 98: 607 return jjMoveStringLiteralDfa4_0(active0, 0x2000000L, active1, 0L); 608 609 case 99: 610 return jjMoveStringLiteralDfa4_0(active0, 0x20000000040000L, active1, 611 0L); 612 613 case 100: 614 if ((active0 & 0x1000000000000000L) != 0L) { 615 return jjStartNfaWithStates_0(3, 60, 32); 616 } 617 break; 618 619 case 101: 620 if ((active0 & 0x10000L) != 0L) { 621 return jjStartNfaWithStates_0(3, 16, 32); 622 } else if ((active0 & 0x20000L) != 0L) { 623 return jjStartNfaWithStates_0(3, 17, 32); 624 } else if ((active0 & 0x4000000L) != 0L) { 625 return jjStartNfaWithStates_0(3, 26, 32); 626 } else if ((active0 & 0x400000000000000L) != 0L) { 627 return jjStartNfaWithStates_0(3, 58, 32); 628 } 629 return jjMoveStringLiteralDfa4_0(active0, 0x8008008000000L, active1, 630 0L); 631 632 case 103: 633 if ((active0 & 0x10000000000L) != 0L) { 634 return jjStartNfaWithStates_0(3, 40, 32); 635 } 636 break; 637 638 case 105: 639 return jjMoveStringLiteralDfa4_0(active0, 0x8000020000000000L, 640 active1, 0L); 641 642 case 107: 643 return jjMoveStringLiteralDfa4_0(active0, 0x100000000000L, active1, 644 0L); 645 646 case 108: 647 if ((active0 & 0x80000000000L) != 0L) { 648 return jjStartNfaWithStates_0(3, 43, 32); 649 } 650 return jjMoveStringLiteralDfa4_0(active0, 0x4000800800004000L, 651 active1, 0L); 652 653 case 110: 654 return jjMoveStringLiteralDfa4_0(active0, 0x200000000000000L, 655 active1, 0L); 656 657 case 111: 658 if ((active0 & 0x200000000L) != 0L) { 659 return jjStartNfaWithStates_0(3, 33, 32); 660 } 661 return jjMoveStringLiteralDfa4_0(active0, 0x180001000000000L, 662 active1, 0L); 663 664 case 114: 665 if ((active0 & 0x80000L) != 0L) { 666 return jjStartNfaWithStates_0(3, 19, 32); 667 } 668 return jjMoveStringLiteralDfa4_0(active0, 0x2000000000000L, active1, 669 0L); 670 671 case 115: 672 if ((active0 & 0x40000000000000L) != 0L) { 673 return jjStartNfaWithStates_0(3, 54, 32); 674 } 675 return jjMoveStringLiteralDfa4_0(active0, 0x10300000L, active1, 0L); 676 677 case 116: 678 return jjMoveStringLiteralDfa4_0(active0, 0x14402000402000L, active1, 679 0L); 680 681 case 117: 682 return jjMoveStringLiteralDfa4_0(active0, 0x1000000000000L, active1, 683 0L); 684 685 case 118: 686 return jjMoveStringLiteralDfa4_0(active0, 0x200000000000L, active1, 687 0L); 688 689 default: 690 break; 691 } 692 return jjStartNfa_0(2, active0, active1); 693 } 694 695 static private final int jjMoveStringLiteralDfa4_0(long old0, long active0, long old1, long active1) { 696 if (((active0 &= old0) | (active1 &= old1)) == 0L) { 697 return jjStartNfa_0(2, old0, old1); 698 } 699 try { 700 curChar = input_stream.readChar(); 701 } catch (java.io.IOException e) { 702 jjStopStringLiteralDfa_0(3, active0, 0L); 703 return 4; 704 } 705 switch (curChar) { 706 case 97: 707 return jjMoveStringLiteralDfa5_0(active0, 0x302000000000L); 708 709 case 99: 710 return jjMoveStringLiteralDfa5_0(active0, 0x8010000000000000L); 711 712 case 101: 713 if ((active0 & 0x10000000L) != 0L) { 714 return jjStartNfaWithStates_0(4, 28, 32); 715 } else if ((active0 & 0x4000000000000000L) != 0L) { 716 return jjStartNfaWithStates_0(4, 62, 32); 717 } 718 return jjMoveStringLiteralDfa5_0(active0, 0x400800004000L); 719 720 case 104: 721 if ((active0 & 0x40000L) != 0L) { 722 return jjStartNfaWithStates_0(4, 18, 32); 723 } 724 return jjMoveStringLiteralDfa5_0(active0, 0x20000000000000L); 725 726 case 105: 727 return jjMoveStringLiteralDfa5_0(active0, 0x4800000400000L); 728 729 case 107: 730 if ((active0 & 0x8000L) != 0L) { 731 return jjStartNfaWithStates_0(4, 15, 32); 732 } 733 break; 734 735 case 108: 736 if ((active0 & 0x20000000L) != 0L) { 737 jjmatchedKind = 29; 738 jjmatchedPos = 4; 739 } 740 return jjMoveStringLiteralDfa5_0(active0, 0x42000000L); 741 742 case 110: 743 return jjMoveStringLiteralDfa5_0(active0, 0x8000000L); 744 745 case 114: 746 if ((active0 & 0x8000000000000L) != 0L) { 747 return jjStartNfaWithStates_0(4, 51, 32); 748 } 749 return jjMoveStringLiteralDfa5_0(active0, 0x1009000002000L); 750 751 case 115: 752 if ((active0 & 0x100000L) != 0L) { 753 return jjStartNfaWithStates_0(4, 20, 32); 754 } 755 return jjMoveStringLiteralDfa5_0(active0, 0x200000000000000L); 756 757 case 116: 758 if ((active0 & 0x200000L) != 0L) { 759 return jjStartNfaWithStates_0(4, 21, 32); 760 } else if ((active0 & 0x80000000L) != 0L) { 761 return jjStartNfaWithStates_0(4, 31, 32); 762 } else if ((active0 & 0x2000000000000L) != 0L) { 763 return jjStartNfaWithStates_0(4, 49, 32); 764 } 765 return jjMoveStringLiteralDfa5_0(active0, 0x2000000000000000L); 766 767 case 117: 768 return jjMoveStringLiteralDfa5_0(active0, 0x800000L); 769 770 case 118: 771 return jjMoveStringLiteralDfa5_0(active0, 0x20000000000L); 772 773 case 119: 774 if ((active0 & 0x80000000000000L) != 0L) { 775 jjmatchedKind = 55; 776 jjmatchedPos = 4; 777 } 778 return jjMoveStringLiteralDfa5_0(active0, 0x100000000000000L); 779 780 default: 781 break; 782 } 783 return jjStartNfa_0(3, active0, 0L); 784 } 785 786 static private final int jjMoveStringLiteralDfa5_0(long old0, long active0) { 787 if (((active0 &= old0)) == 0L) { 788 return jjStartNfa_0(3, old0, 0L); 789 } 790 try { 791 curChar = input_stream.readChar(); 792 } catch (java.io.IOException e) { 793 jjStopStringLiteralDfa_0(4, active0, 0L); 794 return 5; 795 } 796 switch (curChar) { 797 case 97: 798 return jjMoveStringLiteralDfa6_0(active0, 0x6000L); 799 800 case 99: 801 if ((active0 & 0x800000000000L) != 0L) { 802 return jjStartNfaWithStates_0(5, 47, 32); 803 } else if ((active0 & 0x4000000000000L) != 0L) { 804 return jjStartNfaWithStates_0(5, 50, 32); 805 } 806 return jjMoveStringLiteralDfa6_0(active0, 0x400000000000L); 807 808 case 100: 809 return jjMoveStringLiteralDfa6_0(active0, 0x8000000L); 810 811 case 101: 812 if ((active0 & 0x2000000L) != 0L) { 813 return jjStartNfaWithStates_0(5, 25, 32); 814 } else if ((active0 & 0x20000000000L) != 0L) { 815 return jjStartNfaWithStates_0(5, 41, 32); 816 } 817 break; 818 819 case 102: 820 return jjMoveStringLiteralDfa6_0(active0, 0x8000000000L); 821 822 case 103: 823 return jjMoveStringLiteralDfa6_0(active0, 0x100000000000L); 824 825 case 104: 826 if ((active0 & 0x10000000000000L) != 0L) { 827 return jjStartNfaWithStates_0(5, 52, 32); 828 } 829 break; 830 831 case 105: 832 return jjMoveStringLiteralDfa6_0(active0, 0x2200000000000000L); 833 834 case 108: 835 return jjMoveStringLiteralDfa6_0(active0, 0x40800000L); 836 837 case 109: 838 return jjMoveStringLiteralDfa6_0(active0, 0x800000000L); 839 840 case 110: 841 if ((active0 & 0x1000000000000L) != 0L) { 842 return jjStartNfaWithStates_0(5, 48, 32); 843 } 844 return jjMoveStringLiteralDfa6_0(active0, 0x2000400000L); 845 846 case 114: 847 return jjMoveStringLiteralDfa6_0(active0, 0x20000000000000L); 848 849 case 115: 850 if ((active0 & 0x100000000000000L) != 0L) { 851 return jjStartNfaWithStates_0(5, 56, 32); 852 } 853 break; 854 855 case 116: 856 if ((active0 & 0x1000000000L) != 0L) { 857 return jjStartNfaWithStates_0(5, 36, 32); 858 } 859 return jjMoveStringLiteralDfa6_0(active0, 0x8000200000000000L); 860 861 default: 862 break; 863 } 864 return jjStartNfa_0(4, active0, 0L); 865 } 866 867 static private final int jjMoveStringLiteralDfa6_0(long old0, long active0) { 868 if (((active0 &= old0)) == 0L) { 869 return jjStartNfa_0(4, old0, 0L); 870 } 871 try { 872 curChar = input_stream.readChar(); 873 } catch (java.io.IOException e) { 874 jjStopStringLiteralDfa_0(5, active0, 0L); 875 return 6; 876 } 877 switch (curChar) { 878 case 97: 879 return jjMoveStringLiteralDfa7_0(active0, 0x8000000000L); 880 881 case 99: 882 return jjMoveStringLiteralDfa7_0(active0, 0x2000002000L); 883 884 case 101: 885 if ((active0 & 0x100000000000L) != 0L) { 886 return jjStartNfaWithStates_0(6, 44, 32); 887 } else if ((active0 & 0x200000000000L) != 0L) { 888 return jjStartNfaWithStates_0(6, 45, 32); 889 } 890 return jjMoveStringLiteralDfa7_0(active0, 0x200000800000000L); 891 892 case 102: 893 return jjMoveStringLiteralDfa7_0(active0, 0x8000000000000000L); 894 895 case 108: 896 return jjMoveStringLiteralDfa7_0(active0, 0x2000000000000000L); 897 898 case 110: 899 if ((active0 & 0x4000L) != 0L) { 900 return jjStartNfaWithStates_0(6, 14, 32); 901 } 902 break; 903 904 case 111: 905 return jjMoveStringLiteralDfa7_0(active0, 0x20000000000000L); 906 907 case 115: 908 if ((active0 & 0x8000000L) != 0L) { 909 return jjStartNfaWithStates_0(6, 27, 32); 910 } 911 break; 912 913 case 116: 914 if ((active0 & 0x800000L) != 0L) { 915 return jjStartNfaWithStates_0(6, 23, 32); 916 } 917 return jjMoveStringLiteralDfa7_0(active0, 0x400000000000L); 918 919 case 117: 920 return jjMoveStringLiteralDfa7_0(active0, 0x400000L); 921 922 case 121: 923 if ((active0 & 0x40000000L) != 0L) { 924 return jjStartNfaWithStates_0(6, 30, 32); 925 } 926 break; 927 928 default: 929 break; 930 } 931 return jjStartNfa_0(5, active0, 0L); 932 } 933 934 static private final int jjMoveStringLiteralDfa7_0(long old0, long active0) { 935 if (((active0 &= old0)) == 0L) { 936 return jjStartNfa_0(5, old0, 0L); 937 } 938 try { 939 curChar = input_stream.readChar(); 940 } catch (java.io.IOException e) { 941 jjStopStringLiteralDfa_0(6, active0, 0L); 942 return 7; 943 } 944 switch (curChar) { 945 case 99: 946 return jjMoveStringLiteralDfa8_0(active0, 0x8000000000L); 947 948 case 101: 949 if ((active0 & 0x400000L) != 0L) { 950 return jjStartNfaWithStates_0(7, 22, 32); 951 } else if ((active0 & 0x2000000000000000L) != 0L) { 952 return jjStartNfaWithStates_0(7, 61, 32); 953 } 954 return jjMoveStringLiteralDfa8_0(active0, 0x402000000000L); 955 956 case 110: 957 return jjMoveStringLiteralDfa8_0(active0, 0x220000800000000L); 958 959 case 112: 960 if ((active0 & 0x8000000000000000L) != 0L) { 961 return jjStartNfaWithStates_0(7, 63, 32); 962 } 963 break; 964 965 case 116: 966 if ((active0 & 0x2000L) != 0L) { 967 return jjStartNfaWithStates_0(7, 13, 32); 968 } 969 break; 970 971 default: 972 break; 973 } 974 return jjStartNfa_0(6, active0, 0L); 975 } 976 977 static private final int jjMoveStringLiteralDfa8_0(long old0, long active0) { 978 if (((active0 &= old0)) == 0L) { 979 return jjStartNfa_0(6, old0, 0L); 980 } 981 try { 982 curChar = input_stream.readChar(); 983 } catch (java.io.IOException e) { 984 jjStopStringLiteralDfa_0(7, active0, 0L); 985 return 8; 986 } 987 switch (curChar) { 988 case 100: 989 if ((active0 & 0x400000000000L) != 0L) { 990 return jjStartNfaWithStates_0(8, 46, 32); 991 } 992 break; 993 994 case 101: 995 if ((active0 & 0x8000000000L) != 0L) { 996 return jjStartNfaWithStates_0(8, 39, 32); 997 } 998 break; 999 1000 case 105: 1001 return jjMoveStringLiteralDfa9_0(active0, 0x20000000000000L); 1002 1003 case 111: 1004 return jjMoveStringLiteralDfa9_0(active0, 0x2000000000L); 1005 1006 case 116: 1007 if ((active0 & 0x200000000000000L) != 0L) { 1008 return jjStartNfaWithStates_0(8, 57, 32); 1009 } 1010 return jjMoveStringLiteralDfa9_0(active0, 0x800000000L); 1011 1012 default: 1013 break; 1014 } 1015 return jjStartNfa_0(7, active0, 0L); 1016 } 1017 1018 static private final int jjMoveStringLiteralDfa9_0(long old0, long active0) { 1019 if (((active0 &= old0)) == 0L) { 1020 return jjStartNfa_0(7, old0, 0L); 1021 } 1022 try { 1023 curChar = input_stream.readChar(); 1024 } catch (java.io.IOException e) { 1025 jjStopStringLiteralDfa_0(8, active0, 0L); 1026 return 9; 1027 } 1028 switch (curChar) { 1029 case 102: 1030 if ((active0 & 0x2000000000L) != 0L) { 1031 return jjStartNfaWithStates_0(9, 37, 32); 1032 } 1033 break; 1034 1035 case 115: 1036 if ((active0 & 0x800000000L) != 0L) { 1037 return jjStartNfaWithStates_0(9, 35, 32); 1038 } 1039 break; 1040 1041 case 122: 1042 return jjMoveStringLiteralDfa10_0(active0, 0x20000000000000L); 1043 1044 default: 1045 break; 1046 } 1047 return jjStartNfa_0(8, active0, 0L); 1048 } 1049 1050 static private final int jjMoveStringLiteralDfa10_0(long old0, long active0) { 1051 if (((active0 &= old0)) == 0L) { 1052 return jjStartNfa_0(8, old0, 0L); 1053 } 1054 try { 1055 curChar = input_stream.readChar(); 1056 } catch (java.io.IOException e) { 1057 jjStopStringLiteralDfa_0(9, active0, 0L); 1058 return 10; 1059 } 1060 switch (curChar) { 1061 case 101: 1062 return jjMoveStringLiteralDfa11_0(active0, 0x20000000000000L); 1063 1064 default: 1065 break; 1066 } 1067 return jjStartNfa_0(9, active0, 0L); 1068 } 1069 1070 static private final int jjMoveStringLiteralDfa11_0(long old0, long active0) { 1071 if (((active0 &= old0)) == 0L) { 1072 return jjStartNfa_0(9, old0, 0L); 1073 } 1074 try { 1075 curChar = input_stream.readChar(); 1076 } catch (java.io.IOException e) { 1077 jjStopStringLiteralDfa_0(10, active0, 0L); 1078 return 11; 1079 } 1080 switch (curChar) { 1081 case 100: 1082 if ((active0 & 0x20000000000000L) != 0L) { 1083 return jjStartNfaWithStates_0(11, 53, 32); 1084 } 1085 break; 1086 1087 default: 1088 break; 1089 } 1090 return jjStartNfa_0(10, active0, 0L); 1091 } 1092 1093 static private final void jjCheckNAdd(int state) { 1094 if (jjrounds[state] != jjround) { 1095 jjstateSet[jjnewStateCnt++] = state; 1096 jjrounds[state] = jjround; 1097 } 1098 } 1099 1100 static private final void jjAddStates(int start, int end) { 1101 do { 1102 jjstateSet[jjnewStateCnt++] = jjnextStates[start]; 1103 } while (start++ != end); 1104 } 1105 1106 static private final void jjCheckNAddTwoStates(int state1, int state2) { 1107 jjCheckNAdd(state1); 1108 jjCheckNAdd(state2); 1109 } 1110 1111 static private final void jjCheckNAddStates(int start, int end) { 1112 do { 1113 jjCheckNAdd(jjnextStates[start]); 1114 } while (start++ != end); 1115 } 1116 1117 static private final void jjCheckNAddStates(int start) { 1118 jjCheckNAdd(jjnextStates[start]); 1119 jjCheckNAdd(jjnextStates[start + 1]); 1120 } 1121 static final long[] jjbitVec0 = { 1122 0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 1123 0xffffffffffffffffL 1124 }; 1125 static final long[] jjbitVec2 = { 1126 0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL 1127 }; 1128 static final long[] jjbitVec3 = { 1129 0x1ff00000fffffffeL, 0xffffffffffffc000L, 0xffffffffL, 1130 0x600000000000000L 1131 }; 1132 static final long[] jjbitVec4 = { 1133 0x0L, 0x0L, 0x0L, 0xff7fffffff7fffffL 1134 }; 1135 static final long[] jjbitVec5 = { 1136 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL 1137 }; 1138 static final long[] jjbitVec6 = { 1139 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffL, 0x0L 1140 }; 1141 static final long[] jjbitVec7 = { 1142 0xffffffffffffffffL, 0xffffffffffffffffL, 0x0L, 0x0L 1143 }; 1144 static final long[] jjbitVec8 = { 1145 0x3fffffffffffL, 0x0L, 0x0L, 0x0L 1146 }; 1147 static private final int jjMoveNfa_0(int startState, int curPos) { 1148 int[] nextStates; 1149 int startsAt = 0; 1150 1151 jjnewStateCnt = 52; 1152 int i = 1; 1153 1154 jjstateSet[0] = startState; 1155 int j, kind = 0x7fffffff; 1156 1157 for (;;) { 1158 if (++jjround == 0x7fffffff) { 1159 ReInitRounds(); 1160 } 1161 if (curChar < 64) { 1162 long l = 1L << curChar; 1163 1164 MatchLoop: 1165 do { 1166 switch (jjstateSet[--i]) { 1167 case 3: 1168 if ((0x3ff000000000000L & l) != 0L) { 1169 jjCheckNAddStates(0, 6); 1170 } else if (curChar == 36) { 1171 if (kind > 72) { 1172 kind = 72; 1173 } 1174 jjCheckNAdd(32); 1175 } else if (curChar == 34) { 1176 jjCheckNAddStates(7, 9); 1177 } else if (curChar == 39) { 1178 jjAddStates(10, 11); 1179 } else if (curChar == 46) { 1180 jjCheckNAdd(8); 1181 } else if (curChar == 47) { 1182 jjstateSet[jjnewStateCnt++] = 2; 1183 } 1184 if ((0x3fe000000000000L & l) != 0L) { 1185 if (kind > 64) { 1186 kind = 64; 1187 } 1188 jjCheckNAddTwoStates(5, 6); 1189 } else if (curChar == 48) { 1190 if (kind > 64) { 1191 kind = 64; 1192 } 1193 jjCheckNAddStates(12, 14); 1194 } 1195 break; 1196 1197 case 0: 1198 if (curChar == 42) { 1199 jjstateSet[jjnewStateCnt++] = 1; 1200 } 1201 break; 1202 1203 case 1: 1204 if ((0xffff7fffffffffffL & l) != 0L && kind > 7) { 1205 kind = 7; 1206 } 1207 break; 1208 1209 case 2: 1210 if (curChar == 42) { 1211 jjstateSet[jjnewStateCnt++] = 0; 1212 } 1213 break; 1214 1215 case 4: 1216 if ((0x3fe000000000000L & l) == 0L) { 1217 break; 1218 } 1219 if (kind > 64) { 1220 kind = 64; 1221 } 1222 jjCheckNAddTwoStates(5, 6); 1223 break; 1224 1225 case 5: 1226 if ((0x3ff000000000000L & l) == 0L) { 1227 break; 1228 } 1229 if (kind > 64) { 1230 kind = 64; 1231 } 1232 jjCheckNAddTwoStates(5, 6); 1233 break; 1234 1235 case 7: 1236 if (curChar == 46) { 1237 jjCheckNAdd(8); 1238 } 1239 break; 1240 1241 case 8: 1242 if ((0x3ff000000000000L & l) == 0L) { 1243 break; 1244 } 1245 if (kind > 68) { 1246 kind = 68; 1247 } 1248 jjCheckNAddStates(15, 17); 1249 break; 1250 1251 case 10: 1252 if ((0x280000000000L & l) != 0L) { 1253 jjCheckNAdd(11); 1254 } 1255 break; 1256 1257 case 11: 1258 if ((0x3ff000000000000L & l) == 0L) { 1259 break; 1260 } 1261 if (kind > 68) { 1262 kind = 68; 1263 } 1264 jjCheckNAddTwoStates(11, 12); 1265 break; 1266 1267 case 13: 1268 if (curChar == 39) { 1269 jjAddStates(10, 11); 1270 } 1271 break; 1272 1273 case 14: 1274 if ((0xffffff7fffffdbffL & l) != 0L) { 1275 jjCheckNAdd(15); 1276 } 1277 break; 1278 1279 case 15: 1280 if (curChar == 39 && kind > 70) { 1281 kind = 70; 1282 } 1283 break; 1284 1285 case 17: 1286 if ((0x8400000000L & l) != 0L) { 1287 jjCheckNAdd(15); 1288 } 1289 break; 1290 1291 case 18: 1292 if ((0xff000000000000L & l) != 0L) { 1293 jjCheckNAddTwoStates(19, 15); 1294 } 1295 break; 1296 1297 case 19: 1298 if ((0xff000000000000L & l) != 0L) { 1299 jjCheckNAdd(15); 1300 } 1301 break; 1302 1303 case 20: 1304 if ((0xf000000000000L & l) != 0L) { 1305 jjstateSet[jjnewStateCnt++] = 21; 1306 } 1307 break; 1308 1309 case 21: 1310 if ((0xff000000000000L & l) != 0L) { 1311 jjCheckNAdd(19); 1312 } 1313 break; 1314 1315 case 22: 1316 if (curChar == 34) { 1317 jjCheckNAddStates(7, 9); 1318 } 1319 break; 1320 1321 case 23: 1322 if ((0xfffffffbffffdbffL & l) != 0L) { 1323 jjCheckNAddStates(7, 9); 1324 } 1325 break; 1326 1327 case 25: 1328 if ((0x8400000000L & l) != 0L) { 1329 jjCheckNAddStates(7, 9); 1330 } 1331 break; 1332 1333 case 26: 1334 if (curChar == 34 && kind > 71) { 1335 kind = 71; 1336 } 1337 break; 1338 1339 case 27: 1340 if ((0xff000000000000L & l) != 0L) { 1341 jjCheckNAddStates(18, 21); 1342 } 1343 break; 1344 1345 case 28: 1346 if ((0xff000000000000L & l) != 0L) { 1347 jjCheckNAddStates(7, 9); 1348 } 1349 break; 1350 1351 case 29: 1352 if ((0xf000000000000L & l) != 0L) { 1353 jjstateSet[jjnewStateCnt++] = 30; 1354 } 1355 break; 1356 1357 case 30: 1358 if ((0xff000000000000L & l) != 0L) { 1359 jjCheckNAdd(28); 1360 } 1361 break; 1362 1363 case 31: 1364 if (curChar != 36) { 1365 break; 1366 } 1367 if (kind > 72) { 1368 kind = 72; 1369 } 1370 jjCheckNAdd(32); 1371 break; 1372 1373 case 32: 1374 if ((0x3ff001000000000L & l) == 0L) { 1375 break; 1376 } 1377 if (kind > 72) { 1378 kind = 72; 1379 } 1380 jjCheckNAdd(32); 1381 break; 1382 1383 case 33: 1384 if ((0x3ff000000000000L & l) != 0L) { 1385 jjCheckNAddStates(0, 6); 1386 } 1387 break; 1388 1389 case 34: 1390 if ((0x3ff000000000000L & l) != 0L) { 1391 jjCheckNAddTwoStates(34, 35); 1392 } 1393 break; 1394 1395 case 35: 1396 if (curChar != 46) { 1397 break; 1398 } 1399 if (kind > 68) { 1400 kind = 68; 1401 } 1402 jjCheckNAddStates(22, 24); 1403 break; 1404 1405 case 36: 1406 if ((0x3ff000000000000L & l) == 0L) { 1407 break; 1408 } 1409 if (kind > 68) { 1410 kind = 68; 1411 } 1412 jjCheckNAddStates(22, 24); 1413 break; 1414 1415 case 38: 1416 if ((0x280000000000L & l) != 0L) { 1417 jjCheckNAdd(39); 1418 } 1419 break; 1420 1421 case 39: 1422 if ((0x3ff000000000000L & l) == 0L) { 1423 break; 1424 } 1425 if (kind > 68) { 1426 kind = 68; 1427 } 1428 jjCheckNAddTwoStates(39, 12); 1429 break; 1430 1431 case 40: 1432 if ((0x3ff000000000000L & l) != 0L) { 1433 jjCheckNAddTwoStates(40, 41); 1434 } 1435 break; 1436 1437 case 42: 1438 if ((0x280000000000L & l) != 0L) { 1439 jjCheckNAdd(43); 1440 } 1441 break; 1442 1443 case 43: 1444 if ((0x3ff000000000000L & l) == 0L) { 1445 break; 1446 } 1447 if (kind > 68) { 1448 kind = 68; 1449 } 1450 jjCheckNAddTwoStates(43, 12); 1451 break; 1452 1453 case 44: 1454 if ((0x3ff000000000000L & l) != 0L) { 1455 jjCheckNAddStates(25, 27); 1456 } 1457 break; 1458 1459 case 46: 1460 if ((0x280000000000L & l) != 0L) { 1461 jjCheckNAdd(47); 1462 } 1463 break; 1464 1465 case 47: 1466 if ((0x3ff000000000000L & l) != 0L) { 1467 jjCheckNAddTwoStates(47, 12); 1468 } 1469 break; 1470 1471 case 48: 1472 if (curChar != 48) { 1473 break; 1474 } 1475 if (kind > 64) { 1476 kind = 64; 1477 } 1478 jjCheckNAddStates(12, 14); 1479 break; 1480 1481 case 50: 1482 if ((0x3ff000000000000L & l) == 0L) { 1483 break; 1484 } 1485 if (kind > 64) { 1486 kind = 64; 1487 } 1488 jjCheckNAddTwoStates(50, 6); 1489 break; 1490 1491 case 51: 1492 if ((0xff000000000000L & l) == 0L) { 1493 break; 1494 } 1495 if (kind > 64) { 1496 kind = 64; 1497 } 1498 jjCheckNAddTwoStates(51, 6); 1499 break; 1500 1501 default: 1502 break; 1503 } 1504 } while (i != startsAt); 1505 } else if (curChar < 128) { 1506 long l = 1L << (curChar & 077); 1507 1508 MatchLoop: 1509 do { 1510 switch (jjstateSet[--i]) { 1511 case 3: 1512 case 32: 1513 if ((0x7fffffe87fffffeL & l) == 0L) { 1514 break; 1515 } 1516 if (kind > 72) { 1517 kind = 72; 1518 } 1519 jjCheckNAdd(32); 1520 break; 1521 1522 case 1: 1523 if (kind > 7) { 1524 kind = 7; 1525 } 1526 break; 1527 1528 case 6: 1529 if ((0x100000001000L & l) != 0L && kind > 64) { 1530 kind = 64; 1531 } 1532 break; 1533 1534 case 9: 1535 if ((0x2000000020L & l) != 0L) { 1536 jjAddStates(28, 29); 1537 } 1538 break; 1539 1540 case 12: 1541 if ((0x5000000050L & l) != 0L && kind > 68) { 1542 kind = 68; 1543 } 1544 break; 1545 1546 case 14: 1547 if ((0xffffffffefffffffL & l) != 0L) { 1548 jjCheckNAdd(15); 1549 } 1550 break; 1551 1552 case 16: 1553 if (curChar == 92) { 1554 jjAddStates(30, 32); 1555 } 1556 break; 1557 1558 case 17: 1559 if ((0x14404410000000L & l) != 0L) { 1560 jjCheckNAdd(15); 1561 } 1562 break; 1563 1564 case 23: 1565 if ((0xffffffffefffffffL & l) != 0L) { 1566 jjCheckNAddStates(7, 9); 1567 } 1568 break; 1569 1570 case 24: 1571 if (curChar == 92) { 1572 jjAddStates(33, 35); 1573 } 1574 break; 1575 1576 case 25: 1577 if ((0x14404410000000L & l) != 0L) { 1578 jjCheckNAddStates(7, 9); 1579 } 1580 break; 1581 1582 case 37: 1583 if ((0x2000000020L & l) != 0L) { 1584 jjAddStates(36, 37); 1585 } 1586 break; 1587 1588 case 41: 1589 if ((0x2000000020L & l) != 0L) { 1590 jjAddStates(38, 39); 1591 } 1592 break; 1593 1594 case 45: 1595 if ((0x2000000020L & l) != 0L) { 1596 jjAddStates(40, 41); 1597 } 1598 break; 1599 1600 case 49: 1601 if ((0x100000001000000L & l) != 0L) { 1602 jjCheckNAdd(50); 1603 } 1604 break; 1605 1606 case 50: 1607 if ((0x7e0000007eL & l) == 0L) { 1608 break; 1609 } 1610 if (kind > 64) { 1611 kind = 64; 1612 } 1613 jjCheckNAddTwoStates(50, 6); 1614 break; 1615 1616 default: 1617 break; 1618 } 1619 } while (i != startsAt); 1620 } else { 1621 int hiByte = (int) (curChar >> 8); 1622 int i1 = hiByte >> 6; 1623 long l1 = 1L << (hiByte & 077); 1624 int i2 = (curChar & 0xff) >> 6; 1625 long l2 = 1L << (curChar & 077); 1626 1627 MatchLoop: 1628 do { 1629 switch (jjstateSet[--i]) { 1630 case 3: 1631 case 32: 1632 if (!jjCanMove_1(hiByte, i1, i2, l1, l2)) { 1633 break; 1634 } 1635 if (kind > 72) { 1636 kind = 72; 1637 } 1638 jjCheckNAdd(32); 1639 break; 1640 1641 case 1: 1642 if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 7) { 1643 kind = 7; 1644 } 1645 break; 1646 1647 case 14: 1648 if (jjCanMove_0(hiByte, i1, i2, l1, l2)) { 1649 jjstateSet[jjnewStateCnt++] = 15; 1650 } 1651 break; 1652 1653 case 23: 1654 if (jjCanMove_0(hiByte, i1, i2, l1, l2)) { 1655 jjAddStates(7, 9); 1656 } 1657 break; 1658 1659 default: 1660 break; 1661 } 1662 } while (i != startsAt); 1663 } 1664 if (kind != 0x7fffffff) { 1665 jjmatchedKind = kind; 1666 jjmatchedPos = curPos; 1667 kind = 0x7fffffff; 1668 } 1669 ++curPos; 1670 if ((i = jjnewStateCnt) 1671 == (startsAt = 52 - (jjnewStateCnt = startsAt))) { 1672 return curPos; 1673 } 1674 try { 1675 curChar = input_stream.readChar(); 1676 } catch (java.io.IOException e) { 1677 return curPos; 1678 } 1679 } 1680 } 1681 1682 static private final int jjMoveStringLiteralDfa0_3() { 1683 switch (curChar) { 1684 case 42: 1685 return jjMoveStringLiteralDfa1_3(0x800L); 1686 1687 default: 1688 return 1; 1689 } 1690 } 1691 1692 static private final int jjMoveStringLiteralDfa1_3(long active0) { 1693 try { 1694 curChar = input_stream.readChar(); 1695 } catch (java.io.IOException e) { 1696 return 1; 1697 } 1698 switch (curChar) { 1699 case 47: 1700 if ((active0 & 0x800L) != 0L) { 1701 return jjStopAtPos(1, 11); 1702 } 1703 break; 1704 1705 default: 1706 return 2; 1707 } 1708 return 2; 1709 } 1710 1711 static private final int jjMoveStringLiteralDfa0_1() { 1712 return jjMoveNfa_1(0, 0); 1713 } 1714 1715 static private final int jjMoveNfa_1(int startState, int curPos) { 1716 int[] nextStates; 1717 int startsAt = 0; 1718 1719 jjnewStateCnt = 3; 1720 int i = 1; 1721 1722 jjstateSet[0] = startState; 1723 int j, kind = 0x7fffffff; 1724 1725 for (;;) { 1726 if (++jjround == 0x7fffffff) { 1727 ReInitRounds(); 1728 } 1729 if (curChar < 64) { 1730 long l = 1L << curChar; 1731 1732 MatchLoop: 1733 do { 1734 switch (jjstateSet[--i]) { 1735 case 0: 1736 if ((0x2400L & l) != 0L) { 1737 if (kind > 9) { 1738 kind = 9; 1739 } 1740 } 1741 if (curChar == 13) { 1742 jjstateSet[jjnewStateCnt++] = 1; 1743 } 1744 break; 1745 1746 case 1: 1747 if (curChar == 10 && kind > 9) { 1748 kind = 9; 1749 } 1750 break; 1751 1752 case 2: 1753 if (curChar == 13) { 1754 jjstateSet[jjnewStateCnt++] = 1; 1755 } 1756 break; 1757 1758 default: 1759 break; 1760 } 1761 } while (i != startsAt); 1762 } else if (curChar < 128) { 1763 long l = 1L << (curChar & 077); 1764 1765 MatchLoop: 1766 do { 1767 switch (jjstateSet[--i]) { 1768 default: 1769 break; 1770 } 1771 } while (i != startsAt); 1772 } else { 1773 int hiByte = (int) (curChar >> 8); 1774 int i1 = hiByte >> 6; 1775 long l1 = 1L << (hiByte & 077); 1776 int i2 = (curChar & 0xff) >> 6; 1777 long l2 = 1L << (curChar & 077); 1778 1779 MatchLoop: 1780 do { 1781 switch (jjstateSet[--i]) { 1782 default: 1783 break; 1784 } 1785 } while (i != startsAt); 1786 } 1787 if (kind != 0x7fffffff) { 1788 jjmatchedKind = kind; 1789 jjmatchedPos = curPos; 1790 kind = 0x7fffffff; 1791 } 1792 ++curPos; 1793 if ((i = jjnewStateCnt) 1794 == (startsAt = 3 - (jjnewStateCnt = startsAt))) { 1795 return curPos; 1796 } 1797 try { 1798 curChar = input_stream.readChar(); 1799 } catch (java.io.IOException e) { 1800 return curPos; 1801 } 1802 } 1803 } 1804 1805 static private final int jjMoveStringLiteralDfa0_2() { 1806 switch (curChar) { 1807 case 42: 1808 return jjMoveStringLiteralDfa1_2(0x400L); 1809 1810 default: 1811 return 1; 1812 } 1813 } 1814 1815 static private final int jjMoveStringLiteralDfa1_2(long active0) { 1816 try { 1817 curChar = input_stream.readChar(); 1818 } catch (java.io.IOException e) { 1819 return 1; 1820 } 1821 switch (curChar) { 1822 case 47: 1823 if ((active0 & 0x400L) != 0L) { 1824 return jjStopAtPos(1, 10); 1825 } 1826 break; 1827 1828 default: 1829 return 2; 1830 } 1831 return 2; 1832 } 1833 static final int[] jjnextStates = { 1834 34, 35, 40, 41, 44, 45, 12, 23, 24, 26, 14, 16, 49, 51, 6, 8, 9, 12, 23, 1835 24, 28, 26, 36, 37, 12, 44, 45, 12, 10, 11, 17, 18, 20, 25, 27, 29, 38, 1836 39, 42, 43, 46, 47, 1837 }; 1838 private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2) { 1839 switch (hiByte) { 1840 case 0: 1841 return ((jjbitVec2[i2] & l2) != 0L); 1842 1843 default: 1844 if ((jjbitVec0[i1] & l1) != 0L) { 1845 return true; 1846 } 1847 return false; 1848 } 1849 } 1850 1851 private static final boolean jjCanMove_1(int hiByte, int i1, int i2, long l1, long l2) { 1852 switch (hiByte) { 1853 case 0: 1854 return ((jjbitVec4[i2] & l2) != 0L); 1855 1856 case 48: 1857 return ((jjbitVec5[i2] & l2) != 0L); 1858 1859 case 49: 1860 return ((jjbitVec6[i2] & l2) != 0L); 1861 1862 case 51: 1863 return ((jjbitVec7[i2] & l2) != 0L); 1864 1865 case 61: 1866 return ((jjbitVec8[i2] & l2) != 0L); 1867 1868 default: 1869 if ((jjbitVec3[i1] & l1) != 0L) { 1870 return true; 1871 } 1872 return false; 1873 } 1874 } 1875 public static final String [] jjstrLiteralImages = { 1876 "", null, null, null, null, null, null, null, null, null, null, null, 1877 null, "\141\142\163\164\162\141\143\164", "\142\157\157\154\145\141\156", 1878 "\142\162\145\141\153", "\142\171\164\145", "\143\141\163\145", 1879 "\143\141\164\143\150", "\143\150\141\162", "\143\154\141\163\163", 1880 "\143\157\156\163\164", "\143\157\156\164\151\156\165\145", 1881 "\144\145\146\141\165\154\164", "\144\157", "\144\157\165\142\154\145", 1882 "\145\154\163\145", "\145\170\164\145\156\144\163", 1883 "\146\141\154\163\145", "\146\151\156\141\154", 1884 "\146\151\156\141\154\154\171", "\146\154\157\141\164", "\146\157\162", 1885 "\147\157\164\157", "\151\146", 1886 "\151\155\160\154\145\155\145\156\164\163", "\151\155\160\157\162\164", 1887 "\151\156\163\164\141\156\143\145\157\146", "\151\156\164", 1888 "\151\156\164\145\162\146\141\143\145", "\154\157\156\147", 1889 "\156\141\164\151\166\145", "\156\145\167", "\156\165\154\154", 1890 "\160\141\143\153\141\147\145", "\160\162\151\166\141\164\145", 1891 "\160\162\157\164\145\143\164\145\144", "\160\165\142\154\151\143", 1892 "\162\145\164\165\162\156", "\163\150\157\162\164", 1893 "\163\164\141\164\151\143", "\163\165\160\145\162", 1894 "\163\167\151\164\143\150", 1895 "\163\171\156\143\150\162\157\156\151\172\145\144", "\164\150\151\163", 1896 "\164\150\162\157\167", "\164\150\162\157\167\163", 1897 "\164\162\141\156\163\151\145\156\164", "\164\162\165\145", 1898 "\164\162\171", "\166\157\151\144", "\166\157\154\141\164\151\154\145", 1899 "\167\150\151\154\145", "\163\164\162\151\143\164\146\160", null, null, 1900 null, null, null, null, null, null, null, null, null, "\50", "\51", 1901 "\173", "\175", "\133", "\135", "\73", "\54", "\56", "\75", "\76", "\74", 1902 "\41", "\176", "\77", "\72", "\75\75", "\74\75", "\76\75", "\41\75", 1903 "\174\174", "\46\46", "\53\53", "\55\55", "\53", "\55", "\52", "\57", 1904 "\46", "\174", "\136", "\45", "\74\74", "\76\76", "\76\76\76", "\53\75", 1905 "\55\75", "\52\75", "\57\75", "\46\75", "\174\75", "\136\75", "\45\75", 1906 "\74\74\75", "\76\76\75", "\76\76\76\75", }; 1907 public static final String [] lexStateNames = { 1908 "DEFAULT", "IN_SINGLE_LINE_COMMENT", "IN_FORMAL_COMMENT", 1909 "IN_MULTI_LINE_COMMENT", 1910 }; 1911 public static final int[] jjnewLexState = { 1912 -1, -1, -1, -1, -1, -1, 1, 2, 3, 0, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, 1913 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1914 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1915 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1916 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1917 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1918 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1919 }; 1920 static final long[] jjtoToken = { 1921 0xffffffffffffe001L, 0x1fffffffffff9d1L, 1922 }; 1923 static final long[] jjtoSkip = { 1924 0xe3eL, 0x0L, 1925 }; 1926 static final long[] jjtoSpecial = { 1927 0xe3eL, 0x0L, 1928 }; 1929 static final long[] jjtoMore = { 1930 0x11c0L, 0x0L, 1931 }; 1932 static private JavaCharStream input_stream; 1933 static private final int[] jjrounds = new int[52]; 1934 static private final int[] jjstateSet = new int[104]; 1935 static StringBuffer image; 1936 static int jjimageLen; 1937 static int lengthOfMatch; 1938 static protected char curChar; 1939 public JavaParserTokenManager(JavaCharStream stream) { 1940 if (input_stream != null) { 1941 throw new TokenMgrError("ERROR: Second call to constructor of static lexer. You must use ReInit() to initialize the static variables.", 1942 TokenMgrError.STATIC_LEXER_ERROR); 1943 } 1944 input_stream = stream; 1945 } 1946 1947 public JavaParserTokenManager(JavaCharStream stream, int lexState) { 1948 this(stream); 1949 SwitchTo(lexState); 1950 } 1951 1952 static public void ReInit(JavaCharStream stream) { 1953 jjmatchedPos = jjnewStateCnt = 0; 1954 curLexState = defaultLexState; 1955 input_stream = stream; 1956 ReInitRounds(); 1957 } 1958 1959 static private final void ReInitRounds() { 1960 int i; 1961 1962 jjround = 0x80000001; 1963 for (i = 52; i-- > 0;) { 1964 jjrounds[i] = 0x80000000; 1965 } 1966 } 1967 1968 static public void ReInit(JavaCharStream stream, int lexState) { 1969 ReInit(stream); 1970 SwitchTo(lexState); 1971 } 1972 1973 static public void SwitchTo(int lexState) { 1974 if (lexState >= 4 || lexState < 0) { 1975 throw new TokenMgrError("Error: Ignoring invalid lexical state : " 1976 + lexState + ". State unchanged.", 1977 TokenMgrError.INVALID_LEXICAL_STATE); 1978 } else { 1979 curLexState = lexState; 1980 } 1981 } 1982 1983 static private final Token jjFillToken() { 1984 Token t = Token.newToken(jjmatchedKind); 1985 1986 t.kind = jjmatchedKind; 1987 String im = jjstrLiteralImages[jjmatchedKind]; 1988 1989 t.image = (im == null) ? input_stream.GetImage() : im; 1990 t.beginLine = input_stream.getBeginLine(); 1991 t.beginColumn = input_stream.getBeginColumn(); 1992 t.endLine = input_stream.getEndLine(); 1993 t.endColumn = input_stream.getEndColumn(); 1994 return t; 1995 } 1996 static int curLexState = 0; 1997 static int defaultLexState = 0; 1998 static int jjnewStateCnt; 1999 static int jjround; 2000 static int jjmatchedPos; 2001 static int jjmatchedKind; 2002 public static final Token getNextToken() { 2003 int kind; 2004 Token specialToken = null; 2005 Token matchedToken; 2006 int curPos = 0; 2007 2008 EOFLoop: 2009 for (;;) { 2010 try { 2011 curChar = input_stream.BeginToken(); 2012 } catch (java.io.IOException e) { 2013 jjmatchedKind = 0; 2014 matchedToken = jjFillToken(); 2015 matchedToken.specialToken = specialToken; 2016 return matchedToken; 2017 } 2018 image = null; 2019 jjimageLen = 0; 2020 for (;;) { 2021 switch (curLexState) { 2022 case 0: 2023 jjmatchedKind = 0x7fffffff; 2024 jjmatchedPos = 0; 2025 curPos = jjMoveStringLiteralDfa0_0(); 2026 break; 2027 2028 case 1: 2029 jjmatchedKind = 0x7fffffff; 2030 jjmatchedPos = 0; 2031 curPos = jjMoveStringLiteralDfa0_1(); 2032 if (jjmatchedPos == 0 && jjmatchedKind > 12) { 2033 jjmatchedKind = 12; 2034 } 2035 break; 2036 2037 case 2: 2038 jjmatchedKind = 0x7fffffff; 2039 jjmatchedPos = 0; 2040 curPos = jjMoveStringLiteralDfa0_2(); 2041 if (jjmatchedPos == 0 && jjmatchedKind > 12) { 2042 jjmatchedKind = 12; 2043 } 2044 break; 2045 2046 case 3: 2047 jjmatchedKind = 0x7fffffff; 2048 jjmatchedPos = 0; 2049 curPos = jjMoveStringLiteralDfa0_3(); 2050 if (jjmatchedPos == 0 && jjmatchedKind > 12) { 2051 jjmatchedKind = 12; 2052 } 2053 break; 2054 } 2055 if (jjmatchedKind != 0x7fffffff) { 2056 if (jjmatchedPos + 1 < curPos) { 2057 input_stream.backup(curPos - jjmatchedPos - 1); 2058 } 2059 if ((jjtoToken[jjmatchedKind >> 6] 2060 & (1L << (jjmatchedKind & 077))) 2061 != 0L) { 2062 matchedToken = jjFillToken(); 2063 matchedToken.specialToken = specialToken; 2064 if (jjnewLexState[jjmatchedKind] != -1) { 2065 curLexState = jjnewLexState[jjmatchedKind]; 2066 } 2067 return matchedToken; 2068 } else if ((jjtoSkip[jjmatchedKind >> 6] 2069 & (1L << (jjmatchedKind & 077))) 2070 != 0L) { 2071 if ((jjtoSpecial[jjmatchedKind >> 6] 2072 & (1L << (jjmatchedKind & 077))) 2073 != 0L) { 2074 matchedToken = jjFillToken(); 2075 if (specialToken == null) { 2076 specialToken = matchedToken; 2077 } else { 2078 matchedToken.specialToken = specialToken; 2079 specialToken = (specialToken.next = matchedToken); 2080 } 2081 SkipLexicalActions(matchedToken); 2082 } else { 2083 SkipLexicalActions(null); 2084 } 2085 if (jjnewLexState[jjmatchedKind] != -1) { 2086 curLexState = jjnewLexState[jjmatchedKind]; 2087 } 2088 continue EOFLoop; 2089 } 2090 MoreLexicalActions(); 2091 if (jjnewLexState[jjmatchedKind] != -1) { 2092 curLexState = jjnewLexState[jjmatchedKind]; 2093 } 2094 curPos = 0; 2095 jjmatchedKind = 0x7fffffff; 2096 try { 2097 curChar = input_stream.readChar(); 2098 continue; 2099 } catch (java.io.IOException e1) {} 2100 } 2101 int error_line = input_stream.getEndLine(); 2102 int error_column = input_stream.getEndColumn(); 2103 String error_after = null; 2104 boolean EOFSeen = false; 2105 2106 try { 2107 input_stream.readChar(); 2108 input_stream.backup(1); 2109 } catch (java.io.IOException e1) { 2110 EOFSeen = true; 2111 error_after = curPos <= 1 ? "" : input_stream.GetImage(); 2112 if (curChar == '\n' || curChar == '\r') { 2113 error_line++; 2114 error_column = 0; 2115 } else { 2116 error_column++; 2117 } 2118 } 2119 if (!EOFSeen) { 2120 input_stream.backup(1); 2121 error_after = curPos <= 1 ? "" : input_stream.GetImage(); 2122 } 2123 throw new TokenMgrError(EOFSeen, curLexState, error_line, 2124 error_column, error_after, curChar, 2125 TokenMgrError.LEXICAL_ERROR); 2126 } 2127 } 2128 } 2129 2130 static final void SkipLexicalActions(Token matchedToken) { 2131 switch (jjmatchedKind) { 2132 default: 2133 break; 2134 } 2135 } 2136 2137 static final void MoreLexicalActions() { 2138 jjimageLen += (lengthOfMatch = jjmatchedPos + 1); 2139 switch (jjmatchedKind) { 2140 case 7: 2141 if (image == null) { 2142 image = new StringBuffer (new String (input_stream.GetSuffix(jjimageLen))); 2143 } else { 2144 image.append(input_stream.GetSuffix(jjimageLen)); 2145 } 2146 jjimageLen = 0; 2147 input_stream.backup(1); 2148 break; 2149 2150 default: 2151 break; 2152 } 2153 } 2154} 2155
| Popular Tags
|