0001 /* Generated By:JavaCC: Do not edit this line. CppParserTokenManager.java */
0002 package net.sourceforge.pmd.lang.cpp.ast;
0003 import net.sourceforge.pmd.lang.ast.CharStream;
0004 import net.sourceforge.pmd.lang.ast.TokenMgrError;
0005
0006 /** Token Manager. */
0007 public class CppParserTokenManager extends net.sourceforge.pmd.lang.ast.AbstractTokenManager implements CppParserConstants
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_0(int pos, long active0, long active1, long active2)
0015 {
0016 switch (pos)
0017 {
0018 case 0:
0019 if ((active1 & 0x3ffffffffffff0L) != 0L || (active2 & 0x40L) != 0L)
0020 {
0021 jjmatchedKind = 135;
0022 return 29;
0023 }
0024 if ((active0 & 0x40000000L) != 0L || (active1 & 0x5L) != 0L)
0025 return 1;
0026 return -1;
0027 case 1:
0028 if ((active1 & 0x3fffffffbf9ff0L) != 0L || (active2 & 0x40L) != 0L)
0029 {
0030 if (jjmatchedPos != 1)
0031 {
0032 jjmatchedKind = 135;
0033 jjmatchedPos = 1;
0034 }
0035 return 29;
0036 }
0037 if ((active1 & 0x406000L) != 0L)
0038 return 29;
0039 return -1;
0040 case 2:
0041 if ((active1 & 0x3ffbfffab7dff0L) != 0L || (active2 & 0x40L) != 0L)
0042 {
0043 jjmatchedKind = 135;
0044 jjmatchedPos = 2;
0045 return 29;
0046 }
0047 if ((active1 & 0x40005080000L) != 0L)
0048 return 29;
0049 return -1;
0050 case 3:
0051 if ((active1 & 0x3779fff8965ea0L) != 0L || (active2 & 0x40L) != 0L)
0052 {
0053 jjmatchedKind = 135;
0054 jjmatchedPos = 3;
0055 return 29;
0056 }
0057 if ((active1 & 0x8820002218150L) != 0L)
0058 return 29;
0059 return -1;
0060 case 4:
0061 if ((active1 & 0x569bdf8925c00L) != 0L || (active2 & 0x40L) != 0L)
0062 {
0063 jjmatchedKind = 135;
0064 jjmatchedPos = 4;
0065 return 29;
0066 }
0067 if ((active1 & 0x321042000402a0L) != 0L)
0068 return 29;
0069 return -1;
0070 case 5:
0071 if ((active1 & 0x56900d8000c00L) != 0L || (active2 & 0x40L) != 0L)
0072 {
0073 jjmatchedKind = 135;
0074 jjmatchedPos = 5;
0075 return 29;
0076 }
0077 if ((active1 & 0xbd20925000L) != 0L)
0078 return 29;
0079 return -1;
0080 case 6:
0081 if ((active1 & 0x52100d0000400L) != 0L)
0082 {
0083 jjmatchedKind = 135;
0084 jjmatchedPos = 6;
0085 return 29;
0086 }
0087 if ((active1 & 0x480008000800L) != 0L || (active2 & 0x40L) != 0L)
0088 return 29;
0089 return -1;
0090 case 7:
0091 if ((active1 & 0x50000000L) != 0L)
0092 {
0093 jjmatchedKind = 135;
0094 jjmatchedPos = 7;
0095 return 29;
0096 }
0097 if ((active1 & 0x5210080000400L) != 0L)
0098 return 29;
0099 return -1;
0100 case 8:
0101 if ((active1 & 0x40000000L) != 0L)
0102 {
0103 jjmatchedKind = 135;
0104 jjmatchedPos = 8;
0105 return 29;
0106 }
0107 if ((active1 & 0x10000000L) != 0L)
0108 return 29;
0109 return -1;
0110 default :
0111 return -1;
0112 }
0113 }
0114 private final int jjStartNfa_0(int pos, long active0, long active1, long active2)
0115 {
0116 return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0, active1, active2), pos + 1);
0117 }
0118 private int jjStopAtPos(int pos, int kind)
0119 {
0120 jjmatchedKind = kind;
0121 jjmatchedPos = pos;
0122 return pos + 1;
0123 }
0124 private int jjMoveStringLiteralDfa0_0()
0125 {
0126 switch(curChar)
0127 {
0128 case 13:
0129 return jjMoveStringLiteralDfa1_0(0x10L, 0x0L, 0x0L);
0130 case 33:
0131 jjmatchedKind = 63;
0132 return jjMoveStringLiteralDfa1_0(0x1000000000000L, 0x0L, 0x0L);
0133 case 35:
0134 return jjStopAtPos(0, 8);
0135 case 37:
0136 jjmatchedKind = 59;
0137 return jjMoveStringLiteralDfa1_0(0x400000000L, 0x0L, 0x0L);
0138 case 38:
0139 jjmatchedKind = 46;
0140 return jjMoveStringLiteralDfa1_0(0x88000000000L, 0x0L, 0x0L);
0141 case 40:
0142 return jjStopAtPos(0, 23);
0143 case 41:
0144 return jjStopAtPos(0, 24);
0145 case 42:
0146 jjmatchedKind = 57;
0147 return jjMoveStringLiteralDfa1_0(0x100000000L, 0x0L, 0x0L);
0148 case 43:
0149 jjmatchedKind = 55;
0150 return jjMoveStringLiteralDfa1_0(0x1000000800000000L, 0x0L, 0x0L);
0151 case 44:
0152 return jjStopAtPos(0, 28);
0153 case 45:
0154 jjmatchedKind = 56;
0155 return jjMoveStringLiteralDfa1_0(0x2000001000000000L, 0xaL, 0x0L);
0156 case 46:
0157 jjmatchedKind = 64;
0158 return jjMoveStringLiteralDfa1_0(0x40000000L, 0x4L, 0x0L);
0159 case 47:
0160 jjmatchedKind = 58;
0161 return jjMoveStringLiteralDfa1_0(0x2000000c0L, 0x0L, 0x0L);
0162 case 58:
0163 jjmatchedKind = 26;
0164 return jjMoveStringLiteralDfa1_0(0x2000000L, 0x0L, 0x0L);
0165 case 59:
0166 return jjStopAtPos(0, 27);
0167 case 60:
0168 jjmatchedKind = 49;
0169 return jjMoveStringLiteralDfa1_0(0x28002000000000L, 0x0L, 0x0L);
0170 case 61:
0171 jjmatchedKind = 31;
0172 return jjMoveStringLiteralDfa1_0(0x800000000000L, 0x0L, 0x0L);
0173 case 62:
0174 jjmatchedKind = 50;
0175 return jjMoveStringLiteralDfa1_0(0x50004000000000L, 0x0L, 0x0L);
0176 case 63:
0177 return jjStopAtPos(0, 29);
0178 case 91:
0179 return jjStopAtPos(0, 21);
0180 case 93:
0181 return jjStopAtPos(0, 22);
0182 case 94:
0183 jjmatchedKind = 45;
0184 return jjMoveStringLiteralDfa1_0(0x10000000000L, 0x0L, 0x0L);
0185 case 97:
0186 return jjMoveStringLiteralDfa1_0(0x0L, 0x10L, 0x0L);
0187 case 98:
0188 return jjMoveStringLiteralDfa1_0(0x0L, 0x20L, 0x0L);
0189 case 99:
0190 return jjMoveStringLiteralDfa1_0(0x0L, 0x40000007c0L, 0x0L);
0191 case 100:
0192 return jjMoveStringLiteralDfa1_0(0x0L, 0x7800L, 0x0L);
0193 case 101:
0194 return jjMoveStringLiteralDfa1_0(0x0L, 0x38000L, 0x0L);
0195 case 102:
0196 return jjMoveStringLiteralDfa1_0(0x0L, 0x100000001c0000L, 0x40L);
0197 case 103:
0198 return jjMoveStringLiteralDfa1_0(0x0L, 0x200000L, 0x0L);
0199 case 105:
0200 return jjMoveStringLiteralDfa1_0(0x0L, 0x1c00000L, 0x0L);
0201 case 108:
0202 return jjMoveStringLiteralDfa1_0(0x0L, 0x2000000L, 0x0L);
0203 case 110:
0204 return jjMoveStringLiteralDfa1_0(0x0L, 0x4000000L, 0x0L);
0205 case 111:
0206 return jjMoveStringLiteralDfa1_0(0x0L, 0x4000000000000L, 0x0L);
0207 case 112:
0208 return jjMoveStringLiteralDfa1_0(0x0L, 0x38000000L, 0x0L);
0209 case 114:
0210 return jjMoveStringLiteralDfa1_0(0x0L, 0x1c0000000L, 0x0L);
0211 case 115:
0212 return jjMoveStringLiteralDfa1_0(0x0L, 0xbe00000000L, 0x0L);
0213 case 116:
0214 return jjMoveStringLiteralDfa1_0(0x0L, 0x280f0000000000L, 0x0L);
0215 case 117:
0216 return jjMoveStringLiteralDfa1_0(0x0L, 0x300000000000L, 0x0L);
0217 case 118:
0218 return jjMoveStringLiteralDfa1_0(0x0L, 0x1c00000000000L, 0x0L);
0219 case 119:
0220 return jjMoveStringLiteralDfa1_0(0x0L, 0x2000000000000L, 0x0L);
0221 case 123:
0222 return jjStopAtPos(0, 19);
0223 case 124:
0224 jjmatchedKind = 44;
0225 return jjMoveStringLiteralDfa1_0(0x60000000000L, 0x0L, 0x0L);
0226 case 125:
0227 return jjStopAtPos(0, 20);
0228 case 126:
0229 return jjStopAtPos(0, 62);
0230 default :
0231 return jjMoveNfa_0(28, 0);
0232 }
0233 }
0234 private int jjMoveStringLiteralDfa1_0(long active0, long active1, long active2)
0235 {
0236 try { curChar = input_stream.readChar(); }
0237 catch(java.io.IOException e) {
0238 jjStopStringLiteralDfa_0(0, active0, active1, active2);
0239 return 1;
0240 }
0241 switch(curChar)
0242 {
0243 case 10:
0244 if ((active0 & 0x10L) != 0L)
0245 return jjStopAtPos(1, 4);
0246 break;
0247 case 38:
0248 if ((active0 & 0x80000000000L) != 0L)
0249 return jjStopAtPos(1, 43);
0250 break;
0251 case 42:
0252 if ((active0 & 0x80L) != 0L)
0253 return jjStopAtPos(1, 7);
0254 else if ((active1 & 0x4L) != 0L)
0255 return jjStopAtPos(1, 66);
0256 break;
0257 case 43:
0258 if ((active0 & 0x1000000000000000L) != 0L)
0259 return jjStopAtPos(1, 60);
0260 break;
0261 case 45:
0262 if ((active0 & 0x2000000000000000L) != 0L)
0263 return jjStopAtPos(1, 61);
0264 break;
0265 case 46:
0266 return jjMoveStringLiteralDfa2_0(active0, 0x40000000L, active1, 0L, active2, 0L);
0267 case 47:
0268 if ((active0 & 0x40L) != 0L)
0269 return jjStopAtPos(1, 6);
0270 break;
0271 case 58:
0272 if ((active0 & 0x2000000L) != 0L)
0273 return jjStopAtPos(1, 25);
0274 break;
0275 case 60:
0276 if ((active0 & 0x20000000000000L) != 0L)
0277 {
0278 jjmatchedKind = 53;
0279 jjmatchedPos = 1;
0280 }
0281 return jjMoveStringLiteralDfa2_0(active0, 0x2000000000L, active1, 0L, active2, 0L);
0282 case 61:
0283 if ((active0 & 0x100000000L) != 0L)
0284 return jjStopAtPos(1, 32);
0285 else if ((active0 & 0x200000000L) != 0L)
0286 return jjStopAtPos(1, 33);
0287 else if ((active0 & 0x400000000L) != 0L)
0288 return jjStopAtPos(1, 34);
0289 else if ((active0 & 0x800000000L) != 0L)
0290 return jjStopAtPos(1, 35);
0291 else if ((active0 & 0x1000000000L) != 0L)
0292 return jjStopAtPos(1, 36);
0293 else if ((active0 & 0x8000000000L) != 0L)
0294 return jjStopAtPos(1, 39);
0295 else if ((active0 & 0x10000000000L) != 0L)
0296 return jjStopAtPos(1, 40);
0297 else if ((active0 & 0x20000000000L) != 0L)
0298 return jjStopAtPos(1, 41);
0299 else if ((active0 & 0x800000000000L) != 0L)
0300 return jjStopAtPos(1, 47);
0301 else if ((active0 & 0x1000000000000L) != 0L)
0302 return jjStopAtPos(1, 48);
0303 else if ((active0 & 0x8000000000000L) != 0L)
0304 return jjStopAtPos(1, 51);
0305 else if ((active0 & 0x10000000000000L) != 0L)
0306 return jjStopAtPos(1, 52);
0307 break;
0308 case 62:
0309 if ((active0 & 0x40000000000000L) != 0L)
0310 {
0311 jjmatchedKind = 54;
0312 jjmatchedPos = 1;
0313 }
0314 else if ((active1 & 0x2L) != 0L)
0315 {
0316 jjmatchedKind = 65;
0317 jjmatchedPos = 1;
0318 }
0319 return jjMoveStringLiteralDfa2_0(active0, 0x4000000000L, active1, 0x8L, active2, 0L);
0320 case 97:
0321 return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x100000000000c0L, active2, 0L);
0322 case 101:
0323 return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x101c4001800L, active2, 0L);
0324 case 102:
0325 if ((active1 & 0x400000L) != 0L)
0326 return jjStartNfaWithStates_0(1, 86, 29);
0327 break;
0328 case 104:
0329 return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x22020200000100L, active2, 0L);
0330 case 105:
0331 return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x400c00000000L, active2, 0x40L);
0332 case 108:
0333 return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x4000048000L, active2, 0L);
0334 case 110:
0335 return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x300001810000L, active2, 0L);
0336 case 111:
0337 if ((active1 & 0x2000L) != 0L)
0338 {
0339 jjmatchedKind = 77;
0340 jjmatchedPos = 1;
0341 }
0342 return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x1800002284600L, active2, 0L);
0343 case 112:
0344 return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x4000000000000L, active2, 0L);
0345 case 114:
0346 return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x8040018100020L, active2, 0L);
0347 case 116:
0348 return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x3000000000L, active2, 0L);
0349 case 117:
0350 return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x20000010L, active2, 0L);
0351 case 119:
0352 return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x8000000000L, active2, 0L);
0353 case 120:
0354 return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x20000L, active2, 0L);
0355 case 121:
0356 return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x80000000000L, active2, 0L);
0357 case 124:
0358 if ((active0 & 0x40000000000L) != 0L)
0359 return jjStopAtPos(1, 42);
0360 break;
0361 default :
0362 break;
0363 }
0364 return jjStartNfa_0(0, active0, active1, active2);
0365 }
0366 private int jjMoveStringLiteralDfa2_0(long old0, long active0, long old1, long active1, long old2, long active2)
0367 {
0368 if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2)) == 0L)
0369 return jjStartNfa_0(0, old0, old1, old2);
0370 try { curChar = input_stream.readChar(); }
0371 catch(java.io.IOException e) {
0372 jjStopStringLiteralDfa_0(1, active0, active1, active2);
0373 return 2;
0374 }
0375 switch(curChar)
0376 {
0377 case 42:
0378 if ((active1 & 0x8L) != 0L)
0379 return jjStopAtPos(2, 67);
0380 break;
0381 case 46:
0382 if ((active0 & 0x40000000L) != 0L)
0383 return jjStopAtPos(2, 30);
0384 break;
0385 case 61:
0386 if ((active0 & 0x2000000000L) != 0L)
0387 return jjStopAtPos(2, 37);
0388 else if ((active0 & 0x4000000000L) != 0L)
0389 return jjStopAtPos(2, 38);
0390 break;
0391 case 97:
0392 return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x5000000100L, active2, 0L);
0393 case 98:
0394 return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x20000000L, active2, 0L);
0395 case 100:
0396 return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x40000000L, active2, 0L);
0397 case 101:
0398 return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x4000000000020L, active2, 0L);
0399 case 102:
0400 return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x800L, active2, 0L);
0401 case 103:
0402 return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x480000000L, active2, 0L);
0403 case 105:
0404 return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x2928008100000L, active2, 0L);
0405 case 108:
0406 return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x11000000801000L, active2, 0L);
0407 case 109:
0408 return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x10000000000L, active2, 0L);
0409 case 110:
0410 return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x2000600L, active2, 0x40L);
0411 case 111:
0412 return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x210040000L, active2, 0L);
0413 case 112:
0414 return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x80000000000L, active2, 0L);
0415 case 114:
0416 if ((active1 & 0x80000L) != 0L)
0417 return jjStartNfaWithStates_0(2, 83, 29);
0418 return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x20402000000000L, active2, 0L);
0419 case 115:
0420 return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x200000008040L, active2, 0L);
0421 case 116:
0422 if ((active1 & 0x1000000L) != 0L)
0423 return jjStartNfaWithStates_0(2, 88, 29);
0424 return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x100220090L, active2, 0L);
0425 case 117:
0426 return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x8000000014000L, active2, 0L);
0427 case 119:
0428 if ((active1 & 0x4000000L) != 0L)
0429 return jjStartNfaWithStates_0(2, 90, 29);
0430 break;
0431 case 121:
0432 if ((active1 & 0x40000000000L) != 0L)
0433 return jjStartNfaWithStates_0(2, 106, 29);
0434 break;
0435 case 122:
0436 return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x800000000L, active2, 0L);
0437 default :
0438 break;
0439 }
0440 return jjStartNfa_0(1, active0, active1, active2);
0441 }
0442 private int jjMoveStringLiteralDfa3_0(long old0, long active0, long old1, long active1, long old2, long active2)
0443 {
0444 if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2)) == 0L)
0445 return jjStartNfa_0(1, old0, old1, old2);
0446 try { curChar = input_stream.readChar(); }
0447 catch(java.io.IOException e) {
0448 jjStopStringLiteralDfa_0(2, 0L, active1, active2);
0449 return 3;
0450 }
0451 switch(curChar)
0452 {
0453 case 97:
0454 return jjMoveStringLiteralDfa4_0(active1, 0x1000000040820L, active2, 0x40L);
0455 case 98:
0456 return jjMoveStringLiteralDfa4_0(active1, 0x4000L, active2, 0L);
0457 case 99:
0458 return jjMoveStringLiteralDfa4_0(active1, 0x80L, active2, 0L);
0459 case 100:
0460 if ((active1 & 0x800000000000L) != 0L)
0461 return jjStartNfaWithStates_0(3, 111, 29);
0462 break;
0463 case 101:
0464 if ((active1 & 0x40L) != 0L)
0465 return jjStartNfaWithStates_0(3, 70, 29);
0466 else if ((active1 & 0x8000L) != 0L)
0467 return jjStartNfaWithStates_0(3, 79, 29);
0468 else if ((active1 & 0x8000000000000L) != 0L)
0469 return jjStartNfaWithStates_0(3, 115, 29);
0470 return jjMoveStringLiteralDfa4_0(active1, 0x80840121000L, active2, 0L);
0471 case 103:
0472 if ((active1 & 0x2000000L) != 0L)
0473 return jjStartNfaWithStates_0(3, 89, 29);
0474 break;
0475 case 105:
0476 return jjMoveStringLiteralDfa4_0(active1, 0x200080800000L, active2, 0L);
0477 case 108:
0478 return jjMoveStringLiteralDfa4_0(active1, 0x2000020000000L, active2, 0L);
0479 case 109:
0480 if ((active1 & 0x10000L) != 0L)
0481 return jjStartNfaWithStates_0(3, 80, 29);
0482 break;
0483 case 110:
0484 return jjMoveStringLiteralDfa4_0(active1, 0x400000000L, active2, 0L);
0485 case 111:
0486 if ((active1 & 0x10L) != 0L)
0487 return jjStartNfaWithStates_0(3, 68, 29);
0488 else if ((active1 & 0x200000L) != 0L)
0489 return jjStartNfaWithStates_0(3, 85, 29);
0490 return jjMoveStringLiteralDfa4_0(active1, 0x20100000000000L, active2, 0L);
0491 case 112:
0492 return jjMoveStringLiteralDfa4_0(active1, 0x10000000000L, active2, 0L);
0493 case 114:
0494 if ((active1 & 0x100L) != 0L)
0495 return jjStartNfaWithStates_0(3, 72, 29);
0496 return jjMoveStringLiteralDfa4_0(active1, 0x4000200000000L, active2, 0L);
0497 case 115:
0498 if ((active1 & 0x20000000000L) != 0L)
0499 return jjStartNfaWithStates_0(3, 105, 29);
0500 return jjMoveStringLiteralDfa4_0(active1, 0x10004000000200L, active2, 0L);
0501 case 116:
0502 return jjMoveStringLiteralDfa4_0(active1, 0x409010000400L, active2, 0L);
0503 case 117:
0504 return jjMoveStringLiteralDfa4_0(active1, 0x2100000000L, active2, 0L);
0505 case 118:
0506 return jjMoveStringLiteralDfa4_0(active1, 0x8000000L, active2, 0L);
0507 default :
0508 break;
0509 }
0510 return jjStartNfa_0(2, 0L, active1, active2);
0511 }
0512 private int jjMoveStringLiteralDfa4_0(long old1, long active1, long old2, long active2)
0513 {
0514 if (((active1 &= old1) | (active2 &= old2)) == 0L)
0515 return jjStartNfa_0(2, 0L, old1, old2);
0516 try { curChar = input_stream.readChar(); }
0517 catch(java.io.IOException e) {
0518 jjStopStringLiteralDfa_0(3, 0L, active1, active2);
0519 return 4;
0520 }
0521 switch(curChar)
0522 {
0523 case 97:
0524 return jjMoveStringLiteralDfa5_0(active1, 0x4000008000000L, active2, 0L);
0525 case 99:
0526 return jjMoveStringLiteralDfa5_0(active1, 0xa040000000L, active2, 0L);
0527 case 100:
0528 return jjMoveStringLiteralDfa5_0(active1, 0x80000000000L, active2, 0L);
0529 case 101:
0530 if ((active1 & 0x2000000000000L) != 0L)
0531 return jjStartNfaWithStates_0(4, 113, 29);
0532 else if ((active1 & 0x10000000000000L) != 0L)
0533 return jjStartNfaWithStates_0(4, 116, 29);
0534 return jjMoveStringLiteralDfa5_0(active1, 0x410000000L, active2, 0L);
0535 case 103:
0536 return jjMoveStringLiteralDfa5_0(active1, 0x200000000000L, active2, 0L);
0537 case 104:
0538 if ((active1 & 0x80L) != 0L)
0539 return jjStartNfaWithStates_0(4, 71, 29);
0540 break;
0541 case 105:
0542 return jjMoveStringLiteralDfa5_0(active1, 0x1020000400L, active2, 0L);
0543 case 107:
0544 if ((active1 & 0x20L) != 0L)
0545 return jjStartNfaWithStates_0(4, 69, 29);
0546 break;
0547 case 108:
0548 return jjMoveStringLiteralDfa5_0(active1, 0x10000004000L, active2, 0x40L);
0549 case 110:
0550 if ((active1 & 0x100000000000L) != 0L)
0551 return jjStartNfaWithStates_0(4, 108, 29);
0552 return jjMoveStringLiteralDfa5_0(active1, 0x900000L, active2, 0L);
0553 case 111:
0554 return jjMoveStringLiteralDfa5_0(active1, 0x800000000L, active2, 0L);
0555 case 114:
0556 return jjMoveStringLiteralDfa5_0(active1, 0x100020000L, active2, 0L);
0557 case 115:
0558 if ((active1 & 0x4000000000L) != 0L)
0559 return jjStartNfaWithStates_0(4, 102, 29);
0560 return jjMoveStringLiteralDfa5_0(active1, 0x80000000L, active2, 0L);
0561 case 116:
0562 if ((active1 & 0x200L) != 0L)
0563 return jjStartNfaWithStates_0(4, 73, 29);
0564 else if ((active1 & 0x40000L) != 0L)
0565 return jjStartNfaWithStates_0(4, 82, 29);
0566 else if ((active1 & 0x200000000L) != 0L)
0567 return jjStartNfaWithStates_0(4, 97, 29);
0568 return jjMoveStringLiteralDfa5_0(active1, 0x1000000001000L, active2, 0L);
0569 case 117:
0570 return jjMoveStringLiteralDfa5_0(active1, 0x400000000800L, active2, 0L);
0571 case 119:
0572 if ((active1 & 0x20000000000000L) != 0L)
0573 return jjStartNfaWithStates_0(4, 117, 29);
0574 break;
0575 default :
0576 break;
0577 }
0578 return jjStartNfa_0(3, 0L, active1, active2);
0579 }
0580 private int jjMoveStringLiteralDfa5_0(long old1, long active1, long old2, long active2)
0581 {
0582 if (((active1 &= old1) | (active2 &= old2)) == 0L)
0583 return jjStartNfa_0(3, 0L, old1, old2);
0584 try { curChar = input_stream.readChar(); }
0585 catch(java.io.IOException e) {
0586 jjStopStringLiteralDfa_0(4, 0L, active1, active2);
0587 return 5;
0588 }
0589 switch(curChar)
0590 {
0591 case 97:
0592 return jjMoveStringLiteralDfa6_0(active1, 0x410000000000L, active2, 0L);
0593 case 99:
0594 if ((active1 & 0x20000000L) != 0L)
0595 return jjStartNfaWithStates_0(5, 93, 29);
0596 else if ((active1 & 0x1000000000L) != 0L)
0597 return jjStartNfaWithStates_0(5, 100, 29);
0598 return jjMoveStringLiteralDfa6_0(active1, 0x10000000L, active2, 0L);
0599 case 100:
0600 if ((active1 & 0x100000L) != 0L)
0601 return jjStartNfaWithStates_0(5, 84, 29);
0602 else if ((active1 & 0x400000000L) != 0L)
0603 return jjStartNfaWithStates_0(5, 98, 29);
0604 break;
0605 case 101:
0606 if ((active1 & 0x1000L) != 0L)
0607 return jjStartNfaWithStates_0(5, 76, 29);
0608 else if ((active1 & 0x4000L) != 0L)
0609 return jjStartNfaWithStates_0(5, 78, 29);
0610 else if ((active1 & 0x800000L) != 0L)
0611 return jjStartNfaWithStates_0(5, 87, 29);
0612 return jjMoveStringLiteralDfa6_0(active1, 0x80000000000L, active2, 0L);
0613 case 102:
0614 if ((active1 & 0x800000000L) != 0L)
0615 return jjStartNfaWithStates_0(5, 99, 29);
0616 break;
0617 case 104:
0618 if ((active1 & 0x8000000000L) != 0L)
0619 return jjStartNfaWithStates_0(5, 103, 29);
0620 break;
0621 case 105:
0622 return jjMoveStringLiteralDfa6_0(active1, 0x1000000000000L, active2, 0L);
0623 case 108:
0624 return jjMoveStringLiteralDfa6_0(active1, 0x40000800L, active2, 0x40L);
0625 case 110:
0626 if ((active1 & 0x20000L) != 0L)
0627 return jjStartNfaWithStates_0(5, 81, 29);
0628 else if ((active1 & 0x100000000L) != 0L)
0629 return jjStartNfaWithStates_0(5, 96, 29);
0630 return jjMoveStringLiteralDfa6_0(active1, 0x200000000400L, active2, 0L);
0631 case 116:
0632 if ((active1 & 0x2000000000L) != 0L)
0633 return jjStartNfaWithStates_0(5, 101, 29);
0634 return jjMoveStringLiteralDfa6_0(active1, 0x4000088000000L, active2, 0L);
0635 default :
0636 break;
0637 }
0638 return jjStartNfa_0(4, 0L, active1, active2);
0639 }
0640 private int jjMoveStringLiteralDfa6_0(long old1, long active1, long old2, long active2)
0641 {
0642 if (((active1 &= old1) | (active2 &= old2)) == 0L)
0643 return jjStartNfa_0(4, 0L, old1, old2);
0644 try { curChar = input_stream.readChar(); }
0645 catch(java.io.IOException e) {
0646 jjStopStringLiteralDfa_0(5, 0L, active1, active2);
0647 return 6;
0648 }
0649 switch(curChar)
0650 {
0651 case 97:
0652 return jjMoveStringLiteralDfa7_0(active1, 0x40000000L, active2, 0L);
0653 case 101:
0654 if ((active1 & 0x8000000L) != 0L)
0655 return jjStartNfaWithStates_0(6, 91, 29);
0656 return jjMoveStringLiteralDfa7_0(active1, 0x200080000000L, active2, 0L);
0657 case 102:
0658 if ((active1 & 0x80000000000L) != 0L)
0659 return jjStartNfaWithStates_0(6, 107, 29);
0660 break;
0661 case 108:
0662 if ((active1 & 0x400000000000L) != 0L)
0663 return jjStartNfaWithStates_0(6, 110, 29);
0664 return jjMoveStringLiteralDfa7_0(active1, 0x1000000000000L, active2, 0L);
0665 case 111:
0666 return jjMoveStringLiteralDfa7_0(active1, 0x4000000000000L, active2, 0L);
0667 case 116:
0668 if ((active1 & 0x800L) != 0L)
0669 return jjStartNfaWithStates_0(6, 75, 29);
0670 return jjMoveStringLiteralDfa7_0(active1, 0x10010000000L, active2, 0L);
0671 case 117:
0672 return jjMoveStringLiteralDfa7_0(active1, 0x400L, active2, 0L);
0673 case 121:
0674 if ((active2 & 0x40L) != 0L)
0675 return jjStartNfaWithStates_0(6, 134, 29);
0676 break;
0677 default :
0678 break;
0679 }
0680 return jjStartNfa_0(5, 0L, active1, active2);
0681 }
0682 private int jjMoveStringLiteralDfa7_0(long old1, long active1, long old2, long active2)
0683 {
0684 if (((active1 &= old1) | (active2 &= old2)) == 0L)
0685 return jjStartNfa_0(5, 0L, old1, old2);
0686 try { curChar = input_stream.readChar(); }
0687 catch(java.io.IOException e) {
0688 jjStopStringLiteralDfa_0(6, 0L, active1, 0L);
0689 return 7;
0690 }
0691 switch(curChar)
0692 {
0693 case 100:
0694 if ((active1 & 0x200000000000L) != 0L)
0695 return jjStartNfaWithStates_0(7, 109, 29);
0696 break;
0697 case 101:
0698 if ((active1 & 0x400L) != 0L)
0699 return jjStartNfaWithStates_0(7, 74, 29);
0700 else if ((active1 & 0x10000000000L) != 0L)
0701 return jjStartNfaWithStates_0(7, 104, 29);
0702 else if ((active1 & 0x1000000000000L) != 0L)
0703 return jjStartNfaWithStates_0(7, 112, 29);
0704 return jjMoveStringLiteralDfa8_0(active1, 0x10000000L);
0705 case 114:
0706 if ((active1 & 0x80000000L) != 0L)
0707 return jjStartNfaWithStates_0(7, 95, 29);
0708 else if ((active1 & 0x4000000000000L) != 0L)
0709 return jjStartNfaWithStates_0(7, 114, 29);
0710 return jjMoveStringLiteralDfa8_0(active1, 0x40000000L);
0711 default :
0712 break;
0713 }
0714 return jjStartNfa_0(6, 0L, active1, 0L);
0715 }
0716 private int jjMoveStringLiteralDfa8_0(long old1, long active1)
0717 {
0718 if (((active1 &= old1)) == 0L)
0719 return jjStartNfa_0(6, 0L, old1, 0L);
0720 try { curChar = input_stream.readChar(); }
0721 catch(java.io.IOException e) {
0722 jjStopStringLiteralDfa_0(7, 0L, active1, 0L);
0723 return 8;
0724 }
0725 switch(curChar)
0726 {
0727 case 100:
0728 if ((active1 & 0x10000000L) != 0L)
0729 return jjStartNfaWithStates_0(8, 92, 29);
0730 break;
0731 case 101:
0732 return jjMoveStringLiteralDfa9_0(active1, 0x40000000L);
0733 default :
0734 break;
0735 }
0736 return jjStartNfa_0(7, 0L, active1, 0L);
0737 }
0738 private int jjMoveStringLiteralDfa9_0(long old1, long active1)
0739 {
0740 if (((active1 &= old1)) == 0L)
0741 return jjStartNfa_0(7, 0L, old1, 0L);
0742 try { curChar = input_stream.readChar(); }
0743 catch(java.io.IOException e) {
0744 jjStopStringLiteralDfa_0(8, 0L, active1, 0L);
0745 return 9;
0746 }
0747 switch(curChar)
0748 {
0749 case 100:
0750 if ((active1 & 0x40000000L) != 0L)
0751 return jjStartNfaWithStates_0(9, 94, 29);
0752 break;
0753 default :
0754 break;
0755 }
0756 return jjStartNfa_0(8, 0L, active1, 0L);
0757 }
0758 private int jjStartNfaWithStates_0(int pos, int kind, int state)
0759 {
0760 jjmatchedKind = kind;
0761 jjmatchedPos = pos;
0762 try { curChar = input_stream.readChar(); }
0763 catch(java.io.IOException e) { return pos + 1; }
0764 return jjMoveNfa_0(state, pos + 1);
0765 }
0766 static final long[] jjbitVec0 = {
0767 0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
0768 };
0769 private int jjMoveNfa_0(int startState, int curPos)
0770 {
0771 int startsAt = 0;
0772 jjnewStateCnt = 78;
0773 int i = 1;
0774 jjstateSet[0] = startState;
0775 int kind = 0x7fffffff;
0776 for (;;)
0777 {
0778 if (++jjround == 0x7fffffff)
0779 ReInitRounds();
0780 if (curChar < 64)
0781 {
0782 long l = 1L << curChar;
0783 do
0784 {
0785 switch(jjstateSet[--i])
0786 {
0787 case 28:
0788 if ((0x3ff000000000000L & l) != 0L)
0789 jjCheckNAddStates(0, 5);
0790 else if (curChar == 36)
0791 {
0792 if (kind > 135)
0793 kind = 135;
0794 jjCheckNAdd(29);
0795 }
0796 else if (curChar == 34)
0797 jjCheckNAddStates(6, 8);
0798 else if (curChar == 39)
0799 jjCheckNAddTwoStates(7, 9);
0800 else if (curChar == 46)
0801 jjCheckNAdd(1);
0802 if ((0x3fe000000000000L & l) != 0L)
0803 {
0804 if (kind > 122)
0805 kind = 122;
0806 jjCheckNAddStates(9, 16);
0807 }
0808 else if (curChar == 48)
0809 jjAddStates(17, 20);
0810 if (curChar == 48)
0811 {
0812 if (kind > 118)
0813 kind = 118;
0814 jjCheckNAddStates(21, 28);
0815 }
0816 break;
0817 case 0:
0818 if (curChar == 46)
0819 jjCheckNAdd(1);
0820 break;
0821 case 1:
0822 if ((0x3ff000000000000L & l) == 0L)
0823 break;
0824 if (kind > 130)
0825 kind = 130;
0826 jjCheckNAddStates(29, 31);
0827 break;
0828 case 3:
0829 if ((0x280000000000L & l) != 0L)
0830 jjCheckNAdd(4);
0831 break;
0832 case 4:
0833 if ((0x3ff000000000000L & l) == 0L)
0834 break;
0835 if (kind > 130)
0836 kind = 130;
0837 jjCheckNAddTwoStates(4, 5);
0838 break;
0839 case 6:
0840 if (curChar == 39)
0841 jjCheckNAddTwoStates(7, 9);
0842 break;
0843 case 7:
0844 if ((0xffffff7fffffdbffL & l) != 0L)
0845 jjCheckNAddTwoStates(7, 8);
0846 break;
0847 case 8:
0848 if (curChar == 39 && kind > 132)
0849 kind = 132;
0850 break;
0851 case 10:
0852 if ((0x8000008400000000L & l) != 0L)
0853 jjCheckNAdd(8);
0854 break;
0855 case 11:
0856 if (curChar == 48)
0857 jjCheckNAddTwoStates(12, 8);
0858 break;
0859 case 12:
0860 if ((0xff000000000000L & l) != 0L)
0861 jjCheckNAddTwoStates(12, 8);
0862 break;
0863 case 13:
0864 if ((0x3fe000000000000L & l) != 0L)
0865 jjCheckNAddTwoStates(14, 8);
0866 break;
0867 case 14:
0868 if ((0x3ff000000000000L & l) != 0L)
0869 jjCheckNAddTwoStates(14, 8);
0870 break;
0871 case 16:
0872 if ((0x3ff000000000000L & l) != 0L)
0873 jjCheckNAddTwoStates(16, 8);
0874 break;
0875 case 17:
0876 if (curChar == 34)
0877 jjCheckNAddStates(6, 8);
0878 break;
0879 case 18:
0880 if ((0xfffffffbffffdbffL & l) != 0L)
0881 jjCheckNAddStates(6, 8);
0882 break;
0883 case 20:
0884 if ((0x8000008400000400L & l) != 0L)
0885 jjCheckNAddStates(6, 8);
0886 break;
0887 case 21:
0888 if (curChar == 34 && kind > 133)
0889 kind = 133;
0890 break;
0891 case 22:
0892 if (curChar == 48)
0893 jjCheckNAddStates(32, 35);
0894 break;
0895 case 23:
0896 if ((0xff000000000000L & l) != 0L)
0897 jjCheckNAddStates(32, 35);
0898 break;
0899 case 24:
0900 if ((0x3fe000000000000L & l) != 0L)
0901 jjCheckNAddStates(36, 39);
0902 break;
0903 case 25:
0904 if ((0x3ff000000000000L & l) != 0L)
0905 jjCheckNAddStates(36, 39);
0906 break;
0907 case 27:
0908 if ((0x3ff000000000000L & l) != 0L)
0909 jjCheckNAddStates(40, 43);
0910 break;
0911 case 29:
0912 if ((0x3ff001000000000L & l) == 0L)
0913 break;
0914 if (kind > 135)
0915 kind = 135;
0916 jjCheckNAdd(29);
0917 break;
0918 case 30:
0919 if (curChar != 48)
0920 break;
0921 if (kind > 118)
0922 kind = 118;
0923 jjCheckNAddStates(21, 28);
0924 break;
0925 case 31:
0926 if ((0xff000000000000L & l) == 0L)
0927 break;
0928 if (kind > 118)
0929 kind = 118;
0930 jjCheckNAdd(31);
0931 break;
0932 case 32:
0933 if ((0xff000000000000L & l) != 0L)
0934 jjCheckNAddTwoStates(32, 33);
0935 break;
0936 case 34:
0937 if ((0xff000000000000L & l) != 0L)
0938 jjCheckNAddTwoStates(34, 35);
0939 break;
0940 case 36:
0941 if ((0xff000000000000L & l) != 0L)
0942 jjCheckNAddStates(44, 46);
0943 break;
0944 case 41:
0945 if ((0x3fe000000000000L & l) == 0L)
0946 break;
0947 if (kind > 122)
0948 kind = 122;
0949 jjCheckNAddStates(9, 16);
0950 break;
0951 case 42:
0952 if ((0x3ff000000000000L & l) == 0L)
0953 break;
0954 if (kind > 122)
0955 kind = 122;
0956 jjCheckNAdd(42);
0957 break;
0958 case 43:
0959 if ((0x3ff000000000000L & l) != 0L)
0960 jjCheckNAddTwoStates(43, 44);
0961 break;
0962 case 45:
0963 if ((0x3ff000000000000L & l) != 0L)
0964 jjCheckNAddTwoStates(45, 46);
0965 break;
0966 case 47:
0967 if ((0x3ff000000000000L & l) != 0L)
0968 jjCheckNAddStates(47, 49);
0969 break;
0970 case 52:
0971 if (curChar == 48)
0972 jjAddStates(17, 20);
0973 break;
0974 case 54:
0975 if ((0x3ff000000000000L & l) == 0L)
0976 break;
0977 if (kind > 126)
0978 kind = 126;
0979 jjstateSet[jjnewStateCnt++] = 54;
0980 break;
0981 case 56:
0982 if ((0x3ff000000000000L & l) == 0L)
0983 break;
0984 if (kind > 127)
0985 kind = 127;
0986 jjAddStates(50, 51);
0987 break;
0988 case 59:
0989 if ((0x3ff000000000000L & l) != 0L)
0990 jjAddStates(52, 53);
0991 break;
0992 case 62:
0993 if ((0x3ff000000000000L & l) != 0L)
0994 jjAddStates(54, 56);
0995 break;
0996 case 67:
0997 if ((0x3ff000000000000L & l) != 0L)
0998 jjCheckNAddStates(0, 5);
0999 break;
1000 case 68:
1001 if ((0x3ff000000000000L & l) != 0L)
1002 jjCheckNAddTwoStates(68, 69);
1003 break;
1004 case 69:
1005 if (curChar != 46)
1006 break;
1007 if (kind > 130)
1008 kind = 130;
1009 jjCheckNAddStates(57, 59);
1010 break;
1011 case 70:
1012 if ((0x3ff000000000000L & l) == 0L)
1013 break;
1014 if (kind > 130)
1015 kind = 130;
1016 jjCheckNAddStates(57, 59);
1017 break;
1018 case 71:
1019 if ((0x3ff000000000000L & l) != 0L)
1020 jjCheckNAddTwoStates(71, 0);
1021 break;
1022 case 72:
1023 if ((0x3ff000000000000L & l) != 0L)
1024 jjCheckNAddTwoStates(72, 73);
1025 break;
1026 case 74:
1027 if ((0x280000000000L & l) != 0L)
1028 jjCheckNAdd(75);
1029 break;
1030 case 75:
1031 if ((0x3ff000000000000L & l) == 0L)
1032 break;
1033 if (kind > 131)
1034 kind = 131;
1035 jjCheckNAddTwoStates(75, 76);
1036 break;
1037 default : break;
1038 }
1039 } while(i != startsAt);
1040 }
1041 else if (curChar < 128)
1042 {
1043 long l = 1L << (curChar & 077);
1044 do
1045 {
1046 switch(jjstateSet[--i])
1047 {
1048 case 28:
1049 if ((0x7fffffe87fffffeL & l) != 0L)
1050 {
1051 if (kind > 135)
1052 kind = 135;
1053 jjCheckNAdd(29);
1054 }
1055 if (curChar == 76)
1056 jjAddStates(60, 61);
1057 break;
1058 case 2:
1059 if ((0x2000000020L & l) != 0L)
1060 jjAddStates(62, 63);
1061 break;
1062 case 5:
1063 if ((0x104000001040L & l) != 0L && kind > 130)
1064 kind = 130;
1065 break;
1066 case 7:
1067 if ((0xffffffffefffffffL & l) != 0L)
1068 jjCheckNAddTwoStates(7, 8);
1069 break;
1070 case 9:
1071 if (curChar == 92)
1072 jjAddStates(64, 67);
1073 break;
1074 case 10:
1075 if ((0x54404610000000L & l) != 0L)
1076 jjCheckNAdd(8);
1077 break;
1078 case 15:
1079 if ((0x100000001000000L & l) != 0L)
1080 jjCheckNAdd(16);
1081 break;
1082 case 16:
1083 if ((0x7e0000007eL & l) != 0L)
1084 jjCheckNAddTwoStates(16, 8);
1085 break;
1086 case 18:
1087 if ((0xffffffffefffffffL & l) != 0L)
1088 jjCheckNAddStates(6, 8);
1089 break;
1090 case 19:
1091 if (curChar == 92)
1092 jjAddStates(68, 71);
1093 break;
1094 case 20:
1095 if ((0x54404610000000L & l) != 0L)
1096 jjCheckNAddStates(6, 8);
1097 break;
1098 case 26:
1099 if ((0x100000001000000L & l) != 0L)
1100 jjCheckNAdd(27);
1101 break;
1102 case 27:
1103 if ((0x7e0000007eL & l) != 0L)
1104 jjCheckNAddStates(40, 43);
1105 break;
1106 case 29:
1107 if ((0x7fffffe87fffffeL & l) == 0L)
1108 break;
1109 if (kind > 135)
1110 kind = 135;
1111 jjCheckNAdd(29);
1112 break;
1113 case 33:
1114 if ((0x100000001000L & l) != 0L && kind > 119)
1115 kind = 119;
1116 break;
1117 case 35:
1118 if ((0x20000000200000L & l) != 0L && kind > 120)
1119 kind = 120;
1120 break;
1121 case 37:
1122 if ((0x100000001000L & l) != 0L && kind > 121)
1123 kind = 121;
1124 break;
1125 case 38:
1126 if ((0x20000000200000L & l) != 0L)
1127 jjstateSet[jjnewStateCnt++] = 37;
1128 break;
1129 case 39:
1130 if ((0x20000000200000L & l) != 0L && kind > 121)
1131 kind = 121;
1132 break;
1133 case 40:
1134 if ((0x100000001000L & l) != 0L)
1135 jjstateSet[jjnewStateCnt++] = 39;
1136 break;
1137 case 44:
1138 if ((0x20100000201000L & l) != 0L && kind > 123)
1139 kind = 123;
1140 break;
1141 case 46:
1142 if ((0x20000000200000L & l) != 0L && kind > 124)
1143 kind = 124;
1144 break;
1145 case 48:
1146 if ((0x100000001000L & l) != 0L && kind > 125)
1147 kind = 125;
1148 break;
1149 case 49:
1150 if ((0x20000000200000L & l) != 0L)
1151 jjstateSet[jjnewStateCnt++] = 48;
1152 break;
1153 case 50:
1154 if ((0x20000000200000L & l) != 0L && kind > 125)
1155 kind = 125;
1156 break;
1157 case 51:
1158 if ((0x100000001000L & l) != 0L)
1159 jjstateSet[jjnewStateCnt++] = 50;
1160 break;
1161 case 53:
1162 if ((0x100000001000000L & l) != 0L)
1163 jjCheckNAdd(54);
1164 break;
1165 case 54:
1166 if ((0x7e0000007eL & l) == 0L)
1167 break;
1168 if (kind > 126)
1169 kind = 126;
1170 jjCheckNAdd(54);
1171 break;
1172 case 55:
1173 if ((0x100000001000000L & l) != 0L)
1174 jjCheckNAdd(56);
1175 break;
1176 case 56:
1177 if ((0x7e0000007eL & l) == 0L)
1178 break;
1179 if (kind > 127)
1180 kind = 127;
1181 jjCheckNAddTwoStates(56, 57);
1182 break;
1183 case 57:
1184 if ((0x20100000201000L & l) != 0L && kind > 127)
1185 kind = 127;
1186 break;
1187 case 58:
1188 if ((0x100000001000000L & l) != 0L)
1189 jjCheckNAdd(59);
1190 break;
1191 case 59:
1192 if ((0x7e0000007eL & l) != 0L)
1193 jjCheckNAddTwoStates(59, 60);
1194 break;
1195 case 60:
1196 if ((0x20000000200000L & l) != 0L && kind > 128)
1197 kind = 128;
1198 break;
1199 case 61:
1200 if ((0x100000001000000L & l) != 0L)
1201 jjCheckNAdd(62);
1202 break;
1203 case 62:
1204 if ((0x7e0000007eL & l) != 0L)
1205 jjCheckNAddStates(54, 56);
1206 break;
1207 case 63:
1208 if ((0x100000001000L & l) != 0L && kind > 129)
1209 kind = 129;
1210 break;
1211 case 64:
1212 if ((0x20000000200000L & l) != 0L)
1213 jjstateSet[jjnewStateCnt++] = 63;
1214 break;
1215 case 65:
1216 if ((0x20000000200000L & l) != 0L && kind > 129)
1217 kind = 129;
1218 break;
1219 case 66:
1220 if ((0x100000001000L & l) != 0L)
1221 jjstateSet[jjnewStateCnt++] = 65;
1222 break;
1223 case 73:
1224 if ((0x2000000020L & l) != 0L)
1225 jjAddStates(72, 73);
1226 break;
1227 case 76:
1228 if ((0x104000001040L & l) != 0L && kind > 131)
1229 kind = 131;
1230 break;
1231 case 77:
1232 if (curChar == 76)
1233 jjAddStates(60, 61);
1234 break;
1235 default : break;
1236 }
1237 } while(i != startsAt);
1238 }
1239 else
1240 {
1241 int i2 = (curChar & 0xff) >> 6;
1242 long l2 = 1L << (curChar & 077);
1243 do
1244 {
1245 switch(jjstateSet[--i])
1246 {
1247 case 7:
1248 if ((jjbitVec0[i2] & l2) != 0L)
1249 jjAddStates(74, 75);
1250 break;
1251 case 18:
1252 if ((jjbitVec0[i2] & l2) != 0L)
1253 jjAddStates(6, 8);
1254 break;
1255 default : break;
1256 }
1257 } while(i != startsAt);
1258 }
1259 if (kind != 0x7fffffff)
1260 {
1261 jjmatchedKind = kind;
1262 jjmatchedPos = curPos;
1263 kind = 0x7fffffff;
1264 }
1265 ++curPos;
1266 if ((i = jjnewStateCnt) == (startsAt = 78 - (jjnewStateCnt = startsAt)))
1267 return curPos;
1268 try { curChar = input_stream.readChar(); }
1269 catch(java.io.IOException e) { return curPos; }
1270 }
1271 }
1272 private int jjMoveStringLiteralDfa0_1()
1273 {
1274 switch(curChar)
1275 {
1276 case 10:
1277 return jjStopAtPos(0, 9);
1278 default :
1279 return 1;
1280 }
1281 }
1282 private int jjMoveStringLiteralDfa0_4()
1283 {
1284 switch(curChar)
1285 {
1286 case 10:
1287 return jjStopAtPos(0, 14);
1288 case 47:
1289 return jjMoveStringLiteralDfa1_4(0x8000L);
1290 case 92:
1291 return jjMoveStringLiteralDfa1_4(0x30000L);
1292 default :
1293 return 1;
1294 }
1295 }
1296 private int jjMoveStringLiteralDfa1_4(long active0)
1297 {
1298 try { curChar = input_stream.readChar(); }
1299 catch(java.io.IOException e) {
1300 return 1;
1301 }
1302 switch(curChar)
1303 {
1304 case 10:
1305 if ((active0 & 0x10000L) != 0L)
1306 return jjStopAtPos(1, 16);
1307 break;
1308 case 13:
1309 return jjMoveStringLiteralDfa2_4(active0, 0x20000L);
1310 case 42:
1311 if ((active0 & 0x8000L) != 0L)
1312 return jjStopAtPos(1, 15);
1313 break;
1314 default :
1315 return 2;
1316 }
1317 return 2;
1318 }
1319 private int jjMoveStringLiteralDfa2_4(long old0, long active0)
1320 {
1321 if (((active0 &= old0)) == 0L)
1322 return 2;
1323 try { curChar = input_stream.readChar(); }
1324 catch(java.io.IOException e) {
1325 return 2;
1326 }
1327 switch(curChar)
1328 {
1329 case 10:
1330 if ((active0 & 0x20000L) != 0L)
1331 return jjStopAtPos(2, 17);
1332 break;
1333 default :
1334 return 3;
1335 }
1336 return 3;
1337 }
1338 private int jjMoveStringLiteralDfa0_3()
1339 {
1340 switch(curChar)
1341 {
1342 case 42:
1343 return jjMoveStringLiteralDfa1_3(0x2000L);
1344 default :
1345 return 1;
1346 }
1347 }
1348 private int jjMoveStringLiteralDfa1_3(long active0)
1349 {
1350 try { curChar = input_stream.readChar(); }
1351 catch(java.io.IOException e) {
1352 return 1;
1353 }
1354 switch(curChar)
1355 {
1356 case 47:
1357 if ((active0 & 0x2000L) != 0L)
1358 return jjStopAtPos(1, 13);
1359 break;
1360 default :
1361 return 2;
1362 }
1363 return 2;
1364 }
1365 private int jjMoveStringLiteralDfa0_2()
1366 {
1367 switch(curChar)
1368 {
1369 case 42:
1370 return jjMoveStringLiteralDfa1_2(0x800L);
1371 default :
1372 return 1;
1373 }
1374 }
1375 private int jjMoveStringLiteralDfa1_2(long active0)
1376 {
1377 try { curChar = input_stream.readChar(); }
1378 catch(java.io.IOException e) {
1379 return 1;
1380 }
1381 switch(curChar)
1382 {
1383 case 47:
1384 if ((active0 & 0x800L) != 0L)
1385 return jjStopAtPos(1, 11);
1386 break;
1387 default :
1388 return 2;
1389 }
1390 return 2;
1391 }
1392 static final int[] jjnextStates = {
1393 68, 69, 71, 0, 72, 73, 18, 19, 21, 42, 43, 44, 45, 46, 47, 49,
1394 51, 53, 55, 58, 61, 31, 32, 33, 34, 35, 36, 38, 40, 1, 2, 5,
1395 18, 19, 23, 21, 18, 19, 25, 21, 18, 19, 27, 21, 36, 38, 40, 47,
1396 49, 51, 56, 57, 59, 60, 62, 64, 66, 70, 2, 5, 6, 17, 3, 4,
1397 10, 11, 13, 15, 20, 22, 24, 26, 74, 75, 7, 8,
1398 };
1399
1400 /** Token literal values. */
1401 public static final String[] jjstrLiteralImages = {
1402 "", null, null, null, null, null, null, null, null, null, null, null, null,
1403 null, null, null, null, null, null, "\173", "\175", "\133", "\135", "\50", "\51",
1404 "\72\72", "\72", "\73", "\54", "\77", "\56\56\56", "\75", "\52\75", "\57\75", "\45\75",
1405 "\53\75", "\55\75", "\74\74\75", "\76\76\75", "\46\75", "\136\75", "\174\75",
1406 "\174\174", "\46\46", "\174", "\136", "\46", "\75\75", "\41\75", "\74", "\76", "\74\75",
1407 "\76\75", "\74\74", "\76\76", "\53", "\55", "\52", "\57", "\45", "\53\53", "\55\55",
1408 "\176", "\41", "\56", "\55\76", "\56\52", "\55\76\52", "\141\165\164\157",
1409 "\142\162\145\141\153", "\143\141\163\145", "\143\141\164\143\150", "\143\150\141\162",
1410 "\143\157\156\163\164", "\143\157\156\164\151\156\165\145", "\144\145\146\141\165\154\164",
1411 "\144\145\154\145\164\145", "\144\157", "\144\157\165\142\154\145", "\145\154\163\145",
1412 "\145\156\165\155", "\145\170\164\145\162\156", "\146\154\157\141\164", "\146\157\162",
1413 "\146\162\151\145\156\144", "\147\157\164\157", "\151\146", "\151\156\154\151\156\145", "\151\156\164",
1414 "\154\157\156\147", "\156\145\167", "\160\162\151\166\141\164\145",
1415 "\160\162\157\164\145\143\164\145\144", "\160\165\142\154\151\143", "\162\145\144\145\143\154\141\162\145\144",
1416 "\162\145\147\151\163\164\145\162", "\162\145\164\165\162\156", "\163\150\157\162\164",
1417 "\163\151\147\156\145\144", "\163\151\172\145\157\146", "\163\164\141\164\151\143",
1418 "\163\164\162\165\143\164", "\143\154\141\163\163", "\163\167\151\164\143\150",
1419 "\164\145\155\160\154\141\164\145", "\164\150\151\163", "\164\162\171", "\164\171\160\145\144\145\146",
1420 "\165\156\151\157\156", "\165\156\163\151\147\156\145\144", "\166\151\162\164\165\141\154",
1421 "\166\157\151\144", "\166\157\154\141\164\151\154\145", "\167\150\151\154\145",
1422 "\157\160\145\162\141\164\157\162", "\164\162\165\145", "\146\141\154\163\145", "\164\150\162\157\167", null, null,
1423 null, null, null, null, null, null, null, null, null, null, null, null, null, null,
1424 "\146\151\156\141\154\154\171", null, };
1425
1426 /** Lexer state names. */
1427 public static final String[] lexStateNames = {
1428 "DEFAULT",
1429 "IN_LINE_COMMENT",
1430 "IN_COMMENT",
1431 "IN_PREPROCESSOR_OUTPUT_COMMENT",
1432 "PREPROCESSOR_OUTPUT",
1433 };
1434
1435 /** Lex State array. */
1436 public static final int[] jjnewLexState = {
1437 -1, -1, -1, -1, -1, -1, 1, 2, 4, 0, -1, 0, -1, 4, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1438 -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,
1439 -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,
1440 -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,
1441 -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,
1442 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1443 };
1444 static final long[] jjtoToken = {
1445 0xfffffffffff80001L, 0xffffffffffffffffL, 0xffL,
1446 };
1447 static final long[] jjtoSkip = {
1448 0xebfeL, 0x0L, 0x0L,
1449 };
1450 static final long[] jjtoMore = {
1451 0x71400L, 0x0L, 0x0L,
1452 };
1453 protected CharStream input_stream;
1454 private final int[] jjrounds = new int[78];
1455 private final int[] jjstateSet = new int[156];
1456 protected char curChar;
1457 /** Constructor. */
1458 public CppParserTokenManager(CharStream stream){
1459 input_stream = stream;
1460 }
1461
1462 /** Constructor. */
1463 public CppParserTokenManager(CharStream stream, int lexState){
1464 this(stream);
1465 SwitchTo(lexState);
1466 }
1467
1468 /** Reinitialise parser. */
1469 public void ReInit(CharStream stream)
1470 {
1471 jjmatchedPos = jjnewStateCnt = 0;
1472 curLexState = defaultLexState;
1473 input_stream = stream;
1474 ReInitRounds();
1475 }
1476 private void ReInitRounds()
1477 {
1478 int i;
1479 jjround = 0x80000001;
1480 for (i = 78; i-- > 0;)
1481 jjrounds[i] = 0x80000000;
1482 }
1483
1484 /** Reinitialise parser. */
1485 public void ReInit(CharStream stream, int lexState)
1486 {
1487 ReInit(stream);
1488 SwitchTo(lexState);
1489 }
1490
1491 /** Switch to specified lex state. */
1492 public void SwitchTo(int lexState)
1493 {
1494 if (lexState >= 5 || lexState < 0)
1495 throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
1496 else
1497 curLexState = lexState;
1498 }
1499
1500 protected Token jjFillToken()
1501 {
1502 final Token t;
1503 final String curTokenImage;
1504 final int beginLine;
1505 final int endLine;
1506 final int beginColumn;
1507 final int endColumn;
1508 String im = jjstrLiteralImages[jjmatchedKind];
1509 curTokenImage = (im == null) ? input_stream.GetImage() : im;
1510 beginLine = input_stream.getBeginLine();
1511 beginColumn = input_stream.getBeginColumn();
1512 endLine = input_stream.getEndLine();
1513 endColumn = input_stream.getEndColumn();
1514 t = Token.newToken(jjmatchedKind, curTokenImage);
1515
1516 t.beginLine = beginLine;
1517 t.endLine = endLine;
1518 t.beginColumn = beginColumn;
1519 t.endColumn = endColumn;
1520
1521 return t;
1522 }
1523
1524 int curLexState = 0;
1525 int defaultLexState = 0;
1526 int jjnewStateCnt;
1527 int jjround;
1528 int jjmatchedPos;
1529 int jjmatchedKind;
1530
1531 /** Get the next Token. */
1532 public Token getNextToken()
1533 {
1534 Token matchedToken;
1535 int curPos = 0;
1536
1537 EOFLoop :
1538 for (;;)
1539 {
1540 try
1541 {
1542 curChar = input_stream.BeginToken();
1543 }
1544 catch(java.io.IOException e)
1545 {
1546 jjmatchedKind = 0;
1547 matchedToken = jjFillToken();
1548 return matchedToken;
1549 }
1550
1551 for (;;)
1552 {
1553 switch(curLexState)
1554 {
1555 case 0:
1556 try { input_stream.backup(0);
1557 while (curChar <= 32 && (0x100001600L & (1L << curChar)) != 0L)
1558 curChar = input_stream.BeginToken();
1559 }
1560 catch (java.io.IOException e1) { continue EOFLoop; }
1561 jjmatchedKind = 0x7fffffff;
1562 jjmatchedPos = 0;
1563 curPos = jjMoveStringLiteralDfa0_0();
1564 break;
1565 case 1:
1566 jjmatchedKind = 0x7fffffff;
1567 jjmatchedPos = 0;
1568 curPos = jjMoveStringLiteralDfa0_1();
1569 if (jjmatchedPos == 0 && jjmatchedKind > 10)
1570 {
1571 jjmatchedKind = 10;
1572 }
1573 break;
1574 case 2:
1575 jjmatchedKind = 0x7fffffff;
1576 jjmatchedPos = 0;
1577 curPos = jjMoveStringLiteralDfa0_2();
1578 if (jjmatchedPos == 0 && jjmatchedKind > 12)
1579 {
1580 jjmatchedKind = 12;
1581 }
1582 break;
1583 case 3:
1584 jjmatchedKind = 0x7fffffff;
1585 jjmatchedPos = 0;
1586 curPos = jjMoveStringLiteralDfa0_3();
1587 if (jjmatchedPos == 0 && jjmatchedKind > 12)
1588 {
1589 jjmatchedKind = 12;
1590 }
1591 break;
1592 case 4:
1593 jjmatchedKind = 0x7fffffff;
1594 jjmatchedPos = 0;
1595 curPos = jjMoveStringLiteralDfa0_4();
1596 if (jjmatchedPos == 0 && jjmatchedKind > 18)
1597 {
1598 jjmatchedKind = 18;
1599 }
1600 break;
1601 }
1602 if (jjmatchedKind != 0x7fffffff)
1603 {
1604 if (jjmatchedPos + 1 < curPos)
1605 input_stream.backup(curPos - jjmatchedPos - 1);
1606 if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
1607 {
1608 matchedToken = jjFillToken();
1609 if (jjnewLexState[jjmatchedKind] != -1)
1610 curLexState = jjnewLexState[jjmatchedKind];
1611 return matchedToken;
1612 }
1613 else if ((jjtoSkip[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
1614 {
1615 if (jjnewLexState[jjmatchedKind] != -1)
1616 curLexState = jjnewLexState[jjmatchedKind];
1617 continue EOFLoop;
1618 }
1619 if (jjnewLexState[jjmatchedKind] != -1)
1620 curLexState = jjnewLexState[jjmatchedKind];
1621 curPos = 0;
1622 jjmatchedKind = 0x7fffffff;
1623 try {
1624 curChar = input_stream.readChar();
1625 continue;
1626 }
1627 catch (java.io.IOException e1) { }
1628 }
1629 int error_line = input_stream.getEndLine();
1630 int error_column = input_stream.getEndColumn();
1631 String error_after = null;
1632 boolean EOFSeen = false;
1633 try { input_stream.readChar(); input_stream.backup(1); }
1634 catch (java.io.IOException e1) {
1635 EOFSeen = true;
1636 error_after = curPos <= 1 ? "" : input_stream.GetImage();
1637 if (curChar == '\n' || curChar == '\r') {
1638 error_line++;
1639 error_column = 0;
1640 }
1641 else
1642 error_column++;
1643 }
1644 if (!EOFSeen) {
1645 input_stream.backup(1);
1646 error_after = curPos <= 1 ? "" : input_stream.GetImage();
1647 }
1648 throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
1649 }
1650 }
1651 }
1652
1653 private void jjCheckNAdd(int state)
1654 {
1655 if (jjrounds[state] != jjround)
1656 {
1657 jjstateSet[jjnewStateCnt++] = state;
1658 jjrounds[state] = jjround;
1659 }
1660 }
1661 private void jjAddStates(int start, int end)
1662 {
1663 do {
1664 jjstateSet[jjnewStateCnt++] = jjnextStates[start];
1665 } while (start++ != end);
1666 }
1667 private void jjCheckNAddTwoStates(int state1, int state2)
1668 {
1669 jjCheckNAdd(state1);
1670 jjCheckNAdd(state2);
1671 }
1672
1673 private void jjCheckNAddStates(int start, int end)
1674 {
1675 do {
1676 jjCheckNAdd(jjnextStates[start]);
1677 } while (start++ != end);
1678 }
1679
1680 }
|