0001 /* Generated By:JJTree&JavaCC: Do not edit this line. JspParserTokenManager.java */
0002 package net.sourceforge.pmd.lang.jsp.ast;
0003 import net.sourceforge.pmd.lang.ast.CharStream;
0004 import net.sourceforge.pmd.lang.ast.TokenMgrError;
0005
0006 /** Token Manager. */
0007 public class JspParserTokenManager extends net.sourceforge.pmd.lang.ast.AbstractTokenManager implements JspParserConstants
0008 {
0009
0010 /** Debug output. */
0011 public java.io.PrintStream debugStream = System.out;
0012 /** Set debug output. */
0013 public void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
0014 private final int jjStopStringLiteralDfa_9(int pos, long active0)
0015 {
0016 switch (pos)
0017 {
0018 case 0:
0019 if ((active0 & 0x40000000000L) != 0L)
0020 return 2;
0021 return -1;
0022 default :
0023 return -1;
0024 }
0025 }
0026 private final int jjStartNfa_9(int pos, long active0)
0027 {
0028 return jjMoveNfa_9(jjStopStringLiteralDfa_9(pos, active0), pos + 1);
0029 }
0030 private int jjStopAtPos(int pos, int kind)
0031 {
0032 jjmatchedKind = kind;
0033 jjmatchedPos = pos;
0034 return pos + 1;
0035 }
0036 private int jjMoveStringLiteralDfa0_9()
0037 {
0038 switch(curChar)
0039 {
0040 case 37:
0041 return jjMoveStringLiteralDfa1_9(0x40000000000L);
0042 default :
0043 return jjMoveNfa_9(3, 0);
0044 }
0045 }
0046 private int jjMoveStringLiteralDfa1_9(long active0)
0047 {
0048 try { curChar = input_stream.readChar(); }
0049 catch(java.io.IOException e) {
0050 jjStopStringLiteralDfa_9(0, active0);
0051 return 1;
0052 }
0053 switch(curChar)
0054 {
0055 case 62:
0056 if ((active0 & 0x40000000000L) != 0L)
0057 return jjStopAtPos(1, 42);
0058 break;
0059 default :
0060 break;
0061 }
0062 return jjStartNfa_9(0, active0);
0063 }
0064 static final long[] jjbitVec0 = {
0065 0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
0066 };
0067 private int jjMoveNfa_9(int startState, int curPos)
0068 {
0069 int startsAt = 0;
0070 jjnewStateCnt = 3;
0071 int i = 1;
0072 jjstateSet[0] = startState;
0073 int kind = 0x7fffffff;
0074 for (;;)
0075 {
0076 if (++jjround == 0x7fffffff)
0077 ReInitRounds();
0078 if (curChar < 64)
0079 {
0080 long l = 1L << curChar;
0081 do
0082 {
0083 switch(jjstateSet[--i])
0084 {
0085 case 3:
0086 if ((0xffffffdfffffffffL & l) != 0L)
0087 {
0088 if (kind > 43)
0089 kind = 43;
0090 jjCheckNAddTwoStates(0, 1);
0091 }
0092 else if (curChar == 37)
0093 jjstateSet[jjnewStateCnt++] = 2;
0094 break;
0095 case 0:
0096 if ((0xffffffdfffffffffL & l) == 0L)
0097 break;
0098 if (kind > 43)
0099 kind = 43;
0100 jjCheckNAddTwoStates(0, 1);
0101 break;
0102 case 1:
0103 if (curChar == 37)
0104 jjstateSet[jjnewStateCnt++] = 2;
0105 break;
0106 case 2:
0107 if ((0xbfffffffffffffffL & l) == 0L)
0108 break;
0109 if (kind > 43)
0110 kind = 43;
0111 jjCheckNAddTwoStates(0, 1);
0112 break;
0113 default : break;
0114 }
0115 } while(i != startsAt);
0116 }
0117 else if (curChar < 128)
0118 {
0119 long l = 1L << (curChar & 077);
0120 do
0121 {
0122 switch(jjstateSet[--i])
0123 {
0124 case 3:
0125 case 0:
0126 case 2:
0127 if (kind > 43)
0128 kind = 43;
0129 jjCheckNAddTwoStates(0, 1);
0130 break;
0131 default : break;
0132 }
0133 } while(i != startsAt);
0134 }
0135 else
0136 {
0137 int i2 = (curChar & 0xff) >> 6;
0138 long l2 = 1L << (curChar & 077);
0139 do
0140 {
0141 switch(jjstateSet[--i])
0142 {
0143 case 3:
0144 case 0:
0145 case 2:
0146 if ((jjbitVec0[i2] & l2) == 0L)
0147 break;
0148 if (kind > 43)
0149 kind = 43;
0150 jjCheckNAddTwoStates(0, 1);
0151 break;
0152 default : break;
0153 }
0154 } while(i != startsAt);
0155 }
0156 if (kind != 0x7fffffff)
0157 {
0158 jjmatchedKind = kind;
0159 jjmatchedPos = curPos;
0160 kind = 0x7fffffff;
0161 }
0162 ++curPos;
0163 if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
0164 return curPos;
0165 try { curChar = input_stream.readChar(); }
0166 catch(java.io.IOException e) { return curPos; }
0167 }
0168 }
0169 private int jjMoveStringLiteralDfa0_4()
0170 {
0171 switch(curChar)
0172 {
0173 case 93:
0174 return jjMoveStringLiteralDfa1_4(0x80000000000000L);
0175 default :
0176 return 1;
0177 }
0178 }
0179 private int jjMoveStringLiteralDfa1_4(long active0)
0180 {
0181 try { curChar = input_stream.readChar(); }
0182 catch(java.io.IOException e) {
0183 return 1;
0184 }
0185 switch(curChar)
0186 {
0187 case 93:
0188 return jjMoveStringLiteralDfa2_4(active0, 0x80000000000000L);
0189 default :
0190 return 2;
0191 }
0192 }
0193 private int jjMoveStringLiteralDfa2_4(long old0, long active0)
0194 {
0195 if (((active0 &= old0)) == 0L)
0196 return 2;
0197 try { curChar = input_stream.readChar(); }
0198 catch(java.io.IOException e) {
0199 return 2;
0200 }
0201 switch(curChar)
0202 {
0203 case 62:
0204 if ((active0 & 0x80000000000000L) != 0L)
0205 return jjStopAtPos(2, 55);
0206 break;
0207 default :
0208 return 3;
0209 }
0210 return 3;
0211 }
0212 private int jjMoveStringLiteralDfa0_6()
0213 {
0214 return jjMoveNfa_6(1, 0);
0215 }
0216 static final long[] jjbitVec1 = {
0217 0x0L, 0x0L, 0x0L, 0xff7fffffff7fffffL
0218 };
0219 private int jjMoveNfa_6(int startState, int curPos)
0220 {
0221 int startsAt = 0;
0222 jjnewStateCnt = 3;
0223 int i = 1;
0224 jjstateSet[0] = startState;
0225 int kind = 0x7fffffff;
0226 for (;;)
0227 {
0228 if (++jjround == 0x7fffffff)
0229 ReInitRounds();
0230 if (curChar < 64)
0231 {
0232 long l = 1L << curChar;
0233 do
0234 {
0235 switch(jjstateSet[--i])
0236 {
0237 case 1:
0238 if ((0x100002600L & l) != 0L)
0239 {
0240 if (kind > 48)
0241 kind = 48;
0242 jjCheckNAdd(0);
0243 }
0244 else if ((0x400001000000000L & l) != 0L)
0245 {
0246 if (kind > 49)
0247 kind = 49;
0248 jjCheckNAdd(2);
0249 }
0250 break;
0251 case 0:
0252 if ((0x100002600L & l) == 0L)
0253 break;
0254 kind = 48;
0255 jjCheckNAdd(0);
0256 break;
0257 case 2:
0258 if ((0x7ff601000000000L & l) == 0L)
0259 break;
0260 if (kind > 49)
0261 kind = 49;
0262 jjCheckNAdd(2);
0263 break;
0264 default : break;
0265 }
0266 } while(i != startsAt);
0267 }
0268 else if (curChar < 128)
0269 {
0270 long l = 1L << (curChar & 077);
0271 do
0272 {
0273 switch(jjstateSet[--i])
0274 {
0275 case 1:
0276 case 2:
0277 if ((0x7fffffe87fffffeL & l) == 0L)
0278 break;
0279 if (kind > 49)
0280 kind = 49;
0281 jjCheckNAdd(2);
0282 break;
0283 default : break;
0284 }
0285 } while(i != startsAt);
0286 }
0287 else
0288 {
0289 int i2 = (curChar & 0xff) >> 6;
0290 long l2 = 1L << (curChar & 077);
0291 do
0292 {
0293 switch(jjstateSet[--i])
0294 {
0295 case 1:
0296 case 2:
0297 if ((jjbitVec1[i2] & l2) == 0L)
0298 break;
0299 if (kind > 49)
0300 kind = 49;
0301 jjCheckNAdd(2);
0302 break;
0303 default : break;
0304 }
0305 } while(i != startsAt);
0306 }
0307 if (kind != 0x7fffffff)
0308 {
0309 jjmatchedKind = kind;
0310 jjmatchedPos = curPos;
0311 kind = 0x7fffffff;
0312 }
0313 ++curPos;
0314 if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
0315 return curPos;
0316 try { curChar = input_stream.readChar(); }
0317 catch(java.io.IOException e) { return curPos; }
0318 }
0319 }
0320 private int jjMoveStringLiteralDfa0_3()
0321 {
0322 return jjMoveNfa_3(0, 0);
0323 }
0324 private int jjMoveNfa_3(int startState, int curPos)
0325 {
0326 int startsAt = 0;
0327 jjnewStateCnt = 2;
0328 int i = 1;
0329 jjstateSet[0] = startState;
0330 int kind = 0x7fffffff;
0331 for (;;)
0332 {
0333 if (++jjround == 0x7fffffff)
0334 ReInitRounds();
0335 if (curChar < 64)
0336 {
0337 long l = 1L << curChar;
0338 do
0339 {
0340 switch(jjstateSet[--i])
0341 {
0342 case 0:
0343 if (curChar != 36)
0344 break;
0345 if (kind > 56)
0346 kind = 56;
0347 jjCheckNAdd(1);
0348 break;
0349 case 1:
0350 if ((0x7ff601000000000L & l) == 0L)
0351 break;
0352 if (kind > 56)
0353 kind = 56;
0354 jjCheckNAdd(1);
0355 break;
0356 default : break;
0357 }
0358 } while(i != startsAt);
0359 }
0360 else if (curChar < 128)
0361 {
0362 long l = 1L << (curChar & 077);
0363 do
0364 {
0365 switch(jjstateSet[--i])
0366 {
0367 case 0:
0368 case 1:
0369 if ((0x7fffffe87fffffeL & l) == 0L)
0370 break;
0371 if (kind > 56)
0372 kind = 56;
0373 jjCheckNAdd(1);
0374 break;
0375 default : break;
0376 }
0377 } while(i != startsAt);
0378 }
0379 else
0380 {
0381 int i2 = (curChar & 0xff) >> 6;
0382 long l2 = 1L << (curChar & 077);
0383 do
0384 {
0385 switch(jjstateSet[--i])
0386 {
0387 case 0:
0388 case 1:
0389 if ((jjbitVec1[i2] & l2) == 0L)
0390 break;
0391 if (kind > 56)
0392 kind = 56;
0393 jjCheckNAdd(1);
0394 break;
0395 default : break;
0396 }
0397 } while(i != startsAt);
0398 }
0399 if (kind != 0x7fffffff)
0400 {
0401 jjmatchedKind = kind;
0402 jjmatchedPos = curPos;
0403 kind = 0x7fffffff;
0404 }
0405 ++curPos;
0406 if ((i = jjnewStateCnt) == (startsAt = 2 - (jjnewStateCnt = startsAt)))
0407 return curPos;
0408 try { curChar = input_stream.readChar(); }
0409 catch(java.io.IOException e) { return curPos; }
0410 }
0411 }
0412 private int jjMoveStringLiteralDfa0_0()
0413 {
0414 return jjMoveNfa_0(0, 0);
0415 }
0416 private int jjMoveNfa_0(int startState, int curPos)
0417 {
0418 int startsAt = 0;
0419 jjnewStateCnt = 5;
0420 int i = 1;
0421 jjstateSet[0] = startState;
0422 int kind = 0x7fffffff;
0423 for (;;)
0424 {
0425 if (++jjround == 0x7fffffff)
0426 ReInitRounds();
0427 if (curChar < 64)
0428 {
0429 long l = 1L << curChar;
0430 do
0431 {
0432 switch(jjstateSet[--i])
0433 {
0434 case 0:
0435 if (curChar == 45)
0436 jjAddStates(0, 1);
0437 break;
0438 case 1:
0439 if (curChar == 45)
0440 jjCheckNAddTwoStates(2, 3);
0441 break;
0442 case 2:
0443 if (curChar == 32)
0444 jjCheckNAddTwoStates(2, 3);
0445 break;
0446 case 3:
0447 case 4:
0448 if (curChar == 62 && kind > 75)
0449 kind = 75;
0450 break;
0451 default : break;
0452 }
0453 } while(i != startsAt);
0454 }
0455 else if (curChar < 128)
0456 {
0457 long l = 1L << (curChar & 077);
0458 do
0459 {
0460 switch(jjstateSet[--i])
0461 {
0462 default : break;
0463 }
0464 } while(i != startsAt);
0465 }
0466 else
0467 {
0468 int i2 = (curChar & 0xff) >> 6;
0469 long l2 = 1L << (curChar & 077);
0470 do
0471 {
0472 switch(jjstateSet[--i])
0473 {
0474 default : break;
0475 }
0476 } while(i != startsAt);
0477 }
0478 if (kind != 0x7fffffff)
0479 {
0480 jjmatchedKind = kind;
0481 jjmatchedPos = curPos;
0482 kind = 0x7fffffff;
0483 }
0484 ++curPos;
0485 if ((i = jjnewStateCnt) == (startsAt = 5 - (jjnewStateCnt = startsAt)))
0486 return curPos;
0487 try { curChar = input_stream.readChar(); }
0488 catch(java.io.IOException e) { return curPos; }
0489 }
0490 }
0491 private final int jjStopStringLiteralDfa_2(int pos, long active0, long active1)
0492 {
0493 switch (pos)
0494 {
0495 default :
0496 return -1;
0497 }
0498 }
0499 private final int jjStartNfa_2(int pos, long active0, long active1)
0500 {
0501 return jjMoveNfa_2(jjStopStringLiteralDfa_2(pos, active0, active1), pos + 1);
0502 }
0503 private int jjMoveStringLiteralDfa0_2()
0504 {
0505 switch(curChar)
0506 {
0507 case 39:
0508 return jjStopAtPos(0, 69);
0509 default :
0510 return jjMoveNfa_2(9, 0);
0511 }
0512 }
0513 private int jjMoveNfa_2(int startState, int curPos)
0514 {
0515 int startsAt = 0;
0516 jjnewStateCnt = 37;
0517 int i = 1;
0518 jjstateSet[0] = startState;
0519 int kind = 0x7fffffff;
0520 for (;;)
0521 {
0522 if (++jjround == 0x7fffffff)
0523 ReInitRounds();
0524 if (curChar < 64)
0525 {
0526 long l = 1L << curChar;
0527 do
0528 {
0529 switch(jjstateSet[--i])
0530 {
0531 case 9:
0532 if ((0xffffff67ffffffffL & l) != 0L)
0533 {
0534 if (kind > 70)
0535 kind = 70;
0536 jjCheckNAddStates(2, 4);
0537 }
0538 else if ((0x1800000000L & l) != 0L)
0539 jjCheckNAddTwoStates(30, 36);
0540 if (curChar == 60)
0541 jjstateSet[jjnewStateCnt++] = 26;
0542 else if (curChar == 35)
0543 jjstateSet[jjnewStateCnt++] = 10;
0544 else if (curChar == 36)
0545 jjstateSet[jjnewStateCnt++] = 0;
0546 break;
0547 case 1:
0548 if ((0xffffff7bffffffffL & l) != 0L)
0549 jjCheckNAddStates(5, 8);
0550 break;
0551 case 2:
0552 if (curChar == 34)
0553 jjCheckNAddTwoStates(3, 4);
0554 break;
0555 case 3:
0556 if ((0xfffffffbffffffffL & l) != 0L)
0557 jjCheckNAddTwoStates(3, 4);
0558 break;
0559 case 4:
0560 if (curChar == 34)
0561 jjCheckNAddStates(5, 8);
0562 break;
0563 case 5:
0564 if (curChar == 39)
0565 jjCheckNAddTwoStates(6, 7);
0566 break;
0567 case 6:
0568 if ((0xffffff7fffffffffL & l) != 0L)
0569 jjCheckNAddTwoStates(6, 7);
0570 break;
0571 case 7:
0572 if (curChar == 39)
0573 jjCheckNAddStates(5, 8);
0574 break;
0575 case 11:
0576 if ((0xffffff7bffffffffL & l) != 0L)
0577 jjCheckNAddStates(9, 12);
0578 break;
0579 case 12:
0580 if (curChar == 34)
0581 jjCheckNAddTwoStates(13, 14);
0582 break;
0583 case 13:
0584 if ((0xfffffffbffffffffL & l) != 0L)
0585 jjCheckNAddTwoStates(13, 14);
0586 break;
0587 case 14:
0588 if (curChar == 34)
0589 jjCheckNAddStates(9, 12);
0590 break;
0591 case 15:
0592 if (curChar == 39)
0593 jjCheckNAddTwoStates(16, 17);
0594 break;
0595 case 16:
0596 if ((0xffffff7fffffffffL & l) != 0L)
0597 jjCheckNAddTwoStates(16, 17);
0598 break;
0599 case 17:
0600 if (curChar == 39)
0601 jjCheckNAddStates(9, 12);
0602 break;
0603 case 19:
0604 if (curChar == 35)
0605 jjstateSet[jjnewStateCnt++] = 10;
0606 break;
0607 case 20:
0608 if (curChar == 61)
0609 jjCheckNAddTwoStates(21, 22);
0610 break;
0611 case 21:
0612 if ((0xffffffdfffffffffL & l) != 0L)
0613 jjCheckNAddStates(13, 15);
0614 break;
0615 case 22:
0616 if (curChar == 37)
0617 jjstateSet[jjnewStateCnt++] = 23;
0618 break;
0619 case 23:
0620 if ((0xbfffffffffffffffL & l) != 0L)
0621 jjCheckNAddStates(13, 15);
0622 break;
0623 case 24:
0624 if (curChar == 62 && kind > 68)
0625 kind = 68;
0626 break;
0627 case 25:
0628 if (curChar == 37)
0629 jjstateSet[jjnewStateCnt++] = 24;
0630 break;
0631 case 26:
0632 if (curChar == 37)
0633 jjstateSet[jjnewStateCnt++] = 20;
0634 break;
0635 case 27:
0636 if (curChar == 60)
0637 jjstateSet[jjnewStateCnt++] = 26;
0638 break;
0639 case 28:
0640 if ((0xffffff67ffffffffL & l) == 0L)
0641 break;
0642 if (kind > 70)
0643 kind = 70;
0644 jjCheckNAddStates(2, 4);
0645 break;
0646 case 29:
0647 if ((0x1800000000L & l) != 0L)
0648 jjCheckNAdd(30);
0649 break;
0650 case 30:
0651 if ((0xffffff7fffffffffL & l) == 0L)
0652 break;
0653 if (kind > 70)
0654 kind = 70;
0655 jjCheckNAddStates(2, 4);
0656 break;
0657 case 33:
0658 if (curChar == 35)
0659 jjCheckNAdd(32);
0660 break;
0661 case 34:
0662 if (curChar == 36)
0663 jjCheckNAdd(32);
0664 break;
0665 case 35:
0666 if ((0x1800000000L & l) != 0L)
0667 jjCheckNAddTwoStates(30, 36);
0668 break;
0669 case 36:
0670 if (curChar == 39 && kind > 71)
0671 kind = 71;
0672 break;
0673 default : break;
0674 }
0675 } while(i != startsAt);
0676 }
0677 else if (curChar < 128)
0678 {
0679 long l = 1L << (curChar & 077);
0680 do
0681 {
0682 switch(jjstateSet[--i])
0683 {
0684 case 9:
0685 if (kind > 70)
0686 kind = 70;
0687 jjCheckNAddStates(2, 4);
0688 if (curChar == 92)
0689 jjAddStates(16, 17);
0690 break;
0691 case 0:
0692 if (curChar == 123)
0693 jjCheckNAddStates(5, 8);
0694 break;
0695 case 1:
0696 if ((0xdfffffffffffffffL & l) != 0L)
0697 jjCheckNAddStates(5, 8);
0698 break;
0699 case 3:
0700 jjAddStates(18, 19);
0701 break;
0702 case 6:
0703 jjAddStates(20, 21);
0704 break;
0705 case 8:
0706 if (curChar == 125 && kind > 66)
0707 kind = 66;
0708 break;
0709 case 10:
0710 if (curChar == 123)
0711 jjCheckNAddStates(9, 12);
0712 break;
0713 case 11:
0714 if ((0xdfffffffffffffffL & l) != 0L)
0715 jjCheckNAddStates(9, 12);
0716 break;
0717 case 13:
0718 jjAddStates(22, 23);
0719 break;
0720 case 16:
0721 jjAddStates(24, 25);
0722 break;
0723 case 18:
0724 if (curChar == 125 && kind > 67)
0725 kind = 67;
0726 break;
0727 case 21:
0728 case 23:
0729 jjCheckNAddStates(13, 15);
0730 break;
0731 case 28:
0732 if (kind > 70)
0733 kind = 70;
0734 jjCheckNAddStates(2, 4);
0735 break;
0736 case 30:
0737 if ((0xf7ffffffffffffffL & l) == 0L)
0738 break;
0739 if (kind > 70)
0740 kind = 70;
0741 jjCheckNAddStates(2, 4);
0742 break;
0743 case 31:
0744 if (curChar == 92)
0745 jjAddStates(16, 17);
0746 break;
0747 case 32:
0748 if (curChar != 123)
0749 break;
0750 if (kind > 70)
0751 kind = 70;
0752 jjCheckNAddStates(2, 4);
0753 break;
0754 default : break;
0755 }
0756 } while(i != startsAt);
0757 }
0758 else
0759 {
0760 int i2 = (curChar & 0xff) >> 6;
0761 long l2 = 1L << (curChar & 077);
0762 do
0763 {
0764 switch(jjstateSet[--i])
0765 {
0766 case 9:
0767 case 28:
0768 case 30:
0769 if ((jjbitVec0[i2] & l2) == 0L)
0770 break;
0771 if (kind > 70)
0772 kind = 70;
0773 jjCheckNAddStates(2, 4);
0774 break;
0775 case 1:
0776 if ((jjbitVec0[i2] & l2) != 0L)
0777 jjAddStates(5, 8);
0778 break;
0779 case 3:
0780 if ((jjbitVec0[i2] & l2) != 0L)
0781 jjAddStates(18, 19);
0782 break;
0783 case 6:
0784 if ((jjbitVec0[i2] & l2) != 0L)
0785 jjAddStates(20, 21);
0786 break;
0787 case 11:
0788 if ((jjbitVec0[i2] & l2) != 0L)
0789 jjAddStates(9, 12);
0790 break;
0791 case 13:
0792 if ((jjbitVec0[i2] & l2) != 0L)
0793 jjAddStates(22, 23);
0794 break;
0795 case 16:
0796 if ((jjbitVec0[i2] & l2) != 0L)
0797 jjAddStates(24, 25);
0798 break;
0799 case 21:
0800 case 23:
0801 if ((jjbitVec0[i2] & l2) != 0L)
0802 jjCheckNAddStates(13, 15);
0803 break;
0804 default : break;
0805 }
0806 } while(i != startsAt);
0807 }
0808 if (kind != 0x7fffffff)
0809 {
0810 jjmatchedKind = kind;
0811 jjmatchedPos = curPos;
0812 kind = 0x7fffffff;
0813 }
0814 ++curPos;
0815 if ((i = jjnewStateCnt) == (startsAt = 37 - (jjnewStateCnt = startsAt)))
0816 return curPos;
0817 try { curChar = input_stream.readChar(); }
0818 catch(java.io.IOException e) { return curPos; }
0819 }
0820 }
0821 private final int jjStopStringLiteralDfa_7(int pos, long active0)
0822 {
0823 switch (pos)
0824 {
0825 case 0:
0826 if ((active0 & 0x400000000000L) != 0L)
0827 return 3;
0828 return -1;
0829 case 1:
0830 if ((active0 & 0x400000000000L) != 0L)
0831 return 4;
0832 return -1;
0833 case 2:
0834 if ((active0 & 0x400000000000L) != 0L)
0835 return 6;
0836 return -1;
0837 default :
0838 return -1;
0839 }
0840 }
0841 private final int jjStartNfa_7(int pos, long active0)
0842 {
0843 return jjMoveNfa_7(jjStopStringLiteralDfa_7(pos, active0), pos + 1);
0844 }
0845 private int jjMoveStringLiteralDfa0_7()
0846 {
0847 switch(curChar)
0848 {
0849 case 45:
0850 return jjMoveStringLiteralDfa1_7(0x400000000000L);
0851 default :
0852 return jjMoveNfa_7(8, 0);
0853 }
0854 }
0855 private int jjMoveStringLiteralDfa1_7(long active0)
0856 {
0857 try { curChar = input_stream.readChar(); }
0858 catch(java.io.IOException e) {
0859 jjStopStringLiteralDfa_7(0, active0);
0860 return 1;
0861 }
0862 switch(curChar)
0863 {
0864 case 45:
0865 return jjMoveStringLiteralDfa2_7(active0, 0x400000000000L);
0866 default :
0867 break;
0868 }
0869 return jjStartNfa_7(0, active0);
0870 }
0871 private int jjMoveStringLiteralDfa2_7(long old0, long active0)
0872 {
0873 if (((active0 &= old0)) == 0L)
0874 return jjStartNfa_7(0, old0);
0875 try { curChar = input_stream.readChar(); }
0876 catch(java.io.IOException e) {
0877 jjStopStringLiteralDfa_7(1, active0);
0878 return 2;
0879 }
0880 switch(curChar)
0881 {
0882 case 37:
0883 return jjMoveStringLiteralDfa3_7(active0, 0x400000000000L);
0884 default :
0885 break;
0886 }
0887 return jjStartNfa_7(1, active0);
0888 }
0889 private int jjMoveStringLiteralDfa3_7(long old0, long active0)
0890 {
0891 if (((active0 &= old0)) == 0L)
0892 return jjStartNfa_7(1, old0);
0893 try { curChar = input_stream.readChar(); }
0894 catch(java.io.IOException e) {
0895 jjStopStringLiteralDfa_7(2, active0);
0896 return 3;
0897 }
0898 switch(curChar)
0899 {
0900 case 62:
0901 if ((active0 & 0x400000000000L) != 0L)
0902 return jjStopAtPos(3, 46);
0903 break;
0904 default :
0905 break;
0906 }
0907 return jjStartNfa_7(2, active0);
0908 }
0909 private int jjMoveNfa_7(int startState, int curPos)
0910 {
0911 int startsAt = 0;
0912 jjnewStateCnt = 8;
0913 int i = 1;
0914 jjstateSet[0] = startState;
0915 int kind = 0x7fffffff;
0916 for (;;)
0917 {
0918 if (++jjround == 0x7fffffff)
0919 ReInitRounds();
0920 if (curChar < 64)
0921 {
0922 long l = 1L << curChar;
0923 do
0924 {
0925 switch(jjstateSet[--i])
0926 {
0927 case 4:
0928 if ((0xffffffdfffffffffL & l) != 0L)
0929 {
0930 if (kind > 47)
0931 kind = 47;
0932 jjCheckNAddStates(26, 28);
0933 }
0934 else if (curChar == 37)
0935 jjstateSet[jjnewStateCnt++] = 6;
0936 break;
0937 case 3:
0938 if ((0xffffdfffffffffffL & l) != 0L)
0939 {
0940 if (kind > 47)
0941 kind = 47;
0942 jjCheckNAddStates(26, 28);
0943 }
0944 else if (curChar == 45)
0945 jjstateSet[jjnewStateCnt++] = 5;
0946 if (curChar == 45)
0947 jjstateSet[jjnewStateCnt++] = 4;
0948 break;
0949 case 8:
0950 if ((0xffffdfffffffffffL & l) != 0L)
0951 {
0952 if (kind > 47)
0953 kind = 47;
0954 jjCheckNAddStates(26, 28);
0955 }
0956 else if (curChar == 45)
0957 jjAddStates(29, 30);
0958 if (curChar == 45)
0959 jjCheckNAdd(0);
0960 break;
0961 case 0:
0962 if ((0xffffdfffffffffffL & l) == 0L)
0963 break;
0964 if (kind > 47)
0965 kind = 47;
0966 jjCheckNAddStates(26, 28);
0967 break;
0968 case 1:
0969 if (curChar == 45)
0970 jjCheckNAdd(0);
0971 break;
0972 case 2:
0973 if (curChar == 45)
0974 jjAddStates(29, 30);
0975 break;
0976 case 5:
0977 if (curChar == 37)
0978 jjstateSet[jjnewStateCnt++] = 6;
0979 break;
0980 case 6:
0981 if ((0xbfffffffffffffffL & l) == 0L)
0982 break;
0983 if (kind > 47)
0984 kind = 47;
0985 jjCheckNAddStates(26, 28);
0986 break;
0987 case 7:
0988 if (curChar == 45)
0989 jjstateSet[jjnewStateCnt++] = 5;
0990 break;
0991 default : break;
0992 }
0993 } while(i != startsAt);
0994 }
0995 else if (curChar < 128)
0996 {
0997 long l = 1L << (curChar & 077);
0998 do
0999 {
1000 switch(jjstateSet[--i])
1001 {
1002 case 4:
1003 case 6:
1004 if (kind > 47)
1005 kind = 47;
1006 jjCheckNAddStates(26, 28);
1007 break;
1008 case 3:
1009 case 0:
1010 if (kind > 47)
1011 kind = 47;
1012 jjCheckNAddStates(26, 28);
1013 break;
1014 case 8:
1015 if (kind > 47)
1016 kind = 47;
1017 jjCheckNAddStates(26, 28);
1018 break;
1019 default : break;
1020 }
1021 } while(i != startsAt);
1022 }
1023 else
1024 {
1025 int i2 = (curChar & 0xff) >> 6;
1026 long l2 = 1L << (curChar & 077);
1027 do
1028 {
1029 switch(jjstateSet[--i])
1030 {
1031 case 4:
1032 case 6:
1033 if ((jjbitVec0[i2] & l2) == 0L)
1034 break;
1035 if (kind > 47)
1036 kind = 47;
1037 jjCheckNAddStates(26, 28);
1038 break;
1039 case 3:
1040 case 0:
1041 if ((jjbitVec0[i2] & l2) == 0L)
1042 break;
1043 if (kind > 47)
1044 kind = 47;
1045 jjCheckNAddStates(26, 28);
1046 break;
1047 case 8:
1048 if ((jjbitVec0[i2] & l2) == 0L)
1049 break;
1050 if (kind > 47)
1051 kind = 47;
1052 jjCheckNAddStates(26, 28);
1053 break;
1054 default : break;
1055 }
1056 } while(i != startsAt);
1057 }
1058 if (kind != 0x7fffffff)
1059 {
1060 jjmatchedKind = kind;
1061 jjmatchedPos = curPos;
1062 kind = 0x7fffffff;
1063 }
1064 ++curPos;
1065 if ((i = jjnewStateCnt) == (startsAt = 8 - (jjnewStateCnt = startsAt)))
1066 return curPos;
1067 try { curChar = input_stream.readChar(); }
1068 catch(java.io.IOException e) { return curPos; }
1069 }
1070 }
1071 private final int jjStopStringLiteralDfa_13(int pos, long active0, long active1)
1072 {
1073 switch (pos)
1074 {
1075 default :
1076 return -1;
1077 }
1078 }
1079 private final int jjStartNfa_13(int pos, long active0, long active1)
1080 {
1081 return jjMoveNfa_13(jjStopStringLiteralDfa_13(pos, active0, active1), pos + 1);
1082 }
1083 private int jjMoveStringLiteralDfa0_13()
1084 {
1085 switch(curChar)
1086 {
1087 case 34:
1088 return jjStopAtPos(0, 65);
1089 case 39:
1090 return jjStopAtPos(0, 64);
1091 default :
1092 return jjMoveNfa_13(0, 0);
1093 }
1094 }
1095 private int jjMoveNfa_13(int startState, int curPos)
1096 {
1097 int startsAt = 0;
1098 jjnewStateCnt = 1;
1099 int i = 1;
1100 jjstateSet[0] = startState;
1101 int kind = 0x7fffffff;
1102 for (;;)
1103 {
1104 if (++jjround == 0x7fffffff)
1105 ReInitRounds();
1106 if (curChar < 64)
1107 {
1108 long l = 1L << curChar;
1109 do
1110 {
1111 switch(jjstateSet[--i])
1112 {
1113 case 0:
1114 if ((0x100002600L & l) == 0L)
1115 break;
1116 kind = 21;
1117 jjstateSet[jjnewStateCnt++] = 0;
1118 break;
1119 default : break;
1120 }
1121 } while(i != startsAt);
1122 }
1123 else if (curChar < 128)
1124 {
1125 long l = 1L << (curChar & 077);
1126 do
1127 {
1128 switch(jjstateSet[--i])
1129 {
1130 default : break;
1131 }
1132 } while(i != startsAt);
1133 }
1134 else
1135 {
1136 int i2 = (curChar & 0xff) >> 6;
1137 long l2 = 1L << (curChar & 077);
1138 do
1139 {
1140 switch(jjstateSet[--i])
1141 {
1142 default : break;
1143 }
1144 } while(i != startsAt);
1145 }
1146 if (kind != 0x7fffffff)
1147 {
1148 jjmatchedKind = kind;
1149 jjmatchedPos = curPos;
1150 kind = 0x7fffffff;
1151 }
1152 ++curPos;
1153 if ((i = jjnewStateCnt) == (startsAt = 1 - (jjnewStateCnt = startsAt)))
1154 return curPos;
1155 try { curChar = input_stream.readChar(); }
1156 catch(java.io.IOException e) { return curPos; }
1157 }
1158 }
1159 private final int jjStopStringLiteralDfa_16(int pos, long active0)
1160 {
1161 switch (pos)
1162 {
1163 default :
1164 return -1;
1165 }
1166 }
1167 private final int jjStartNfa_16(int pos, long active0)
1168 {
1169 return jjMoveNfa_16(jjStopStringLiteralDfa_16(pos, active0), pos + 1);
1170 }
1171 private int jjMoveStringLiteralDfa0_16()
1172 {
1173 switch(curChar)
1174 {
1175 case 60:
1176 jjmatchedKind = 22;
1177 return jjMoveStringLiteralDfa1_16(0x1ff800000L);
1178 default :
1179 return jjMoveNfa_16(0, 0);
1180 }
1181 }
1182 private int jjMoveStringLiteralDfa1_16(long active0)
1183 {
1184 try { curChar = input_stream.readChar(); }
1185 catch(java.io.IOException e) {
1186 jjStopStringLiteralDfa_16(0, active0);
1187 return 1;
1188 }
1189 switch(curChar)
1190 {
1191 case 33:
1192 return jjMoveStringLiteralDfa2_16(active0, 0xd000000L);
1193 case 37:
1194 if ((active0 & 0x80000000L) != 0L)
1195 {
1196 jjmatchedKind = 31;
1197 jjmatchedPos = 1;
1198 }
1199 return jjMoveStringLiteralDfa2_16(active0, 0x170000000L);
1200 case 47:
1201 if ((active0 & 0x800000L) != 0L)
1202 return jjStopAtPos(1, 23);
1203 break;
1204 case 63:
1205 if ((active0 & 0x2000000L) != 0L)
1206 return jjStopAtPos(1, 25);
1207 break;
1208 default :
1209 break;
1210 }
1211 return jjStartNfa_16(0, active0);
1212 }
1213 private int jjMoveStringLiteralDfa2_16(long old0, long active0)
1214 {
1215 if (((active0 &= old0)) == 0L)
1216 return jjStartNfa_16(0, old0);
1217 try { curChar = input_stream.readChar(); }
1218 catch(java.io.IOException e) {
1219 jjStopStringLiteralDfa_16(1, active0);
1220 return 2;
1221 }
1222 switch(curChar)
1223 {
1224 case 33:
1225 if ((active0 & 0x20000000L) != 0L)
1226 return jjStopAtPos(2, 29);
1227 break;
1228 case 45:
1229 return jjMoveStringLiteralDfa3_16(active0, 0x11000000L);
1230 case 61:
1231 if ((active0 & 0x40000000L) != 0L)
1232 return jjStopAtPos(2, 30);
1233 break;
1234 case 64:
1235 if ((active0 & 0x100000000L) != 0L)
1236 return jjStopAtPos(2, 32);
1237 break;
1238 case 91:
1239 return jjMoveStringLiteralDfa3_16(active0, 0x8000000L);
1240 case 68:
1241 case 100:
1242 return jjMoveStringLiteralDfa3_16(active0, 0x4000000L);
1243 default :
1244 break;
1245 }
1246 return jjStartNfa_16(1, active0);
1247 }
1248 private int jjMoveStringLiteralDfa3_16(long old0, long active0)
1249 {
1250 if (((active0 &= old0)) == 0L)
1251 return jjStartNfa_16(1, old0);
1252 try { curChar = input_stream.readChar(); }
1253 catch(java.io.IOException e) {
1254 jjStopStringLiteralDfa_16(2, active0);
1255 return 3;
1256 }
1257 switch(curChar)
1258 {
1259 case 45:
1260 if ((active0 & 0x1000000L) != 0L)
1261 return jjStopAtPos(3, 24);
1262 else if ((active0 & 0x10000000L) != 0L)
1263 return jjStopAtPos(3, 28);
1264 break;
1265 case 67:
1266 case 99:
1267 return jjMoveStringLiteralDfa4_16(active0, 0x8000000L);
1268 case 79:
1269 case 111:
1270 return jjMoveStringLiteralDfa4_16(active0, 0x4000000L);
1271 default :
1272 break;
1273 }
1274 return jjStartNfa_16(2, active0);
1275 }
1276 private int jjMoveStringLiteralDfa4_16(long old0, long active0)
1277 {
1278 if (((active0 &= old0)) == 0L)
1279 return jjStartNfa_16(2, old0);
1280 try { curChar = input_stream.readChar(); }
1281 catch(java.io.IOException e) {
1282 jjStopStringLiteralDfa_16(3, active0);
1283 return 4;
1284 }
1285 switch(curChar)
1286 {
1287 case 67:
1288 case 99:
1289 return jjMoveStringLiteralDfa5_16(active0, 0x4000000L);
1290 case 68:
1291 case 100:
1292 return jjMoveStringLiteralDfa5_16(active0, 0x8000000L);
1293 default :
1294 break;
1295 }
1296 return jjStartNfa_16(3, active0);
1297 }
1298 private int jjMoveStringLiteralDfa5_16(long old0, long active0)
1299 {
1300 if (((active0 &= old0)) == 0L)
1301 return jjStartNfa_16(3, old0);
1302 try { curChar = input_stream.readChar(); }
1303 catch(java.io.IOException e) {
1304 jjStopStringLiteralDfa_16(4, active0);
1305 return 5;
1306 }
1307 switch(curChar)
1308 {
1309 case 65:
1310 case 97:
1311 return jjMoveStringLiteralDfa6_16(active0, 0x8000000L);
1312 case 84:
1313 case 116:
1314 return jjMoveStringLiteralDfa6_16(active0, 0x4000000L);
1315 default :
1316 break;
1317 }
1318 return jjStartNfa_16(4, active0);
1319 }
1320 private int jjMoveStringLiteralDfa6_16(long old0, long active0)
1321 {
1322 if (((active0 &= old0)) == 0L)
1323 return jjStartNfa_16(4, old0);
1324 try { curChar = input_stream.readChar(); }
1325 catch(java.io.IOException e) {
1326 jjStopStringLiteralDfa_16(5, active0);
1327 return 6;
1328 }
1329 switch(curChar)
1330 {
1331 case 84:
1332 case 116:
1333 return jjMoveStringLiteralDfa7_16(active0, 0x8000000L);
1334 case 89:
1335 case 121:
1336 return jjMoveStringLiteralDfa7_16(active0, 0x4000000L);
1337 default :
1338 break;
1339 }
1340 return jjStartNfa_16(5, active0);
1341 }
1342 private int jjMoveStringLiteralDfa7_16(long old0, long active0)
1343 {
1344 if (((active0 &= old0)) == 0L)
1345 return jjStartNfa_16(5, old0);
1346 try { curChar = input_stream.readChar(); }
1347 catch(java.io.IOException e) {
1348 jjStopStringLiteralDfa_16(6, active0);
1349 return 7;
1350 }
1351 switch(curChar)
1352 {
1353 case 65:
1354 case 97:
1355 return jjMoveStringLiteralDfa8_16(active0, 0x8000000L);
1356 case 80:
1357 case 112:
1358 return jjMoveStringLiteralDfa8_16(active0, 0x4000000L);
1359 default :
1360 break;
1361 }
1362 return jjStartNfa_16(6, active0);
1363 }
1364 private int jjMoveStringLiteralDfa8_16(long old0, long active0)
1365 {
1366 if (((active0 &= old0)) == 0L)
1367 return jjStartNfa_16(6, old0);
1368 try { curChar = input_stream.readChar(); }
1369 catch(java.io.IOException e) {
1370 jjStopStringLiteralDfa_16(7, active0);
1371 return 8;
1372 }
1373 switch(curChar)
1374 {
1375 case 91:
1376 if ((active0 & 0x8000000L) != 0L)
1377 return jjStopAtPos(8, 27);
1378 break;
1379 case 69:
1380 case 101:
1381 if ((active0 & 0x4000000L) != 0L)
1382 return jjStopAtPos(8, 26);
1383 break;
1384 default :
1385 break;
1386 }
1387 return jjStartNfa_16(7, active0);
1388 }
1389 private int jjMoveNfa_16(int startState, int curPos)
1390 {
1391 int startsAt = 0;
1392 jjnewStateCnt = 1;
1393 int i = 1;
1394 jjstateSet[0] = startState;
1395 int kind = 0x7fffffff;
1396 for (;;)
1397 {
1398 if (++jjround == 0x7fffffff)
1399 ReInitRounds();
1400 if (curChar < 64)
1401 {
1402 long l = 1L << curChar;
1403 do
1404 {
1405 switch(jjstateSet[--i])
1406 {
1407 case 0:
1408 if ((0x100002600L & l) == 0L)
1409 break;
1410 kind = 20;
1411 jjstateSet[jjnewStateCnt++] = 0;
1412 break;
1413 default : break;
1414 }
1415 } while(i != startsAt);
1416 }
1417 else if (curChar < 128)
1418 {
1419 long l = 1L << (curChar & 077);
1420 do
1421 {
1422 switch(jjstateSet[--i])
1423 {
1424 default : break;
1425 }
1426 } while(i != startsAt);
1427 }
1428 else
1429 {
1430 int i2 = (curChar & 0xff) >> 6;
1431 long l2 = 1L << (curChar & 077);
1432 do
1433 {
1434 switch(jjstateSet[--i])
1435 {
1436 default : break;
1437 }
1438 } while(i != startsAt);
1439 }
1440 if (kind != 0x7fffffff)
1441 {
1442 jjmatchedKind = kind;
1443 jjmatchedPos = curPos;
1444 kind = 0x7fffffff;
1445 }
1446 ++curPos;
1447 if ((i = jjnewStateCnt) == (startsAt = 1 - (jjnewStateCnt = startsAt)))
1448 return curPos;
1449 try { curChar = input_stream.readChar(); }
1450 catch(java.io.IOException e) { return curPos; }
1451 }
1452 }
1453 private final int jjStopStringLiteralDfa_12(int pos, long active0)
1454 {
1455 switch (pos)
1456 {
1457 default :
1458 return -1;
1459 }
1460 }
1461 private final int jjStartNfa_12(int pos, long active0)
1462 {
1463 return jjMoveNfa_12(jjStopStringLiteralDfa_12(pos, active0), pos + 1);
1464 }
1465 private int jjMoveStringLiteralDfa0_12()
1466 {
1467 switch(curChar)
1468 {
1469 case 60:
1470 jjmatchedKind = 22;
1471 return jjMoveStringLiteralDfa1_12(0x1ff800000L);
1472 default :
1473 return jjMoveNfa_12(10, 0);
1474 }
1475 }
1476 private int jjMoveStringLiteralDfa1_12(long active0)
1477 {
1478 try { curChar = input_stream.readChar(); }
1479 catch(java.io.IOException e) {
1480 jjStopStringLiteralDfa_12(0, active0);
1481 return 1;
1482 }
1483 switch(curChar)
1484 {
1485 case 33:
1486 return jjMoveStringLiteralDfa2_12(active0, 0xd000000L);
1487 case 37:
1488 if ((active0 & 0x80000000L) != 0L)
1489 {
1490 jjmatchedKind = 31;
1491 jjmatchedPos = 1;
1492 }
1493 return jjMoveStringLiteralDfa2_12(active0, 0x170000000L);
1494 case 47:
1495 if ((active0 & 0x800000L) != 0L)
1496 return jjStopAtPos(1, 23);
1497 break;
1498 case 63:
1499 if ((active0 & 0x2000000L) != 0L)
1500 return jjStopAtPos(1, 25);
1501 break;
1502 default :
1503 break;
1504 }
1505 return jjStartNfa_12(0, active0);
1506 }
1507 private int jjMoveStringLiteralDfa2_12(long old0, long active0)
1508 {
1509 if (((active0 &= old0)) == 0L)
1510 return jjStartNfa_12(0, old0);
1511 try { curChar = input_stream.readChar(); }
1512 catch(java.io.IOException e) {
1513 jjStopStringLiteralDfa_12(1, active0);
1514 return 2;
1515 }
1516 switch(curChar)
1517 {
1518 case 33:
1519 if ((active0 & 0x20000000L) != 0L)
1520 return jjStopAtPos(2, 29);
1521 break;
1522 case 45:
1523 return jjMoveStringLiteralDfa3_12(active0, 0x11000000L);
1524 case 61:
1525 if ((active0 & 0x40000000L) != 0L)
1526 return jjStopAtPos(2, 30);
1527 break;
1528 case 64:
1529 if ((active0 & 0x100000000L) != 0L)
1530 return jjStopAtPos(2, 32);
1531 break;
1532 case 91:
1533 return jjMoveStringLiteralDfa3_12(active0, 0x8000000L);
1534 case 68:
1535 case 100:
1536 return jjMoveStringLiteralDfa3_12(active0, 0x4000000L);
1537 default :
1538 break;
1539 }
1540 return jjStartNfa_12(1, active0);
1541 }
1542 private int jjMoveStringLiteralDfa3_12(long old0, long active0)
1543 {
1544 if (((active0 &= old0)) == 0L)
1545 return jjStartNfa_12(1, old0);
1546 try { curChar = input_stream.readChar(); }
1547 catch(java.io.IOException e) {
1548 jjStopStringLiteralDfa_12(2, active0);
1549 return 3;
1550 }
1551 switch(curChar)
1552 {
1553 case 45:
1554 if ((active0 & 0x1000000L) != 0L)
1555 return jjStopAtPos(3, 24);
1556 else if ((active0 & 0x10000000L) != 0L)
1557 return jjStopAtPos(3, 28);
1558 break;
1559 case 67:
1560 case 99:
1561 return jjMoveStringLiteralDfa4_12(active0, 0x8000000L);
1562 case 79:
1563 case 111:
1564 return jjMoveStringLiteralDfa4_12(active0, 0x4000000L);
1565 default :
1566 break;
1567 }
1568 return jjStartNfa_12(2, active0);
1569 }
1570 private int jjMoveStringLiteralDfa4_12(long old0, long active0)
1571 {
1572 if (((active0 &= old0)) == 0L)
1573 return jjStartNfa_12(2, old0);
1574 try { curChar = input_stream.readChar(); }
1575 catch(java.io.IOException e) {
1576 jjStopStringLiteralDfa_12(3, active0);
1577 return 4;
1578 }
1579 switch(curChar)
1580 {
1581 case 67:
1582 case 99:
1583 return jjMoveStringLiteralDfa5_12(active0, 0x4000000L);
1584 case 68:
1585 case 100:
1586 return jjMoveStringLiteralDfa5_12(active0, 0x8000000L);
1587 default :
1588 break;
1589 }
1590 return jjStartNfa_12(3, active0);
1591 }
1592 private int jjMoveStringLiteralDfa5_12(long old0, long active0)
1593 {
1594 if (((active0 &= old0)) == 0L)
1595 return jjStartNfa_12(3, old0);
1596 try { curChar = input_stream.readChar(); }
1597 catch(java.io.IOException e) {
1598 jjStopStringLiteralDfa_12(4, active0);
1599 return 5;
1600 }
1601 switch(curChar)
1602 {
1603 case 65:
1604 case 97:
1605 return jjMoveStringLiteralDfa6_12(active0, 0x8000000L);
1606 case 84:
1607 case 116:
1608 return jjMoveStringLiteralDfa6_12(active0, 0x4000000L);
1609 default :
1610 break;
1611 }
1612 return jjStartNfa_12(4, active0);
1613 }
1614 private int jjMoveStringLiteralDfa6_12(long old0, long active0)
1615 {
1616 if (((active0 &= old0)) == 0L)
1617 return jjStartNfa_12(4, old0);
1618 try { curChar = input_stream.readChar(); }
1619 catch(java.io.IOException e) {
1620 jjStopStringLiteralDfa_12(5, active0);
1621 return 6;
1622 }
1623 switch(curChar)
1624 {
1625 case 84:
1626 case 116:
1627 return jjMoveStringLiteralDfa7_12(active0, 0x8000000L);
1628 case 89:
1629 case 121:
1630 return jjMoveStringLiteralDfa7_12(active0, 0x4000000L);
1631 default :
1632 break;
1633 }
1634 return jjStartNfa_12(5, active0);
1635 }
1636 private int jjMoveStringLiteralDfa7_12(long old0, long active0)
1637 {
1638 if (((active0 &= old0)) == 0L)
1639 return jjStartNfa_12(5, old0);
1640 try { curChar = input_stream.readChar(); }
1641 catch(java.io.IOException e) {
1642 jjStopStringLiteralDfa_12(6, active0);
1643 return 7;
1644 }
1645 switch(curChar)
1646 {
1647 case 65:
1648 case 97:
1649 return jjMoveStringLiteralDfa8_12(active0, 0x8000000L);
1650 case 80:
1651 case 112:
1652 return jjMoveStringLiteralDfa8_12(active0, 0x4000000L);
1653 default :
1654 break;
1655 }
1656 return jjStartNfa_12(6, active0);
1657 }
1658 private int jjMoveStringLiteralDfa8_12(long old0, long active0)
1659 {
1660 if (((active0 &= old0)) == 0L)
1661 return jjStartNfa_12(6, old0);
1662 try { curChar = input_stream.readChar(); }
1663 catch(java.io.IOException e) {
1664 jjStopStringLiteralDfa_12(7, active0);
1665 return 8;
1666 }
1667 switch(curChar)
1668 {
1669 case 91:
1670 if ((active0 & 0x8000000L) != 0L)
1671 return jjStopAtPos(8, 27);
1672 break;
1673 case 69:
1674 case 101:
1675 if ((active0 & 0x4000000L) != 0L)
1676 return jjStopAtPos(8, 26);
1677 break;
1678 default :
1679 break;
1680 }
1681 return jjStartNfa_12(7, active0);
1682 }
1683 private int jjMoveNfa_12(int startState, int curPos)
1684 {
1685 int startsAt = 0;
1686 jjnewStateCnt = 18;
1687 int i = 1;
1688 jjstateSet[0] = startState;
1689 int kind = 0x7fffffff;
1690 for (;;)
1691 {
1692 if (++jjround == 0x7fffffff)
1693 ReInitRounds();
1694 if (curChar < 64)
1695 {
1696 long l = 1L << curChar;
1697 do
1698 {
1699 switch(jjstateSet[--i])
1700 {
1701 case 10:
1702 if ((0xefffffefffffffffL & l) != 0L)
1703 {
1704 if (kind > 34)
1705 kind = 34;
1706 jjCheckNAddStates(31, 33);
1707 }
1708 else if (curChar == 36)
1709 jjstateSet[jjnewStateCnt++] = 13;
1710 if ((0x100002600L & l) != 0L)
1711 {
1712 if (kind > 21)
1713 kind = 21;
1714 jjCheckNAdd(0);
1715 }
1716 else if (curChar == 36)
1717 jjstateSet[jjnewStateCnt++] = 1;
1718 break;
1719 case 0:
1720 if ((0x100002600L & l) == 0L)
1721 break;
1722 if (kind > 21)
1723 kind = 21;
1724 jjCheckNAdd(0);
1725 break;
1726 case 2:
1727 if ((0xffffff7bffffffffL & l) != 0L)
1728 jjCheckNAddStates(34, 37);
1729 break;
1730 case 3:
1731 if (curChar == 34)
1732 jjCheckNAddTwoStates(4, 5);
1733 break;
1734 case 4:
1735 if ((0xfffffffbffffffffL & l) != 0L)
1736 jjCheckNAddTwoStates(4, 5);
1737 break;
1738 case 5:
1739 if (curChar == 34)
1740 jjCheckNAddStates(34, 37);
1741 break;
1742 case 6:
1743 if (curChar == 39)
1744 jjCheckNAddTwoStates(7, 8);
1745 break;
1746 case 7:
1747 if ((0xffffff7fffffffffL & l) != 0L)
1748 jjCheckNAddTwoStates(7, 8);
1749 break;
1750 case 8:
1751 if (curChar == 39)
1752 jjCheckNAddStates(34, 37);
1753 break;
1754 case 11:
1755 if ((0xefffffefffffffffL & l) == 0L)
1756 break;
1757 if (kind > 34)
1758 kind = 34;
1759 jjCheckNAddStates(31, 33);
1760 break;
1761 case 12:
1762 if (curChar == 36)
1763 jjstateSet[jjnewStateCnt++] = 13;
1764 break;
1765 case 13:
1766 if ((0xefffffffffffffffL & l) == 0L)
1767 break;
1768 if (kind > 34)
1769 kind = 34;
1770 jjCheckNAddStates(31, 33);
1771 break;
1772 case 16:
1773 if (curChar == 35)
1774 jjCheckNAdd(15);
1775 break;
1776 case 17:
1777 if (curChar == 36)
1778 jjCheckNAdd(15);
1779 break;
1780 default : break;
1781 }
1782 } while(i != startsAt);
1783 }
1784 else if (curChar < 128)
1785 {
1786 long l = 1L << (curChar & 077);
1787 do
1788 {
1789 switch(jjstateSet[--i])
1790 {
1791 case 10:
1792 if (kind > 34)
1793 kind = 34;
1794 jjCheckNAddStates(31, 33);
1795 if (curChar == 92)
1796 jjAddStates(24, 25);
1797 break;
1798 case 1:
1799 if (curChar == 123)
1800 jjCheckNAddStates(34, 37);
1801 break;
1802 case 2:
1803 if ((0xdfffffffffffffffL & l) != 0L)
1804 jjCheckNAddStates(34, 37);
1805 break;
1806 case 4:
1807 jjAddStates(38, 39);
1808 break;
1809 case 7:
1810 jjAddStates(40, 41);
1811 break;
1812 case 9:
1813 if (curChar == 125 && kind > 33)
1814 kind = 33;
1815 break;
1816 case 11:
1817 if (kind > 34)
1818 kind = 34;
1819 jjCheckNAddStates(31, 33);
1820 break;
1821 case 13:
1822 if ((0xf7ffffffffffffffL & l) == 0L)
1823 break;
1824 if (kind > 34)
1825 kind = 34;
1826 jjCheckNAddStates(31, 33);
1827 break;
1828 case 14:
1829 if (curChar == 92)
1830 jjAddStates(24, 25);
1831 break;
1832 case 15:
1833 if (curChar != 123)
1834 break;
1835 if (kind > 34)
1836 kind = 34;
1837 jjCheckNAddStates(31, 33);
1838 break;
1839 default : break;
1840 }
1841 } while(i != startsAt);
1842 }
1843 else
1844 {
1845 int i2 = (curChar & 0xff) >> 6;
1846 long l2 = 1L << (curChar & 077);
1847 do
1848 {
1849 switch(jjstateSet[--i])
1850 {
1851 case 10:
1852 case 11:
1853 case 13:
1854 if ((jjbitVec0[i2] & l2) == 0L)
1855 break;
1856 if (kind > 34)
1857 kind = 34;
1858 jjCheckNAddStates(31, 33);
1859 break;
1860 case 2:
1861 if ((jjbitVec0[i2] & l2) != 0L)
1862 jjAddStates(34, 37);
1863 break;
1864 case 4:
1865 if ((jjbitVec0[i2] & l2) != 0L)
1866 jjAddStates(38, 39);
1867 break;
1868 case 7:
1869 if ((jjbitVec0[i2] & l2) != 0L)
1870 jjAddStates(40, 41);
1871 break;
1872 default : break;
1873 }
1874 } while(i != startsAt);
1875 }
1876 if (kind != 0x7fffffff)
1877 {
1878 jjmatchedKind = kind;
1879 jjmatchedPos = curPos;
1880 kind = 0x7fffffff;
1881 }
1882 ++curPos;
1883 if ((i = jjnewStateCnt) == (startsAt = 18 - (jjnewStateCnt = startsAt)))
1884 return curPos;
1885 try { curChar = input_stream.readChar(); }
1886 catch(java.io.IOException e) { return curPos; }
1887 }
1888 }
1889 private final int jjStopStringLiteralDfa_8(int pos, long active0)
1890 {
1891 switch (pos)
1892 {
1893 case 0:
1894 if ((active0 & 0x100000000000L) != 0L)
1895 return 2;
1896 return -1;
1897 default :
1898 return -1;
1899 }
1900 }
1901 private final int jjStartNfa_8(int pos, long active0)
1902 {
1903 return jjMoveNfa_8(jjStopStringLiteralDfa_8(pos, active0), pos + 1);
1904 }
1905 private int jjMoveStringLiteralDfa0_8()
1906 {
1907 switch(curChar)
1908 {
1909 case 37:
1910 return jjMoveStringLiteralDfa1_8(0x100000000000L);
1911 default :
1912 return jjMoveNfa_8(3, 0);
1913 }
1914 }
1915 private int jjMoveStringLiteralDfa1_8(long active0)
1916 {
1917 try { curChar = input_stream.readChar(); }
1918 catch(java.io.IOException e) {
1919 jjStopStringLiteralDfa_8(0, active0);
1920 return 1;
1921 }
1922 switch(curChar)
1923 {
1924 case 62:
1925 if ((active0 & 0x100000000000L) != 0L)
1926 return jjStopAtPos(1, 44);
1927 break;
1928 default :
1929 break;
1930 }
1931 return jjStartNfa_8(0, active0);
1932 }
1933 private int jjMoveNfa_8(int startState, int curPos)
1934 {
1935 int startsAt = 0;
1936 jjnewStateCnt = 3;
1937 int i = 1;
1938 jjstateSet[0] = startState;
1939 int kind = 0x7fffffff;
1940 for (;;)
1941 {
1942 if (++jjround == 0x7fffffff)
1943 ReInitRounds();
1944 if (curChar < 64)
1945 {
1946 long l = 1L << curChar;
1947 do
1948 {
1949 switch(jjstateSet[--i])
1950 {
1951 case 3:
1952 if ((0xffffffdfffffffffL & l) != 0L)
1953 {
1954 if (kind > 45)
1955 kind = 45;
1956 jjCheckNAddTwoStates(0, 1);
1957 }
1958 else if (curChar == 37)
1959 jjstateSet[jjnewStateCnt++] = 2;
1960 break;
1961 case 0:
1962 if ((0xffffffdfffffffffL & l) == 0L)
1963 break;
1964 if (kind > 45)
1965 kind = 45;
1966 jjCheckNAddTwoStates(0, 1);
1967 break;
1968 case 1:
1969 if (curChar == 37)
1970 jjstateSet[jjnewStateCnt++] = 2;
1971 break;
1972 case 2:
1973 if ((0xbfffffffffffffffL & l) == 0L)
1974 break;
1975 if (kind > 45)
1976 kind = 45;
1977 jjCheckNAddTwoStates(0, 1);
1978 break;
1979 default : break;
1980 }
1981 } while(i != startsAt);
1982 }
1983 else if (curChar < 128)
1984 {
1985 long l = 1L << (curChar & 077);
1986 do
1987 {
1988 switch(jjstateSet[--i])
1989 {
1990 case 3:
1991 case 0:
1992 case 2:
1993 if (kind > 45)
1994 kind = 45;
1995 jjCheckNAddTwoStates(0, 1);
1996 break;
1997 default : break;
1998 }
1999 } while(i != startsAt);
2000 }
2001 else
2002 {
2003 int i2 = (curChar & 0xff) >> 6;
2004 long l2 = 1L << (curChar & 077);
2005 do
2006 {
2007 switch(jjstateSet[--i])
2008 {
2009 case 3:
2010 case 0:
2011 case 2:
2012 if ((jjbitVec0[i2] & l2) == 0L)
2013 break;
2014 if (kind > 45)
2015 kind = 45;
2016 jjCheckNAddTwoStates(0, 1);
2017 break;
2018 default : break;
2019 }
2020 } while(i != startsAt);
2021 }
2022 if (kind != 0x7fffffff)
2023 {
2024 jjmatchedKind = kind;
2025 jjmatchedPos = curPos;
2026 kind = 0x7fffffff;
2027 }
2028 ++curPos;
2029 if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
2030 return curPos;
2031 try { curChar = input_stream.readChar(); }
2032 catch(java.io.IOException e) { return curPos; }
2033 }
2034 }
2035 private final int jjStopStringLiteralDfa_11(int pos, long active0)
2036 {
2037 switch (pos)
2038 {
2039 default :
2040 return -1;
2041 }
2042 }
2043 private final int jjStartNfa_11(int pos, long active0)
2044 {
2045 return jjMoveNfa_11(jjStopStringLiteralDfa_11(pos, active0), pos + 1);
2046 }
2047 private int jjMoveStringLiteralDfa0_11()
2048 {
2049 switch(curChar)
2050 {
2051 case 47:
2052 return jjMoveStringLiteralDfa1_11(0x2000000000000000L);
2053 case 61:
2054 return jjStopAtPos(0, 62);
2055 case 62:
2056 return jjStopAtPos(0, 59);
2057 default :
2058 return jjMoveNfa_11(1, 0);
2059 }
2060 }
2061 private int jjMoveStringLiteralDfa1_11(long active0)
2062 {
2063 try { curChar = input_stream.readChar(); }
2064 catch(java.io.IOException e) {
2065 jjStopStringLiteralDfa_11(0, active0);
2066 return 1;
2067 }
2068 switch(curChar)
2069 {
2070 case 62:
2071 if ((active0 & 0x2000000000000000L) != 0L)
2072 return jjStopAtPos(1, 61);
2073 break;
2074 default :
2075 break;
2076 }
2077 return jjStartNfa_11(0, active0);
2078 }
2079 private int jjMoveNfa_11(int startState, int curPos)
2080 {
2081 int startsAt = 0;
2082 jjnewStateCnt = 6;
2083 int i = 1;
2084 jjstateSet[0] = startState;
2085 int kind = 0x7fffffff;
2086 for (;;)
2087 {
2088 if (++jjround == 0x7fffffff)
2089 ReInitRounds();
2090 if (curChar < 64)
2091 {
2092 long l = 1L << curChar;
2093 do
2094 {
2095 switch(jjstateSet[--i])
2096 {
2097 case 1:
2098 if ((0x100002600L & l) != 0L)
2099 {
2100 if (kind > 21)
2101 kind = 21;
2102 jjCheckNAdd(0);
2103 }
2104 else if (curChar == 33)
2105 jjCheckNAdd(3);
2106 else if (curChar == 36)
2107 {
2108 if (kind > 58)
2109 kind = 58;
2110 jjCheckNAdd(2);
2111 }
2112 else if (curChar == 63)
2113 jjCheckNAdd(3);
2114 break;
2115 case 0:
2116 if ((0x100002600L & l) == 0L)
2117 break;
2118 kind = 21;
2119 jjCheckNAdd(0);
2120 break;
2121 case 2:
2122 if ((0x7ff601000000000L & l) == 0L)
2123 break;
2124 if (kind > 58)
2125 kind = 58;
2126 jjCheckNAdd(2);
2127 break;
2128 case 3:
2129 if (curChar == 62)
2130 kind = 60;
2131 break;
2132 case 4:
2133 if (curChar == 63)
2134 jjCheckNAdd(3);
2135 break;
2136 case 5:
2137 if (curChar == 33)
2138 jjCheckNAdd(3);
2139 break;
2140 default : break;
2141 }
2142 } while(i != startsAt);
2143 }
2144 else if (curChar < 128)
2145 {
2146 long l = 1L << (curChar & 077);
2147 do
2148 {
2149 switch(jjstateSet[--i])
2150 {
2151 case 1:
2152 case 2:
2153 if ((0x7fffffe87fffffeL & l) == 0L)
2154 break;
2155 if (kind > 58)
2156 kind = 58;
2157 jjCheckNAdd(2);
2158 break;
2159 default : break;
2160 }
2161 } while(i != startsAt);
2162 }
2163 else
2164 {
2165 int i2 = (curChar & 0xff) >> 6;
2166 long l2 = 1L << (curChar & 077);
2167 do
2168 {
2169 switch(jjstateSet[--i])
2170 {
2171 case 1:
2172 case 2:
2173 if ((jjbitVec1[i2] & l2) == 0L)
2174 break;
2175 if (kind > 58)
2176 kind = 58;
2177 jjCheckNAdd(2);
2178 break;
2179 default : break;
2180 }
2181 } while(i != startsAt);
2182 }
2183 if (kind != 0x7fffffff)
2184 {
2185 jjmatchedKind = kind;
2186 jjmatchedPos = curPos;
2187 kind = 0x7fffffff;
2188 }
2189 ++curPos;
2190 if ((i = jjnewStateCnt) == (startsAt = 6 - (jjnewStateCnt = startsAt)))
2191 return curPos;
2192 try { curChar = input_stream.readChar(); }
2193 catch(java.io.IOException e) { return curPos; }
2194 }
2195 }
2196 private int jjMoveStringLiteralDfa0_15()
2197 {
2198 return jjMoveNfa_15(1, 0);
2199 }
2200 private int jjMoveNfa_15(int startState, int curPos)
2201 {
2202 int startsAt = 0;
2203 jjnewStateCnt = 3;
2204 int i = 1;
2205 jjstateSet[0] = startState;
2206 int kind = 0x7fffffff;
2207 for (;;)
2208 {
2209 if (++jjround == 0x7fffffff)
2210 ReInitRounds();
2211 if (curChar < 64)
2212 {
2213 long l = 1L << curChar;
2214 do
2215 {
2216 switch(jjstateSet[--i])
2217 {
2218 case 1:
2219 if ((0x100002600L & l) != 0L)
2220 {
2221 if (kind > 20)
2222 kind = 20;
2223 jjCheckNAdd(0);
2224 }
2225 else if (curChar == 36)
2226 {
2227 if (kind > 35)
2228 kind = 35;
2229 jjCheckNAdd(2);
2230 }
2231 break;
2232 case 0:
2233 if ((0x100002600L & l) == 0L)
2234 break;
2235 kind = 20;
2236 jjCheckNAdd(0);
2237 break;
2238 case 2:
2239 if ((0x7ff601000000000L & l) == 0L)
2240 break;
2241 if (kind > 35)
2242 kind = 35;
2243 jjCheckNAdd(2);
2244 break;
2245 default : break;
2246 }
2247 } while(i != startsAt);
2248 }
2249 else if (curChar < 128)
2250 {
2251 long l = 1L << (curChar & 077);
2252 do
2253 {
2254 switch(jjstateSet[--i])
2255 {
2256 case 1:
2257 case 2:
2258 if ((0x7fffffe87fffffeL & l) == 0L)
2259 break;
2260 if (kind > 35)
2261 kind = 35;
2262 jjCheckNAdd(2);
2263 break;
2264 default : break;
2265 }
2266 } while(i != startsAt);
2267 }
2268 else
2269 {
2270 int i2 = (curChar & 0xff) >> 6;
2271 long l2 = 1L << (curChar & 077);
2272 do
2273 {
2274 switch(jjstateSet[--i])
2275 {
2276 case 1:
2277 case 2:
2278 if ((jjbitVec1[i2] & l2) == 0L)
2279 break;
2280 if (kind > 35)
2281 kind = 35;
2282 jjCheckNAdd(2);
2283 break;
2284 default : break;
2285 }
2286 } while(i != startsAt);
2287 }
2288 if (kind != 0x7fffffff)
2289 {
2290 jjmatchedKind = kind;
2291 jjmatchedPos = curPos;
2292 kind = 0x7fffffff;
2293 }
2294 ++curPos;
2295 if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
2296 return curPos;
2297 try { curChar = input_stream.readChar(); }
2298 catch(java.io.IOException e) { return curPos; }
2299 }
2300 }
2301 private final int jjStopStringLiteralDfa_1(int pos, long active0, long active1)
2302 {
2303 switch (pos)
2304 {
2305 default :
2306 return -1;
2307 }
2308 }
2309 private final int jjStartNfa_1(int pos, long active0, long active1)
2310 {
2311 return jjMoveNfa_1(jjStopStringLiteralDfa_1(pos, active0, active1), pos + 1);
2312 }
2313 private int jjMoveStringLiteralDfa0_1()
2314 {
2315 switch(curChar)
2316 {
2317 case 34:
2318 return jjStopAtPos(0, 72);
2319 default :
2320 return jjMoveNfa_1(9, 0);
2321 }
2322 }
2323 private int jjMoveNfa_1(int startState, int curPos)
2324 {
2325 int startsAt = 0;
2326 jjnewStateCnt = 37;
2327 int i = 1;
2328 jjstateSet[0] = startState;
2329 int kind = 0x7fffffff;
2330 for (;;)
2331 {
2332 if (++jjround == 0x7fffffff)
2333 ReInitRounds();
2334 if (curChar < 64)
2335 {
2336 long l = 1L << curChar;
2337 do
2338 {
2339 switch(jjstateSet[--i])
2340 {
2341 case 9:
2342 if ((0xffffffe3ffffffffL & l) != 0L)
2343 {
2344 if (kind > 73)
2345 kind = 73;
2346 jjCheckNAddStates(2, 4);
2347 }
2348 else if ((0x1800000000L & l) != 0L)
2349 jjCheckNAddTwoStates(30, 36);
2350 if (curChar == 60)
2351 jjstateSet[jjnewStateCnt++] = 26;
2352 else if (curChar == 35)
2353 jjstateSet[jjnewStateCnt++] = 10;
2354 else if (curChar == 36)
2355 jjstateSet[jjnewStateCnt++] = 0;
2356 break;
2357 case 1:
2358 if ((0xffffff7bffffffffL & l) != 0L)
2359 jjCheckNAddStates(5, 8);
2360 break;
2361 case 2:
2362 if (curChar == 34)
2363 jjCheckNAddTwoStates(3, 4);
2364 break;
2365 case 3:
2366 if ((0xfffffffbffffffffL & l) != 0L)
2367 jjCheckNAddTwoStates(3, 4);
2368 break;
2369 case 4:
2370 if (curChar == 34)
2371 jjCheckNAddStates(5, 8);
2372 break;
2373 case 5:
2374 if (curChar == 39)
2375 jjCheckNAddTwoStates(6, 7);
2376 break;
2377 case 6:
2378 if ((0xffffff7fffffffffL & l) != 0L)
2379 jjCheckNAddTwoStates(6, 7);
2380 break;
2381 case 7:
2382 if (curChar == 39)
2383 jjCheckNAddStates(5, 8);
2384 break;
2385 case 11:
2386 if ((0xffffff7bffffffffL & l) != 0L)
2387 jjCheckNAddStates(9, 12);
2388 break;
2389 case 12:
2390 if (curChar == 34)
2391 jjCheckNAddTwoStates(13, 14);
2392 break;
2393 case 13:
2394 if ((0xfffffffbffffffffL & l) != 0L)
2395 jjCheckNAddTwoStates(13, 14);
2396 break;
2397 case 14:
2398 if (curChar == 34)
2399 jjCheckNAddStates(9, 12);
2400 break;
2401 case 15:
2402 if (curChar == 39)
2403 jjCheckNAddTwoStates(16, 17);
2404 break;
2405 case 16:
2406 if ((0xffffff7fffffffffL & l) != 0L)
2407 jjCheckNAddTwoStates(16, 17);
2408 break;
2409 case 17:
2410 if (curChar == 39)
2411 jjCheckNAddStates(9, 12);
2412 break;
2413 case 19:
2414 if (curChar == 35)
2415 jjstateSet[jjnewStateCnt++] = 10;
2416 break;
2417 case 20:
2418 if (curChar == 61)
2419 jjCheckNAddTwoStates(21, 22);
2420 break;
2421 case 21:
2422 if ((0xffffffdfffffffffL & l) != 0L)
2423 jjCheckNAddStates(13, 15);
2424 break;
2425 case 22:
2426 if (curChar == 37)
2427 jjstateSet[jjnewStateCnt++] = 23;
2428 break;
2429 case 23:
2430 if ((0xbfffffffffffffffL & l) != 0L)
2431 jjCheckNAddStates(13, 15);
2432 break;
2433 case 24:
2434 if (curChar == 62 && kind > 68)
2435 kind = 68;
2436 break;
2437 case 25:
2438 if (curChar == 37)
2439 jjstateSet[jjnewStateCnt++] = 24;
2440 break;
2441 case 26:
2442 if (curChar == 37)
2443 jjstateSet[jjnewStateCnt++] = 20;
2444 break;
2445 case 27:
2446 if (curChar == 60)
2447 jjstateSet[jjnewStateCnt++] = 26;
2448 break;
2449 case 28:
2450 if ((0xffffffe3ffffffffL & l) == 0L)
2451 break;
2452 if (kind > 73)
2453 kind = 73;
2454 jjCheckNAddStates(2, 4);
2455 break;
2456 case 29:
2457 if ((0x1800000000L & l) != 0L)
2458 jjCheckNAdd(30);
2459 break;
2460 case 30:
2461 if ((0xfffffffbffffffffL & l) == 0L)
2462 break;
2463 if (kind > 73)
2464 kind = 73;
2465 jjCheckNAddStates(2, 4);
2466 break;
2467 case 33:
2468 if (curChar == 35)
2469 jjCheckNAdd(32);
2470 break;
2471 case 34:
2472 if (curChar == 36)
2473 jjCheckNAdd(32);
2474 break;
2475 case 35:
2476 if ((0x1800000000L & l) != 0L)
2477 jjCheckNAddTwoStates(30, 36);
2478 break;
2479 case 36:
2480 if (curChar == 34 && kind > 74)
2481 kind = 74;
2482 break;
2483 default : break;
2484 }
2485 } while(i != startsAt);
2486 }
2487 else if (curChar < 128)
2488 {
2489 long l = 1L << (curChar & 077);
2490 do
2491 {
2492 switch(jjstateSet[--i])
2493 {
2494 case 9:
2495 if (kind > 73)
2496 kind = 73;
2497 jjCheckNAddStates(2, 4);
2498 if (curChar == 92)
2499 jjAddStates(16, 17);
2500 break;
2501 case 0:
2502 if (curChar == 123)
2503 jjCheckNAddStates(5, 8);
2504 break;
2505 case 1:
2506 if ((0xdfffffffffffffffL & l) != 0L)
2507 jjCheckNAddStates(5, 8);
2508 break;
2509 case 3:
2510 jjAddStates(18, 19);
2511 break;
2512 case 6:
2513 jjAddStates(20, 21);
2514 break;
2515 case 8:
2516 if (curChar == 125 && kind > 66)
2517 kind = 66;
2518 break;
2519 case 10:
2520 if (curChar == 123)
2521 jjCheckNAddStates(9, 12);
2522 break;
2523 case 11:
2524 if ((0xdfffffffffffffffL & l) != 0L)
2525 jjCheckNAddStates(9, 12);
2526 break;
2527 case 13:
2528 jjAddStates(22, 23);
2529 break;
2530 case 16:
2531 jjAddStates(24, 25);
2532 break;
2533 case 18:
2534 if (curChar == 125 && kind > 67)
2535 kind = 67;
2536 break;
2537 case 21:
2538 case 23:
2539 jjCheckNAddStates(13, 15);
2540 break;
2541 case 28:
2542 if (kind > 73)
2543 kind = 73;
2544 jjCheckNAddStates(2, 4);
2545 break;
2546 case 30:
2547 if ((0xf7ffffffffffffffL & l) == 0L)
2548 break;
2549 if (kind > 73)
2550 kind = 73;
2551 jjCheckNAddStates(2, 4);
2552 break;
2553 case 31:
2554 if (curChar == 92)
2555 jjAddStates(16, 17);
2556 break;
2557 case 32:
2558 if (curChar != 123)
2559 break;
2560 if (kind > 73)
2561 kind = 73;
2562 jjCheckNAddStates(2, 4);
2563 break;
2564 default : break;
2565 }
2566 } while(i != startsAt);
2567 }
2568 else
2569 {
2570 int i2 = (curChar & 0xff) >> 6;
2571 long l2 = 1L << (curChar & 077);
2572 do
2573 {
2574 switch(jjstateSet[--i])
2575 {
2576 case 9:
2577 case 28:
2578 case 30:
2579 if ((jjbitVec0[i2] & l2) == 0L)
2580 break;
2581 if (kind > 73)
2582 kind = 73;
2583 jjCheckNAddStates(2, 4);
2584 break;
2585 case 1:
2586 if ((jjbitVec0[i2] & l2) != 0L)
2587 jjAddStates(5, 8);
2588 break;
2589 case 3:
2590 if ((jjbitVec0[i2] & l2) != 0L)
2591 jjAddStates(18, 19);
2592 break;
2593 case 6:
2594 if ((jjbitVec0[i2] & l2) != 0L)
2595 jjAddStates(20, 21);
2596 break;
2597 case 11:
2598 if ((jjbitVec0[i2] & l2) != 0L)
2599 jjAddStates(9, 12);
2600 break;
2601 case 13:
2602 if ((jjbitVec0[i2] & l2) != 0L)
2603 jjAddStates(22, 23);
2604 break;
2605 case 16:
2606 if ((jjbitVec0[i2] & l2) != 0L)
2607 jjAddStates(24, 25);
2608 break;
2609 case 21:
2610 case 23:
2611 if ((jjbitVec0[i2] & l2) != 0L)
2612 jjCheckNAddStates(13, 15);
2613 break;
2614 default : break;
2615 }
2616 } while(i != startsAt);
2617 }
2618 if (kind != 0x7fffffff)
2619 {
2620 jjmatchedKind = kind;
2621 jjmatchedPos = curPos;
2622 kind = 0x7fffffff;
2623 }
2624 ++curPos;
2625 if ((i = jjnewStateCnt) == (startsAt = 37 - (jjnewStateCnt = startsAt)))
2626 return curPos;
2627 try { curChar = input_stream.readChar(); }
2628 catch(java.io.IOException e) { return curPos; }
2629 }
2630 }
2631 private final int jjStopStringLiteralDfa_5(int pos, long active0)
2632 {
2633 switch (pos)
2634 {
2635 default :
2636 return -1;
2637 }
2638 }
2639 private final int jjStartNfa_5(int pos, long active0)
2640 {
2641 return jjMoveNfa_5(jjStopStringLiteralDfa_5(pos, active0), pos + 1);
2642 }
2643 private int jjMoveStringLiteralDfa0_5()
2644 {
2645 switch(curChar)
2646 {
2647 case 62:
2648 return jjStopAtPos(0, 52);
2649 case 80:
2650 case 112:
2651 return jjMoveStringLiteralDfa1_5(0x4000000000000L);
2652 case 83:
2653 case 115:
2654 return jjMoveStringLiteralDfa1_5(0x8000000000000L);
2655 default :
2656 return jjMoveNfa_5(1, 0);
2657 }
2658 }
2659 private int jjMoveStringLiteralDfa1_5(long active0)
2660 {
2661 try { curChar = input_stream.readChar(); }
2662 catch(java.io.IOException e) {
2663 jjStopStringLiteralDfa_5(0, active0);
2664 return 1;
2665 }
2666 switch(curChar)
2667 {
2668 case 85:
2669 case 117:
2670 return jjMoveStringLiteralDfa2_5(active0, 0x4000000000000L);
2671 case 89:
2672 case 121:
2673 return jjMoveStringLiteralDfa2_5(active0, 0x8000000000000L);
2674 default :
2675 break;
2676 }
2677 return jjStartNfa_5(0, active0);
2678 }
2679 private int jjMoveStringLiteralDfa2_5(long old0, long active0)
2680 {
2681 if (((active0 &= old0)) == 0L)
2682 return jjStartNfa_5(0, old0);
2683 try { curChar = input_stream.readChar(); }
2684 catch(java.io.IOException e) {
2685 jjStopStringLiteralDfa_5(1, active0);
2686 return 2;
2687 }
2688 switch(curChar)
2689 {
2690 case 66:
2691 case 98:
2692 return jjMoveStringLiteralDfa3_5(active0, 0x4000000000000L);
2693 case 83:
2694 case 115:
2695 return jjMoveStringLiteralDfa3_5(active0, 0x8000000000000L);
2696 default :
2697 break;
2698 }
2699 return jjStartNfa_5(1, active0);
2700 }
2701 private int jjMoveStringLiteralDfa3_5(long old0, long active0)
2702 {
2703 if (((active0 &= old0)) == 0L)
2704 return jjStartNfa_5(1, old0);
2705 try { curChar = input_stream.readChar(); }
2706 catch(java.io.IOException e) {
2707 jjStopStringLiteralDfa_5(2, active0);
2708 return 3;
2709 }
2710 switch(curChar)
2711 {
2712 case 76:
2713 case 108:
2714 return jjMoveStringLiteralDfa4_5(active0, 0x4000000000000L);
2715 case 84:
2716 case 116:
2717 return jjMoveStringLiteralDfa4_5(active0, 0x8000000000000L);
2718 default :
2719 break;
2720 }
2721 return jjStartNfa_5(2, active0);
2722 }
2723 private int jjMoveStringLiteralDfa4_5(long old0, long active0)
2724 {
2725 if (((active0 &= old0)) == 0L)
2726 return jjStartNfa_5(2, old0);
2727 try { curChar = input_stream.readChar(); }
2728 catch(java.io.IOException e) {
2729 jjStopStringLiteralDfa_5(3, active0);
2730 return 4;
2731 }
2732 switch(curChar)
2733 {
2734 case 69:
2735 case 101:
2736 return jjMoveStringLiteralDfa5_5(active0, 0x8000000000000L);
2737 case 73:
2738 case 105:
2739 return jjMoveStringLiteralDfa5_5(active0, 0x4000000000000L);
2740 default :
2741 break;
2742 }
2743 return jjStartNfa_5(3, active0);
2744 }
2745 private int jjMoveStringLiteralDfa5_5(long old0, long active0)
2746 {
2747 if (((active0 &= old0)) == 0L)
2748 return jjStartNfa_5(3, old0);
2749 try { curChar = input_stream.readChar(); }
2750 catch(java.io.IOException e) {
2751 jjStopStringLiteralDfa_5(4, active0);
2752 return 5;
2753 }
2754 switch(curChar)
2755 {
2756 case 67:
2757 case 99:
2758 if ((active0 & 0x4000000000000L) != 0L)
2759 return jjStopAtPos(5, 50);
2760 break;
2761 case 77:
2762 case 109:
2763 if ((active0 & 0x8000000000000L) != 0L)
2764 return jjStopAtPos(5, 51);
2765 break;
2766 default :
2767 break;
2768 }
2769 return jjStartNfa_5(4, active0);
2770 }
2771 private int jjMoveNfa_5(int startState, int curPos)
2772 {
2773 int startsAt = 0;
2774 jjnewStateCnt = 7;
2775 int i = 1;
2776 jjstateSet[0] = startState;
2777 int kind = 0x7fffffff;
2778 for (;;)
2779 {
2780 if (++jjround == 0x7fffffff)
2781 ReInitRounds();
2782 if (curChar < 64)
2783 {
2784 long l = 1L << curChar;
2785 do
2786 {
2787 switch(jjstateSet[--i])
2788 {
2789 case 1:
2790 if ((0x100002600L & l) != 0L)
2791 {
2792 if (kind > 48)
2793 kind = 48;
2794 jjCheckNAdd(0);
2795 }
2796 else if (curChar == 34)
2797 jjCheckNAddTwoStates(5, 6);
2798 else if (curChar == 39)
2799 jjCheckNAddTwoStates(2, 3);
2800 break;
2801 case 0:
2802 if ((0x100002600L & l) == 0L)
2803 break;
2804 if (kind > 48)
2805 kind = 48;
2806 jjCheckNAdd(0);
2807 break;
2808 case 2:
2809 if ((0xffffff7fffffffffL & l) != 0L)
2810 jjCheckNAddTwoStates(2, 3);
2811 break;
2812 case 3:
2813 if (curChar == 39 && kind > 53)
2814 kind = 53;
2815 break;
2816 case 4:
2817 if (curChar == 34)
2818 jjCheckNAddTwoStates(5, 6);
2819 break;
2820 case 5:
2821 if ((0xfffffffbffffffffL & l) != 0L)
2822 jjCheckNAddTwoStates(5, 6);
2823 break;
2824 case 6:
2825 if (curChar == 34 && kind > 53)
2826 kind = 53;
2827 break;
2828 default : break;
2829 }
2830 } while(i != startsAt);
2831 }
2832 else if (curChar < 128)
2833 {
2834 long l = 1L << (curChar & 077);
2835 do
2836 {
2837 switch(jjstateSet[--i])
2838 {
2839 case 2:
2840 jjAddStates(42, 43);
2841 break;
2842 case 5:
2843 jjAddStates(44, 45);
2844 break;
2845 default : break;
2846 }
2847 } while(i != startsAt);
2848 }
2849 else
2850 {
2851 int i2 = (curChar & 0xff) >> 6;
2852 long l2 = 1L << (curChar & 077);
2853 do
2854 {
2855 switch(jjstateSet[--i])
2856 {
2857 case 2:
2858 if ((jjbitVec0[i2] & l2) != 0L)
2859 jjAddStates(42, 43);
2860 break;
2861 case 5:
2862 if ((jjbitVec0[i2] & l2) != 0L)
2863 jjAddStates(44, 45);
2864 break;
2865 default : break;
2866 }
2867 } while(i != startsAt);
2868 }
2869 if (kind != 0x7fffffff)
2870 {
2871 jjmatchedKind = kind;
2872 jjmatchedPos = curPos;
2873 kind = 0x7fffffff;
2874 }
2875 ++curPos;
2876 if ((i = jjnewStateCnt) == (startsAt = 7 - (jjnewStateCnt = startsAt)))
2877 return curPos;
2878 try { curChar = input_stream.readChar(); }
2879 catch(java.io.IOException e) { return curPos; }
2880 }
2881 }
2882 private final int jjStopStringLiteralDfa_10(int pos, long active0)
2883 {
2884 switch (pos)
2885 {
2886 case 0:
2887 if ((active0 & 0x10000000000L) != 0L)
2888 return 2;
2889 return -1;
2890 default :
2891 return -1;
2892 }
2893 }
2894 private final int jjStartNfa_10(int pos, long active0)
2895 {
2896 return jjMoveNfa_10(jjStopStringLiteralDfa_10(pos, active0), pos + 1);
2897 }
2898 private int jjMoveStringLiteralDfa0_10()
2899 {
2900 switch(curChar)
2901 {
2902 case 37:
2903 return jjMoveStringLiteralDfa1_10(0x10000000000L);
2904 default :
2905 return jjMoveNfa_10(3, 0);
2906 }
2907 }
2908 private int jjMoveStringLiteralDfa1_10(long active0)
2909 {
2910 try { curChar = input_stream.readChar(); }
2911 catch(java.io.IOException e) {
2912 jjStopStringLiteralDfa_10(0, active0);
2913 return 1;
2914 }
2915 switch(curChar)
2916 {
2917 case 62:
2918 if ((active0 & 0x10000000000L) != 0L)
2919 return jjStopAtPos(1, 40);
2920 break;
2921 default :
2922 break;
2923 }
2924 return jjStartNfa_10(0, active0);
2925 }
2926 private int jjMoveNfa_10(int startState, int curPos)
2927 {
2928 int startsAt = 0;
2929 jjnewStateCnt = 3;
2930 int i = 1;
2931 jjstateSet[0] = startState;
2932 int kind = 0x7fffffff;
2933 for (;;)
2934 {
2935 if (++jjround == 0x7fffffff)
2936 ReInitRounds();
2937 if (curChar < 64)
2938 {
2939 long l = 1L << curChar;
2940 do
2941 {
2942 switch(jjstateSet[--i])
2943 {
2944 case 3:
2945 if ((0xffffffdfffffffffL & l) != 0L)
2946 {
2947 if (kind > 41)
2948 kind = 41;
2949 jjCheckNAddTwoStates(0, 1);
2950 }
2951 else if (curChar == 37)
2952 jjstateSet[jjnewStateCnt++] = 2;
2953 break;
2954 case 0:
2955 if ((0xffffffdfffffffffL & l) == 0L)
2956 break;
2957 if (kind > 41)
2958 kind = 41;
2959 jjCheckNAddTwoStates(0, 1);
2960 break;
2961 case 1:
2962 if (curChar == 37)
2963 jjstateSet[jjnewStateCnt++] = 2;
2964 break;
2965 case 2:
2966 if ((0xbfffffffffffffffL & l) == 0L)
2967 break;
2968 if (kind > 41)
2969 kind = 41;
2970 jjCheckNAddTwoStates(0, 1);
2971 break;
2972 default : break;
2973 }
2974 } while(i != startsAt);
2975 }
2976 else if (curChar < 128)
2977 {
2978 long l = 1L << (curChar & 077);
2979 do
2980 {
2981 switch(jjstateSet[--i])
2982 {
2983 case 3:
2984 case 0:
2985 case 2:
2986 if (kind > 41)
2987 kind = 41;
2988 jjCheckNAddTwoStates(0, 1);
2989 break;
2990 default : break;
2991 }
2992 } while(i != startsAt);
2993 }
2994 else
2995 {
2996 int i2 = (curChar & 0xff) >> 6;
2997 long l2 = 1L << (curChar & 077);
2998 do
2999 {
3000 switch(jjstateSet[--i])
3001 {
3002 case 3:
3003 case 0:
3004 case 2:
3005 if ((jjbitVec0[i2] & l2) == 0L)
3006 break;
3007 if (kind > 41)
3008 kind = 41;
3009 jjCheckNAddTwoStates(0, 1);
3010 break;
3011 default : break;
3012 }
3013 } while(i != startsAt);
3014 }
3015 if (kind != 0x7fffffff)
3016 {
3017 jjmatchedKind = kind;
3018 jjmatchedPos = curPos;
3019 kind = 0x7fffffff;
3020 }
3021 ++curPos;
3022 if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
3023 return curPos;
3024 try { curChar = input_stream.readChar(); }
3025 catch(java.io.IOException e) { return curPos; }
3026 }
3027 }
3028 private final int jjStopStringLiteralDfa_14(int pos, long active0)
3029 {
3030 switch (pos)
3031 {
3032 default :
3033 return -1;
3034 }
3035 }
3036 private final int jjStartNfa_14(int pos, long active0)
3037 {
3038 return jjMoveNfa_14(jjStopStringLiteralDfa_14(pos, active0), pos + 1);
3039 }
3040 private int jjMoveStringLiteralDfa0_14()
3041 {
3042 switch(curChar)
3043 {
3044 case 37:
3045 return jjMoveStringLiteralDfa1_14(0x8000000000L);
3046 case 61:
3047 return jjStopAtPos(0, 37);
3048 default :
3049 return jjMoveNfa_14(1, 0);
3050 }
3051 }
3052 private int jjMoveStringLiteralDfa1_14(long active0)
3053 {
3054 try { curChar = input_stream.readChar(); }
3055 catch(java.io.IOException e) {
3056 jjStopStringLiteralDfa_14(0, active0);
3057 return 1;
3058 }
3059 switch(curChar)
3060 {
3061 case 62:
3062 if ((active0 & 0x8000000000L) != 0L)
3063 return jjStopAtPos(1, 39);
3064 break;
3065 default :
3066 break;
3067 }
3068 return jjStartNfa_14(0, active0);
3069 }
3070 private int jjMoveNfa_14(int startState, int curPos)
3071 {
3072 int startsAt = 0;
3073 jjnewStateCnt = 9;
3074 int i = 1;
3075 jjstateSet[0] = startState;
3076 int kind = 0x7fffffff;
3077 for (;;)
3078 {
3079 if (++jjround == 0x7fffffff)
3080 ReInitRounds();
3081 if (curChar < 64)
3082 {
3083 long l = 1L << curChar;
3084 do
3085 {
3086 switch(jjstateSet[--i])
3087 {
3088 case 1:
3089 if ((0x100002600L & l) != 0L)
3090 {
3091 if (kind > 20)
3092 kind = 20;
3093 jjCheckNAdd(0);
3094 }
3095 else if (curChar == 34)
3096 jjCheckNAddTwoStates(7, 8);
3097 else if (curChar == 39)
3098 jjCheckNAddTwoStates(4, 5);
3099 else if (curChar == 36)
3100 {
3101 if (kind > 36)
3102 kind = 36;
3103 jjCheckNAdd(2);
3104 }
3105 break;
3106 case 0:
3107 if ((0x100002600L & l) == 0L)
3108 break;
3109 if (kind > 20)
3110 kind = 20;
3111 jjCheckNAdd(0);
3112 break;
3113 case 2:
3114 if ((0x7ff601000000000L & l) == 0L)
3115 break;
3116 if (kind > 36)
3117 kind = 36;
3118 jjCheckNAdd(2);
3119 break;
3120 case 3:
3121 if (curChar == 39)
3122 jjCheckNAddTwoStates(4, 5);
3123 break;
3124 case 4:
3125 if ((0xffffff7fffffffffL & l) != 0L)
3126 jjCheckNAddTwoStates(4, 5);
3127 break;
3128 case 5:
3129 if (curChar == 39 && kind > 38)
3130 kind = 38;
3131 break;
3132 case 6:
3133 if (curChar == 34)
3134 jjCheckNAddTwoStates(7, 8);
3135 break;
3136 case 7:
3137 if ((0xfffffffbffffffffL & l) != 0L)
3138 jjCheckNAddTwoStates(7, 8);
3139 break;
3140 case 8:
3141 if (curChar == 34 && kind > 38)
3142 kind = 38;
3143 break;
3144 default : break;
3145 }
3146 } while(i != startsAt);
3147 }
3148 else if (curChar < 128)
3149 {
3150 long l = 1L << (curChar & 077);
3151 do
3152 {
3153 switch(jjstateSet[--i])
3154 {
3155 case 1:
3156 case 2:
3157 if ((0x7fffffe87fffffeL & l) == 0L)
3158 break;
3159 if (kind > 36)
3160 kind = 36;
3161 jjCheckNAdd(2);
3162 break;
3163 case 4:
3164 jjAddStates(38, 39);
3165 break;
3166 case 7:
3167 jjAddStates(40, 41);
3168 break;
3169 default : break;
3170 }
3171 } while(i != startsAt);
3172 }
3173 else
3174 {
3175 int i2 = (curChar & 0xff) >> 6;
3176 long l2 = 1L << (curChar & 077);
3177 do
3178 {
3179 switch(jjstateSet[--i])
3180 {
3181 case 1:
3182 case 2:
3183 if ((jjbitVec1[i2] & l2) == 0L)
3184 break;
3185 if (kind > 36)
3186 kind = 36;
3187 jjCheckNAdd(2);
3188 break;
3189 case 4:
3190 if ((jjbitVec0[i2] & l2) != 0L)
3191 jjAddStates(38, 39);
3192 break;
3193 case 7:
3194 if ((jjbitVec0[i2] & l2) != 0L)
3195 jjAddStates(40, 41);
3196 break;
3197 default : break;
3198 }
3199 } while(i != startsAt);
3200 }
3201 if (kind != 0x7fffffff)
3202 {
3203 jjmatchedKind = kind;
3204 jjmatchedPos = curPos;
3205 kind = 0x7fffffff;
3206 }
3207 ++curPos;
3208 if ((i = jjnewStateCnt) == (startsAt = 9 - (jjnewStateCnt = startsAt)))
3209 return curPos;
3210 try { curChar = input_stream.readChar(); }
3211 catch(java.io.IOException e) { return curPos; }
3212 }
3213 }
3214 static final int[] jjnextStates = {
3215 1, 4, 28, 29, 31, 1, 2, 5, 8, 11, 12, 15, 18, 21, 22, 25,
3216 33, 34, 3, 4, 6, 7, 13, 14, 16, 17, 0, 1, 2, 3, 7, 11,
3217 12, 14, 2, 3, 6, 9, 4, 5, 7, 8, 2, 3, 5, 6,
3218 };
3219
3220 /** Token literal values. */
3221 public static final String[] jjstrLiteralImages = {
3222 "", null, null, null, null, null, null, null, null, null, null, null, null,
3223 null, null, null, null, null, null, null, null, null, "\74", "\74\57",
3224 "\74\41\55\55", "\74\77", null, null, "\74\45\55\55", "\74\45\41", "\74\45\75", "\74\45",
3225 "\74\45\100", null, null, null, null, "\75", null, "\45\76", "\45\76", null, "\45\76", null,
3226 "\45\76", null, "\55\55\45\76", null, null, null, null, null, "\76", null, null,
3227 "\135\135\76", null, null, null, "\76", null, "\57\76", "\75", null, "\47", "\42", null, null,
3228 null, "\47", null, null, "\42", null, null, null, null, };
3229
3230 /** Lexer state names. */
3231 public static final String[] lexStateNames = {
3232 "CommentState",
3233 "AttrValueBetweenDoubleQuotesState",
3234 "AttrValueBetweenSingleQuotesState",
3235 "StartTagState",
3236 "CDataState",
3237 "DocTypeExternalIdState",
3238 "DocTypeState",
3239 "JspCommentState",
3240 "JspDeclarationState",
3241 "JspExpressionState",
3242 "JspScriptletState",
3243 "InTagState",
3244 "AfterTagState",
3245 "AttrValueState",
3246 "JspDirectiveAttributesState",
3247 "JspDirectiveState",
3248 "DEFAULT",
3249 };
3250
3251 /** Lex State array. */
3252 public static final int[] jjnewLexState = {
3253 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 3, 3, 0,
3254 3, 6, 4, 7, 8, 9, 10, 15, -1, -1, 14, -1, -1, -1, 12, 12, -1, 12, -1, 12, -1, 12, -1, -1, 5,
3255 -1, -1, 12, -1, -1, 12, 11, 16, -1, 12, 12, 12, 13, -1, 2, 1, -1, -1, -1, 11, -1, 11, 11, -1, 11,
3256 12, -1,
3257 };
3258 static final long[] jjtoToken = {
3259 0xffffffffffc00001L, 0x1fffL,
3260 };
3261 static final long[] jjtoSkip = {
3262 0x300000L, 0x0L,
3263 };
3264 static final long[] jjtoSpecial = {
3265 0x200000L, 0x0L,
3266 };
3267 protected CharStream input_stream;
3268 private final int[] jjrounds = new int[37];
3269 private final int[] jjstateSet = new int[74];
3270 protected char curChar;
3271 /** Constructor. */
3272 public JspParserTokenManager(CharStream stream){
3273 input_stream = stream;
3274 }
3275
3276 /** Constructor. */
3277 public JspParserTokenManager(CharStream stream, int lexState){
3278 this(stream);
3279 SwitchTo(lexState);
3280 }
3281
3282 /** Reinitialise parser. */
3283 public void ReInit(CharStream stream)
3284 {
3285 jjmatchedPos = jjnewStateCnt = 0;
3286 curLexState = defaultLexState;
3287 input_stream = stream;
3288 ReInitRounds();
3289 }
3290 private void ReInitRounds()
3291 {
3292 int i;
3293 jjround = 0x80000001;
3294 for (i = 37; i-- > 0;)
3295 jjrounds[i] = 0x80000000;
3296 }
3297
3298 /** Reinitialise parser. */
3299 public void ReInit(CharStream stream, int lexState)
3300 {
3301 ReInit(stream);
3302 SwitchTo(lexState);
3303 }
3304
3305 /** Switch to specified lex state. */
3306 public void SwitchTo(int lexState)
3307 {
3308 if (lexState >= 17 || lexState < 0)
3309 throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
3310 else
3311 curLexState = lexState;
3312 }
3313
3314 protected Token jjFillToken()
3315 {
3316 final Token t;
3317 final String curTokenImage;
3318 final int beginLine;
3319 final int endLine;
3320 final int beginColumn;
3321 final int endColumn;
3322 String im = jjstrLiteralImages[jjmatchedKind];
3323 curTokenImage = (im == null) ? input_stream.GetImage() : im;
3324 beginLine = input_stream.getBeginLine();
3325 beginColumn = input_stream.getBeginColumn();
3326 endLine = input_stream.getEndLine();
3327 endColumn = input_stream.getEndColumn();
3328 t = Token.newToken(jjmatchedKind, curTokenImage);
3329
3330 t.beginLine = beginLine;
3331 t.endLine = endLine;
3332 t.beginColumn = beginColumn;
3333 t.endColumn = endColumn;
3334
3335 return t;
3336 }
3337
3338 int curLexState = 16;
3339 int defaultLexState = 16;
3340 int jjnewStateCnt;
3341 int jjround;
3342 int jjmatchedPos;
3343 int jjmatchedKind;
3344
3345 /** Get the next Token. */
3346 public Token getNextToken()
3347 {
3348 Token specialToken = null;
3349 Token matchedToken;
3350 int curPos = 0;
3351
3352 EOFLoop :
3353 for (;;)
3354 {
3355 try
3356 {
3357 curChar = input_stream.BeginToken();
3358 }
3359 catch(java.io.IOException e)
3360 {
3361 jjmatchedKind = 0;
3362 matchedToken = jjFillToken();
3363 matchedToken.specialToken = specialToken;
3364 return matchedToken;
3365 }
3366
3367 switch(curLexState)
3368 {
3369 case 0:
3370 jjmatchedKind = 0x7fffffff;
3371 jjmatchedPos = 0;
3372 curPos = jjMoveStringLiteralDfa0_0();
3373 if (jjmatchedPos == 0 && jjmatchedKind > 76)
3374 {
3375 jjmatchedKind = 76;
3376 }
3377 break;
3378 case 1:
3379 jjmatchedKind = 0x7fffffff;
3380 jjmatchedPos = 0;
3381 curPos = jjMoveStringLiteralDfa0_1();
3382 break;
3383 case 2:
3384 jjmatchedKind = 0x7fffffff;
3385 jjmatchedPos = 0;
3386 curPos = jjMoveStringLiteralDfa0_2();
3387 break;
3388 case 3:
3389 jjmatchedKind = 0x7fffffff;
3390 jjmatchedPos = 0;
3391 curPos = jjMoveStringLiteralDfa0_3();
3392 if (jjmatchedPos == 0 && jjmatchedKind > 57)
3393 {
3394 jjmatchedKind = 57;
3395 }
3396 break;
3397 case 4:
3398 jjmatchedKind = 0x7fffffff;
3399 jjmatchedPos = 0;
3400 curPos = jjMoveStringLiteralDfa0_4();
3401 if (jjmatchedPos == 0 && jjmatchedKind > 54)
3402 {
3403 jjmatchedKind = 54;
3404 }
3405 break;
3406 case 5:
3407 jjmatchedKind = 0x7fffffff;
3408 jjmatchedPos = 0;
3409 curPos = jjMoveStringLiteralDfa0_5();
3410 break;
3411 case 6:
3412 jjmatchedKind = 0x7fffffff;
3413 jjmatchedPos = 0;
3414 curPos = jjMoveStringLiteralDfa0_6();
3415 break;
3416 case 7:
3417 jjmatchedKind = 0x7fffffff;
3418 jjmatchedPos = 0;
3419 curPos = jjMoveStringLiteralDfa0_7();
3420 break;
3421 case 8:
3422 jjmatchedKind = 0x7fffffff;
3423 jjmatchedPos = 0;
3424 curPos = jjMoveStringLiteralDfa0_8();
3425 break;
3426 case 9:
3427 jjmatchedKind = 0x7fffffff;
3428 jjmatchedPos = 0;
3429 curPos = jjMoveStringLiteralDfa0_9();
3430 break;
3431 case 10:
3432 jjmatchedKind = 0x7fffffff;
3433 jjmatchedPos = 0;
3434 curPos = jjMoveStringLiteralDfa0_10();
3435 break;
3436 case 11:
3437 jjmatchedKind = 0x7fffffff;
3438 jjmatchedPos = 0;
3439 curPos = jjMoveStringLiteralDfa0_11();
3440 if (jjmatchedPos == 0 && jjmatchedKind > 63)
3441 {
3442 jjmatchedKind = 63;
3443 }
3444 break;
3445 case 12:
3446 jjmatchedKind = 0x7fffffff;
3447 jjmatchedPos = 0;
3448 curPos = jjMoveStringLiteralDfa0_12();
3449 break;
3450 case 13:
3451 jjmatchedKind = 0x7fffffff;
3452 jjmatchedPos = 0;
3453 curPos = jjMoveStringLiteralDfa0_13();
3454 break;
3455 case 14:
3456 jjmatchedKind = 0x7fffffff;
3457 jjmatchedPos = 0;
3458 curPos = jjMoveStringLiteralDfa0_14();
3459 break;
3460 case 15:
3461 jjmatchedKind = 0x7fffffff;
3462 jjmatchedPos = 0;
3463 curPos = jjMoveStringLiteralDfa0_15();
3464 break;
3465 case 16:
3466 jjmatchedKind = 0x7fffffff;
3467 jjmatchedPos = 0;
3468 curPos = jjMoveStringLiteralDfa0_16();
3469 break;
3470 }
3471 if (jjmatchedKind != 0x7fffffff)
3472 {
3473 if (jjmatchedPos + 1 < curPos)
3474 input_stream.backup(curPos - jjmatchedPos - 1);
3475 if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
3476 {
3477 matchedToken = jjFillToken();
3478 matchedToken.specialToken = specialToken;
3479 if (jjnewLexState[jjmatchedKind] != -1)
3480 curLexState = jjnewLexState[jjmatchedKind];
3481 return matchedToken;
3482 }
3483 else
3484 {
3485 if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
3486 {
3487 matchedToken = jjFillToken();
3488 if (specialToken == null)
3489 specialToken = matchedToken;
3490 else
3491 {
3492 matchedToken.specialToken = specialToken;
3493 specialToken = (specialToken.next = matchedToken);
3494 }
3495 }
3496 if (jjnewLexState[jjmatchedKind] != -1)
3497 curLexState = jjnewLexState[jjmatchedKind];
3498 continue EOFLoop;
3499 }
3500 }
3501 int error_line = input_stream.getEndLine();
3502 int error_column = input_stream.getEndColumn();
3503 String error_after = null;
3504 boolean EOFSeen = false;
3505 try { input_stream.readChar(); input_stream.backup(1); }
3506 catch (java.io.IOException e1) {
3507 EOFSeen = true;
3508 error_after = curPos <= 1 ? "" : input_stream.GetImage();
3509 if (curChar == '\n' || curChar == '\r') {
3510 error_line++;
3511 error_column = 0;
3512 }
3513 else
3514 error_column++;
3515 }
3516 if (!EOFSeen) {
3517 input_stream.backup(1);
3518 error_after = curPos <= 1 ? "" : input_stream.GetImage();
3519 }
3520 throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
3521 }
3522 }
3523
3524 private void jjCheckNAdd(int state)
3525 {
3526 if (jjrounds[state] != jjround)
3527 {
3528 jjstateSet[jjnewStateCnt++] = state;
3529 jjrounds[state] = jjround;
3530 }
3531 }
3532 private void jjAddStates(int start, int end)
3533 {
3534 do {
3535 jjstateSet[jjnewStateCnt++] = jjnextStates[start];
3536 } while (start++ != end);
3537 }
3538 private void jjCheckNAddTwoStates(int state1, int state2)
3539 {
3540 jjCheckNAdd(state1);
3541 jjCheckNAdd(state2);
3542 }
3543
3544 private void jjCheckNAddStates(int start, int end)
3545 {
3546 do {
3547 jjCheckNAdd(jjnextStates[start]);
3548 } while (start++ != end);
3549 }
3550
3551 }
|