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