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