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_2(int pos, long active0) 015 { 016 switch (pos) 017 { 018 case 0: 019 if ((active0 & 0xd3a00L) != 0L) 020 { 021 jjmatchedKind = 54; 022 return 37; 023 } 024 if ((active0 & 0x8000000000000L) != 0L) 025 return 6; 026 if ((active0 & 0x10000000000000L) != 0L) 027 return 11; 028 if ((active0 & 0x24000L) != 0L) 029 { 030 jjmatchedKind = 54; 031 return 61; 032 } 033 if ((active0 & 0x8400L) != 0L) 034 { 035 jjmatchedKind = 54; 036 return 17; 037 } 038 if ((active0 & 0x4000000000L) != 0L) 039 { 040 jjmatchedKind = 46; 041 return 19; 042 } 043 if ((active0 & 0x82000000000L) != 0L) 044 return 15; 045 return -1; 046 case 1: 047 if ((active0 & 0x4000L) != 0L) 048 { 049 jjmatchedKind = 36; 050 jjmatchedPos = 1; 051 return 37; 052 } 053 if ((active0 & 0xfbc00L) != 0L) 054 { 055 jjmatchedKind = 54; 056 jjmatchedPos = 1; 057 return 37; 058 } 059 if ((active0 & 0x200L) != 0L) 060 return 37; 061 return -1; 062 case 2: 063 if ((active0 & 0x5800L) != 0L) 064 return 37; 065 if ((active0 & 0xfa400L) != 0L) 066 { 067 if (jjmatchedPos != 2) 068 { 069 jjmatchedKind = 54; 070 jjmatchedPos = 2; 071 } 072 return 37; 073 } 074 return -1; 075 case 3: 076 if ((active0 & 0x8b000L) != 0L) 077 { 078 jjmatchedKind = 54; 079 jjmatchedPos = 3; 080 return 37; 081 } 082 if ((active0 & 0x70400L) != 0L) 083 return 37; 084 return -1; 085 case 4: 086 if ((active0 & 0x1000L) != 0L) 087 { 088 jjmatchedKind = 54; 089 jjmatchedPos = 4; 090 return 37; 091 } 092 if ((active0 & 0x8a000L) != 0L) 093 return 37; 094 return -1; 095 case 5: 096 if ((active0 & 0x1000L) != 0L) 097 { 098 jjmatchedKind = 54; 099 jjmatchedPos = 5; 100 return 37; 101 } 102 return -1; 103 default : 104 return -1; 105 } 106 } 107 private final int jjStartNfa_2(int pos, long active0) 108 { 109 return jjMoveNfa_2(jjStopStringLiteralDfa_2(pos, active0), pos + 1); 110 } 111 private int jjStopAtPos(int pos, int kind) 112 { 113 jjmatchedKind = kind; 114 jjmatchedPos = pos; 115 return pos + 1; 116 } 117 private int jjMoveStringLiteralDfa0_2() 118 { 119 switch(curChar) 120 { 121 case 33: 122 return jjMoveStringLiteralDfa1_2(0x4000000000L); 123 case 38: 124 return jjStartNfaWithStates_2(0, 51, 6); 125 case 40: 126 return jjStopAtPos(0, 21); 127 case 41: 128 return jjStopAtPos(0, 22); 129 case 42: 130 return jjStopAtPos(0, 49); 131 case 43: 132 return jjStopAtPos(0, 47); 133 case 44: 134 return jjStopAtPos(0, 29); 135 case 45: 136 return jjStopAtPos(0, 48); 137 case 46: 138 return jjStopAtPos(0, 30); 139 case 58: 140 return jjStopAtPos(0, 28); 141 case 59: 142 return jjStopAtPos(0, 27); 143 case 61: 144 jjmatchedKind = 43; 145 return jjMoveStringLiteralDfa1_2(0x2000000000L); 146 case 63: 147 jjmatchedKind = 31; 148 return jjMoveStringLiteralDfa1_2(0x100000000L); 149 case 91: 150 return jjStopAtPos(0, 25); 151 case 93: 152 return jjStopAtPos(0, 26); 153 case 94: 154 return jjStopAtPos(0, 53); 155 case 101: 156 return jjMoveStringLiteralDfa1_2(0x8400L); 157 case 102: 158 return jjMoveStringLiteralDfa1_2(0x81800L); 159 case 105: 160 return jjMoveStringLiteralDfa1_2(0x200L); 161 case 110: 162 return jjMoveStringLiteralDfa1_2(0x24000L); 163 case 115: 164 return jjMoveStringLiteralDfa1_2(0x10000L); 165 case 116: 166 return jjMoveStringLiteralDfa1_2(0x40000L); 167 case 119: 168 return jjMoveStringLiteralDfa1_2(0x2000L); 169 case 123: 170 return jjStopAtPos(0, 23); 171 case 124: 172 return jjStartNfaWithStates_2(0, 52, 11); 173 case 125: 174 return jjStopAtPos(0, 24); 175 case 126: 176 return jjStopAtPos(0, 50); 177 default : 178 return jjMoveNfa_2(5, 0); 179 } 180 } 181 private int jjMoveStringLiteralDfa1_2(long active0) 182 { 183 try { curChar = input_stream.readChar(); } 184 catch(java.io.IOException e) { 185 jjStopStringLiteralDfa_2(0, active0); 186 return 1; 187 } 188 switch(curChar) 189 { 190 case 58: 191 if ((active0 & 0x100000000L) != 0L) 192 return jjStopAtPos(1, 32); 193 break; 194 case 97: 195 return jjMoveStringLiteralDfa2_2(active0, 0x80000L); 196 case 101: 197 return jjMoveStringLiteralDfa2_2(active0, 0x4000L); 198 case 102: 199 if ((active0 & 0x200L) != 0L) 200 return jjStartNfaWithStates_2(1, 9, 37); 201 break; 202 case 104: 203 return jjMoveStringLiteralDfa2_2(active0, 0x2000L); 204 case 105: 205 return jjMoveStringLiteralDfa2_2(active0, 0x10000L); 206 case 108: 207 return jjMoveStringLiteralDfa2_2(active0, 0x400L); 208 case 109: 209 return jjMoveStringLiteralDfa2_2(active0, 0x8000L); 210 case 111: 211 return jjMoveStringLiteralDfa2_2(active0, 0x1800L); 212 case 114: 213 return jjMoveStringLiteralDfa2_2(active0, 0x40000L); 214 case 117: 215 return jjMoveStringLiteralDfa2_2(active0, 0x20000L); 216 case 126: 217 if ((active0 & 0x2000000000L) != 0L) 218 return jjStopAtPos(1, 37); 219 else if ((active0 & 0x4000000000L) != 0L) 220 return jjStopAtPos(1, 38); 221 break; 222 default : 223 break; 224 } 225 return jjStartNfa_2(0, active0); 226 } 227 private int jjMoveStringLiteralDfa2_2(long old0, long active0) 228 { 229 if (((active0 &= old0)) == 0L) 230 return jjStartNfa_2(0, old0); 231 try { curChar = input_stream.readChar(); } 232 catch(java.io.IOException e) { 233 jjStopStringLiteralDfa_2(1, active0); 234 return 2; 235 } 236 switch(curChar) 237 { 238 case 105: 239 return jjMoveStringLiteralDfa3_2(active0, 0x2000L); 240 case 108: 241 return jjMoveStringLiteralDfa3_2(active0, 0xa0000L); 242 case 112: 243 return jjMoveStringLiteralDfa3_2(active0, 0x8000L); 244 case 114: 245 if ((active0 & 0x800L) != 0L) 246 { 247 jjmatchedKind = 11; 248 jjmatchedPos = 2; 249 } 250 return jjMoveStringLiteralDfa3_2(active0, 0x1000L); 251 case 115: 252 return jjMoveStringLiteralDfa3_2(active0, 0x400L); 253 case 117: 254 return jjMoveStringLiteralDfa3_2(active0, 0x40000L); 255 case 119: 256 if ((active0 & 0x4000L) != 0L) 257 return jjStartNfaWithStates_2(2, 14, 37); 258 break; 259 case 122: 260 return jjMoveStringLiteralDfa3_2(active0, 0x10000L); 261 default : 262 break; 263 } 264 return jjStartNfa_2(1, active0); 265 } 266 private int jjMoveStringLiteralDfa3_2(long old0, long active0) 267 { 268 if (((active0 &= old0)) == 0L) 269 return jjStartNfa_2(1, old0); 270 try { curChar = input_stream.readChar(); } 271 catch(java.io.IOException e) { 272 jjStopStringLiteralDfa_2(2, active0); 273 return 3; 274 } 275 switch(curChar) 276 { 277 case 101: 278 if ((active0 & 0x400L) != 0L) 279 return jjStartNfaWithStates_2(3, 10, 37); 280 else if ((active0 & 0x10000L) != 0L) 281 return jjStartNfaWithStates_2(3, 16, 37); 282 else if ((active0 & 0x40000L) != 0L) 283 return jjStartNfaWithStates_2(3, 18, 37); 284 return jjMoveStringLiteralDfa4_2(active0, 0x1000L); 285 case 108: 286 if ((active0 & 0x20000L) != 0L) 287 return jjStartNfaWithStates_2(3, 17, 37); 288 return jjMoveStringLiteralDfa4_2(active0, 0x2000L); 289 case 115: 290 return jjMoveStringLiteralDfa4_2(active0, 0x80000L); 291 case 116: 292 return jjMoveStringLiteralDfa4_2(active0, 0x8000L); 293 default : 294 break; 295 } 296 return jjStartNfa_2(2, active0); 297 } 298 private int jjMoveStringLiteralDfa4_2(long old0, long active0) 299 { 300 if (((active0 &= old0)) == 0L) 301 return jjStartNfa_2(2, old0); 302 try { curChar = input_stream.readChar(); } 303 catch(java.io.IOException e) { 304 jjStopStringLiteralDfa_2(3, active0); 305 return 4; 306 } 307 switch(curChar) 308 { 309 case 97: 310 return jjMoveStringLiteralDfa5_2(active0, 0x1000L); 311 case 101: 312 if ((active0 & 0x2000L) != 0L) 313 return jjStartNfaWithStates_2(4, 13, 37); 314 else if ((active0 & 0x80000L) != 0L) 315 return jjStartNfaWithStates_2(4, 19, 37); 316 break; 317 case 121: 318 if ((active0 & 0x8000L) != 0L) 319 return jjStartNfaWithStates_2(4, 15, 37); 320 break; 321 default : 322 break; 323 } 324 return jjStartNfa_2(3, active0); 325 } 326 private int jjMoveStringLiteralDfa5_2(long old0, long active0) 327 { 328 if (((active0 &= old0)) == 0L) 329 return jjStartNfa_2(3, old0); 330 try { curChar = input_stream.readChar(); } 331 catch(java.io.IOException e) { 332 jjStopStringLiteralDfa_2(4, active0); 333 return 5; 334 } 335 switch(curChar) 336 { 337 case 99: 338 return jjMoveStringLiteralDfa6_2(active0, 0x1000L); 339 default : 340 break; 341 } 342 return jjStartNfa_2(4, active0); 343 } 344 private int jjMoveStringLiteralDfa6_2(long old0, long active0) 345 { 346 if (((active0 &= old0)) == 0L) 347 return jjStartNfa_2(4, old0); 348 try { curChar = input_stream.readChar(); } 349 catch(java.io.IOException e) { 350 jjStopStringLiteralDfa_2(5, active0); 351 return 6; 352 } 353 switch(curChar) 354 { 355 case 104: 356 if ((active0 & 0x1000L) != 0L) 357 return jjStartNfaWithStates_2(6, 12, 37); 358 break; 359 default : 360 break; 361 } 362 return jjStartNfa_2(5, active0); 363 } 364 private int jjStartNfaWithStates_2(int pos, int kind, int state) 365 { 366 jjmatchedKind = kind; 367 jjmatchedPos = pos; 368 try { curChar = input_stream.readChar(); } 369 catch(java.io.IOException e) { return pos + 1; } 370 return jjMoveNfa_2(state, pos + 1); 371 } 372 static final long[] jjbitVec0 = { 373 0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL 374 }; 375 static final long[] jjbitVec2 = { 376 0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL 377 }; 378 static final long[] jjbitVec3 = { 379 0xfffffffefffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL 380 }; 381 static final long[] jjbitVec4 = { 382 0xfffffcffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL 383 }; 384 private int jjMoveNfa_2(int startState, int curPos) 385 { 386 int startsAt = 0; 387 jjnewStateCnt = 75; 388 int i = 1; 389 jjstateSet[0] = startState; 390 int kind = 0x7fffffff; 391 for (;;) 392 { 393 if (++jjround == 0x7fffffff) 394 ReInitRounds(); 395 if (curChar < 64) 396 { 397 long l = 1L << curChar; 398 do 399 { 400 switch(jjstateSet[--i]) 401 { 402 case 5: 403 if ((0x3ff000000000000L & l) != 0L) 404 { 405 if (kind > 58) 406 kind = 58; 407 jjCheckNAddStates(0, 2); 408 } 409 else if (curChar == 47) 410 jjAddStates(3, 4); 411 else if (curChar == 39) 412 jjCheckNAddStates(5, 7); 413 else if (curChar == 34) 414 jjCheckNAddStates(8, 10); 415 else if (curChar == 36) 416 { 417 if (kind > 54) 418 kind = 54; 419 jjCheckNAdd(37); 420 } 421 else if (curChar == 33) 422 { 423 if (kind > 46) 424 kind = 46; 425 } 426 else if (curChar == 37) 427 { 428 if (kind > 44) 429 kind = 44; 430 } 431 else if (curChar == 60) 432 jjstateSet[jjnewStateCnt++] = 25; 433 else if (curChar == 62) 434 jjstateSet[jjnewStateCnt++] = 22; 435 else if (curChar == 61) 436 jjstateSet[jjnewStateCnt++] = 15; 437 else if (curChar == 38) 438 jjstateSet[jjnewStateCnt++] = 6; 439 else if (curChar == 35) 440 jjstateSet[jjnewStateCnt++] = 0; 441 if (curChar == 47) 442 { 443 if (kind > 45) 444 kind = 45; 445 } 446 else if (curChar == 60) 447 { 448 if (kind > 41) 449 kind = 41; 450 } 451 else if (curChar == 62) 452 { 453 if (kind > 39) 454 kind = 39; 455 } 456 else if (curChar == 33) 457 jjstateSet[jjnewStateCnt++] = 19; 458 break; 459 case 61: 460 case 37: 461 if ((0x3ff001000000000L & l) == 0L) 462 break; 463 if (kind > 54) 464 kind = 54; 465 jjCheckNAdd(37); 466 break; 467 case 17: 468 if ((0x3ff001000000000L & l) == 0L) 469 break; 470 if (kind > 54) 471 kind = 54; 472 jjCheckNAdd(37); 473 break; 474 case 0: 475 if (curChar != 35) 476 break; 477 if (kind > 1) 478 kind = 1; 479 jjCheckNAddStates(11, 13); 480 break; 481 case 1: 482 if ((0xffffffffffffdbffL & l) == 0L) 483 break; 484 if (kind > 1) 485 kind = 1; 486 jjCheckNAddStates(11, 13); 487 break; 488 case 2: 489 if ((0x2400L & l) != 0L && kind > 1) 490 kind = 1; 491 break; 492 case 3: 493 if (curChar == 10 && kind > 1) 494 kind = 1; 495 break; 496 case 4: 497 if (curChar == 13) 498 jjstateSet[jjnewStateCnt++] = 3; 499 break; 500 case 6: 501 if (curChar == 38 && kind > 33) 502 kind = 33; 503 break; 504 case 7: 505 if (curChar == 38) 506 jjstateSet[jjnewStateCnt++] = 6; 507 break; 508 case 15: 509 if (curChar == 61 && kind > 35) 510 kind = 35; 511 break; 512 case 16: 513 if (curChar == 61) 514 jjstateSet[jjnewStateCnt++] = 15; 515 break; 516 case 19: 517 if (curChar == 61 && kind > 36) 518 kind = 36; 519 break; 520 case 20: 521 if (curChar == 33) 522 jjstateSet[jjnewStateCnt++] = 19; 523 break; 524 case 21: 525 if (curChar == 62 && kind > 39) 526 kind = 39; 527 break; 528 case 22: 529 if (curChar == 61 && kind > 40) 530 kind = 40; 531 break; 532 case 23: 533 if (curChar == 62) 534 jjstateSet[jjnewStateCnt++] = 22; 535 break; 536 case 24: 537 if (curChar == 60 && kind > 41) 538 kind = 41; 539 break; 540 case 25: 541 if (curChar == 61 && kind > 42) 542 kind = 42; 543 break; 544 case 26: 545 if (curChar == 60) 546 jjstateSet[jjnewStateCnt++] = 25; 547 break; 548 case 27: 549 if (curChar == 37 && kind > 44) 550 kind = 44; 551 break; 552 case 31: 553 if (curChar == 47 && kind > 45) 554 kind = 45; 555 break; 556 case 35: 557 if (curChar == 33 && kind > 46) 558 kind = 46; 559 break; 560 case 36: 561 if (curChar != 36) 562 break; 563 if (kind > 54) 564 kind = 54; 565 jjCheckNAdd(37); 566 break; 567 case 38: 568 if (curChar == 34) 569 jjCheckNAddStates(8, 10); 570 break; 571 case 39: 572 if ((0xfffffffbffffdbffL & l) != 0L) 573 jjCheckNAddStates(8, 10); 574 break; 575 case 41: 576 if ((0xffffffffffffdbffL & l) != 0L) 577 jjCheckNAddStates(8, 10); 578 break; 579 case 42: 580 if (curChar == 34 && kind > 60) 581 kind = 60; 582 break; 583 case 43: 584 if (curChar == 39) 585 jjCheckNAddStates(5, 7); 586 break; 587 case 44: 588 if ((0xffffff7fffffdbffL & l) != 0L) 589 jjCheckNAddStates(5, 7); 590 break; 591 case 46: 592 if ((0xffffffffffffdbffL & l) != 0L) 593 jjCheckNAddStates(5, 7); 594 break; 595 case 47: 596 if (curChar == 39 && kind > 60) 597 kind = 60; 598 break; 599 case 48: 600 if (curChar == 47) 601 jjAddStates(3, 4); 602 break; 603 case 49: 604 if (curChar == 42) 605 jjCheckNAddTwoStates(50, 51); 606 break; 607 case 50: 608 if ((0xfffffbffffffffffL & l) != 0L) 609 jjCheckNAddTwoStates(50, 51); 610 break; 611 case 51: 612 if (curChar == 42) 613 jjCheckNAddStates(14, 16); 614 break; 615 case 52: 616 if ((0xffff7bffffffffffL & l) != 0L) 617 jjCheckNAddTwoStates(53, 51); 618 break; 619 case 53: 620 if ((0xfffffbffffffffffL & l) != 0L) 621 jjCheckNAddTwoStates(53, 51); 622 break; 623 case 54: 624 if (curChar == 47 && kind > 2) 625 kind = 2; 626 break; 627 case 55: 628 if (curChar != 47) 629 break; 630 if (kind > 3) 631 kind = 3; 632 jjCheckNAddStates(17, 19); 633 break; 634 case 56: 635 if ((0xffffffffffffdbffL & l) == 0L) 636 break; 637 if (kind > 3) 638 kind = 3; 639 jjCheckNAddStates(17, 19); 640 break; 641 case 57: 642 if ((0x2400L & l) != 0L && kind > 3) 643 kind = 3; 644 break; 645 case 58: 646 if (curChar == 10 && kind > 3) 647 kind = 3; 648 break; 649 case 59: 650 if (curChar == 13) 651 jjstateSet[jjnewStateCnt++] = 58; 652 break; 653 case 70: 654 if ((0x3ff000000000000L & l) == 0L) 655 break; 656 if (kind > 58) 657 kind = 58; 658 jjCheckNAddStates(0, 2); 659 break; 660 case 71: 661 if ((0x3ff000000000000L & l) == 0L) 662 break; 663 if (kind > 58) 664 kind = 58; 665 jjCheckNAdd(71); 666 break; 667 case 72: 668 if ((0x3ff000000000000L & l) != 0L) 669 jjCheckNAddTwoStates(72, 73); 670 break; 671 case 73: 672 if (curChar == 46) 673 jjCheckNAdd(74); 674 break; 675 case 74: 676 if ((0x3ff000000000000L & l) == 0L) 677 break; 678 if (kind > 59) 679 kind = 59; 680 jjCheckNAdd(74); 681 break; 682 default : break; 683 } 684 } while(i != startsAt); 685 } 686 else if (curChar < 128) 687 { 688 long l = 1L << (curChar & 077); 689 do 690 { 691 switch(jjstateSet[--i]) 692 { 693 case 5: 694 if ((0x7fffffe87fffffeL & l) != 0L) 695 { 696 if (kind > 54) 697 kind = 54; 698 jjCheckNAdd(37); 699 } 700 else if (curChar == 124) 701 jjstateSet[jjnewStateCnt++] = 11; 702 if (curChar == 108) 703 jjAddStates(20, 21); 704 else if (curChar == 103) 705 jjAddStates(22, 23); 706 else if (curChar == 110) 707 jjAddStates(24, 25); 708 else if (curChar == 100) 709 jjstateSet[jjnewStateCnt++] = 33; 710 else if (curChar == 109) 711 jjstateSet[jjnewStateCnt++] = 29; 712 else if (curChar == 101) 713 jjstateSet[jjnewStateCnt++] = 17; 714 else if (curChar == 111) 715 jjstateSet[jjnewStateCnt++] = 13; 716 else if (curChar == 97) 717 jjstateSet[jjnewStateCnt++] = 9; 718 break; 719 case 61: 720 if ((0x7fffffe87fffffeL & l) != 0L) 721 { 722 if (kind > 54) 723 kind = 54; 724 jjCheckNAdd(37); 725 } 726 if (curChar == 111) 727 jjstateSet[jjnewStateCnt++] = 62; 728 else if (curChar == 101) 729 { 730 if (kind > 36) 731 kind = 36; 732 } 733 break; 734 case 17: 735 if ((0x7fffffe87fffffeL & l) != 0L) 736 { 737 if (kind > 54) 738 kind = 54; 739 jjCheckNAdd(37); 740 } 741 if (curChar == 113) 742 { 743 if (kind > 35) 744 kind = 35; 745 } 746 break; 747 case 1: 748 if (kind > 1) 749 kind = 1; 750 jjAddStates(11, 13); 751 break; 752 case 8: 753 if (curChar == 100 && kind > 33) 754 kind = 33; 755 break; 756 case 9: 757 if (curChar == 110) 758 jjstateSet[jjnewStateCnt++] = 8; 759 break; 760 case 10: 761 if (curChar == 97) 762 jjstateSet[jjnewStateCnt++] = 9; 763 break; 764 case 11: 765 if (curChar == 124 && kind > 34) 766 kind = 34; 767 break; 768 case 12: 769 if (curChar == 124) 770 jjstateSet[jjnewStateCnt++] = 11; 771 break; 772 case 13: 773 if (curChar == 114 && kind > 34) 774 kind = 34; 775 break; 776 case 14: 777 if (curChar == 111) 778 jjstateSet[jjnewStateCnt++] = 13; 779 break; 780 case 18: 781 if (curChar == 101) 782 jjstateSet[jjnewStateCnt++] = 17; 783 break; 784 case 28: 785 if (curChar == 100 && kind > 44) 786 kind = 44; 787 break; 788 case 29: 789 if (curChar == 111) 790 jjstateSet[jjnewStateCnt++] = 28; 791 break; 792 case 30: 793 if (curChar == 109) 794 jjstateSet[jjnewStateCnt++] = 29; 795 break; 796 case 32: 797 if (curChar == 118 && kind > 45) 798 kind = 45; 799 break; 800 case 33: 801 if (curChar == 105) 802 jjstateSet[jjnewStateCnt++] = 32; 803 break; 804 case 34: 805 if (curChar == 100) 806 jjstateSet[jjnewStateCnt++] = 33; 807 break; 808 case 36: 809 if ((0x7fffffe87fffffeL & l) == 0L) 810 break; 811 if (kind > 54) 812 kind = 54; 813 jjCheckNAdd(37); 814 break; 815 case 37: 816 if ((0x7fffffe87fffffeL & l) == 0L) 817 break; 818 if (kind > 54) 819 kind = 54; 820 jjCheckNAdd(37); 821 break; 822 case 39: 823 if ((0xffffffffefffffffL & l) != 0L) 824 jjCheckNAddStates(8, 10); 825 break; 826 case 40: 827 if (curChar == 92) 828 jjstateSet[jjnewStateCnt++] = 41; 829 break; 830 case 41: 831 jjCheckNAddStates(8, 10); 832 break; 833 case 44: 834 if ((0xffffffffefffffffL & l) != 0L) 835 jjCheckNAddStates(5, 7); 836 break; 837 case 45: 838 if (curChar == 92) 839 jjstateSet[jjnewStateCnt++] = 46; 840 break; 841 case 46: 842 jjCheckNAddStates(5, 7); 843 break; 844 case 50: 845 jjCheckNAddTwoStates(50, 51); 846 break; 847 case 52: 848 case 53: 849 jjCheckNAddTwoStates(53, 51); 850 break; 851 case 56: 852 if (kind > 3) 853 kind = 3; 854 jjAddStates(17, 19); 855 break; 856 case 60: 857 if (curChar == 110) 858 jjAddStates(24, 25); 859 break; 860 case 62: 861 if (curChar == 116 && kind > 46) 862 kind = 46; 863 break; 864 case 63: 865 if (curChar == 111) 866 jjstateSet[jjnewStateCnt++] = 62; 867 break; 868 case 64: 869 if (curChar == 103) 870 jjAddStates(22, 23); 871 break; 872 case 65: 873 if (curChar == 116 && kind > 39) 874 kind = 39; 875 break; 876 case 66: 877 if (curChar == 101 && kind > 40) 878 kind = 40; 879 break; 880 case 67: 881 if (curChar == 108) 882 jjAddStates(20, 21); 883 break; 884 case 68: 885 if (curChar == 116 && kind > 41) 886 kind = 41; 887 break; 888 case 69: 889 if (curChar == 101 && kind > 42) 890 kind = 42; 891 break; 892 default : break; 893 } 894 } while(i != startsAt); 895 } 896 else 897 { 898 int hiByte = (int)(curChar >> 8); 899 int i1 = hiByte >> 6; 900 long l1 = 1L << (hiByte & 077); 901 int i2 = (curChar & 0xff) >> 6; 902 long l2 = 1L << (curChar & 077); 903 do 904 { 905 switch(jjstateSet[--i]) 906 { 907 case 1: 908 if (!jjCanMove_0(hiByte, i1, i2, l1, l2)) 909 break; 910 if (kind > 1) 911 kind = 1; 912 jjAddStates(11, 13); 913 break; 914 case 39: 915 case 41: 916 if (jjCanMove_1(hiByte, i1, i2, l1, l2)) 917 jjCheckNAddStates(8, 10); 918 break; 919 case 44: 920 case 46: 921 if (jjCanMove_1(hiByte, i1, i2, l1, l2)) 922 jjCheckNAddStates(5, 7); 923 break; 924 case 50: 925 if (jjCanMove_0(hiByte, i1, i2, l1, l2)) 926 jjCheckNAddTwoStates(50, 51); 927 break; 928 case 52: 929 case 53: 930 if (jjCanMove_0(hiByte, i1, i2, l1, l2)) 931 jjCheckNAddTwoStates(53, 51); 932 break; 933 case 56: 934 if (!jjCanMove_0(hiByte, i1, i2, l1, l2)) 935 break; 936 if (kind > 3) 937 kind = 3; 938 jjAddStates(17, 19); 939 break; 940 default : break; 941 } 942 } while(i != startsAt); 943 } 944 if (kind != 0x7fffffff) 945 { 946 jjmatchedKind = kind; 947 jjmatchedPos = curPos; 948 kind = 0x7fffffff; 949 } 950 ++curPos; 951 if ((i = jjnewStateCnt) == (startsAt = 75 - (jjnewStateCnt = startsAt))) 952 return curPos; 953 try { curChar = input_stream.readChar(); } 954 catch(java.io.IOException e) { return curPos; } 955 } 956 } 957 private final int jjStopStringLiteralDfa_1(int pos, long active0) 958 { 959 switch (pos) 960 { 961 case 0: 962 if ((active0 & 0x1d3a00L) != 0L) 963 { 964 jjmatchedKind = 54; 965 return 37; 966 } 967 if ((active0 & 0x8000000000000L) != 0L) 968 return 6; 969 if ((active0 & 0x10000000000000L) != 0L) 970 return 11; 971 if ((active0 & 0x24000L) != 0L) 972 { 973 jjmatchedKind = 54; 974 return 61; 975 } 976 if ((active0 & 0x8400L) != 0L) 977 { 978 jjmatchedKind = 54; 979 return 17; 980 } 981 if ((active0 & 0x4000000000L) != 0L) 982 { 983 jjmatchedKind = 46; 984 return 19; 985 } 986 if ((active0 & 0x82000000000L) != 0L) 987 return 15; 988 return -1; 989 case 1: 990 if ((active0 & 0x4000L) != 0L) 991 { 992 jjmatchedKind = 36; 993 jjmatchedPos = 1; 994 return 37; 995 } 996 if ((active0 & 0xfbc00L) != 0L) 997 { 998 jjmatchedKind = 54; 999 jjmatchedPos = 1; 1000 return 37; 1001 } 1002 if ((active0 & 0x100200L) != 0L) 1003 return 37; 1004 return -1; 1005 case 2: 1006 if ((active0 & 0x5800L) != 0L) 1007 return 37; 1008 if ((active0 & 0xfa400L) != 0L) 1009 { 1010 if (jjmatchedPos != 2) 1011 { 1012 jjmatchedKind = 54; 1013 jjmatchedPos = 2; 1014 } 1015 return 37; 1016 } 1017 return -1; 1018 case 3: 1019 if ((active0 & 0x8b000L) != 0L) 1020 { 1021 jjmatchedKind = 54; 1022 jjmatchedPos = 3; 1023 return 37; 1024 } 1025 if ((active0 & 0x70400L) != 0L) 1026 return 37; 1027 return -1; 1028 case 4: 1029 if ((active0 & 0x1000L) != 0L) 1030 { 1031 jjmatchedKind = 54; 1032 jjmatchedPos = 4; 1033 return 37; 1034 } 1035 if ((active0 & 0x8a000L) != 0L) 1036 return 37; 1037 return -1; 1038 case 5: 1039 if ((active0 & 0x1000L) != 0L) 1040 { 1041 jjmatchedKind = 54; 1042 jjmatchedPos = 5; 1043 return 37; 1044 } 1045 return -1; 1046 default : 1047 return -1; 1048 } 1049 } 1050 private final int jjStartNfa_1(int pos, long active0) 1051 { 1052 return jjMoveNfa_1(jjStopStringLiteralDfa_1(pos, active0), pos + 1); 1053 } 1054 private int jjMoveStringLiteralDfa0_1() 1055 { 1056 switch(curChar) 1057 { 1058 case 33: 1059 return jjMoveStringLiteralDfa1_1(0x4000000000L); 1060 case 38: 1061 return jjStartNfaWithStates_1(0, 51, 6); 1062 case 40: 1063 return jjStopAtPos(0, 21); 1064 case 41: 1065 return jjStopAtPos(0, 22); 1066 case 42: 1067 return jjStopAtPos(0, 49); 1068 case 43: 1069 return jjStopAtPos(0, 47); 1070 case 44: 1071 return jjStopAtPos(0, 29); 1072 case 45: 1073 return jjStopAtPos(0, 48); 1074 case 46: 1075 return jjStopAtPos(0, 30); 1076 case 58: 1077 return jjStopAtPos(0, 28); 1078 case 59: 1079 return jjStopAtPos(0, 27); 1080 case 61: 1081 jjmatchedKind = 43; 1082 return jjMoveStringLiteralDfa1_1(0x2000000000L); 1083 case 63: 1084 jjmatchedKind = 31; 1085 return jjMoveStringLiteralDfa1_1(0x100000000L); 1086 case 91: 1087 return jjStopAtPos(0, 25); 1088 case 93: 1089 return jjStopAtPos(0, 26); 1090 case 94: 1091 return jjStopAtPos(0, 53); 1092 case 101: 1093 return jjMoveStringLiteralDfa1_1(0x8400L); 1094 case 102: 1095 return jjMoveStringLiteralDfa1_1(0x81800L); 1096 case 105: 1097 return jjMoveStringLiteralDfa1_1(0x100200L); 1098 case 110: 1099 return jjMoveStringLiteralDfa1_1(0x24000L); 1100 case 115: 1101 return jjMoveStringLiteralDfa1_1(0x10000L); 1102 case 116: 1103 return jjMoveStringLiteralDfa1_1(0x40000L); 1104 case 119: 1105 return jjMoveStringLiteralDfa1_1(0x2000L); 1106 case 123: 1107 return jjStopAtPos(0, 23); 1108 case 124: 1109 return jjStartNfaWithStates_1(0, 52, 11); 1110 case 125: 1111 return jjStopAtPos(0, 24); 1112 case 126: 1113 return jjStopAtPos(0, 50); 1114 default : 1115 return jjMoveNfa_1(5, 0); 1116 } 1117 } 1118 private int jjMoveStringLiteralDfa1_1(long active0) 1119 { 1120 try { curChar = input_stream.readChar(); } 1121 catch(java.io.IOException e) { 1122 jjStopStringLiteralDfa_1(0, active0); 1123 return 1; 1124 } 1125 switch(curChar) 1126 { 1127 case 58: 1128 if ((active0 & 0x100000000L) != 0L) 1129 return jjStopAtPos(1, 32); 1130 break; 1131 case 97: 1132 return jjMoveStringLiteralDfa2_1(active0, 0x80000L); 1133 case 101: 1134 return jjMoveStringLiteralDfa2_1(active0, 0x4000L); 1135 case 102: 1136 if ((active0 & 0x200L) != 0L) 1137 return jjStartNfaWithStates_1(1, 9, 37); 1138 break; 1139 case 104: 1140 return jjMoveStringLiteralDfa2_1(active0, 0x2000L); 1141 case 105: 1142 return jjMoveStringLiteralDfa2_1(active0, 0x10000L); 1143 case 108: 1144 return jjMoveStringLiteralDfa2_1(active0, 0x400L); 1145 case 109: 1146 return jjMoveStringLiteralDfa2_1(active0, 0x8000L); 1147 case 110: 1148 if ((active0 & 0x100000L) != 0L) 1149 return jjStartNfaWithStates_1(1, 20, 37); 1150 break; 1151 case 111: 1152 return jjMoveStringLiteralDfa2_1(active0, 0x1800L); 1153 case 114: 1154 return jjMoveStringLiteralDfa2_1(active0, 0x40000L); 1155 case 117: 1156 return jjMoveStringLiteralDfa2_1(active0, 0x20000L); 1157 case 126: 1158 if ((active0 & 0x2000000000L) != 0L) 1159 return jjStopAtPos(1, 37); 1160 else if ((active0 & 0x4000000000L) != 0L) 1161 return jjStopAtPos(1, 38); 1162 break; 1163 default : 1164 break; 1165 } 1166 return jjStartNfa_1(0, active0); 1167 } 1168 private int jjMoveStringLiteralDfa2_1(long old0, long active0) 1169 { 1170 if (((active0 &= old0)) == 0L) 1171 return jjStartNfa_1(0, old0); 1172 try { curChar = input_stream.readChar(); } 1173 catch(java.io.IOException e) { 1174 jjStopStringLiteralDfa_1(1, active0); 1175 return 2; 1176 } 1177 switch(curChar) 1178 { 1179 case 105: 1180 return jjMoveStringLiteralDfa3_1(active0, 0x2000L); 1181 case 108: 1182 return jjMoveStringLiteralDfa3_1(active0, 0xa0000L); 1183 case 112: 1184 return jjMoveStringLiteralDfa3_1(active0, 0x8000L); 1185 case 114: 1186 if ((active0 & 0x800L) != 0L) 1187 { 1188 jjmatchedKind = 11; 1189 jjmatchedPos = 2; 1190 } 1191 return jjMoveStringLiteralDfa3_1(active0, 0x1000L); 1192 case 115: 1193 return jjMoveStringLiteralDfa3_1(active0, 0x400L); 1194 case 117: 1195 return jjMoveStringLiteralDfa3_1(active0, 0x40000L); 1196 case 119: 1197 if ((active0 & 0x4000L) != 0L) 1198 return jjStartNfaWithStates_1(2, 14, 37); 1199 break; 1200 case 122: 1201 return jjMoveStringLiteralDfa3_1(active0, 0x10000L); 1202 default : 1203 break; 1204 } 1205 return jjStartNfa_1(1, active0); 1206 } 1207 private int jjMoveStringLiteralDfa3_1(long old0, long active0) 1208 { 1209 if (((active0 &= old0)) == 0L) 1210 return jjStartNfa_1(1, old0); 1211 try { curChar = input_stream.readChar(); } 1212 catch(java.io.IOException e) { 1213 jjStopStringLiteralDfa_1(2, active0); 1214 return 3; 1215 } 1216 switch(curChar) 1217 { 1218 case 101: 1219 if ((active0 & 0x400L) != 0L) 1220 return jjStartNfaWithStates_1(3, 10, 37); 1221 else if ((active0 & 0x10000L) != 0L) 1222 return jjStartNfaWithStates_1(3, 16, 37); 1223 else if ((active0 & 0x40000L) != 0L) 1224 return jjStartNfaWithStates_1(3, 18, 37); 1225 return jjMoveStringLiteralDfa4_1(active0, 0x1000L); 1226 case 108: 1227 if ((active0 & 0x20000L) != 0L) 1228 return jjStartNfaWithStates_1(3, 17, 37); 1229 return jjMoveStringLiteralDfa4_1(active0, 0x2000L); 1230 case 115: 1231 return jjMoveStringLiteralDfa4_1(active0, 0x80000L); 1232 case 116: 1233 return jjMoveStringLiteralDfa4_1(active0, 0x8000L); 1234 default : 1235 break; 1236 } 1237 return jjStartNfa_1(2, active0); 1238 } 1239 private int jjMoveStringLiteralDfa4_1(long old0, long active0) 1240 { 1241 if (((active0 &= old0)) == 0L) 1242 return jjStartNfa_1(2, old0); 1243 try { curChar = input_stream.readChar(); } 1244 catch(java.io.IOException e) { 1245 jjStopStringLiteralDfa_1(3, active0); 1246 return 4; 1247 } 1248 switch(curChar) 1249 { 1250 case 97: 1251 return jjMoveStringLiteralDfa5_1(active0, 0x1000L); 1252 case 101: 1253 if ((active0 & 0x2000L) != 0L) 1254 return jjStartNfaWithStates_1(4, 13, 37); 1255 else if ((active0 & 0x80000L) != 0L) 1256 return jjStartNfaWithStates_1(4, 19, 37); 1257 break; 1258 case 121: 1259 if ((active0 & 0x8000L) != 0L) 1260 return jjStartNfaWithStates_1(4, 15, 37); 1261 break; 1262 default : 1263 break; 1264 } 1265 return jjStartNfa_1(3, active0); 1266 } 1267 private int jjMoveStringLiteralDfa5_1(long old0, long active0) 1268 { 1269 if (((active0 &= old0)) == 0L) 1270 return jjStartNfa_1(3, old0); 1271 try { curChar = input_stream.readChar(); } 1272 catch(java.io.IOException e) { 1273 jjStopStringLiteralDfa_1(4, active0); 1274 return 5; 1275 } 1276 switch(curChar) 1277 { 1278 case 99: 1279 return jjMoveStringLiteralDfa6_1(active0, 0x1000L); 1280 default : 1281 break; 1282 } 1283 return jjStartNfa_1(4, active0); 1284 } 1285 private int jjMoveStringLiteralDfa6_1(long old0, long active0) 1286 { 1287 if (((active0 &= old0)) == 0L) 1288 return jjStartNfa_1(4, old0); 1289 try { curChar = input_stream.readChar(); } 1290 catch(java.io.IOException e) { 1291 jjStopStringLiteralDfa_1(5, active0); 1292 return 6; 1293 } 1294 switch(curChar) 1295 { 1296 case 104: 1297 if ((active0 & 0x1000L) != 0L) 1298 return jjStartNfaWithStates_1(6, 12, 37); 1299 break; 1300 default : 1301 break; 1302 } 1303 return jjStartNfa_1(5, active0); 1304 } 1305 private int jjStartNfaWithStates_1(int pos, int kind, int state) 1306 { 1307 jjmatchedKind = kind; 1308 jjmatchedPos = pos; 1309 try { curChar = input_stream.readChar(); } 1310 catch(java.io.IOException e) { return pos + 1; } 1311 return jjMoveNfa_1(state, pos + 1); 1312 } 1313 private int jjMoveNfa_1(int startState, int curPos) 1314 { 1315 int startsAt = 0; 1316 jjnewStateCnt = 75; 1317 int i = 1; 1318 jjstateSet[0] = startState; 1319 int kind = 0x7fffffff; 1320 for (;;) 1321 { 1322 if (++jjround == 0x7fffffff) 1323 ReInitRounds(); 1324 if (curChar < 64) 1325 { 1326 long l = 1L << curChar; 1327 do 1328 { 1329 switch(jjstateSet[--i]) 1330 { 1331 case 5: 1332 if ((0x3ff000000000000L & l) != 0L) 1333 { 1334 if (kind > 58) 1335 kind = 58; 1336 jjCheckNAddStates(0, 2); 1337 } 1338 else if (curChar == 47) 1339 jjAddStates(3, 4); 1340 else if (curChar == 39) 1341 jjCheckNAddStates(5, 7); 1342 else if (curChar == 34) 1343 jjCheckNAddStates(8, 10); 1344 else if (curChar == 36) 1345 { 1346 if (kind > 54) 1347 kind = 54; 1348 jjCheckNAdd(37); 1349 } 1350 else if (curChar == 33) 1351 { 1352 if (kind > 46) 1353 kind = 46; 1354 } 1355 else if (curChar == 37) 1356 { 1357 if (kind > 44) 1358 kind = 44; 1359 } 1360 else if (curChar == 60) 1361 jjstateSet[jjnewStateCnt++] = 25; 1362 else if (curChar == 62) 1363 jjstateSet[jjnewStateCnt++] = 22; 1364 else if (curChar == 61) 1365 jjstateSet[jjnewStateCnt++] = 15; 1366 else if (curChar == 38) 1367 jjstateSet[jjnewStateCnt++] = 6; 1368 else if (curChar == 35) 1369 jjstateSet[jjnewStateCnt++] = 0; 1370 if (curChar == 47) 1371 { 1372 if (kind > 45) 1373 kind = 45; 1374 } 1375 else if (curChar == 60) 1376 { 1377 if (kind > 41) 1378 kind = 41; 1379 } 1380 else if (curChar == 62) 1381 { 1382 if (kind > 39) 1383 kind = 39; 1384 } 1385 else if (curChar == 33) 1386 jjstateSet[jjnewStateCnt++] = 19; 1387 break; 1388 case 61: 1389 case 37: 1390 if ((0x3ff001000000000L & l) == 0L) 1391 break; 1392 if (kind > 54) 1393 kind = 54; 1394 jjCheckNAdd(37); 1395 break; 1396 case 17: 1397 if ((0x3ff001000000000L & l) == 0L) 1398 break; 1399 if (kind > 54) 1400 kind = 54; 1401 jjCheckNAdd(37); 1402 break; 1403 case 0: 1404 if (curChar != 35) 1405 break; 1406 if (kind > 1) 1407 kind = 1; 1408 jjCheckNAddStates(11, 13); 1409 break; 1410 case 1: 1411 if ((0xffffffffffffdbffL & l) == 0L) 1412 break; 1413 if (kind > 1) 1414 kind = 1; 1415 jjCheckNAddStates(11, 13); 1416 break; 1417 case 2: 1418 if ((0x2400L & l) != 0L && kind > 1) 1419 kind = 1; 1420 break; 1421 case 3: 1422 if (curChar == 10 && kind > 1) 1423 kind = 1; 1424 break; 1425 case 4: 1426 if (curChar == 13) 1427 jjstateSet[jjnewStateCnt++] = 3; 1428 break; 1429 case 6: 1430 if (curChar == 38 && kind > 33) 1431 kind = 33; 1432 break; 1433 case 7: 1434 if (curChar == 38) 1435 jjstateSet[jjnewStateCnt++] = 6; 1436 break; 1437 case 15: 1438 if (curChar == 61 && kind > 35) 1439 kind = 35; 1440 break; 1441 case 16: 1442 if (curChar == 61) 1443 jjstateSet[jjnewStateCnt++] = 15; 1444 break; 1445 case 19: 1446 if (curChar == 61 && kind > 36) 1447 kind = 36; 1448 break; 1449 case 20: 1450 if (curChar == 33) 1451 jjstateSet[jjnewStateCnt++] = 19; 1452 break; 1453 case 21: 1454 if (curChar == 62 && kind > 39) 1455 kind = 39; 1456 break; 1457 case 22: 1458 if (curChar == 61 && kind > 40) 1459 kind = 40; 1460 break; 1461 case 23: 1462 if (curChar == 62) 1463 jjstateSet[jjnewStateCnt++] = 22; 1464 break; 1465 case 24: 1466 if (curChar == 60 && kind > 41) 1467 kind = 41; 1468 break; 1469 case 25: 1470 if (curChar == 61 && kind > 42) 1471 kind = 42; 1472 break; 1473 case 26: 1474 if (curChar == 60) 1475 jjstateSet[jjnewStateCnt++] = 25; 1476 break; 1477 case 27: 1478 if (curChar == 37 && kind > 44) 1479 kind = 44; 1480 break; 1481 case 31: 1482 if (curChar == 47 && kind > 45) 1483 kind = 45; 1484 break; 1485 case 35: 1486 if (curChar == 33 && kind > 46) 1487 kind = 46; 1488 break; 1489 case 36: 1490 if (curChar != 36) 1491 break; 1492 if (kind > 54) 1493 kind = 54; 1494 jjCheckNAdd(37); 1495 break; 1496 case 38: 1497 if (curChar == 34) 1498 jjCheckNAddStates(8, 10); 1499 break; 1500 case 39: 1501 if ((0xfffffffbffffdbffL & l) != 0L) 1502 jjCheckNAddStates(8, 10); 1503 break; 1504 case 41: 1505 if ((0xffffffffffffdbffL & l) != 0L) 1506 jjCheckNAddStates(8, 10); 1507 break; 1508 case 42: 1509 if (curChar == 34 && kind > 60) 1510 kind = 60; 1511 break; 1512 case 43: 1513 if (curChar == 39) 1514 jjCheckNAddStates(5, 7); 1515 break; 1516 case 44: 1517 if ((0xffffff7fffffdbffL & l) != 0L) 1518 jjCheckNAddStates(5, 7); 1519 break; 1520 case 46: 1521 if ((0xffffffffffffdbffL & l) != 0L) 1522 jjCheckNAddStates(5, 7); 1523 break; 1524 case 47: 1525 if (curChar == 39 && kind > 60) 1526 kind = 60; 1527 break; 1528 case 48: 1529 if (curChar == 47) 1530 jjAddStates(3, 4); 1531 break; 1532 case 49: 1533 if (curChar == 42) 1534 jjCheckNAddTwoStates(50, 51); 1535 break; 1536 case 50: 1537 if ((0xfffffbffffffffffL & l) != 0L) 1538 jjCheckNAddTwoStates(50, 51); 1539 break; 1540 case 51: 1541 if (curChar == 42) 1542 jjCheckNAddStates(14, 16); 1543 break; 1544 case 52: 1545 if ((0xffff7bffffffffffL & l) != 0L) 1546 jjCheckNAddTwoStates(53, 51); 1547 break; 1548 case 53: 1549 if ((0xfffffbffffffffffL & l) != 0L) 1550 jjCheckNAddTwoStates(53, 51); 1551 break; 1552 case 54: 1553 if (curChar == 47 && kind > 2) 1554 kind = 2; 1555 break; 1556 case 55: 1557 if (curChar != 47) 1558 break; 1559 if (kind > 3) 1560 kind = 3; 1561 jjCheckNAddStates(17, 19); 1562 break; 1563 case 56: 1564 if ((0xffffffffffffdbffL & l) == 0L) 1565 break; 1566 if (kind > 3) 1567 kind = 3; 1568 jjCheckNAddStates(17, 19); 1569 break; 1570 case 57: 1571 if ((0x2400L & l) != 0L && kind > 3) 1572 kind = 3; 1573 break; 1574 case 58: 1575 if (curChar == 10 && kind > 3) 1576 kind = 3; 1577 break; 1578 case 59: 1579 if (curChar == 13) 1580 jjstateSet[jjnewStateCnt++] = 58; 1581 break; 1582 case 70: 1583 if ((0x3ff000000000000L & l) == 0L) 1584 break; 1585 if (kind > 58) 1586 kind = 58; 1587 jjCheckNAddStates(0, 2); 1588 break; 1589 case 71: 1590 if ((0x3ff000000000000L & l) == 0L) 1591 break; 1592 if (kind > 58) 1593 kind = 58; 1594 jjCheckNAdd(71); 1595 break; 1596 case 72: 1597 if ((0x3ff000000000000L & l) != 0L) 1598 jjCheckNAddTwoStates(72, 73); 1599 break; 1600 case 73: 1601 if (curChar == 46) 1602 jjCheckNAdd(74); 1603 break; 1604 case 74: 1605 if ((0x3ff000000000000L & l) == 0L) 1606 break; 1607 if (kind > 59) 1608 kind = 59; 1609 jjCheckNAdd(74); 1610 break; 1611 default : break; 1612 } 1613 } while(i != startsAt); 1614 } 1615 else if (curChar < 128) 1616 { 1617 long l = 1L << (curChar & 077); 1618 do 1619 { 1620 switch(jjstateSet[--i]) 1621 { 1622 case 5: 1623 if ((0x7fffffe87fffffeL & l) != 0L) 1624 { 1625 if (kind > 54) 1626 kind = 54; 1627 jjCheckNAdd(37); 1628 } 1629 else if (curChar == 124) 1630 jjstateSet[jjnewStateCnt++] = 11; 1631 if (curChar == 108) 1632 jjAddStates(20, 21); 1633 else if (curChar == 103) 1634 jjAddStates(22, 23); 1635 else if (curChar == 110) 1636 jjAddStates(24, 25); 1637 else if (curChar == 100) 1638 jjstateSet[jjnewStateCnt++] = 33; 1639 else if (curChar == 109) 1640 jjstateSet[jjnewStateCnt++] = 29; 1641 else if (curChar == 101) 1642 jjstateSet[jjnewStateCnt++] = 17; 1643 else if (curChar == 111) 1644 jjstateSet[jjnewStateCnt++] = 13; 1645 else if (curChar == 97) 1646 jjstateSet[jjnewStateCnt++] = 9; 1647 break; 1648 case 61: 1649 if ((0x7fffffe87fffffeL & l) != 0L) 1650 { 1651 if (kind > 54) 1652 kind = 54; 1653 jjCheckNAdd(37); 1654 } 1655 if (curChar == 111) 1656 jjstateSet[jjnewStateCnt++] = 62; 1657 else if (curChar == 101) 1658 { 1659 if (kind > 36) 1660 kind = 36; 1661 } 1662 break; 1663 case 17: 1664 if ((0x7fffffe87fffffeL & l) != 0L) 1665 { 1666 if (kind > 54) 1667 kind = 54; 1668 jjCheckNAdd(37); 1669 } 1670 if (curChar == 113) 1671 { 1672 if (kind > 35) 1673 kind = 35; 1674 } 1675 break; 1676 case 1: 1677 if (kind > 1) 1678 kind = 1; 1679 jjAddStates(11, 13); 1680 break; 1681 case 8: 1682 if (curChar == 100 && kind > 33) 1683 kind = 33; 1684 break; 1685 case 9: 1686 if (curChar == 110) 1687 jjstateSet[jjnewStateCnt++] = 8; 1688 break; 1689 case 10: 1690 if (curChar == 97) 1691 jjstateSet[jjnewStateCnt++] = 9; 1692 break; 1693 case 11: 1694 if (curChar == 124 && kind > 34) 1695 kind = 34; 1696 break; 1697 case 12: 1698 if (curChar == 124) 1699 jjstateSet[jjnewStateCnt++] = 11; 1700 break; 1701 case 13: 1702 if (curChar == 114 && kind > 34) 1703 kind = 34; 1704 break; 1705 case 14: 1706 if (curChar == 111) 1707 jjstateSet[jjnewStateCnt++] = 13; 1708 break; 1709 case 18: 1710 if (curChar == 101) 1711 jjstateSet[jjnewStateCnt++] = 17; 1712 break; 1713 case 28: 1714 if (curChar == 100 && kind > 44) 1715 kind = 44; 1716 break; 1717 case 29: 1718 if (curChar == 111) 1719 jjstateSet[jjnewStateCnt++] = 28; 1720 break; 1721 case 30: 1722 if (curChar == 109) 1723 jjstateSet[jjnewStateCnt++] = 29; 1724 break; 1725 case 32: 1726 if (curChar == 118 && kind > 45) 1727 kind = 45; 1728 break; 1729 case 33: 1730 if (curChar == 105) 1731 jjstateSet[jjnewStateCnt++] = 32; 1732 break; 1733 case 34: 1734 if (curChar == 100) 1735 jjstateSet[jjnewStateCnt++] = 33; 1736 break; 1737 case 36: 1738 if ((0x7fffffe87fffffeL & l) == 0L) 1739 break; 1740 if (kind > 54) 1741 kind = 54; 1742 jjCheckNAdd(37); 1743 break; 1744 case 37: 1745 if ((0x7fffffe87fffffeL & l) == 0L) 1746 break; 1747 if (kind > 54) 1748 kind = 54; 1749 jjCheckNAdd(37); 1750 break; 1751 case 39: 1752 if ((0xffffffffefffffffL & l) != 0L) 1753 jjCheckNAddStates(8, 10); 1754 break; 1755 case 40: 1756 if (curChar == 92) 1757 jjstateSet[jjnewStateCnt++] = 41; 1758 break; 1759 case 41: 1760 jjCheckNAddStates(8, 10); 1761 break; 1762 case 44: 1763 if ((0xffffffffefffffffL & l) != 0L) 1764 jjCheckNAddStates(5, 7); 1765 break; 1766 case 45: 1767 if (curChar == 92) 1768 jjstateSet[jjnewStateCnt++] = 46; 1769 break; 1770 case 46: 1771 jjCheckNAddStates(5, 7); 1772 break; 1773 case 50: 1774 jjCheckNAddTwoStates(50, 51); 1775 break; 1776 case 52: 1777 case 53: 1778 jjCheckNAddTwoStates(53, 51); 1779 break; 1780 case 56: 1781 if (kind > 3) 1782 kind = 3; 1783 jjAddStates(17, 19); 1784 break; 1785 case 60: 1786 if (curChar == 110) 1787 jjAddStates(24, 25); 1788 break; 1789 case 62: 1790 if (curChar == 116 && kind > 46) 1791 kind = 46; 1792 break; 1793 case 63: 1794 if (curChar == 111) 1795 jjstateSet[jjnewStateCnt++] = 62; 1796 break; 1797 case 64: 1798 if (curChar == 103) 1799 jjAddStates(22, 23); 1800 break; 1801 case 65: 1802 if (curChar == 116 && kind > 39) 1803 kind = 39; 1804 break; 1805 case 66: 1806 if (curChar == 101 && kind > 40) 1807 kind = 40; 1808 break; 1809 case 67: 1810 if (curChar == 108) 1811 jjAddStates(20, 21); 1812 break; 1813 case 68: 1814 if (curChar == 116 && kind > 41) 1815 kind = 41; 1816 break; 1817 case 69: 1818 if (curChar == 101 && kind > 42) 1819 kind = 42; 1820 break; 1821 default : break; 1822 } 1823 } while(i != startsAt); 1824 } 1825 else 1826 { 1827 int hiByte = (int)(curChar >> 8); 1828 int i1 = hiByte >> 6; 1829 long l1 = 1L << (hiByte & 077); 1830 int i2 = (curChar & 0xff) >> 6; 1831 long l2 = 1L << (curChar & 077); 1832 do 1833 { 1834 switch(jjstateSet[--i]) 1835 { 1836 case 1: 1837 if (!jjCanMove_0(hiByte, i1, i2, l1, l2)) 1838 break; 1839 if (kind > 1) 1840 kind = 1; 1841 jjAddStates(11, 13); 1842 break; 1843 case 39: 1844 case 41: 1845 if (jjCanMove_1(hiByte, i1, i2, l1, l2)) 1846 jjCheckNAddStates(8, 10); 1847 break; 1848 case 44: 1849 case 46: 1850 if (jjCanMove_1(hiByte, i1, i2, l1, l2)) 1851 jjCheckNAddStates(5, 7); 1852 break; 1853 case 50: 1854 if (jjCanMove_0(hiByte, i1, i2, l1, l2)) 1855 jjCheckNAddTwoStates(50, 51); 1856 break; 1857 case 52: 1858 case 53: 1859 if (jjCanMove_0(hiByte, i1, i2, l1, l2)) 1860 jjCheckNAddTwoStates(53, 51); 1861 break; 1862 case 56: 1863 if (!jjCanMove_0(hiByte, i1, i2, l1, l2)) 1864 break; 1865 if (kind > 3) 1866 kind = 3; 1867 jjAddStates(17, 19); 1868 break; 1869 default : break; 1870 } 1871 } while(i != startsAt); 1872 } 1873 if (kind != 0x7fffffff) 1874 { 1875 jjmatchedKind = kind; 1876 jjmatchedPos = curPos; 1877 kind = 0x7fffffff; 1878 } 1879 ++curPos; 1880 if ((i = jjnewStateCnt) == (startsAt = 75 - (jjnewStateCnt = startsAt))) 1881 return curPos; 1882 try { curChar = input_stream.readChar(); } 1883 catch(java.io.IOException e) { return curPos; } 1884 } 1885 } 1886 private final int jjStopStringLiteralDfa_0(int pos, long active0) 1887 { 1888 switch (pos) 1889 { 1890 case 0: 1891 if ((active0 & 0xd3a00L) != 0L) 1892 { 1893 jjmatchedKind = 54; 1894 return 37; 1895 } 1896 if ((active0 & 0x8000000000000L) != 0L) 1897 return 6; 1898 if ((active0 & 0x10000000000000L) != 0L) 1899 return 11; 1900 if ((active0 & 0x8400L) != 0L) 1901 { 1902 jjmatchedKind = 54; 1903 return 17; 1904 } 1905 if ((active0 & 0x24000L) != 0L) 1906 { 1907 jjmatchedKind = 54; 1908 return 63; 1909 } 1910 if ((active0 & 0x4000000000L) != 0L) 1911 { 1912 jjmatchedKind = 46; 1913 return 19; 1914 } 1915 if ((active0 & 0x82000000000L) != 0L) 1916 return 15; 1917 return -1; 1918 case 1: 1919 if ((active0 & 0x4000L) != 0L) 1920 { 1921 jjmatchedKind = 36; 1922 jjmatchedPos = 1; 1923 return 37; 1924 } 1925 if ((active0 & 0xfbc00L) != 0L) 1926 { 1927 jjmatchedKind = 54; 1928 jjmatchedPos = 1; 1929 return 37; 1930 } 1931 if ((active0 & 0x200L) != 0L) 1932 return 37; 1933 return -1; 1934 case 2: 1935 if ((active0 & 0x5800L) != 0L) 1936 return 37; 1937 if ((active0 & 0xfa400L) != 0L) 1938 { 1939 if (jjmatchedPos != 2) 1940 { 1941 jjmatchedKind = 54; 1942 jjmatchedPos = 2; 1943 } 1944 return 37; 1945 } 1946 return -1; 1947 case 3: 1948 if ((active0 & 0x8b000L) != 0L) 1949 { 1950 jjmatchedKind = 54; 1951 jjmatchedPos = 3; 1952 return 37; 1953 } 1954 if ((active0 & 0x70400L) != 0L) 1955 return 37; 1956 return -1; 1957 case 4: 1958 if ((active0 & 0x1000L) != 0L) 1959 { 1960 jjmatchedKind = 54; 1961 jjmatchedPos = 4; 1962 return 37; 1963 } 1964 if ((active0 & 0x8a000L) != 0L) 1965 return 37; 1966 return -1; 1967 case 5: 1968 if ((active0 & 0x1000L) != 0L) 1969 { 1970 jjmatchedKind = 54; 1971 jjmatchedPos = 5; 1972 return 37; 1973 } 1974 return -1; 1975 default : 1976 return -1; 1977 } 1978 } 1979 private final int jjStartNfa_0(int pos, long active0) 1980 { 1981 return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1); 1982 } 1983 private int jjMoveStringLiteralDfa0_0() 1984 { 1985 switch(curChar) 1986 { 1987 case 33: 1988 return jjMoveStringLiteralDfa1_0(0x4000000000L); 1989 case 38: 1990 return jjStartNfaWithStates_0(0, 51, 6); 1991 case 40: 1992 return jjStopAtPos(0, 21); 1993 case 41: 1994 return jjStopAtPos(0, 22); 1995 case 42: 1996 return jjStopAtPos(0, 49); 1997 case 43: 1998 return jjStopAtPos(0, 47); 1999 case 44: 2000 return jjStopAtPos(0, 29); 2001 case 45: 2002 return jjStopAtPos(0, 48); 2003 case 46: 2004 return jjStopAtPos(0, 30); 2005 case 58: 2006 return jjStopAtPos(0, 28); 2007 case 59: 2008 return jjStopAtPos(0, 27); 2009 case 61: 2010 jjmatchedKind = 43; 2011 return jjMoveStringLiteralDfa1_0(0x2000000000L); 2012 case 63: 2013 jjmatchedKind = 31; 2014 return jjMoveStringLiteralDfa1_0(0x100000000L); 2015 case 91: 2016 return jjStopAtPos(0, 25); 2017 case 93: 2018 return jjStopAtPos(0, 26); 2019 case 94: 2020 return jjStopAtPos(0, 53); 2021 case 101: 2022 return jjMoveStringLiteralDfa1_0(0x8400L); 2023 case 102: 2024 return jjMoveStringLiteralDfa1_0(0x81800L); 2025 case 105: 2026 return jjMoveStringLiteralDfa1_0(0x200L); 2027 case 110: 2028 return jjMoveStringLiteralDfa1_0(0x24000L); 2029 case 115: 2030 return jjMoveStringLiteralDfa1_0(0x10000L); 2031 case 116: 2032 return jjMoveStringLiteralDfa1_0(0x40000L); 2033 case 119: 2034 return jjMoveStringLiteralDfa1_0(0x2000L); 2035 case 123: 2036 return jjStopAtPos(0, 23); 2037 case 124: 2038 return jjStartNfaWithStates_0(0, 52, 11); 2039 case 125: 2040 return jjStopAtPos(0, 24); 2041 case 126: 2042 return jjStopAtPos(0, 50); 2043 default : 2044 return jjMoveNfa_0(5, 0); 2045 } 2046 } 2047 private int jjMoveStringLiteralDfa1_0(long active0) 2048 { 2049 try { curChar = input_stream.readChar(); } 2050 catch(java.io.IOException e) { 2051 jjStopStringLiteralDfa_0(0, active0); 2052 return 1; 2053 } 2054 switch(curChar) 2055 { 2056 case 58: 2057 if ((active0 & 0x100000000L) != 0L) 2058 return jjStopAtPos(1, 32); 2059 break; 2060 case 97: 2061 return jjMoveStringLiteralDfa2_0(active0, 0x80000L); 2062 case 101: 2063 return jjMoveStringLiteralDfa2_0(active0, 0x4000L); 2064 case 102: 2065 if ((active0 & 0x200L) != 0L) 2066 return jjStartNfaWithStates_0(1, 9, 37); 2067 break; 2068 case 104: 2069 return jjMoveStringLiteralDfa2_0(active0, 0x2000L); 2070 case 105: 2071 return jjMoveStringLiteralDfa2_0(active0, 0x10000L); 2072 case 108: 2073 return jjMoveStringLiteralDfa2_0(active0, 0x400L); 2074 case 109: 2075 return jjMoveStringLiteralDfa2_0(active0, 0x8000L); 2076 case 111: 2077 return jjMoveStringLiteralDfa2_0(active0, 0x1800L); 2078 case 114: 2079 return jjMoveStringLiteralDfa2_0(active0, 0x40000L); 2080 case 117: 2081 return jjMoveStringLiteralDfa2_0(active0, 0x20000L); 2082 case 126: 2083 if ((active0 & 0x2000000000L) != 0L) 2084 return jjStopAtPos(1, 37); 2085 else if ((active0 & 0x4000000000L) != 0L) 2086 return jjStopAtPos(1, 38); 2087 break; 2088 default : 2089 break; 2090 } 2091 return jjStartNfa_0(0, active0); 2092 } 2093 private int jjMoveStringLiteralDfa2_0(long old0, long active0) 2094 { 2095 if (((active0 &= old0)) == 0L) 2096 return jjStartNfa_0(0, old0); 2097 try { curChar = input_stream.readChar(); } 2098 catch(java.io.IOException e) { 2099 jjStopStringLiteralDfa_0(1, active0); 2100 return 2; 2101 } 2102 switch(curChar) 2103 { 2104 case 105: 2105 return jjMoveStringLiteralDfa3_0(active0, 0x2000L); 2106 case 108: 2107 return jjMoveStringLiteralDfa3_0(active0, 0xa0000L); 2108 case 112: 2109 return jjMoveStringLiteralDfa3_0(active0, 0x8000L); 2110 case 114: 2111 if ((active0 & 0x800L) != 0L) 2112 { 2113 jjmatchedKind = 11; 2114 jjmatchedPos = 2; 2115 } 2116 return jjMoveStringLiteralDfa3_0(active0, 0x1000L); 2117 case 115: 2118 return jjMoveStringLiteralDfa3_0(active0, 0x400L); 2119 case 117: 2120 return jjMoveStringLiteralDfa3_0(active0, 0x40000L); 2121 case 119: 2122 if ((active0 & 0x4000L) != 0L) 2123 return jjStartNfaWithStates_0(2, 14, 37); 2124 break; 2125 case 122: 2126 return jjMoveStringLiteralDfa3_0(active0, 0x10000L); 2127 default : 2128 break; 2129 } 2130 return jjStartNfa_0(1, active0); 2131 } 2132 private int jjMoveStringLiteralDfa3_0(long old0, long active0) 2133 { 2134 if (((active0 &= old0)) == 0L) 2135 return jjStartNfa_0(1, old0); 2136 try { curChar = input_stream.readChar(); } 2137 catch(java.io.IOException e) { 2138 jjStopStringLiteralDfa_0(2, active0); 2139 return 3; 2140 } 2141 switch(curChar) 2142 { 2143 case 101: 2144 if ((active0 & 0x400L) != 0L) 2145 return jjStartNfaWithStates_0(3, 10, 37); 2146 else if ((active0 & 0x10000L) != 0L) 2147 return jjStartNfaWithStates_0(3, 16, 37); 2148 else if ((active0 & 0x40000L) != 0L) 2149 return jjStartNfaWithStates_0(3, 18, 37); 2150 return jjMoveStringLiteralDfa4_0(active0, 0x1000L); 2151 case 108: 2152 if ((active0 & 0x20000L) != 0L) 2153 return jjStartNfaWithStates_0(3, 17, 37); 2154 return jjMoveStringLiteralDfa4_0(active0, 0x2000L); 2155 case 115: 2156 return jjMoveStringLiteralDfa4_0(active0, 0x80000L); 2157 case 116: 2158 return jjMoveStringLiteralDfa4_0(active0, 0x8000L); 2159 default : 2160 break; 2161 } 2162 return jjStartNfa_0(2, active0); 2163 } 2164 private int jjMoveStringLiteralDfa4_0(long old0, long active0) 2165 { 2166 if (((active0 &= old0)) == 0L) 2167 return jjStartNfa_0(2, old0); 2168 try { curChar = input_stream.readChar(); } 2169 catch(java.io.IOException e) { 2170 jjStopStringLiteralDfa_0(3, active0); 2171 return 4; 2172 } 2173 switch(curChar) 2174 { 2175 case 97: 2176 return jjMoveStringLiteralDfa5_0(active0, 0x1000L); 2177 case 101: 2178 if ((active0 & 0x2000L) != 0L) 2179 return jjStartNfaWithStates_0(4, 13, 37); 2180 else if ((active0 & 0x80000L) != 0L) 2181 return jjStartNfaWithStates_0(4, 19, 37); 2182 break; 2183 case 121: 2184 if ((active0 & 0x8000L) != 0L) 2185 return jjStartNfaWithStates_0(4, 15, 37); 2186 break; 2187 default : 2188 break; 2189 } 2190 return jjStartNfa_0(3, active0); 2191 } 2192 private int jjMoveStringLiteralDfa5_0(long old0, long active0) 2193 { 2194 if (((active0 &= old0)) == 0L) 2195 return jjStartNfa_0(3, old0); 2196 try { curChar = input_stream.readChar(); } 2197 catch(java.io.IOException e) { 2198 jjStopStringLiteralDfa_0(4, active0); 2199 return 5; 2200 } 2201 switch(curChar) 2202 { 2203 case 99: 2204 return jjMoveStringLiteralDfa6_0(active0, 0x1000L); 2205 default : 2206 break; 2207 } 2208 return jjStartNfa_0(4, active0); 2209 } 2210 private int jjMoveStringLiteralDfa6_0(long old0, long active0) 2211 { 2212 if (((active0 &= old0)) == 0L) 2213 return jjStartNfa_0(4, old0); 2214 try { curChar = input_stream.readChar(); } 2215 catch(java.io.IOException e) { 2216 jjStopStringLiteralDfa_0(5, active0); 2217 return 6; 2218 } 2219 switch(curChar) 2220 { 2221 case 104: 2222 if ((active0 & 0x1000L) != 0L) 2223 return jjStartNfaWithStates_0(6, 12, 37); 2224 break; 2225 default : 2226 break; 2227 } 2228 return jjStartNfa_0(5, active0); 2229 } 2230 private int jjStartNfaWithStates_0(int pos, int kind, int state) 2231 { 2232 jjmatchedKind = kind; 2233 jjmatchedPos = pos; 2234 try { curChar = input_stream.readChar(); } 2235 catch(java.io.IOException e) { return pos + 1; } 2236 return jjMoveNfa_0(state, pos + 1); 2237 } 2238 private int jjMoveNfa_0(int startState, int curPos) 2239 { 2240 int startsAt = 0; 2241 jjnewStateCnt = 77; 2242 int i = 1; 2243 jjstateSet[0] = startState; 2244 int kind = 0x7fffffff; 2245 for (;;) 2246 { 2247 if (++jjround == 0x7fffffff) 2248 ReInitRounds(); 2249 if (curChar < 64) 2250 { 2251 long l = 1L << curChar; 2252 do 2253 { 2254 switch(jjstateSet[--i]) 2255 { 2256 case 5: 2257 if ((0x3ff000000000000L & l) != 0L) 2258 { 2259 if (kind > 58) 2260 kind = 58; 2261 jjCheckNAddStates(26, 28); 2262 } 2263 else if (curChar == 47) 2264 jjAddStates(29, 30); 2265 else if (curChar == 39) 2266 jjCheckNAddStates(31, 33); 2267 else if (curChar == 34) 2268 jjCheckNAddStates(34, 36); 2269 else if (curChar == 35) 2270 jjstateSet[jjnewStateCnt++] = 39; 2271 else if (curChar == 36) 2272 { 2273 if (kind > 54) 2274 kind = 54; 2275 jjCheckNAdd(37); 2276 } 2277 else if (curChar == 33) 2278 { 2279 if (kind > 46) 2280 kind = 46; 2281 } 2282 else if (curChar == 37) 2283 { 2284 if (kind > 44) 2285 kind = 44; 2286 } 2287 else if (curChar == 60) 2288 jjstateSet[jjnewStateCnt++] = 25; 2289 else if (curChar == 62) 2290 jjstateSet[jjnewStateCnt++] = 22; 2291 else if (curChar == 61) 2292 jjstateSet[jjnewStateCnt++] = 15; 2293 else if (curChar == 38) 2294 jjstateSet[jjnewStateCnt++] = 6; 2295 if (curChar == 47) 2296 { 2297 if (kind > 45) 2298 kind = 45; 2299 } 2300 else if (curChar == 60) 2301 { 2302 if (kind > 41) 2303 kind = 41; 2304 } 2305 else if (curChar == 62) 2306 { 2307 if (kind > 39) 2308 kind = 39; 2309 } 2310 else if (curChar == 33) 2311 jjstateSet[jjnewStateCnt++] = 19; 2312 else if (curChar == 35) 2313 jjstateSet[jjnewStateCnt++] = 0; 2314 break; 2315 case 63: 2316 case 37: 2317 if ((0x3ff001000000000L & l) == 0L) 2318 break; 2319 if (kind > 54) 2320 kind = 54; 2321 jjCheckNAdd(37); 2322 break; 2323 case 17: 2324 if ((0x3ff001000000000L & l) == 0L) 2325 break; 2326 if (kind > 54) 2327 kind = 54; 2328 jjCheckNAdd(37); 2329 break; 2330 case 0: 2331 if (curChar != 35) 2332 break; 2333 if (kind > 1) 2334 kind = 1; 2335 jjCheckNAddStates(11, 13); 2336 break; 2337 case 1: 2338 if ((0xffffffffffffdbffL & l) == 0L) 2339 break; 2340 if (kind > 1) 2341 kind = 1; 2342 jjCheckNAddStates(11, 13); 2343 break; 2344 case 2: 2345 if ((0x2400L & l) != 0L && kind > 1) 2346 kind = 1; 2347 break; 2348 case 3: 2349 if (curChar == 10 && kind > 1) 2350 kind = 1; 2351 break; 2352 case 4: 2353 if (curChar == 13) 2354 jjstateSet[jjnewStateCnt++] = 3; 2355 break; 2356 case 6: 2357 if (curChar == 38 && kind > 33) 2358 kind = 33; 2359 break; 2360 case 7: 2361 if (curChar == 38) 2362 jjstateSet[jjnewStateCnt++] = 6; 2363 break; 2364 case 15: 2365 if (curChar == 61 && kind > 35) 2366 kind = 35; 2367 break; 2368 case 16: 2369 if (curChar == 61) 2370 jjstateSet[jjnewStateCnt++] = 15; 2371 break; 2372 case 19: 2373 if (curChar == 61 && kind > 36) 2374 kind = 36; 2375 break; 2376 case 20: 2377 if (curChar == 33) 2378 jjstateSet[jjnewStateCnt++] = 19; 2379 break; 2380 case 21: 2381 if (curChar == 62 && kind > 39) 2382 kind = 39; 2383 break; 2384 case 22: 2385 if (curChar == 61 && kind > 40) 2386 kind = 40; 2387 break; 2388 case 23: 2389 if (curChar == 62) 2390 jjstateSet[jjnewStateCnt++] = 22; 2391 break; 2392 case 24: 2393 if (curChar == 60 && kind > 41) 2394 kind = 41; 2395 break; 2396 case 25: 2397 if (curChar == 61 && kind > 42) 2398 kind = 42; 2399 break; 2400 case 26: 2401 if (curChar == 60) 2402 jjstateSet[jjnewStateCnt++] = 25; 2403 break; 2404 case 27: 2405 if (curChar == 37 && kind > 44) 2406 kind = 44; 2407 break; 2408 case 31: 2409 if (curChar == 47 && kind > 45) 2410 kind = 45; 2411 break; 2412 case 35: 2413 if (curChar == 33 && kind > 46) 2414 kind = 46; 2415 break; 2416 case 36: 2417 if (curChar != 36) 2418 break; 2419 if (kind > 54) 2420 kind = 54; 2421 jjCheckNAdd(37); 2422 break; 2423 case 38: 2424 if (curChar == 35) 2425 jjstateSet[jjnewStateCnt++] = 39; 2426 break; 2427 case 39: 2428 if ((0x3ff000000000000L & l) != 0L && kind > 57) 2429 kind = 57; 2430 break; 2431 case 40: 2432 if (curChar == 34) 2433 jjCheckNAddStates(34, 36); 2434 break; 2435 case 41: 2436 if ((0xfffffffbffffdbffL & l) != 0L) 2437 jjCheckNAddStates(34, 36); 2438 break; 2439 case 43: 2440 if ((0xffffffffffffdbffL & l) != 0L) 2441 jjCheckNAddStates(34, 36); 2442 break; 2443 case 44: 2444 if (curChar == 34 && kind > 60) 2445 kind = 60; 2446 break; 2447 case 45: 2448 if (curChar == 39) 2449 jjCheckNAddStates(31, 33); 2450 break; 2451 case 46: 2452 if ((0xffffff7fffffdbffL & l) != 0L) 2453 jjCheckNAddStates(31, 33); 2454 break; 2455 case 48: 2456 if ((0xffffffffffffdbffL & l) != 0L) 2457 jjCheckNAddStates(31, 33); 2458 break; 2459 case 49: 2460 if (curChar == 39 && kind > 60) 2461 kind = 60; 2462 break; 2463 case 50: 2464 if (curChar == 47) 2465 jjAddStates(29, 30); 2466 break; 2467 case 51: 2468 if (curChar == 42) 2469 jjCheckNAddTwoStates(52, 53); 2470 break; 2471 case 52: 2472 if ((0xfffffbffffffffffL & l) != 0L) 2473 jjCheckNAddTwoStates(52, 53); 2474 break; 2475 case 53: 2476 if (curChar == 42) 2477 jjCheckNAddStates(37, 39); 2478 break; 2479 case 54: 2480 if ((0xffff7bffffffffffL & l) != 0L) 2481 jjCheckNAddTwoStates(55, 53); 2482 break; 2483 case 55: 2484 if ((0xfffffbffffffffffL & l) != 0L) 2485 jjCheckNAddTwoStates(55, 53); 2486 break; 2487 case 56: 2488 if (curChar == 47 && kind > 2) 2489 kind = 2; 2490 break; 2491 case 57: 2492 if (curChar != 47) 2493 break; 2494 if (kind > 3) 2495 kind = 3; 2496 jjCheckNAddStates(40, 42); 2497 break; 2498 case 58: 2499 if ((0xffffffffffffdbffL & l) == 0L) 2500 break; 2501 if (kind > 3) 2502 kind = 3; 2503 jjCheckNAddStates(40, 42); 2504 break; 2505 case 59: 2506 if ((0x2400L & l) != 0L && kind > 3) 2507 kind = 3; 2508 break; 2509 case 60: 2510 if (curChar == 10 && kind > 3) 2511 kind = 3; 2512 break; 2513 case 61: 2514 if (curChar == 13) 2515 jjstateSet[jjnewStateCnt++] = 60; 2516 break; 2517 case 72: 2518 if ((0x3ff000000000000L & l) == 0L) 2519 break; 2520 if (kind > 58) 2521 kind = 58; 2522 jjCheckNAddStates(26, 28); 2523 break; 2524 case 73: 2525 if ((0x3ff000000000000L & l) == 0L) 2526 break; 2527 if (kind > 58) 2528 kind = 58; 2529 jjCheckNAdd(73); 2530 break; 2531 case 74: 2532 if ((0x3ff000000000000L & l) != 0L) 2533 jjCheckNAddTwoStates(74, 75); 2534 break; 2535 case 75: 2536 if (curChar == 46) 2537 jjCheckNAdd(76); 2538 break; 2539 case 76: 2540 if ((0x3ff000000000000L & l) == 0L) 2541 break; 2542 if (kind > 59) 2543 kind = 59; 2544 jjCheckNAdd(76); 2545 break; 2546 default : break; 2547 } 2548 } while(i != startsAt); 2549 } 2550 else if (curChar < 128) 2551 { 2552 long l = 1L << (curChar & 077); 2553 do 2554 { 2555 switch(jjstateSet[--i]) 2556 { 2557 case 5: 2558 if ((0x7fffffe87fffffeL & l) != 0L) 2559 { 2560 if (kind > 54) 2561 kind = 54; 2562 jjCheckNAdd(37); 2563 } 2564 else if (curChar == 124) 2565 jjstateSet[jjnewStateCnt++] = 11; 2566 if (curChar == 108) 2567 jjAddStates(43, 44); 2568 else if (curChar == 103) 2569 jjAddStates(45, 46); 2570 else if (curChar == 110) 2571 jjAddStates(47, 48); 2572 else if (curChar == 100) 2573 jjstateSet[jjnewStateCnt++] = 33; 2574 else if (curChar == 109) 2575 jjstateSet[jjnewStateCnt++] = 29; 2576 else if (curChar == 101) 2577 jjstateSet[jjnewStateCnt++] = 17; 2578 else if (curChar == 111) 2579 jjstateSet[jjnewStateCnt++] = 13; 2580 else if (curChar == 97) 2581 jjstateSet[jjnewStateCnt++] = 9; 2582 break; 2583 case 63: 2584 if ((0x7fffffe87fffffeL & l) != 0L) 2585 { 2586 if (kind > 54) 2587 kind = 54; 2588 jjCheckNAdd(37); 2589 } 2590 if (curChar == 111) 2591 jjstateSet[jjnewStateCnt++] = 64; 2592 else if (curChar == 101) 2593 { 2594 if (kind > 36) 2595 kind = 36; 2596 } 2597 break; 2598 case 17: 2599 if ((0x7fffffe87fffffeL & l) != 0L) 2600 { 2601 if (kind > 54) 2602 kind = 54; 2603 jjCheckNAdd(37); 2604 } 2605 if (curChar == 113) 2606 { 2607 if (kind > 35) 2608 kind = 35; 2609 } 2610 break; 2611 case 1: 2612 if (kind > 1) 2613 kind = 1; 2614 jjAddStates(11, 13); 2615 break; 2616 case 8: 2617 if (curChar == 100 && kind > 33) 2618 kind = 33; 2619 break; 2620 case 9: 2621 if (curChar == 110) 2622 jjstateSet[jjnewStateCnt++] = 8; 2623 break; 2624 case 10: 2625 if (curChar == 97) 2626 jjstateSet[jjnewStateCnt++] = 9; 2627 break; 2628 case 11: 2629 if (curChar == 124 && kind > 34) 2630 kind = 34; 2631 break; 2632 case 12: 2633 if (curChar == 124) 2634 jjstateSet[jjnewStateCnt++] = 11; 2635 break; 2636 case 13: 2637 if (curChar == 114 && kind > 34) 2638 kind = 34; 2639 break; 2640 case 14: 2641 if (curChar == 111) 2642 jjstateSet[jjnewStateCnt++] = 13; 2643 break; 2644 case 18: 2645 if (curChar == 101) 2646 jjstateSet[jjnewStateCnt++] = 17; 2647 break; 2648 case 28: 2649 if (curChar == 100 && kind > 44) 2650 kind = 44; 2651 break; 2652 case 29: 2653 if (curChar == 111) 2654 jjstateSet[jjnewStateCnt++] = 28; 2655 break; 2656 case 30: 2657 if (curChar == 109) 2658 jjstateSet[jjnewStateCnt++] = 29; 2659 break; 2660 case 32: 2661 if (curChar == 118 && kind > 45) 2662 kind = 45; 2663 break; 2664 case 33: 2665 if (curChar == 105) 2666 jjstateSet[jjnewStateCnt++] = 32; 2667 break; 2668 case 34: 2669 if (curChar == 100) 2670 jjstateSet[jjnewStateCnt++] = 33; 2671 break; 2672 case 36: 2673 if ((0x7fffffe87fffffeL & l) == 0L) 2674 break; 2675 if (kind > 54) 2676 kind = 54; 2677 jjCheckNAdd(37); 2678 break; 2679 case 37: 2680 if ((0x7fffffe87fffffeL & l) == 0L) 2681 break; 2682 if (kind > 54) 2683 kind = 54; 2684 jjCheckNAdd(37); 2685 break; 2686 case 41: 2687 if ((0xffffffffefffffffL & l) != 0L) 2688 jjCheckNAddStates(34, 36); 2689 break; 2690 case 42: 2691 if (curChar == 92) 2692 jjstateSet[jjnewStateCnt++] = 43; 2693 break; 2694 case 43: 2695 jjCheckNAddStates(34, 36); 2696 break; 2697 case 46: 2698 if ((0xffffffffefffffffL & l) != 0L) 2699 jjCheckNAddStates(31, 33); 2700 break; 2701 case 47: 2702 if (curChar == 92) 2703 jjstateSet[jjnewStateCnt++] = 48; 2704 break; 2705 case 48: 2706 jjCheckNAddStates(31, 33); 2707 break; 2708 case 52: 2709 jjCheckNAddTwoStates(52, 53); 2710 break; 2711 case 54: 2712 case 55: 2713 jjCheckNAddTwoStates(55, 53); 2714 break; 2715 case 58: 2716 if (kind > 3) 2717 kind = 3; 2718 jjAddStates(40, 42); 2719 break; 2720 case 62: 2721 if (curChar == 110) 2722 jjAddStates(47, 48); 2723 break; 2724 case 64: 2725 if (curChar == 116 && kind > 46) 2726 kind = 46; 2727 break; 2728 case 65: 2729 if (curChar == 111) 2730 jjstateSet[jjnewStateCnt++] = 64; 2731 break; 2732 case 66: 2733 if (curChar == 103) 2734 jjAddStates(45, 46); 2735 break; 2736 case 67: 2737 if (curChar == 116 && kind > 39) 2738 kind = 39; 2739 break; 2740 case 68: 2741 if (curChar == 101 && kind > 40) 2742 kind = 40; 2743 break; 2744 case 69: 2745 if (curChar == 108) 2746 jjAddStates(43, 44); 2747 break; 2748 case 70: 2749 if (curChar == 116 && kind > 41) 2750 kind = 41; 2751 break; 2752 case 71: 2753 if (curChar == 101 && kind > 42) 2754 kind = 42; 2755 break; 2756 default : break; 2757 } 2758 } while(i != startsAt); 2759 } 2760 else 2761 { 2762 int hiByte = (int)(curChar >> 8); 2763 int i1 = hiByte >> 6; 2764 long l1 = 1L << (hiByte & 077); 2765 int i2 = (curChar & 0xff) >> 6; 2766 long l2 = 1L << (curChar & 077); 2767 do 2768 { 2769 switch(jjstateSet[--i]) 2770 { 2771 case 1: 2772 if (!jjCanMove_0(hiByte, i1, i2, l1, l2)) 2773 break; 2774 if (kind > 1) 2775 kind = 1; 2776 jjAddStates(11, 13); 2777 break; 2778 case 41: 2779 case 43: 2780 if (jjCanMove_1(hiByte, i1, i2, l1, l2)) 2781 jjCheckNAddStates(34, 36); 2782 break; 2783 case 46: 2784 case 48: 2785 if (jjCanMove_1(hiByte, i1, i2, l1, l2)) 2786 jjCheckNAddStates(31, 33); 2787 break; 2788 case 52: 2789 if (jjCanMove_0(hiByte, i1, i2, l1, l2)) 2790 jjCheckNAddTwoStates(52, 53); 2791 break; 2792 case 54: 2793 case 55: 2794 if (jjCanMove_0(hiByte, i1, i2, l1, l2)) 2795 jjCheckNAddTwoStates(55, 53); 2796 break; 2797 case 58: 2798 if (!jjCanMove_0(hiByte, i1, i2, l1, l2)) 2799 break; 2800 if (kind > 3) 2801 kind = 3; 2802 jjAddStates(40, 42); 2803 break; 2804 default : break; 2805 } 2806 } while(i != startsAt); 2807 } 2808 if (kind != 0x7fffffff) 2809 { 2810 jjmatchedKind = kind; 2811 jjmatchedPos = curPos; 2812 kind = 0x7fffffff; 2813 } 2814 ++curPos; 2815 if ((i = jjnewStateCnt) == (startsAt = 77 - (jjnewStateCnt = startsAt))) 2816 return curPos; 2817 try { curChar = input_stream.readChar(); } 2818 catch(java.io.IOException e) { return curPos; } 2819 } 2820 } 2821 static final int[] jjnextStates = { 2822 71, 72, 73, 49, 55, 44, 45, 47, 39, 40, 42, 1, 2, 4, 51, 52, 2823 54, 56, 57, 59, 68, 69, 65, 66, 61, 63, 73, 74, 75, 51, 57, 46, 2824 47, 49, 41, 42, 44, 53, 54, 56, 58, 59, 61, 70, 71, 67, 68, 63, 2825 65, 2826 }; 2827 private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2) 2828 { 2829 switch(hiByte) 2830 { 2831 case 0: 2832 return ((jjbitVec2[i2] & l2) != 0L); 2833 default : 2834 if ((jjbitVec0[i1] & l1) != 0L) 2835 return true; 2836 return false; 2837 } 2838 } 2839 private static final boolean jjCanMove_1(int hiByte, int i1, int i2, long l1, long l2) 2840 { 2841 switch(hiByte) 2842 { 2843 case 0: 2844 return ((jjbitVec2[i2] & l2) != 0L); 2845 case 32: 2846 return ((jjbitVec4[i2] & l2) != 0L); 2847 default : 2848 if ((jjbitVec3[i1] & l1) != 0L) 2849 return true; 2850 return false; 2851 } 2852 } 2853 2854 /** Token literal values. */ 2855 public static final String[] jjstrLiteralImages = { 2856 "", null, null, null, null, null, null, null, null, "\151\146", 2857 "\145\154\163\145", "\146\157\162", "\146\157\162\145\141\143\150", "\167\150\151\154\145", 2858 "\156\145\167", "\145\155\160\164\171", "\163\151\172\145", "\156\165\154\154", 2859 "\164\162\165\145", "\146\141\154\163\145", "\151\156", "\50", "\51", "\173", "\175", "\133", 2860 "\135", "\73", "\72", "\54", "\56", "\77", "\77\72", null, null, null, null, 2861 "\75\176", "\41\176", null, null, null, null, "\75", null, null, null, "\53", "\55", 2862 "\52", "\176", "\46", "\174", "\136", null, null, null, null, null, null, null, }; 2863 2864 /** Lexer state names. */ 2865 public static final String[] lexStateNames = { 2866 "REGISTERS", 2867 "FOR_EACH_IN", 2868 "DEFAULT", 2869 }; 2870 2871 /** Lex State array. */ 2872 public static final int[] jjnewLexState = { 2873 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, -1, -1, -1, -1, -1, -1, -1, 2, -1, -1, -1, -1, 2874 -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, 2875 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2876 }; 2877 static final long[] jjtoToken = { 2878 0x1e7ffffffffffe01L, 2879 }; 2880 static final long[] jjtoSkip = { 2881 0x1feL, 2882 }; 2883 protected SimpleCharStream input_stream; 2884 private final int[] jjrounds = new int[77]; 2885 private final int[] jjstateSet = new int[154]; 2886 protected char curChar; 2887 /** Constructor. */ 2888 public ParserTokenManager(SimpleCharStream stream){ 2889 if (SimpleCharStream.staticFlag) 2890 throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer."); 2891 input_stream = stream; 2892 } 2893 2894 /** Constructor. */ 2895 public ParserTokenManager(SimpleCharStream stream, int lexState){ 2896 this(stream); 2897 SwitchTo(lexState); 2898 } 2899 2900 /** Reinitialise parser. */ 2901 public void ReInit(SimpleCharStream stream) 2902 { 2903 jjmatchedPos = jjnewStateCnt = 0; 2904 curLexState = defaultLexState; 2905 input_stream = stream; 2906 ReInitRounds(); 2907 } 2908 private void ReInitRounds() 2909 { 2910 int i; 2911 jjround = 0x80000001; 2912 for (i = 77; i-- > 0;) 2913 jjrounds[i] = 0x80000000; 2914 } 2915 2916 /** Reinitialise parser. */ 2917 public void ReInit(SimpleCharStream stream, int lexState) 2918 { 2919 ReInit(stream); 2920 SwitchTo(lexState); 2921 } 2922 2923 /** Switch to specified lex state. */ 2924 public void SwitchTo(int lexState) 2925 { 2926 if (lexState >= 3 || lexState < 0) 2927 throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE); 2928 else 2929 curLexState = lexState; 2930 } 2931 2932 protected Token jjFillToken() 2933 { 2934 final Token t; 2935 final String curTokenImage; 2936 final int beginLine; 2937 final int endLine; 2938 final int beginColumn; 2939 final int endColumn; 2940 String im = jjstrLiteralImages[jjmatchedKind]; 2941 curTokenImage = (im == null) ? input_stream.GetImage() : im; 2942 beginLine = input_stream.getBeginLine(); 2943 beginColumn = input_stream.getBeginColumn(); 2944 endLine = input_stream.getEndLine(); 2945 endColumn = input_stream.getEndColumn(); 2946 t = Token.newToken(jjmatchedKind, curTokenImage); 2947 2948 t.beginLine = beginLine; 2949 t.endLine = endLine; 2950 t.beginColumn = beginColumn; 2951 t.endColumn = endColumn; 2952 2953 return t; 2954 } 2955 2956 int curLexState = 2; 2957 int defaultLexState = 2; 2958 int jjnewStateCnt; 2959 int jjround; 2960 int jjmatchedPos; 2961 int jjmatchedKind; 2962 2963 /** Get the next Token. */ 2964 public Token getNextToken() 2965 { 2966 Token matchedToken; 2967 int curPos = 0; 2968 2969 EOFLoop : 2970 for (;;) 2971 { 2972 try 2973 { 2974 curChar = input_stream.BeginToken(); 2975 } 2976 catch(java.io.IOException e) 2977 { 2978 jjmatchedKind = 0; 2979 matchedToken = jjFillToken(); 2980 return matchedToken; 2981 } 2982 2983 switch(curLexState) 2984 { 2985 case 0: 2986 try { input_stream.backup(0); 2987 while (curChar <= 32 && (0x100003600L & (1L << curChar)) != 0L) 2988 curChar = input_stream.BeginToken(); 2989 } 2990 catch (java.io.IOException e1) { continue EOFLoop; } 2991 jjmatchedKind = 0x7fffffff; 2992 jjmatchedPos = 0; 2993 curPos = jjMoveStringLiteralDfa0_0(); 2994 break; 2995 case 1: 2996 try { input_stream.backup(0); 2997 while (curChar <= 32 && (0x100003600L & (1L << curChar)) != 0L) 2998 curChar = input_stream.BeginToken(); 2999 } 3000 catch (java.io.IOException e1) { continue EOFLoop; } 3001 jjmatchedKind = 0x7fffffff; 3002 jjmatchedPos = 0; 3003 curPos = jjMoveStringLiteralDfa0_1(); 3004 break; 3005 case 2: 3006 try { input_stream.backup(0); 3007 while (curChar <= 32 && (0x100003600L & (1L << curChar)) != 0L) 3008 curChar = input_stream.BeginToken(); 3009 } 3010 catch (java.io.IOException e1) { continue EOFLoop; } 3011 jjmatchedKind = 0x7fffffff; 3012 jjmatchedPos = 0; 3013 curPos = jjMoveStringLiteralDfa0_2(); 3014 break; 3015 } 3016 if (jjmatchedKind != 0x7fffffff) 3017 { 3018 if (jjmatchedPos + 1 < curPos) 3019 input_stream.backup(curPos - jjmatchedPos - 1); 3020 if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) 3021 { 3022 matchedToken = jjFillToken(); 3023 if (jjnewLexState[jjmatchedKind] != -1) 3024 curLexState = jjnewLexState[jjmatchedKind]; 3025 return matchedToken; 3026 } 3027 else 3028 { 3029 if (jjnewLexState[jjmatchedKind] != -1) 3030 curLexState = jjnewLexState[jjmatchedKind]; 3031 continue EOFLoop; 3032 } 3033 } 3034 int error_line = input_stream.getEndLine(); 3035 int error_column = input_stream.getEndColumn(); 3036 String error_after = null; 3037 boolean EOFSeen = false; 3038 try { input_stream.readChar(); input_stream.backup(1); } 3039 catch (java.io.IOException e1) { 3040 EOFSeen = true; 3041 error_after = curPos <= 1 ? "" : input_stream.GetImage(); 3042 if (curChar == '\n' || curChar == '\r') { 3043 error_line++; 3044 error_column = 0; 3045 } 3046 else 3047 error_column++; 3048 } 3049 if (!EOFSeen) { 3050 input_stream.backup(1); 3051 error_after = curPos <= 1 ? "" : input_stream.GetImage(); 3052 } 3053 throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR); 3054 } 3055 } 3056 3057 private void jjCheckNAdd(int state) 3058 { 3059 if (jjrounds[state] != jjround) 3060 { 3061 jjstateSet[jjnewStateCnt++] = state; 3062 jjrounds[state] = jjround; 3063 } 3064 } 3065 private void jjAddStates(int start, int end) 3066 { 3067 do { 3068 jjstateSet[jjnewStateCnt++] = jjnextStates[start]; 3069 } while (start++ != end); 3070 } 3071 private void jjCheckNAddTwoStates(int state1, int state2) 3072 { 3073 jjCheckNAdd(state1); 3074 jjCheckNAdd(state2); 3075 } 3076 3077 private void jjCheckNAddStates(int start, int end) 3078 { 3079 do { 3080 jjCheckNAdd(jjnextStates[start]); 3081 } while (start++ != end); 3082 } 3083 3084 }