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