0001 /* Generated By:JavaCC: Do not edit this line. ParseCpslTokenManager.java */
0002 package gate.jape.parser;
0003 import java.io.*;
0004 import java.net.*;
0005 import java.util.*;
0006 import java.util.regex.*;
0007 import gate.Factory;
0008 import gate.util.*;
0009 import gate.jape.*;
0010 import gate.jape.constraint.*;
0011 import gate.event.*;
0012 import org.apache.log4j.Logger;
0013
0014 public class ParseCpslTokenManager implements ParseCpslConstants
0015 {
0016 public java.io.PrintStream debugStream = System.out;
0017 public void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
0018 private final int jjStopAtPos(int pos, int kind)
0019 {
0020 jjmatchedKind = kind;
0021 jjmatchedPos = pos;
0022 return pos + 1;
0023 }
0024 private final int jjMoveStringLiteralDfa0_0()
0025 {
0026 switch(curChar)
0027 {
0028 case 33:
0029 jjmatchedKind = 31;
0030 return jjMoveNfa_0(0, 0);
0031 case 34:
0032 jjmatchedKind = 36;
0033 return jjMoveNfa_0(0, 0);
0034 case 40:
0035 jjmatchedKind = 59;
0036 return jjMoveNfa_0(0, 0);
0037 case 41:
0038 jjmatchedKind = 60;
0039 return jjMoveNfa_0(0, 0);
0040 case 44:
0041 jjmatchedKind = 56;
0042 return jjMoveNfa_0(0, 0);
0043 case 45:
0044 return jjMoveStringLiteralDfa1_0(0x0L, 0x100L);
0045 case 46:
0046 jjmatchedKind = 54;
0047 return jjMoveNfa_0(0, 0);
0048 case 58:
0049 jjmatchedKind = 52;
0050 return jjMoveStringLiteralDfa1_0(0x0L, 0x1L);
0051 case 59:
0052 jjmatchedKind = 53;
0053 return jjMoveNfa_0(0, 0);
0054 case 61:
0055 jjmatchedKind = 63;
0056 return jjMoveNfa_0(0, 0);
0057 case 64:
0058 jjmatchedKind = 34;
0059 return jjMoveNfa_0(0, 0);
0060 case 67:
0061 return jjMoveStringLiteralDfa1_0(0xe00000L, 0x0L);
0062 case 73:
0063 return jjMoveStringLiteralDfa1_0(0x2100000L, 0x0L);
0064 case 77:
0065 return jjMoveStringLiteralDfa1_0(0x10000800L, 0x0L);
0066 case 79:
0067 return jjMoveStringLiteralDfa1_0(0x4000000L, 0x0L);
0068 case 80:
0069 return jjMoveStringLiteralDfa1_0(0x41001000L, 0x0L);
0070 case 82:
0071 return jjMoveStringLiteralDfa1_0(0x8000000L, 0x0L);
0072 case 84:
0073 return jjMoveStringLiteralDfa1_0(0x20000000L, 0x0L);
0074 case 91:
0075 jjmatchedKind = 61;
0076 return jjMoveNfa_0(0, 0);
0077 case 93:
0078 jjmatchedKind = 62;
0079 return jjMoveNfa_0(0, 0);
0080 case 99:
0081 return jjMoveStringLiteralDfa1_0(0xe00000L, 0x0L);
0082 case 105:
0083 return jjMoveStringLiteralDfa1_0(0x2100000L, 0x0L);
0084 case 109:
0085 return jjMoveStringLiteralDfa1_0(0x10000800L, 0x0L);
0086 case 111:
0087 return jjMoveStringLiteralDfa1_0(0x4000000L, 0x0L);
0088 case 112:
0089 return jjMoveStringLiteralDfa1_0(0x41001000L, 0x0L);
0090 case 114:
0091 return jjMoveStringLiteralDfa1_0(0x8000000L, 0x0L);
0092 case 116:
0093 return jjMoveStringLiteralDfa1_0(0x20000000L, 0x0L);
0094 case 123:
0095 jjmatchedKind = 57;
0096 return jjMoveNfa_0(0, 0);
0097 case 124:
0098 jjmatchedKind = 55;
0099 return jjMoveNfa_0(0, 0);
0100 case 125:
0101 jjmatchedKind = 58;
0102 return jjMoveNfa_0(0, 0);
0103 default :
0104 return jjMoveNfa_0(0, 0);
0105 }
0106 }
0107 private final int jjMoveStringLiteralDfa1_0(long active0, long active1)
0108 {
0109 try { curChar = input_stream.readChar(); }
0110 catch(java.io.IOException e) {
0111 return jjMoveNfa_0(0, 0);
0112 }
0113 switch(curChar)
0114 {
0115 case 43:
0116 if ((active1 & 0x1L) != 0L)
0117 {
0118 jjmatchedKind = 64;
0119 jjmatchedPos = 1;
0120 }
0121 break;
0122 case 45:
0123 return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x100L);
0124 case 65:
0125 return jjMoveStringLiteralDfa2_0(active0, 0x10000000L, active1, 0L);
0126 case 69:
0127 return jjMoveStringLiteralDfa2_0(active0, 0x20000000L, active1, 0L);
0128 case 72:
0129 return jjMoveStringLiteralDfa2_0(active0, 0x1001000L, active1, 0L);
0130 case 77:
0131 return jjMoveStringLiteralDfa2_0(active0, 0x100000L, active1, 0L);
0132 case 78:
0133 return jjMoveStringLiteralDfa2_0(active0, 0x2000000L, active1, 0L);
0134 case 79:
0135 return jjMoveStringLiteralDfa2_0(active0, 0xe00000L, active1, 0L);
0136 case 80:
0137 return jjMoveStringLiteralDfa2_0(active0, 0x4000000L, active1, 0L);
0138 case 82:
0139 return jjMoveStringLiteralDfa2_0(active0, 0x40000000L, active1, 0L);
0140 case 85:
0141 return jjMoveStringLiteralDfa2_0(active0, 0x8000800L, active1, 0L);
0142 case 97:
0143 return jjMoveStringLiteralDfa2_0(active0, 0x10000000L, active1, 0L);
0144 case 101:
0145 return jjMoveStringLiteralDfa2_0(active0, 0x20000000L, active1, 0L);
0146 case 104:
0147 return jjMoveStringLiteralDfa2_0(active0, 0x1001000L, active1, 0L);
0148 case 109:
0149 return jjMoveStringLiteralDfa2_0(active0, 0x100000L, active1, 0L);
0150 case 110:
0151 return jjMoveStringLiteralDfa2_0(active0, 0x2000000L, active1, 0L);
0152 case 111:
0153 return jjMoveStringLiteralDfa2_0(active0, 0xe00000L, active1, 0L);
0154 case 112:
0155 return jjMoveStringLiteralDfa2_0(active0, 0x4000000L, active1, 0L);
0156 case 114:
0157 return jjMoveStringLiteralDfa2_0(active0, 0x40000000L, active1, 0L);
0158 case 117:
0159 return jjMoveStringLiteralDfa2_0(active0, 0x8000800L, active1, 0L);
0160 default :
0161 break;
0162 }
0163 return jjMoveNfa_0(0, 1);
0164 }
0165 private final int jjMoveStringLiteralDfa2_0(long old0, long active0, long old1, long active1)
0166 {
0167 if (((active0 &= old0) | (active1 &= old1)) == 0L)
0168 return jjMoveNfa_0(0, 1);
0169 try { curChar = input_stream.readChar(); }
0170 catch(java.io.IOException e) {
0171 return jjMoveNfa_0(0, 1);
0172 }
0173 switch(curChar)
0174 {
0175 case 62:
0176 if ((active1 & 0x100L) != 0L)
0177 {
0178 jjmatchedKind = 72;
0179 jjmatchedPos = 2;
0180 }
0181 break;
0182 case 65:
0183 return jjMoveStringLiteralDfa3_0(active0, 0x1001000L, active1, 0L);
0184 case 67:
0185 return jjMoveStringLiteralDfa3_0(active0, 0x10000000L, active1, 0L);
0186 case 73:
0187 return jjMoveStringLiteralDfa3_0(active0, 0x40000000L, active1, 0L);
0188 case 76:
0189 return jjMoveStringLiteralDfa3_0(active0, 0x8000800L, active1, 0L);
0190 case 77:
0191 return jjMoveStringLiteralDfa3_0(active0, 0x20000000L, active1, 0L);
0192 case 78:
0193 return jjMoveStringLiteralDfa3_0(active0, 0xe00000L, active1, 0L);
0194 case 80:
0195 return jjMoveStringLiteralDfa3_0(active0, 0x2100000L, active1, 0L);
0196 case 84:
0197 return jjMoveStringLiteralDfa3_0(active0, 0x4000000L, active1, 0L);
0198 case 97:
0199 return jjMoveStringLiteralDfa3_0(active0, 0x1001000L, active1, 0L);
0200 case 99:
0201 return jjMoveStringLiteralDfa3_0(active0, 0x10000000L, active1, 0L);
0202 case 105:
0203 return jjMoveStringLiteralDfa3_0(active0, 0x40000000L, active1, 0L);
0204 case 108:
0205 return jjMoveStringLiteralDfa3_0(active0, 0x8000800L, active1, 0L);
0206 case 109:
0207 return jjMoveStringLiteralDfa3_0(active0, 0x20000000L, active1, 0L);
0208 case 110:
0209 return jjMoveStringLiteralDfa3_0(active0, 0xe00000L, active1, 0L);
0210 case 112:
0211 return jjMoveStringLiteralDfa3_0(active0, 0x2100000L, active1, 0L);
0212 case 116:
0213 return jjMoveStringLiteralDfa3_0(active0, 0x4000000L, active1, 0L);
0214 default :
0215 break;
0216 }
0217 return jjMoveNfa_0(0, 2);
0218 }
0219 private final int jjMoveStringLiteralDfa3_0(long old0, long active0, long old1, long active1)
0220 {
0221 if (((active0 &= old0) | (active1 &= old1)) == 0L)
0222 return jjMoveNfa_0(0, 2);
0223 try { curChar = input_stream.readChar(); }
0224 catch(java.io.IOException e) {
0225 return jjMoveNfa_0(0, 2);
0226 }
0227 switch(curChar)
0228 {
0229 case 69:
0230 return jjMoveStringLiteralDfa4_0(active0, 0x8000000L);
0231 case 73:
0232 return jjMoveStringLiteralDfa4_0(active0, 0x4000000L);
0233 case 79:
0234 return jjMoveStringLiteralDfa4_0(active0, 0x40100000L);
0235 case 80:
0236 return jjMoveStringLiteralDfa4_0(active0, 0x20000000L);
0237 case 82:
0238 return jjMoveStringLiteralDfa4_0(active0, 0x10000000L);
0239 case 83:
0240 return jjMoveStringLiteralDfa4_0(active0, 0x1001000L);
0241 case 84:
0242 return jjMoveStringLiteralDfa4_0(active0, 0xe00800L);
0243 case 85:
0244 return jjMoveStringLiteralDfa4_0(active0, 0x2000000L);
0245 case 101:
0246 return jjMoveStringLiteralDfa4_0(active0, 0x8000000L);
0247 case 105:
0248 return jjMoveStringLiteralDfa4_0(active0, 0x4000000L);
0249 case 111:
0250 return jjMoveStringLiteralDfa4_0(active0, 0x40100000L);
0251 case 112:
0252 return jjMoveStringLiteralDfa4_0(active0, 0x20000000L);
0253 case 114:
0254 return jjMoveStringLiteralDfa4_0(active0, 0x10000000L);
0255 case 115:
0256 return jjMoveStringLiteralDfa4_0(active0, 0x1001000L);
0257 case 116:
0258 return jjMoveStringLiteralDfa4_0(active0, 0xe00800L);
0259 case 117:
0260 return jjMoveStringLiteralDfa4_0(active0, 0x2000000L);
0261 default :
0262 break;
0263 }
0264 return jjMoveNfa_0(0, 3);
0265 }
0266 private final int jjMoveStringLiteralDfa4_0(long old0, long active0)
0267 {
0268 if (((active0 &= old0)) == 0L)
0269 return jjMoveNfa_0(0, 3);
0270 try { curChar = input_stream.readChar(); }
0271 catch(java.io.IOException e) {
0272 return jjMoveNfa_0(0, 3);
0273 }
0274 switch(curChar)
0275 {
0276 case 58:
0277 if ((active0 & 0x8000000L) != 0L)
0278 {
0279 jjmatchedKind = 27;
0280 jjmatchedPos = 4;
0281 }
0282 break;
0283 case 69:
0284 return jjMoveStringLiteralDfa5_0(active0, 0x1001000L);
0285 case 73:
0286 return jjMoveStringLiteralDfa5_0(active0, 0x800L);
0287 case 76:
0288 return jjMoveStringLiteralDfa5_0(active0, 0x20000000L);
0289 case 79:
0290 return jjMoveStringLiteralDfa5_0(active0, 0x14000000L);
0291 case 82:
0292 return jjMoveStringLiteralDfa5_0(active0, 0x40f00000L);
0293 case 84:
0294 return jjMoveStringLiteralDfa5_0(active0, 0x2000000L);
0295 case 101:
0296 return jjMoveStringLiteralDfa5_0(active0, 0x1001000L);
0297 case 105:
0298 return jjMoveStringLiteralDfa5_0(active0, 0x800L);
0299 case 108:
0300 return jjMoveStringLiteralDfa5_0(active0, 0x20000000L);
0301 case 111:
0302 return jjMoveStringLiteralDfa5_0(active0, 0x14000000L);
0303 case 114:
0304 return jjMoveStringLiteralDfa5_0(active0, 0x40f00000L);
0305 case 116:
0306 return jjMoveStringLiteralDfa5_0(active0, 0x2000000L);
0307 default :
0308 break;
0309 }
0310 return jjMoveNfa_0(0, 4);
0311 }
0312 private final int jjMoveStringLiteralDfa5_0(long old0, long active0)
0313 {
0314 if (((active0 &= old0)) == 0L)
0315 return jjMoveNfa_0(0, 4);
0316 try { curChar = input_stream.readChar(); }
0317 catch(java.io.IOException e) {
0318 return jjMoveNfa_0(0, 4);
0319 }
0320 switch(curChar)
0321 {
0322 case 58:
0323 if ((active0 & 0x1000000L) != 0L)
0324 {
0325 jjmatchedKind = 24;
0326 jjmatchedPos = 5;
0327 }
0328 else if ((active0 & 0x2000000L) != 0L)
0329 {
0330 jjmatchedKind = 25;
0331 jjmatchedPos = 5;
0332 }
0333 else if ((active0 & 0x10000000L) != 0L)
0334 {
0335 jjmatchedKind = 28;
0336 jjmatchedPos = 5;
0337 }
0338 break;
0339 case 65:
0340 return jjMoveStringLiteralDfa6_0(active0, 0x20000000L);
0341 case 73:
0342 return jjMoveStringLiteralDfa6_0(active0, 0x40000000L);
0343 case 78:
0344 return jjMoveStringLiteralDfa6_0(active0, 0x4000000L);
0345 case 79:
0346 return jjMoveStringLiteralDfa6_0(active0, 0xe00000L);
0347 case 80:
0348 return jjMoveStringLiteralDfa6_0(active0, 0x800L);
0349 case 83:
0350 return jjMoveStringLiteralDfa6_0(active0, 0x1000L);
0351 case 84:
0352 return jjMoveStringLiteralDfa6_0(active0, 0x100000L);
0353 case 97:
0354 return jjMoveStringLiteralDfa6_0(active0, 0x20000000L);
0355 case 105:
0356 return jjMoveStringLiteralDfa6_0(active0, 0x40000000L);
0357 case 110:
0358 return jjMoveStringLiteralDfa6_0(active0, 0x4000000L);
0359 case 111:
0360 return jjMoveStringLiteralDfa6_0(active0, 0xe00000L);
0361 case 112:
0362 return jjMoveStringLiteralDfa6_0(active0, 0x800L);
0363 case 115:
0364 return jjMoveStringLiteralDfa6_0(active0, 0x1000L);
0365 case 116:
0366 return jjMoveStringLiteralDfa6_0(active0, 0x100000L);
0367 default :
0368 break;
0369 }
0370 return jjMoveNfa_0(0, 5);
0371 }
0372 private final int jjMoveStringLiteralDfa6_0(long old0, long active0)
0373 {
0374 if (((active0 &= old0)) == 0L)
0375 return jjMoveNfa_0(0, 5);
0376 try { curChar = input_stream.readChar(); }
0377 catch(java.io.IOException e) {
0378 return jjMoveNfa_0(0, 5);
0379 }
0380 switch(curChar)
0381 {
0382 case 58:
0383 if ((active0 & 0x1000L) != 0L)
0384 {
0385 jjmatchedKind = 12;
0386 jjmatchedPos = 6;
0387 }
0388 break;
0389 case 72:
0390 return jjMoveStringLiteralDfa7_0(active0, 0x800L);
0391 case 76:
0392 return jjMoveStringLiteralDfa7_0(active0, 0xe00000L);
0393 case 83:
0394 return jjMoveStringLiteralDfa7_0(active0, 0x4100000L);
0395 case 84:
0396 return jjMoveStringLiteralDfa7_0(active0, 0x60000000L);
0397 case 104:
0398 return jjMoveStringLiteralDfa7_0(active0, 0x800L);
0399 case 108:
0400 return jjMoveStringLiteralDfa7_0(active0, 0xe00000L);
0401 case 115:
0402 return jjMoveStringLiteralDfa7_0(active0, 0x4100000L);
0403 case 116:
0404 return jjMoveStringLiteralDfa7_0(active0, 0x60000000L);
0405 default :
0406 break;
0407 }
0408 return jjMoveNfa_0(0, 6);
0409 }
0410 private final int jjMoveStringLiteralDfa7_0(long old0, long active0)
0411 {
0412 if (((active0 &= old0)) == 0L)
0413 return jjMoveNfa_0(0, 6);
0414 try { curChar = input_stream.readChar(); }
0415 catch(java.io.IOException e) {
0416 return jjMoveNfa_0(0, 6);
0417 }
0418 switch(curChar)
0419 {
0420 case 58:
0421 if ((active0 & 0x100000L) != 0L)
0422 {
0423 jjmatchedKind = 20;
0424 jjmatchedPos = 7;
0425 }
0426 else if ((active0 & 0x4000000L) != 0L)
0427 {
0428 jjmatchedKind = 26;
0429 jjmatchedPos = 7;
0430 }
0431 break;
0432 case 65:
0433 return jjMoveStringLiteralDfa8_0(active0, 0x800L);
0434 case 69:
0435 return jjMoveStringLiteralDfa8_0(active0, 0x20000000L);
0436 case 76:
0437 return jjMoveStringLiteralDfa8_0(active0, 0xe00000L);
0438 case 89:
0439 return jjMoveStringLiteralDfa8_0(active0, 0x40000000L);
0440 case 97:
0441 return jjMoveStringLiteralDfa8_0(active0, 0x800L);
0442 case 101:
0443 return jjMoveStringLiteralDfa8_0(active0, 0x20000000L);
0444 case 108:
0445 return jjMoveStringLiteralDfa8_0(active0, 0xe00000L);
0446 case 121:
0447 return jjMoveStringLiteralDfa8_0(active0, 0x40000000L);
0448 default :
0449 break;
0450 }
0451 return jjMoveNfa_0(0, 7);
0452 }
0453 private final int jjMoveStringLiteralDfa8_0(long old0, long active0)
0454 {
0455 if (((active0 &= old0)) == 0L)
0456 return jjMoveNfa_0(0, 7);
0457 try { curChar = input_stream.readChar(); }
0458 catch(java.io.IOException e) {
0459 return jjMoveNfa_0(0, 7);
0460 }
0461 switch(curChar)
0462 {
0463 case 58:
0464 if ((active0 & 0x20000000L) != 0L)
0465 {
0466 jjmatchedKind = 29;
0467 jjmatchedPos = 8;
0468 }
0469 else if ((active0 & 0x40000000L) != 0L)
0470 {
0471 jjmatchedKind = 30;
0472 jjmatchedPos = 8;
0473 }
0474 break;
0475 case 69:
0476 return jjMoveStringLiteralDfa9_0(active0, 0xe00000L);
0477 case 83:
0478 return jjMoveStringLiteralDfa9_0(active0, 0x800L);
0479 case 101:
0480 return jjMoveStringLiteralDfa9_0(active0, 0xe00000L);
0481 case 115:
0482 return jjMoveStringLiteralDfa9_0(active0, 0x800L);
0483 default :
0484 break;
0485 }
0486 return jjMoveNfa_0(0, 8);
0487 }
0488 private final int jjMoveStringLiteralDfa9_0(long old0, long active0)
0489 {
0490 if (((active0 &= old0)) == 0L)
0491 return jjMoveNfa_0(0, 8);
0492 try { curChar = input_stream.readChar(); }
0493 catch(java.io.IOException e) {
0494 return jjMoveNfa_0(0, 8);
0495 }
0496 switch(curChar)
0497 {
0498 case 69:
0499 return jjMoveStringLiteralDfa10_0(active0, 0x800L);
0500 case 82:
0501 return jjMoveStringLiteralDfa10_0(active0, 0xe00000L);
0502 case 101:
0503 return jjMoveStringLiteralDfa10_0(active0, 0x800L);
0504 case 114:
0505 return jjMoveStringLiteralDfa10_0(active0, 0xe00000L);
0506 default :
0507 break;
0508 }
0509 return jjMoveNfa_0(0, 9);
0510 }
0511 private final int jjMoveStringLiteralDfa10_0(long old0, long active0)
0512 {
0513 if (((active0 &= old0)) == 0L)
0514 return jjMoveNfa_0(0, 9);
0515 try { curChar = input_stream.readChar(); }
0516 catch(java.io.IOException e) {
0517 return jjMoveNfa_0(0, 9);
0518 }
0519 switch(curChar)
0520 {
0521 case 58:
0522 if ((active0 & 0x800L) != 0L)
0523 {
0524 jjmatchedKind = 11;
0525 jjmatchedPos = 10;
0526 }
0527 break;
0528 case 65:
0529 return jjMoveStringLiteralDfa11_0(active0, 0x800000L);
0530 case 70:
0531 return jjMoveStringLiteralDfa11_0(active0, 0x400000L);
0532 case 83:
0533 return jjMoveStringLiteralDfa11_0(active0, 0x200000L);
0534 case 97:
0535 return jjMoveStringLiteralDfa11_0(active0, 0x800000L);
0536 case 102:
0537 return jjMoveStringLiteralDfa11_0(active0, 0x400000L);
0538 case 115:
0539 return jjMoveStringLiteralDfa11_0(active0, 0x200000L);
0540 default :
0541 break;
0542 }
0543 return jjMoveNfa_0(0, 10);
0544 }
0545 private final int jjMoveStringLiteralDfa11_0(long old0, long active0)
0546 {
0547 if (((active0 &= old0)) == 0L)
0548 return jjMoveNfa_0(0, 10);
0549 try { curChar = input_stream.readChar(); }
0550 catch(java.io.IOException e) {
0551 return jjMoveNfa_0(0, 10);
0552 }
0553 switch(curChar)
0554 {
0555 case 66:
0556 return jjMoveStringLiteralDfa12_0(active0, 0x800000L);
0557 case 73:
0558 return jjMoveStringLiteralDfa12_0(active0, 0x400000L);
0559 case 84:
0560 return jjMoveStringLiteralDfa12_0(active0, 0x200000L);
0561 case 98:
0562 return jjMoveStringLiteralDfa12_0(active0, 0x800000L);
0563 case 105:
0564 return jjMoveStringLiteralDfa12_0(active0, 0x400000L);
0565 case 116:
0566 return jjMoveStringLiteralDfa12_0(active0, 0x200000L);
0567 default :
0568 break;
0569 }
0570 return jjMoveNfa_0(0, 11);
0571 }
0572 private final int jjMoveStringLiteralDfa12_0(long old0, long active0)
0573 {
0574 if (((active0 &= old0)) == 0L)
0575 return jjMoveNfa_0(0, 11);
0576 try { curChar = input_stream.readChar(); }
0577 catch(java.io.IOException e) {
0578 return jjMoveNfa_0(0, 11);
0579 }
0580 switch(curChar)
0581 {
0582 case 65:
0583 return jjMoveStringLiteralDfa13_0(active0, 0x200000L);
0584 case 78:
0585 return jjMoveStringLiteralDfa13_0(active0, 0x400000L);
0586 case 79:
0587 return jjMoveStringLiteralDfa13_0(active0, 0x800000L);
0588 case 97:
0589 return jjMoveStringLiteralDfa13_0(active0, 0x200000L);
0590 case 110:
0591 return jjMoveStringLiteralDfa13_0(active0, 0x400000L);
0592 case 111:
0593 return jjMoveStringLiteralDfa13_0(active0, 0x800000L);
0594 default :
0595 break;
0596 }
0597 return jjMoveNfa_0(0, 12);
0598 }
0599 private final int jjMoveStringLiteralDfa13_0(long old0, long active0)
0600 {
0601 if (((active0 &= old0)) == 0L)
0602 return jjMoveNfa_0(0, 12);
0603 try { curChar = input_stream.readChar(); }
0604 catch(java.io.IOException e) {
0605 return jjMoveNfa_0(0, 12);
0606 }
0607 switch(curChar)
0608 {
0609 case 73:
0610 return jjMoveStringLiteralDfa14_0(active0, 0x400000L);
0611 case 82:
0612 return jjMoveStringLiteralDfa14_0(active0, 0xa00000L);
0613 case 105:
0614 return jjMoveStringLiteralDfa14_0(active0, 0x400000L);
0615 case 114:
0616 return jjMoveStringLiteralDfa14_0(active0, 0xa00000L);
0617 default :
0618 break;
0619 }
0620 return jjMoveNfa_0(0, 13);
0621 }
0622 private final int jjMoveStringLiteralDfa14_0(long old0, long active0)
0623 {
0624 if (((active0 &= old0)) == 0L)
0625 return jjMoveNfa_0(0, 13);
0626 try { curChar = input_stream.readChar(); }
0627 catch(java.io.IOException e) {
0628 return jjMoveNfa_0(0, 13);
0629 }
0630 switch(curChar)
0631 {
0632 case 83:
0633 return jjMoveStringLiteralDfa15_0(active0, 0x400000L);
0634 case 84:
0635 return jjMoveStringLiteralDfa15_0(active0, 0xa00000L);
0636 case 115:
0637 return jjMoveStringLiteralDfa15_0(active0, 0x400000L);
0638 case 116:
0639 return jjMoveStringLiteralDfa15_0(active0, 0xa00000L);
0640 default :
0641 break;
0642 }
0643 return jjMoveNfa_0(0, 14);
0644 }
0645 private final int jjMoveStringLiteralDfa15_0(long old0, long active0)
0646 {
0647 if (((active0 &= old0)) == 0L)
0648 return jjMoveNfa_0(0, 14);
0649 try { curChar = input_stream.readChar(); }
0650 catch(java.io.IOException e) {
0651 return jjMoveNfa_0(0, 14);
0652 }
0653 switch(curChar)
0654 {
0655 case 69:
0656 return jjMoveStringLiteralDfa16_0(active0, 0xa00000L);
0657 case 72:
0658 return jjMoveStringLiteralDfa16_0(active0, 0x400000L);
0659 case 101:
0660 return jjMoveStringLiteralDfa16_0(active0, 0xa00000L);
0661 case 104:
0662 return jjMoveStringLiteralDfa16_0(active0, 0x400000L);
0663 default :
0664 break;
0665 }
0666 return jjMoveNfa_0(0, 15);
0667 }
0668 private final int jjMoveStringLiteralDfa16_0(long old0, long active0)
0669 {
0670 if (((active0 &= old0)) == 0L)
0671 return jjMoveNfa_0(0, 15);
0672 try { curChar = input_stream.readChar(); }
0673 catch(java.io.IOException e) {
0674 return jjMoveNfa_0(0, 15);
0675 }
0676 switch(curChar)
0677 {
0678 case 68:
0679 return jjMoveStringLiteralDfa17_0(active0, 0xa00000L);
0680 case 69:
0681 return jjMoveStringLiteralDfa17_0(active0, 0x400000L);
0682 case 100:
0683 return jjMoveStringLiteralDfa17_0(active0, 0xa00000L);
0684 case 101:
0685 return jjMoveStringLiteralDfa17_0(active0, 0x400000L);
0686 default :
0687 break;
0688 }
0689 return jjMoveNfa_0(0, 16);
0690 }
0691 private final int jjMoveStringLiteralDfa17_0(long old0, long active0)
0692 {
0693 if (((active0 &= old0)) == 0L)
0694 return jjMoveNfa_0(0, 16);
0695 try { curChar = input_stream.readChar(); }
0696 catch(java.io.IOException e) {
0697 return jjMoveNfa_0(0, 16);
0698 }
0699 switch(curChar)
0700 {
0701 case 58:
0702 if ((active0 & 0x200000L) != 0L)
0703 {
0704 jjmatchedKind = 21;
0705 jjmatchedPos = 17;
0706 }
0707 else if ((active0 & 0x800000L) != 0L)
0708 {
0709 jjmatchedKind = 23;
0710 jjmatchedPos = 17;
0711 }
0712 break;
0713 case 68:
0714 return jjMoveStringLiteralDfa18_0(active0, 0x400000L);
0715 case 100:
0716 return jjMoveStringLiteralDfa18_0(active0, 0x400000L);
0717 default :
0718 break;
0719 }
0720 return jjMoveNfa_0(0, 17);
0721 }
0722 private final int jjMoveStringLiteralDfa18_0(long old0, long active0)
0723 {
0724 if (((active0 &= old0)) == 0L)
0725 return jjMoveNfa_0(0, 17);
0726 try { curChar = input_stream.readChar(); }
0727 catch(java.io.IOException e) {
0728 return jjMoveNfa_0(0, 17);
0729 }
0730 switch(curChar)
0731 {
0732 case 58:
0733 if ((active0 & 0x400000L) != 0L)
0734 {
0735 jjmatchedKind = 22;
0736 jjmatchedPos = 18;
0737 }
0738 break;
0739 default :
0740 break;
0741 }
0742 return jjMoveNfa_0(0, 18);
0743 }
0744 private final void jjCheckNAdd(int state)
0745 {
0746 if (jjrounds[state] != jjround)
0747 {
0748 jjstateSet[jjnewStateCnt++] = state;
0749 jjrounds[state] = jjround;
0750 }
0751 }
0752 private final void jjAddStates(int start, int end)
0753 {
0754 do {
0755 jjstateSet[jjnewStateCnt++] = jjnextStates[start];
0756 } while (start++ != end);
0757 }
0758 private final void jjCheckNAddTwoStates(int state1, int state2)
0759 {
0760 jjCheckNAdd(state1);
0761 jjCheckNAdd(state2);
0762 }
0763 private final void jjCheckNAddStates(int start, int end)
0764 {
0765 do {
0766 jjCheckNAdd(jjnextStates[start]);
0767 } while (start++ != end);
0768 }
0769 private final void jjCheckNAddStates(int start)
0770 {
0771 jjCheckNAdd(jjnextStates[start]);
0772 jjCheckNAdd(jjnextStates[start + 1]);
0773 }
0774 static final long[] jjbitVec0 = {
0775 0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
0776 };
0777 static final long[] jjbitVec2 = {
0778 0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
0779 };
0780 private final int jjMoveNfa_0(int startState, int curPos)
0781 {
0782 int strKind = jjmatchedKind;
0783 int strPos = jjmatchedPos;
0784 int seenUpto;
0785 input_stream.backup(seenUpto = curPos + 1);
0786 try { curChar = input_stream.readChar(); }
0787 catch(java.io.IOException e) { throw new Error("Internal Error"); }
0788 curPos = 0;
0789 int[] nextStates;
0790 int startsAt = 0;
0791 jjnewStateCnt = 62;
0792 int i = 1;
0793 jjstateSet[0] = startState;
0794 int j, kind = 0x7fffffff;
0795 for (;;)
0796 {
0797 if (++jjround == 0x7fffffff)
0798 ReInitRounds();
0799 if (curChar < 64)
0800 {
0801 long l = 1L << curChar;
0802 MatchLoop: do
0803 {
0804 switch(jjstateSet[--i])
0805 {
0806 case 0:
0807 if ((0x3ff000000000000L & l) != 0L)
0808 {
0809 if (kind > 35)
0810 kind = 35;
0811 jjCheckNAddStates(0, 7);
0812 }
0813 else if ((0x100003600L & l) != 0L)
0814 {
0815 if (kind > 65)
0816 kind = 65;
0817 jjCheckNAdd(21);
0818 }
0819 else if ((0x5000000000000000L & l) != 0L)
0820 {
0821 if (kind > 33)
0822 kind = 33;
0823 }
0824 else if ((0x80000c0000000000L & l) != 0L)
0825 {
0826 if (kind > 32)
0827 kind = 32;
0828 }
0829 else if (curChar == 47)
0830 jjAddStates(8, 9);
0831 else if (curChar == 33)
0832 jjCheckNAddStates(10, 12);
0833 else if (curChar == 61)
0834 jjCheckNAddStates(13, 15);
0835 else if (curChar == 35)
0836 jjstateSet[jjnewStateCnt++] = 30;
0837 else if (curChar == 59)
0838 jjstateSet[jjnewStateCnt++] = 22;
0839 else if (curChar == 46)
0840 jjCheckNAdd(16);
0841 if (curChar == 60)
0842 jjCheckNAdd(2);
0843 else if (curChar == 62)
0844 jjCheckNAdd(2);
0845 break;
0846 case 1:
0847 if ((0x5000000000000000L & l) != 0L && kind > 33)
0848 kind = 33;
0849 break;
0850 case 2:
0851 if (curChar == 61 && kind > 33)
0852 kind = 33;
0853 break;
0854 case 3:
0855 if (curChar == 62)
0856 jjCheckNAdd(2);
0857 break;
0858 case 4:
0859 if (curChar == 60)
0860 jjCheckNAdd(2);
0861 break;
0862 case 14:
0863 if ((0x3ff200000000000L & l) == 0L)
0864 break;
0865 if (kind > 49)
0866 kind = 49;
0867 jjstateSet[jjnewStateCnt++] = 14;
0868 break;
0869 case 15:
0870 if (curChar == 46)
0871 jjCheckNAdd(16);
0872 break;
0873 case 16:
0874 if ((0x3ff000000000000L & l) == 0L)
0875 break;
0876 if (kind > 50)
0877 kind = 50;
0878 jjCheckNAddStates(16, 18);
0879 break;
0880 case 18:
0881 if ((0x280000000000L & l) != 0L)
0882 jjCheckNAdd(19);
0883 break;
0884 case 19:
0885 if ((0x3ff000000000000L & l) == 0L)
0886 break;
0887 if (kind > 50)
0888 kind = 50;
0889 jjCheckNAddTwoStates(19, 20);
0890 break;
0891 case 21:
0892 if ((0x100003600L & l) == 0L)
0893 break;
0894 if (kind > 65)
0895 kind = 65;
0896 jjCheckNAdd(21);
0897 break;
0898 case 22:
0899 if (curChar == 59)
0900 jjCheckNAddStates(19, 22);
0901 break;
0902 case 23:
0903 if ((0xffffffffffffdbffL & l) != 0L)
0904 jjCheckNAddStates(19, 22);
0905 break;
0906 case 24:
0907 if ((0x2400L & l) != 0L && kind > 67)
0908 kind = 67;
0909 break;
0910 case 25:
0911 if (curChar == 13 && kind > 67)
0912 kind = 67;
0913 break;
0914 case 26:
0915 if (curChar == 10)
0916 jjstateSet[jjnewStateCnt++] = 25;
0917 break;
0918 case 27:
0919 if (curChar == 10 && kind > 67)
0920 kind = 67;
0921 break;
0922 case 28:
0923 if (curChar == 13)
0924 jjstateSet[jjnewStateCnt++] = 27;
0925 break;
0926 case 29:
0927 if (curChar == 59)
0928 jjstateSet[jjnewStateCnt++] = 22;
0929 break;
0930 case 31:
0931 if (curChar == 35)
0932 jjstateSet[jjnewStateCnt++] = 30;
0933 break;
0934 case 32:
0935 if (curChar == 61)
0936 jjCheckNAddStates(13, 15);
0937 break;
0938 case 34:
0939 case 36:
0940 if (curChar == 61)
0941 jjCheckNAdd(33);
0942 break;
0943 case 35:
0944 if (curChar == 33)
0945 jjCheckNAddStates(10, 12);
0946 break;
0947 case 37:
0948 if ((0x3ff000000000000L & l) == 0L)
0949 break;
0950 if (kind > 35)
0951 kind = 35;
0952 jjCheckNAddStates(0, 7);
0953 break;
0954 case 38:
0955 if ((0x3ff000000000000L & l) == 0L)
0956 break;
0957 if (kind > 35)
0958 kind = 35;
0959 jjCheckNAdd(38);
0960 break;
0961 case 39:
0962 if ((0x3ff000000000000L & l) != 0L)
0963 jjCheckNAddTwoStates(39, 40);
0964 break;
0965 case 40:
0966 if (curChar != 46)
0967 break;
0968 if (kind > 50)
0969 kind = 50;
0970 jjCheckNAddStates(23, 25);
0971 break;
0972 case 41:
0973 if ((0x3ff000000000000L & l) == 0L)
0974 break;
0975 if (kind > 50)
0976 kind = 50;
0977 jjCheckNAddStates(23, 25);
0978 break;
0979 case 43:
0980 if ((0x280000000000L & l) != 0L)
0981 jjCheckNAdd(44);
0982 break;
0983 case 44:
0984 if ((0x3ff000000000000L & l) == 0L)
0985 break;
0986 if (kind > 50)
0987 kind = 50;
0988 jjCheckNAddTwoStates(44, 20);
0989 break;
0990 case 45:
0991 if ((0x3ff000000000000L & l) != 0L)
0992 jjCheckNAddTwoStates(45, 46);
0993 break;
0994 case 47:
0995 if ((0x280000000000L & l) != 0L)
0996 jjCheckNAdd(48);
0997 break;
0998 case 48:
0999 if ((0x3ff000000000000L & l) == 0L)
1000 break;
1001 if (kind > 50)
1002 kind = 50;
1003 jjCheckNAddTwoStates(48, 20);
1004 break;
1005 case 49:
1006 if ((0x3ff000000000000L & l) != 0L)
1007 jjCheckNAddStates(26, 28);
1008 break;
1009 case 51:
1010 if ((0x280000000000L & l) != 0L)
1011 jjCheckNAdd(52);
1012 break;
1013 case 52:
1014 if ((0x3ff000000000000L & l) != 0L)
1015 jjCheckNAddTwoStates(52, 20);
1016 break;
1017 case 53:
1018 if (curChar == 47)
1019 jjAddStates(8, 9);
1020 break;
1021 case 54:
1022 if (curChar == 47)
1023 jjCheckNAddStates(29, 32);
1024 break;
1025 case 55:
1026 if ((0xffffffffffffdbffL & l) != 0L)
1027 jjCheckNAddStates(29, 32);
1028 break;
1029 case 56:
1030 if ((0x2400L & l) != 0L && kind > 66)
1031 kind = 66;
1032 break;
1033 case 57:
1034 if (curChar == 13 && kind > 66)
1035 kind = 66;
1036 break;
1037 case 58:
1038 if (curChar == 10)
1039 jjstateSet[jjnewStateCnt++] = 57;
1040 break;
1041 case 59:
1042 if (curChar == 10 && kind > 66)
1043 kind = 66;
1044 break;
1045 case 60:
1046 if (curChar == 13)
1047 jjstateSet[jjnewStateCnt++] = 59;
1048 break;
1049 case 61:
1050 if (curChar == 42 && kind > 68)
1051 kind = 68;
1052 break;
1053 default : break;
1054 }
1055 } while(i != startsAt);
1056 }
1057 else if (curChar < 128)
1058 {
1059 long l = 1L << (curChar & 077);
1060 MatchLoop: do
1061 {
1062 switch(jjstateSet[--i])
1063 {
1064 case 0:
1065 if ((0x7fffffe87fffffeL & l) != 0L)
1066 {
1067 if (kind > 49)
1068 kind = 49;
1069 jjCheckNAdd(14);
1070 }
1071 if (curChar == 102)
1072 jjstateSet[jjnewStateCnt++] = 11;
1073 else if (curChar == 116)
1074 jjstateSet[jjnewStateCnt++] = 7;
1075 break;
1076 case 5:
1077 if (curChar == 101 && kind > 48)
1078 kind = 48;
1079 break;
1080 case 6:
1081 if (curChar == 117)
1082 jjCheckNAdd(5);
1083 break;
1084 case 7:
1085 if (curChar == 114)
1086 jjstateSet[jjnewStateCnt++] = 6;
1087 break;
1088 case 8:
1089 if (curChar == 116)
1090 jjstateSet[jjnewStateCnt++] = 7;
1091 break;
1092 case 9:
1093 if (curChar == 115)
1094 jjCheckNAdd(5);
1095 break;
1096 case 10:
1097 if (curChar == 108)
1098 jjstateSet[jjnewStateCnt++] = 9;
1099 break;
1100 case 11:
1101 if (curChar == 97)
1102 jjstateSet[jjnewStateCnt++] = 10;
1103 break;
1104 case 12:
1105 if (curChar == 102)
1106 jjstateSet[jjnewStateCnt++] = 11;
1107 break;
1108 case 13:
1109 case 14:
1110 if ((0x7fffffe87fffffeL & l) == 0L)
1111 break;
1112 if (kind > 49)
1113 kind = 49;
1114 jjCheckNAdd(14);
1115 break;
1116 case 17:
1117 if ((0x2000000020L & l) != 0L)
1118 jjAddStates(33, 34);
1119 break;
1120 case 20:
1121 if ((0x5000000050L & l) != 0L && kind > 50)
1122 kind = 50;
1123 break;
1124 case 23:
1125 jjAddStates(19, 22);
1126 break;
1127 case 30:
1128 if (curChar == 124 && kind > 68)
1129 kind = 68;
1130 break;
1131 case 33:
1132 if (curChar == 126 && kind > 33)
1133 kind = 33;
1134 break;
1135 case 42:
1136 if ((0x2000000020L & l) != 0L)
1137 jjAddStates(35, 36);
1138 break;
1139 case 46:
1140 if ((0x2000000020L & l) != 0L)
1141 jjAddStates(37, 38);
1142 break;
1143 case 50:
1144 if ((0x2000000020L & l) != 0L)
1145 jjAddStates(39, 40);
1146 break;
1147 case 55:
1148 jjAddStates(29, 32);
1149 break;
1150 default : break;
1151 }
1152 } while(i != startsAt);
1153 }
1154 else
1155 {
1156 int hiByte = (int)(curChar >> 8);
1157 int i1 = hiByte >> 6;
1158 long l1 = 1L << (hiByte & 077);
1159 int i2 = (curChar & 0xff) >> 6;
1160 long l2 = 1L << (curChar & 077);
1161 MatchLoop: do
1162 {
1163 switch(jjstateSet[--i])
1164 {
1165 case 23:
1166 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1167 jjAddStates(19, 22);
1168 break;
1169 case 55:
1170 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1171 jjAddStates(29, 32);
1172 break;
1173 default : break;
1174 }
1175 } while(i != startsAt);
1176 }
1177 if (kind != 0x7fffffff)
1178 {
1179 jjmatchedKind = kind;
1180 jjmatchedPos = curPos;
1181 kind = 0x7fffffff;
1182 }
1183 ++curPos;
1184 if ((i = jjnewStateCnt) == (startsAt = 62 - (jjnewStateCnt = startsAt)))
1185 break;
1186 try { curChar = input_stream.readChar(); }
1187 catch(java.io.IOException e) { break; }
1188 }
1189 if (jjmatchedPos > strPos)
1190 return curPos;
1191
1192 int toRet = Math.max(curPos, seenUpto);
1193
1194 if (curPos < toRet)
1195 for (i = toRet - Math.min(curPos, seenUpto); i-- > 0; )
1196 try { curChar = input_stream.readChar(); }
1197 catch(java.io.IOException e) { throw new Error("Internal Error : Please send a bug report."); }
1198
1199 if (jjmatchedPos < strPos)
1200 {
1201 jjmatchedKind = strKind;
1202 jjmatchedPos = strPos;
1203 }
1204 else if (jjmatchedPos == strPos && jjmatchedKind > strKind)
1205 jjmatchedKind = strKind;
1206
1207 return toRet;
1208 }
1209 private final int jjStopStringLiteralDfa_3(int pos, long active0)
1210 {
1211 switch (pos)
1212 {
1213 case 0:
1214 if ((active0 & 0x1fe000000000L) != 0L)
1215 return 0;
1216 return -1;
1217 default :
1218 return -1;
1219 }
1220 }
1221 private final int jjStartNfa_3(int pos, long active0)
1222 {
1223 return jjMoveNfa_3(jjStopStringLiteralDfa_3(pos, active0), pos + 1);
1224 }
1225 private final int jjStartNfaWithStates_3(int pos, int kind, int state)
1226 {
1227 jjmatchedKind = kind;
1228 jjmatchedPos = pos;
1229 try { curChar = input_stream.readChar(); }
1230 catch(java.io.IOException e) { return pos + 1; }
1231 return jjMoveNfa_3(state, pos + 1);
1232 }
1233 private final int jjMoveStringLiteralDfa0_3()
1234 {
1235 switch(curChar)
1236 {
1237 case 34:
1238 return jjStopAtPos(0, 47);
1239 case 92:
1240 return jjMoveStringLiteralDfa1_3(0x1fe000000000L);
1241 default :
1242 return jjMoveNfa_3(5, 0);
1243 }
1244 }
1245 private final int jjMoveStringLiteralDfa1_3(long active0)
1246 {
1247 try { curChar = input_stream.readChar(); }
1248 catch(java.io.IOException e) {
1249 jjStopStringLiteralDfa_3(0, active0);
1250 return 1;
1251 }
1252 switch(curChar)
1253 {
1254 case 34:
1255 if ((active0 & 0x40000000000L) != 0L)
1256 return jjStopAtPos(1, 42);
1257 break;
1258 case 39:
1259 if ((active0 & 0x80000000000L) != 0L)
1260 return jjStopAtPos(1, 43);
1261 break;
1262 case 92:
1263 if ((active0 & 0x100000000000L) != 0L)
1264 return jjStopAtPos(1, 44);
1265 break;
1266 case 98:
1267 if ((active0 & 0x10000000000L) != 0L)
1268 return jjStopAtPos(1, 40);
1269 break;
1270 case 102:
1271 if ((active0 & 0x20000000000L) != 0L)
1272 return jjStopAtPos(1, 41);
1273 break;
1274 case 110:
1275 if ((active0 & 0x2000000000L) != 0L)
1276 return jjStopAtPos(1, 37);
1277 break;
1278 case 114:
1279 if ((active0 & 0x4000000000L) != 0L)
1280 return jjStopAtPos(1, 38);
1281 break;
1282 case 116:
1283 if ((active0 & 0x8000000000L) != 0L)
1284 return jjStopAtPos(1, 39);
1285 break;
1286 default :
1287 break;
1288 }
1289 return jjStartNfa_3(0, active0);
1290 }
1291 private final int jjMoveNfa_3(int startState, int curPos)
1292 {
1293 int[] nextStates;
1294 int startsAt = 0;
1295 jjnewStateCnt = 7;
1296 int i = 1;
1297 jjstateSet[0] = startState;
1298 int j, kind = 0x7fffffff;
1299 for (;;)
1300 {
1301 if (++jjround == 0x7fffffff)
1302 ReInitRounds();
1303 if (curChar < 64)
1304 {
1305 long l = 1L << curChar;
1306 MatchLoop: do
1307 {
1308 switch(jjstateSet[--i])
1309 {
1310 case 5:
1311 if ((0xfffffffbffffffffL & l) != 0L && kind > 46)
1312 kind = 46;
1313 break;
1314 case 1:
1315 if ((0x3ff000000000000L & l) != 0L)
1316 jjstateSet[jjnewStateCnt++] = 2;
1317 break;
1318 case 2:
1319 if ((0x3ff000000000000L & l) != 0L)
1320 jjstateSet[jjnewStateCnt++] = 3;
1321 break;
1322 case 3:
1323 if ((0x3ff000000000000L & l) != 0L)
1324 jjstateSet[jjnewStateCnt++] = 4;
1325 break;
1326 case 4:
1327 if ((0x3ff000000000000L & l) != 0L && kind > 45)
1328 kind = 45;
1329 break;
1330 default : break;
1331 }
1332 } while(i != startsAt);
1333 }
1334 else if (curChar < 128)
1335 {
1336 long l = 1L << (curChar & 077);
1337 MatchLoop: do
1338 {
1339 switch(jjstateSet[--i])
1340 {
1341 case 5:
1342 if ((0xffffffffefffffffL & l) != 0L)
1343 {
1344 if (kind > 46)
1345 kind = 46;
1346 }
1347 else if (curChar == 92)
1348 jjstateSet[jjnewStateCnt++] = 0;
1349 break;
1350 case 0:
1351 if (curChar == 117)
1352 jjstateSet[jjnewStateCnt++] = 1;
1353 break;
1354 case 1:
1355 if ((0x7e0000007eL & l) != 0L)
1356 jjstateSet[jjnewStateCnt++] = 2;
1357 break;
1358 case 2:
1359 if ((0x7e0000007eL & l) != 0L)
1360 jjstateSet[jjnewStateCnt++] = 3;
1361 break;
1362 case 3:
1363 if ((0x7e0000007eL & l) != 0L)
1364 jjstateSet[jjnewStateCnt++] = 4;
1365 break;
1366 case 4:
1367 if ((0x7e0000007eL & l) != 0L && kind > 45)
1368 kind = 45;
1369 break;
1370 case 6:
1371 if ((0xffffffffefffffffL & l) != 0L && kind > 46)
1372 kind = 46;
1373 break;
1374 default : break;
1375 }
1376 } while(i != startsAt);
1377 }
1378 else
1379 {
1380 int hiByte = (int)(curChar >> 8);
1381 int i1 = hiByte >> 6;
1382 long l1 = 1L << (hiByte & 077);
1383 int i2 = (curChar & 0xff) >> 6;
1384 long l2 = 1L << (curChar & 077);
1385 MatchLoop: do
1386 {
1387 switch(jjstateSet[--i])
1388 {
1389 case 5:
1390 if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 46)
1391 kind = 46;
1392 break;
1393 default : break;
1394 }
1395 } while(i != startsAt);
1396 }
1397 if (kind != 0x7fffffff)
1398 {
1399 jjmatchedKind = kind;
1400 jjmatchedPos = curPos;
1401 kind = 0x7fffffff;
1402 }
1403 ++curPos;
1404 if ((i = jjnewStateCnt) == (startsAt = 7 - (jjnewStateCnt = startsAt)))
1405 return curPos;
1406 try { curChar = input_stream.readChar(); }
1407 catch(java.io.IOException e) { return curPos; }
1408 }
1409 }
1410 private final int jjMoveStringLiteralDfa0_1()
1411 {
1412 return jjMoveNfa_1(9, 0);
1413 }
1414 private final int jjMoveNfa_1(int startState, int curPos)
1415 {
1416 int[] nextStates;
1417 int startsAt = 0;
1418 jjnewStateCnt = 21;
1419 int i = 1;
1420 jjstateSet[0] = startState;
1421 int j, kind = 0x7fffffff;
1422 for (;;)
1423 {
1424 if (++jjround == 0x7fffffff)
1425 ReInitRounds();
1426 if (curChar < 64)
1427 {
1428 long l = 1L << curChar;
1429 MatchLoop: do
1430 {
1431 switch(jjstateSet[--i])
1432 {
1433 case 9:
1434 if ((0x3ffe00000000000L & l) != 0L)
1435 {
1436 if (kind > 13)
1437 kind = 13;
1438 jjCheckNAdd(0);
1439 }
1440 else if ((0x100003600L & l) != 0L)
1441 {
1442 if (kind > 14)
1443 kind = 14;
1444 jjCheckNAdd(1);
1445 }
1446 else if (curChar == 35)
1447 jjstateSet[jjnewStateCnt++] = 10;
1448 else if (curChar == 59)
1449 jjstateSet[jjnewStateCnt++] = 2;
1450 if (curChar == 47)
1451 jjAddStates(41, 42);
1452 break;
1453 case 0:
1454 if ((0x3ffe00000000000L & l) == 0L)
1455 break;
1456 if (kind > 13)
1457 kind = 13;
1458 jjCheckNAdd(0);
1459 break;
1460 case 1:
1461 if ((0x100003600L & l) == 0L)
1462 break;
1463 if (kind > 14)
1464 kind = 14;
1465 jjCheckNAdd(1);
1466 break;
1467 case 2:
1468 if (curChar == 59)
1469 jjCheckNAddStates(43, 46);
1470 break;
1471 case 3:
1472 if ((0xffffffffffffdbffL & l) != 0L)
1473 jjCheckNAddStates(43, 46);
1474 break;
1475 case 4:
1476 if ((0x2400L & l) != 0L && kind > 16)
1477 kind = 16;
1478 break;
1479 case 5:
1480 if (curChar == 13 && kind > 16)
1481 kind = 16;
1482 break;
1483 case 6:
1484 if (curChar == 10)
1485 jjstateSet[jjnewStateCnt++] = 5;
1486 break;
1487 case 7:
1488 if (curChar == 10 && kind > 16)
1489 kind = 16;
1490 break;
1491 case 8:
1492 if (curChar == 13)
1493 jjstateSet[jjnewStateCnt++] = 7;
1494 break;
1495 case 11:
1496 if (curChar == 35)
1497 jjstateSet[jjnewStateCnt++] = 10;
1498 break;
1499 case 12:
1500 if (curChar == 47)
1501 jjAddStates(41, 42);
1502 break;
1503 case 13:
1504 if (curChar == 47)
1505 jjCheckNAddStates(47, 50);
1506 break;
1507 case 14:
1508 if ((0xffffffffffffdbffL & l) != 0L)
1509 jjCheckNAddStates(47, 50);
1510 break;
1511 case 15:
1512 if ((0x2400L & l) != 0L && kind > 15)
1513 kind = 15;
1514 break;
1515 case 16:
1516 if (curChar == 13 && kind > 15)
1517 kind = 15;
1518 break;
1519 case 17:
1520 if (curChar == 10)
1521 jjstateSet[jjnewStateCnt++] = 16;
1522 break;
1523 case 18:
1524 if (curChar == 10 && kind > 15)
1525 kind = 15;
1526 break;
1527 case 19:
1528 if (curChar == 13)
1529 jjstateSet[jjnewStateCnt++] = 18;
1530 break;
1531 case 20:
1532 if (curChar == 42 && kind > 17)
1533 kind = 17;
1534 break;
1535 default : break;
1536 }
1537 } while(i != startsAt);
1538 }
1539 else if (curChar < 128)
1540 {
1541 long l = 1L << (curChar & 077);
1542 MatchLoop: do
1543 {
1544 switch(jjstateSet[--i])
1545 {
1546 case 9:
1547 case 0:
1548 if ((0x7fffffe97fffffeL & l) == 0L)
1549 break;
1550 if (kind > 13)
1551 kind = 13;
1552 jjCheckNAdd(0);
1553 break;
1554 case 3:
1555 jjAddStates(43, 46);
1556 break;
1557 case 10:
1558 if (curChar == 124 && kind > 17)
1559 kind = 17;
1560 break;
1561 case 14:
1562 jjAddStates(47, 50);
1563 break;
1564 default : break;
1565 }
1566 } while(i != startsAt);
1567 }
1568 else
1569 {
1570 int hiByte = (int)(curChar >> 8);
1571 int i1 = hiByte >> 6;
1572 long l1 = 1L << (hiByte & 077);
1573 int i2 = (curChar & 0xff) >> 6;
1574 long l2 = 1L << (curChar & 077);
1575 MatchLoop: do
1576 {
1577 switch(jjstateSet[--i])
1578 {
1579 case 3:
1580 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1581 jjAddStates(43, 46);
1582 break;
1583 case 14:
1584 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1585 jjAddStates(47, 50);
1586 break;
1587 default : break;
1588 }
1589 } while(i != startsAt);
1590 }
1591 if (kind != 0x7fffffff)
1592 {
1593 jjmatchedKind = kind;
1594 jjmatchedPos = curPos;
1595 kind = 0x7fffffff;
1596 }
1597 ++curPos;
1598 if ((i = jjnewStateCnt) == (startsAt = 21 - (jjnewStateCnt = startsAt)))
1599 return curPos;
1600 try { curChar = input_stream.readChar(); }
1601 catch(java.io.IOException e) { return curPos; }
1602 }
1603 }
1604 private final int jjMoveStringLiteralDfa0_4()
1605 {
1606 return jjMoveNfa_4(1, 0);
1607 }
1608 private final int jjMoveNfa_4(int startState, int curPos)
1609 {
1610 int[] nextStates;
1611 int startsAt = 0;
1612 jjnewStateCnt = 4;
1613 int i = 1;
1614 jjstateSet[0] = startState;
1615 int j, kind = 0x7fffffff;
1616 for (;;)
1617 {
1618 if (++jjround == 0x7fffffff)
1619 ReInitRounds();
1620 if (curChar < 64)
1621 {
1622 long l = 1L << curChar;
1623 MatchLoop: do
1624 {
1625 switch(jjstateSet[--i])
1626 {
1627 case 1:
1628 if (curChar == 42)
1629 jjstateSet[jjnewStateCnt++] = 0;
1630 break;
1631 case 0:
1632 if (curChar == 47)
1633 kind = 70;
1634 break;
1635 case 2:
1636 if (curChar == 35)
1637 kind = 70;
1638 break;
1639 default : break;
1640 }
1641 } while(i != startsAt);
1642 }
1643 else if (curChar < 128)
1644 {
1645 long l = 1L << (curChar & 077);
1646 MatchLoop: do
1647 {
1648 switch(jjstateSet[--i])
1649 {
1650 case 1:
1651 if (curChar == 124)
1652 jjstateSet[jjnewStateCnt++] = 2;
1653 break;
1654 default : break;
1655 }
1656 } while(i != startsAt);
1657 }
1658 else
1659 {
1660 int hiByte = (int)(curChar >> 8);
1661 int i1 = hiByte >> 6;
1662 long l1 = 1L << (hiByte & 077);
1663 int i2 = (curChar & 0xff) >> 6;
1664 long l2 = 1L << (curChar & 077);
1665 MatchLoop: do
1666 {
1667 switch(jjstateSet[--i])
1668 {
1669 default : break;
1670 }
1671 } while(i != startsAt);
1672 }
1673 if (kind != 0x7fffffff)
1674 {
1675 jjmatchedKind = kind;
1676 jjmatchedPos = curPos;
1677 kind = 0x7fffffff;
1678 }
1679 ++curPos;
1680 if ((i = jjnewStateCnt) == (startsAt = 4 - (jjnewStateCnt = startsAt)))
1681 return curPos;
1682 try { curChar = input_stream.readChar(); }
1683 catch(java.io.IOException e) { return curPos; }
1684 }
1685 }
1686 private final int jjMoveStringLiteralDfa0_2()
1687 {
1688 return jjMoveNfa_2(1, 0);
1689 }
1690 private final int jjMoveNfa_2(int startState, int curPos)
1691 {
1692 int[] nextStates;
1693 int startsAt = 0;
1694 jjnewStateCnt = 4;
1695 int i = 1;
1696 jjstateSet[0] = startState;
1697 int j, kind = 0x7fffffff;
1698 for (;;)
1699 {
1700 if (++jjround == 0x7fffffff)
1701 ReInitRounds();
1702 if (curChar < 64)
1703 {
1704 long l = 1L << curChar;
1705 MatchLoop: do
1706 {
1707 switch(jjstateSet[--i])
1708 {
1709 case 1:
1710 if (curChar == 42)
1711 jjstateSet[jjnewStateCnt++] = 0;
1712 break;
1713 case 0:
1714 if (curChar == 47)
1715 kind = 19;
1716 break;
1717 case 2:
1718 if (curChar == 35)
1719 kind = 19;
1720 break;
1721 default : break;
1722 }
1723 } while(i != startsAt);
1724 }
1725 else if (curChar < 128)
1726 {
1727 long l = 1L << (curChar & 077);
1728 MatchLoop: do
1729 {
1730 switch(jjstateSet[--i])
1731 {
1732 case 1:
1733 if (curChar == 124)
1734 jjstateSet[jjnewStateCnt++] = 2;
1735 break;
1736 default : break;
1737 }
1738 } while(i != startsAt);
1739 }
1740 else
1741 {
1742 int hiByte = (int)(curChar >> 8);
1743 int i1 = hiByte >> 6;
1744 long l1 = 1L << (hiByte & 077);
1745 int i2 = (curChar & 0xff) >> 6;
1746 long l2 = 1L << (curChar & 077);
1747 MatchLoop: do
1748 {
1749 switch(jjstateSet[--i])
1750 {
1751 default : break;
1752 }
1753 } while(i != startsAt);
1754 }
1755 if (kind != 0x7fffffff)
1756 {
1757 jjmatchedKind = kind;
1758 jjmatchedPos = curPos;
1759 kind = 0x7fffffff;
1760 }
1761 ++curPos;
1762 if ((i = jjnewStateCnt) == (startsAt = 4 - (jjnewStateCnt = startsAt)))
1763 return curPos;
1764 try { curChar = input_stream.readChar(); }
1765 catch(java.io.IOException e) { return curPos; }
1766 }
1767 }
1768 static final int[] jjnextStates = {
1769 38, 39, 40, 45, 46, 49, 50, 20, 54, 61, 2, 33, 36, 2, 33, 34,
1770 16, 17, 20, 23, 24, 26, 28, 41, 42, 20, 49, 50, 20, 55, 56, 58,
1771 60, 18, 19, 43, 44, 47, 48, 51, 52, 13, 20, 3, 4, 6, 8, 14,
1772 15, 17, 19,
1773 };
1774 private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2)
1775 {
1776 switch(hiByte)
1777 {
1778 case 0:
1779 return ((jjbitVec2[i2] & l2) != 0L);
1780 default :
1781 if ((jjbitVec0[i1] & l1) != 0L)
1782 return true;
1783 return false;
1784 }
1785 }
1786 public static final String[] jjstrLiteralImages = {
1787 "", null, null, null, null, null, null, null, null, null, null, null, null,
1788 null, null, null, null, null, null, null, null, null, null, null, null, null, null,
1789 null, null, null, null, "\41", null, null, "\100", null, null, null, null, null,
1790 null, null, null, null, null, null, null, null, null, null, null, null, "\72",
1791 "\73", "\56", "\174", "\54", "\173", "\175", "\50", "\51", "\133", "\135", "\75",
1792 "\72\53", null, null, null, null, null, null, null, "\55\55\76", };
1793 public static final String[] lexStateNames = {
1794 "DEFAULT",
1795 "IN_PHASES",
1796 "PHASES_WITHIN_COMMENT",
1797 "IN_STRING",
1798 "WITHIN_COMMENT",
1799 };
1800 public static final int[] jjnewLexState = {
1801 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, -1, -1, -1, -1, 2, -1, 1, -1, -1, -1, -1, -1,
1802 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, -1,
1803 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 4, -1, 0, -1, -1,
1804 };
1805 static final long[] jjtoToken = {
1806 0xfff7800ffff03801L, 0x181L,
1807 };
1808 static final long[] jjtoSkip = {
1809 0xbc000L, 0x5eL,
1810 };
1811 static final long[] jjtoSpecial = {
1812 0xbc000L, 0x5eL,
1813 };
1814 static final long[] jjtoMore = {
1815 0x7ff000040000L, 0x20L,
1816 };
1817 protected SimpleCharStream input_stream;
1818 private final int[] jjrounds = new int[62];
1819 private final int[] jjstateSet = new int[124];
1820 StringBuffer image;
1821 int jjimageLen;
1822 int lengthOfMatch;
1823 protected char curChar;
1824 public ParseCpslTokenManager(SimpleCharStream stream){
1825 if (SimpleCharStream.staticFlag)
1826 throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
1827 input_stream = stream;
1828 }
1829 public ParseCpslTokenManager(SimpleCharStream stream, int lexState){
1830 this(stream);
1831 SwitchTo(lexState);
1832 }
1833 public void ReInit(SimpleCharStream stream)
1834 {
1835 jjmatchedPos = jjnewStateCnt = 0;
1836 curLexState = defaultLexState;
1837 input_stream = stream;
1838 ReInitRounds();
1839 }
1840 private final void ReInitRounds()
1841 {
1842 int i;
1843 jjround = 0x80000001;
1844 for (i = 62; i-- > 0;)
1845 jjrounds[i] = 0x80000000;
1846 }
1847 public void ReInit(SimpleCharStream stream, int lexState)
1848 {
1849 ReInit(stream);
1850 SwitchTo(lexState);
1851 }
1852 public void SwitchTo(int lexState)
1853 {
1854 if (lexState >= 5 || lexState < 0)
1855 throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
1856 else
1857 curLexState = lexState;
1858 }
1859
1860 protected Token jjFillToken()
1861 {
1862 Token t = Token.newToken(jjmatchedKind);
1863 t.kind = jjmatchedKind;
1864 String im = jjstrLiteralImages[jjmatchedKind];
1865 t.image = (im == null) ? input_stream.GetImage() : im;
1866 t.beginLine = input_stream.getBeginLine();
1867 t.beginColumn = input_stream.getBeginColumn();
1868 t.endLine = input_stream.getEndLine();
1869 t.endColumn = input_stream.getEndColumn();
1870 return t;
1871 }
1872
1873 int curLexState = 0;
1874 int defaultLexState = 0;
1875 int jjnewStateCnt;
1876 int jjround;
1877 int jjmatchedPos;
1878 int jjmatchedKind;
1879
1880 public Token getNextToken()
1881 {
1882 int kind;
1883 Token specialToken = null;
1884 Token matchedToken;
1885 int curPos = 0;
1886
1887 EOFLoop :
1888 for (;;)
1889 {
1890 try
1891 {
1892 curChar = input_stream.BeginToken();
1893 }
1894 catch(java.io.IOException e)
1895 {
1896 jjmatchedKind = 0;
1897 matchedToken = jjFillToken();
1898 matchedToken.specialToken = specialToken;
1899 return matchedToken;
1900 }
1901 image = null;
1902 jjimageLen = 0;
1903
1904 for (;;)
1905 {
1906 switch(curLexState)
1907 {
1908 case 0:
1909 jjmatchedKind = 0x7fffffff;
1910 jjmatchedPos = 0;
1911 curPos = jjMoveStringLiteralDfa0_0();
1912 if (jjmatchedPos == 0 && jjmatchedKind > 71)
1913 {
1914 jjmatchedKind = 71;
1915 }
1916 break;
1917 case 1:
1918 jjmatchedKind = 0x7fffffff;
1919 jjmatchedPos = 0;
1920 curPos = jjMoveStringLiteralDfa0_1();
1921 break;
1922 case 2:
1923 jjmatchedKind = 0x7fffffff;
1924 jjmatchedPos = 0;
1925 curPos = jjMoveStringLiteralDfa0_2();
1926 if (jjmatchedPos == 0 && jjmatchedKind > 18)
1927 {
1928 jjmatchedKind = 18;
1929 }
1930 break;
1931 case 3:
1932 jjmatchedKind = 0x7fffffff;
1933 jjmatchedPos = 0;
1934 curPos = jjMoveStringLiteralDfa0_3();
1935 break;
1936 case 4:
1937 jjmatchedKind = 0x7fffffff;
1938 jjmatchedPos = 0;
1939 curPos = jjMoveStringLiteralDfa0_4();
1940 if (jjmatchedPos == 0 && jjmatchedKind > 69)
1941 {
1942 jjmatchedKind = 69;
1943 }
1944 break;
1945 }
1946 if (jjmatchedKind != 0x7fffffff)
1947 {
1948 if (jjmatchedPos + 1 < curPos)
1949 input_stream.backup(curPos - jjmatchedPos - 1);
1950 if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
1951 {
1952 matchedToken = jjFillToken();
1953 matchedToken.specialToken = specialToken;
1954 TokenLexicalActions(matchedToken);
1955 if (jjnewLexState[jjmatchedKind] != -1)
1956 curLexState = jjnewLexState[jjmatchedKind];
1957 return matchedToken;
1958 }
1959 else if ((jjtoSkip[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
1960 {
1961 if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
1962 {
1963 matchedToken = jjFillToken();
1964 if (specialToken == null)
1965 specialToken = matchedToken;
1966 else
1967 {
1968 matchedToken.specialToken = specialToken;
1969 specialToken = (specialToken.next = matchedToken);
1970 }
1971 SkipLexicalActions(matchedToken);
1972 }
1973 else
1974 SkipLexicalActions(null);
1975 if (jjnewLexState[jjmatchedKind] != -1)
1976 curLexState = jjnewLexState[jjmatchedKind];
1977 continue EOFLoop;
1978 }
1979 MoreLexicalActions();
1980 if (jjnewLexState[jjmatchedKind] != -1)
1981 curLexState = jjnewLexState[jjmatchedKind];
1982 curPos = 0;
1983 jjmatchedKind = 0x7fffffff;
1984 try {
1985 curChar = input_stream.readChar();
1986 continue;
1987 }
1988 catch (java.io.IOException e1) { }
1989 }
1990 int error_line = input_stream.getEndLine();
1991 int error_column = input_stream.getEndColumn();
1992 String error_after = null;
1993 boolean EOFSeen = false;
1994 try { input_stream.readChar(); input_stream.backup(1); }
1995 catch (java.io.IOException e1) {
1996 EOFSeen = true;
1997 error_after = curPos <= 1 ? "" : input_stream.GetImage();
1998 if (curChar == '\n' || curChar == '\r') {
1999 error_line++;
2000 error_column = 0;
2001 }
2002 else
2003 error_column++;
2004 }
2005 if (!EOFSeen) {
2006 input_stream.backup(1);
2007 error_after = curPos <= 1 ? "" : input_stream.GetImage();
2008 }
2009 throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
2010 }
2011 }
2012 }
2013
2014 void SkipLexicalActions(Token matchedToken)
2015 {
2016 switch(jjmatchedKind)
2017 {
2018 default :
2019 break;
2020 }
2021 }
2022 void MoreLexicalActions()
2023 {
2024 jjimageLen += (lengthOfMatch = jjmatchedPos + 1);
2025 switch(jjmatchedKind)
2026 {
2027 case 37 :
2028 if (image == null)
2029 image = new StringBuffer();
2030 image.append(input_stream.GetSuffix(jjimageLen));
2031 jjimageLen = 0;
2032 image.setLength(image.length() - 2); image.append("\n");
2033 break;
2034 case 38 :
2035 if (image == null)
2036 image = new StringBuffer();
2037 image.append(input_stream.GetSuffix(jjimageLen));
2038 jjimageLen = 0;
2039 image.setLength(image.length() - 2); image.append("\r");
2040 break;
2041 case 39 :
2042 if (image == null)
2043 image = new StringBuffer();
2044 image.append(input_stream.GetSuffix(jjimageLen));
2045 jjimageLen = 0;
2046 image.setLength(image.length() - 2); image.append("\t");
2047 break;
2048 case 40 :
2049 if (image == null)
2050 image = new StringBuffer();
2051 image.append(input_stream.GetSuffix(jjimageLen));
2052 jjimageLen = 0;
2053 image.setLength(image.length() - 2); image.append("\b");
2054 break;
2055 case 41 :
2056 if (image == null)
2057 image = new StringBuffer();
2058 image.append(input_stream.GetSuffix(jjimageLen));
2059 jjimageLen = 0;
2060 image.setLength(image.length() - 2); image.append("\f");
2061 break;
2062 case 42 :
2063 if (image == null)
2064 image = new StringBuffer();
2065 image.append(input_stream.GetSuffix(jjimageLen));
2066 jjimageLen = 0;
2067 image.setLength(image.length() - 2); image.append("\"");
2068 break;
2069 case 43 :
2070 if (image == null)
2071 image = new StringBuffer();
2072 image.append(input_stream.GetSuffix(jjimageLen));
2073 jjimageLen = 0;
2074 image.setLength(image.length() - 2); image.append("\'");
2075 break;
2076 case 44 :
2077 if (image == null)
2078 image = new StringBuffer();
2079 image.append(input_stream.GetSuffix(jjimageLen));
2080 jjimageLen = 0;
2081 image.setLength(image.length() - 2); image.append("\\");
2082 break;
2083 case 45 :
2084 if (image == null)
2085 image = new StringBuffer();
2086 image.append(input_stream.GetSuffix(jjimageLen));
2087 jjimageLen = 0;
2088 String digits = image.substring(image.length() - 4, image.length());
2089 image.setLength(image.length() - 6);
2090 image.append((char)Integer.parseInt(digits, 16));
2091 break;
2092 default :
2093 break;
2094 }
2095 }
2096 void TokenLexicalActions(Token matchedToken)
2097 {
2098 switch(jjmatchedKind)
2099 {
2100 case 47 :
2101 if (image == null)
2102 image = new StringBuffer();
2103 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
2104 // image.setLength(image.length() - 1);
2105 matchedToken.image = image.toString();
2106 break;
2107 default :
2108 break;
2109 }
2110 }
2111 }
|