1 2 package org.apache.taglibs.standard.extra.spath; 3 4 public class SPathParserTokenManager implements SPathParserConstants 5 { 6 private final int jjStopStringLiteralDfa_0(int pos, long active0) 7 { 8 switch (pos) 9 { 10 default : 11 return -1; 12 } 13 } 14 private final int jjStartNfa_0(int pos, long active0) 15 { 16 return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1); 17 } 18 private final int jjStopAtPos(int pos, int kind) 19 { 20 jjmatchedKind = kind; 21 jjmatchedPos = pos; 22 return pos + 1; 23 } 24 private final int jjStartNfaWithStates_0(int pos, int kind, int state) 25 { 26 jjmatchedKind = kind; 27 jjmatchedPos = pos; 28 try { curChar = input_stream.readChar(); } 29 catch(java.io.IOException e) { return pos + 1; } 30 return jjMoveNfa_0(state, pos + 1); 31 } 32 private final int jjMoveStringLiteralDfa0_0() 33 { 34 switch(curChar) 35 { 36 case 42: 37 return jjStopAtPos(0, 14); 38 case 47: 39 return jjStopAtPos(0, 13); 40 case 58: 41 return jjStopAtPos(0, 15); 42 case 61: 43 return jjStopAtPos(0, 19); 44 case 64: 45 return jjStopAtPos(0, 18); 46 case 91: 47 return jjStopAtPos(0, 16); 48 case 93: 49 return jjStopAtPos(0, 17); 50 default : 51 return jjMoveNfa_0(0, 0); 52 } 53 } 54 private final void jjCheckNAdd(int state) 55 { 56 if (jjrounds[state] != jjround) 57 { 58 jjstateSet[jjnewStateCnt++] = state; 59 jjrounds[state] = jjround; 60 } 61 } 62 private final void jjAddStates(int start, int end) 63 { 64 do { 65 jjstateSet[jjnewStateCnt++] = jjnextStates[start]; 66 } while (start++ != end); 67 } 68 private final void jjCheckNAddTwoStates(int state1, int state2) 69 { 70 jjCheckNAdd(state1); 71 jjCheckNAdd(state2); 72 } 73 private final void jjCheckNAddStates(int start, int end) 74 { 75 do { 76 jjCheckNAdd(jjnextStates[start]); 77 } while (start++ != end); 78 } 79 private final void jjCheckNAddStates(int start) 80 { 81 jjCheckNAdd(jjnextStates[start]); 82 jjCheckNAdd(jjnextStates[start + 1]); 83 } 84 static final long[] jjbitVec0 = { 85 0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL 86 }; 87 static final long[] jjbitVec2 = { 88 0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL 89 }; 90 static final long[] jjbitVec3 = { 91 0x0L, 0xffffffffffffc000L, 0xfffff0007fffffffL, 0x7fffffL 92 }; 93 static final long[] jjbitVec4 = { 94 0x0L, 0x0L, 0x0L, 0xff7fffffff7fffffL 95 }; 96 static final long[] jjbitVec5 = { 97 0x7ff3ffffffffffffL, 0x7ffffffffffffdfeL, 0xffffffffffffffffL, 0xfc31ffffffffe00fL 98 }; 99 static final long[] jjbitVec6 = { 100 0xffffffL, 0xffffffffffff0000L, 0xf80001ffffffffffL, 0x3L 101 }; 102 static final long[] jjbitVec7 = { 103 0x0L, 0x0L, 0xfffffffbffffd740L, 0xffffd547f7fffL 104 }; 105 static final long[] jjbitVec8 = { 106 0xffffffffffffdffeL, 0xffffffffdffeffffL, 0xffffffffffff0003L, 0x33fcfffffff199fL 107 }; 108 static final long[] jjbitVec9 = { 109 0xfffe000000000000L, 0xfffffffe027fffffL, 0x7fL, 0x707ffffff0000L 110 }; 111 static final long[] jjbitVec10 = { 112 0x7fffffe00000000L, 0xfffe0000000007feL, 0x7cffffffffffffffL, 0x60002f7fffL 113 }; 114 static final long[] jjbitVec11 = { 115 0x23ffffffffffffe0L, 0x3ff000000L, 0x3c5fdfffff99fe0L, 0x30003b0000000L 116 }; 117 static final long[] jjbitVec12 = { 118 0x36dfdfffff987e0L, 0x1c00005e000000L, 0x23edfdfffffbafe0L, 0x100000000L 119 }; 120 static final long[] jjbitVec13 = { 121 0x23cdfdfffff99fe0L, 0x3b0000000L, 0x3bfc718d63dc7e0L, 0x0L 122 }; 123 static final long[] jjbitVec14 = { 124 0x3effdfffffddfe0L, 0x300000000L, 0x3effdfffffddfe0L, 0x340000000L 125 }; 126 static final long[] jjbitVec15 = { 127 0x3fffdfffffddfe0L, 0x300000000L, 0x0L, 0x0L 128 }; 129 static final long[] jjbitVec16 = { 130 0xd7ffffffffffeL, 0x3fL, 0x200d6caefef02596L, 0x1fL 131 }; 132 static final long[] jjbitVec17 = { 133 0x0L, 0x3fffffffeffL, 0x0L, 0x0L 134 }; 135 static final long[] jjbitVec18 = { 136 0x0L, 0x0L, 0xffffffff00000000L, 0x7fffffffff003fL 137 }; 138 static final long[] jjbitVec19 = { 139 0x500000000007daedL, 0x2c62ab82315001L, 0xf580c90040000000L, 0x201080000000007L 140 }; 141 static final long[] jjbitVec20 = { 142 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffff0fffffffL, 0x3ffffffffffffffL 143 }; 144 static final long[] jjbitVec21 = { 145 0xffffffff3f3fffffL, 0x3fffffffaaff3f3fL, 0x5fdfffffffffffffL, 0x1fdc1fff0fcf1fdcL 146 }; 147 static final long[] jjbitVec22 = { 148 0x4c4000000000L, 0x0L, 0x7L, 0x0L 149 }; 150 static final long[] jjbitVec23 = { 151 0x3fe00000080L, 0xfffffffffffffffeL, 0xfffffffe001fffffL, 0x7ffffffffffffffL 152 }; 153 static final long[] jjbitVec24 = { 154 0x1fffffffffe0L, 0x0L, 0x0L, 0x0L 155 }; 156 static final long[] jjbitVec25 = { 157 0xffffffffffffffffL, 0xffffffffffffffffL, 0x3fffffffffL, 0x0L 158 }; 159 static final long[] jjbitVec26 = { 160 0xffffffffffffffffL, 0xffffffffffffffffL, 0xfffffffffL, 0x0L 161 }; 162 static final long[] jjbitVec27 = { 163 0x0L, 0x0L, 0x80000000000000L, 0xff7fffffff7fffffL 164 }; 165 static final long[] jjbitVec28 = { 166 0xffffffL, 0xffffffffffff0000L, 0xf80001ffffffffffL, 0x30003L 167 }; 168 static final long[] jjbitVec29 = { 169 0xffffffffffffffffL, 0x30000003fL, 0xfffffffbffffd7c0L, 0xffffd547f7fffL 170 }; 171 static final long[] jjbitVec30 = { 172 0xffffffffffffdffeL, 0xffffffffdffeffffL, 0xffffffffffff007bL, 0x33fcfffffff199fL 173 }; 174 static final long[] jjbitVec31 = { 175 0xfffe000000000000L, 0xfffffffe027fffffL, 0xbbfffffbfffe007fL, 0x707ffffff0016L 176 }; 177 static final long[] jjbitVec32 = { 178 0x7fffffe00000000L, 0xffff03ff0007ffffL, 0x7cffffffffffffffL, 0x3ff3dffffef7fffL 179 }; 180 static final long[] jjbitVec33 = { 181 0xf3ffffffffffffeeL, 0xffcfff1e3fffL, 0xd3c5fdfffff99feeL, 0x3ffcfb080399fL 182 }; 183 static final long[] jjbitVec34 = { 184 0xd36dfdfffff987e4L, 0x1fffc05e003987L, 0xf3edfdfffffbafeeL, 0xffc100003bbfL 185 }; 186 static final long[] jjbitVec35 = { 187 0xf3cdfdfffff99feeL, 0xffc3b0c0398fL, 0xc3bfc718d63dc7ecL, 0xff8000803dc7L 188 }; 189 static final long[] jjbitVec36 = { 190 0xc3effdfffffddfeeL, 0xffc300603ddfL, 0xc3effdfffffddfecL, 0xffc340603ddfL 191 }; 192 static final long[] jjbitVec37 = { 193 0xc3fffdfffffddfecL, 0xffc300803dcfL, 0x0L, 0x0L 194 }; 195 static final long[] jjbitVec38 = { 196 0x7ff7ffffffffffeL, 0x3ff7fffL, 0x3bff6caefef02596L, 0x3ff3f5fL 197 }; 198 static final long[] jjbitVec39 = { 199 0xc2a003ff03000000L, 0xfffe03fffffffeffL, 0x2fe3ffffebf0fdfL, 0x0L 200 }; 201 static final long[] jjbitVec40 = { 202 0x0L, 0x0L, 0x0L, 0x21fff0000L 203 }; 204 static final long[] jjbitVec41 = { 205 0x3efffe000000a0L, 0xfffffffffffffffeL, 0xfffffffe661fffffL, 0x77ffffffffffffffL 206 }; 207 private final int jjMoveNfa_0(int startState, int curPos) 208 { 209 int[] nextStates; 210 int startsAt = 0; 211 jjnewStateCnt = 19; 212 int i = 1; 213 jjstateSet[0] = startState; 214 int j, kind = 0x7fffffff; 215 for (;;) 216 { 217 if (++jjround == 0x7fffffff) 218 ReInitRounds(); 219 if (curChar < 64) 220 { 221 long l = 1L << curChar; 222 MatchLoop: do 223 { 224 switch(jjstateSet[--i]) 225 { 226 case 0: 227 if (curChar == 39) 228 jjCheckNAddStates(0, 2); 229 else if (curChar == 34) 230 jjCheckNAddStates(3, 5); 231 break; 232 case 1: 233 if ((0xfffffffbffffffffL & l) != 0L) 234 jjCheckNAddStates(3, 5); 235 break; 236 case 3: 237 if (curChar == 34) 238 jjCheckNAddStates(3, 5); 239 break; 240 case 4: 241 if (curChar == 34 && kind > 1) 242 kind = 1; 243 break; 244 case 5: 245 case 8: 246 if (curChar == 39) 247 jjCheckNAddStates(0, 2); 248 break; 249 case 6: 250 if ((0xffffff7fffffffffL & l) != 0L) 251 jjCheckNAddStates(0, 2); 252 break; 253 case 9: 254 if (curChar == 39 && kind > 1) 255 kind = 1; 256 break; 257 case 11: 258 if ((0x3ff600000000000L & l) != 0L) 259 jjAddStates(6, 7); 260 break; 261 case 12: 262 if (curChar == 58) 263 jjstateSet[jjnewStateCnt++] = 13; 264 break; 265 case 14: 266 if ((0x3ff600000000000L & l) == 0L) 267 break; 268 if (kind > 2) 269 kind = 2; 270 jjstateSet[jjnewStateCnt++] = 14; 271 break; 272 case 15: 273 if ((0x3ff600000000000L & l) == 0L) 274 break; 275 if (kind > 3) 276 kind = 3; 277 jjstateSet[jjnewStateCnt++] = 15; 278 break; 279 case 16: 280 if ((0x3ff600000000000L & l) != 0L) 281 jjAddStates(8, 9); 282 break; 283 case 17: 284 if (curChar == 58) 285 jjstateSet[jjnewStateCnt++] = 18; 286 break; 287 case 18: 288 if (curChar == 42 && kind > 4) 289 kind = 4; 290 break; 291 default : break; 292 } 293 } while(i != startsAt); 294 } 295 else if (curChar < 128) 296 { 297 long l = 1L << (curChar & 077); 298 MatchLoop: do 299 { 300 switch(jjstateSet[--i]) 301 { 302 case 0: 303 if ((0x7fffffe87fffffeL & l) == 0L) 304 break; 305 if (kind > 2) 306 kind = 2; 307 jjCheckNAddStates(10, 15); 308 break; 309 case 1: 310 if ((0xffffffffefffffffL & l) != 0L) 311 jjCheckNAddStates(3, 5); 312 break; 313 case 2: 314 if (curChar == 92) 315 jjstateSet[jjnewStateCnt++] = 3; 316 break; 317 case 3: 318 if (curChar == 92) 319 jjCheckNAddStates(3, 5); 320 break; 321 case 6: 322 if ((0xffffffffefffffffL & l) != 0L) 323 jjCheckNAddStates(0, 2); 324 break; 325 case 7: 326 if (curChar == 92) 327 jjstateSet[jjnewStateCnt++] = 8; 328 break; 329 case 8: 330 if (curChar == 92) 331 jjCheckNAddStates(0, 2); 332 break; 333 case 11: 334 if ((0x7fffffe87fffffeL & l) != 0L) 335 jjCheckNAddTwoStates(11, 12); 336 break; 337 case 13: 338 case 14: 339 if ((0x7fffffe87fffffeL & l) == 0L) 340 break; 341 if (kind > 2) 342 kind = 2; 343 jjCheckNAdd(14); 344 break; 345 case 15: 346 if ((0x7fffffe87fffffeL & l) == 0L) 347 break; 348 if (kind > 3) 349 kind = 3; 350 jjCheckNAdd(15); 351 break; 352 case 16: 353 if ((0x7fffffe87fffffeL & l) != 0L) 354 jjCheckNAddTwoStates(16, 17); 355 break; 356 default : break; 357 } 358 } while(i != startsAt); 359 } 360 else 361 { 362 int hiByte = (int)(curChar >> 8); 363 int i1 = hiByte >> 6; 364 long l1 = 1L << (hiByte & 077); 365 int i2 = (curChar & 0xff) >> 6; 366 long l2 = 1L << (curChar & 077); 367 MatchLoop: do 368 { 369 switch(jjstateSet[--i]) 370 { 371 case 0: 372 if (!jjCanMove_1(hiByte, i1, i2, l1, l2)) 373 break; 374 if (kind > 2) 375 kind = 2; 376 jjCheckNAddStates(10, 15); 377 break; 378 case 1: 379 if (jjCanMove_0(hiByte, i1, i2, l1, l2)) 380 jjAddStates(3, 5); 381 break; 382 case 6: 383 if (jjCanMove_0(hiByte, i1, i2, l1, l2)) 384 jjAddStates(0, 2); 385 break; 386 case 11: 387 if (jjCanMove_2(hiByte, i1, i2, l1, l2)) 388 jjCheckNAddTwoStates(11, 12); 389 break; 390 case 13: 391 if (!jjCanMove_1(hiByte, i1, i2, l1, l2)) 392 break; 393 if (kind > 2) 394 kind = 2; 395 jjCheckNAdd(14); 396 break; 397 case 14: 398 if (!jjCanMove_2(hiByte, i1, i2, l1, l2)) 399 break; 400 if (kind > 2) 401 kind = 2; 402 jjCheckNAdd(14); 403 break; 404 case 15: 405 if (!jjCanMove_2(hiByte, i1, i2, l1, l2)) 406 break; 407 if (kind > 3) 408 kind = 3; 409 jjCheckNAdd(15); 410 break; 411 case 16: 412 if (jjCanMove_2(hiByte, i1, i2, l1, l2)) 413 jjCheckNAddTwoStates(16, 17); 414 break; 415 default : break; 416 } 417 } while(i != startsAt); 418 } 419 if (kind != 0x7fffffff) 420 { 421 jjmatchedKind = kind; 422 jjmatchedPos = curPos; 423 kind = 0x7fffffff; 424 } 425 ++curPos; 426 if ((i = jjnewStateCnt) == (startsAt = 19 - (jjnewStateCnt = startsAt))) 427 return curPos; 428 try { curChar = input_stream.readChar(); } 429 catch(java.io.IOException e) { return curPos; } 430 } 431 } 432 static final int[] jjnextStates = { 433 6, 7, 9, 1, 2, 4, 11, 12, 16, 17, 11, 12, 14, 15, 16, 17, 434 }; 435 private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2) 436 { 437 switch(hiByte) 438 { 439 case 0: 440 return ((jjbitVec2[i2] & l2) != 0L); 441 default : 442 if ((jjbitVec0[i1] & l1) != 0L) 443 return true; 444 return false; 445 } 446 } 447 private static final boolean jjCanMove_1(int hiByte, int i1, int i2, long l1, long l2) 448 { 449 switch(hiByte) 450 { 451 case 0: 452 return ((jjbitVec4[i2] & l2) != 0L); 453 case 1: 454 return ((jjbitVec5[i2] & l2) != 0L); 455 case 2: 456 return ((jjbitVec6[i2] & l2) != 0L); 457 case 3: 458 return ((jjbitVec7[i2] & l2) != 0L); 459 case 4: 460 return ((jjbitVec8[i2] & l2) != 0L); 461 case 5: 462 return ((jjbitVec9[i2] & l2) != 0L); 463 case 6: 464 return ((jjbitVec10[i2] & l2) != 0L); 465 case 9: 466 return ((jjbitVec11[i2] & l2) != 0L); 467 case 10: 468 return ((jjbitVec12[i2] & l2) != 0L); 469 case 11: 470 return ((jjbitVec13[i2] & l2) != 0L); 471 case 12: 472 return ((jjbitVec14[i2] & l2) != 0L); 473 case 13: 474 return ((jjbitVec15[i2] & l2) != 0L); 475 case 14: 476 return ((jjbitVec16[i2] & l2) != 0L); 477 case 15: 478 return ((jjbitVec17[i2] & l2) != 0L); 479 case 16: 480 return ((jjbitVec18[i2] & l2) != 0L); 481 case 17: 482 return ((jjbitVec19[i2] & l2) != 0L); 483 case 30: 484 return ((jjbitVec20[i2] & l2) != 0L); 485 case 31: 486 return ((jjbitVec21[i2] & l2) != 0L); 487 case 33: 488 return ((jjbitVec22[i2] & l2) != 0L); 489 case 48: 490 return ((jjbitVec23[i2] & l2) != 0L); 491 case 49: 492 return ((jjbitVec24[i2] & l2) != 0L); 493 case 159: 494 return ((jjbitVec25[i2] & l2) != 0L); 495 case 215: 496 return ((jjbitVec26[i2] & l2) != 0L); 497 default : 498 if ((jjbitVec3[i1] & l1) != 0L) 499 return true; 500 return false; 501 } 502 } 503 private static final boolean jjCanMove_2(int hiByte, int i1, int i2, long l1, long l2) 504 { 505 switch(hiByte) 506 { 507 case 0: 508 return ((jjbitVec27[i2] & l2) != 0L); 509 case 1: 510 return ((jjbitVec5[i2] & l2) != 0L); 511 case 2: 512 return ((jjbitVec28[i2] & l2) != 0L); 513 case 3: 514 return ((jjbitVec29[i2] & l2) != 0L); 515 case 4: 516 return ((jjbitVec30[i2] & l2) != 0L); 517 case 5: 518 return ((jjbitVec31[i2] & l2) != 0L); 519 case 6: 520 return ((jjbitVec32[i2] & l2) != 0L); 521 case 9: 522 return ((jjbitVec33[i2] & l2) != 0L); 523 case 10: 524 return ((jjbitVec34[i2] & l2) != 0L); 525 case 11: 526 return ((jjbitVec35[i2] & l2) != 0L); 527 case 12: 528 return ((jjbitVec36[i2] & l2) != 0L); 529 case 13: 530 return ((jjbitVec37[i2] & l2) != 0L); 531 case 14: 532 return ((jjbitVec38[i2] & l2) != 0L); 533 case 15: 534 return ((jjbitVec39[i2] & l2) != 0L); 535 case 16: 536 return ((jjbitVec18[i2] & l2) != 0L); 537 case 17: 538 return ((jjbitVec19[i2] & l2) != 0L); 539 case 30: 540 return ((jjbitVec20[i2] & l2) != 0L); 541 case 31: 542 return ((jjbitVec21[i2] & l2) != 0L); 543 case 32: 544 return ((jjbitVec40[i2] & l2) != 0L); 545 case 33: 546 return ((jjbitVec22[i2] & l2) != 0L); 547 case 48: 548 return ((jjbitVec41[i2] & l2) != 0L); 549 case 49: 550 return ((jjbitVec24[i2] & l2) != 0L); 551 case 159: 552 return ((jjbitVec25[i2] & l2) != 0L); 553 case 215: 554 return ((jjbitVec26[i2] & l2) != 0L); 555 default : 556 if ((jjbitVec3[i1] & l1) != 0L) 557 return true; 558 return false; 559 } 560 } 561 public static final String [] jjstrLiteralImages = { 562 "", null, null, null, null, null, null, null, null, null, null, null, null, 563 "\57", "\52", "\72", "\133", "\135", "\100", "\75", }; 564 public static final String [] lexStateNames = { 565 "DEFAULT", 566 }; 567 private ASCII_UCodeESC_CharStream input_stream; 568 private final int[] jjrounds = new int[19]; 569 private final int[] jjstateSet = new int[38]; 570 protected char curChar; 571 public SPathParserTokenManager(ASCII_UCodeESC_CharStream stream) 572 { 573 if (ASCII_UCodeESC_CharStream.staticFlag) 574 throw new Error ("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer."); 575 input_stream = stream; 576 } 577 public SPathParserTokenManager(ASCII_UCodeESC_CharStream stream, int lexState) 578 { 579 this(stream); 580 SwitchTo(lexState); 581 } 582 public void ReInit(ASCII_UCodeESC_CharStream stream) 583 { 584 jjmatchedPos = jjnewStateCnt = 0; 585 curLexState = defaultLexState; 586 input_stream = stream; 587 ReInitRounds(); 588 } 589 private final void ReInitRounds() 590 { 591 int i; 592 jjround = 0x80000001; 593 for (i = 19; i-- > 0;) 594 jjrounds[i] = 0x80000000; 595 } 596 public void ReInit(ASCII_UCodeESC_CharStream stream, int lexState) 597 { 598 ReInit(stream); 599 SwitchTo(lexState); 600 } 601 public void SwitchTo(int lexState) 602 { 603 if (lexState >= 1 || lexState < 0) 604 throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE); 605 else 606 curLexState = lexState; 607 } 608 609 private final Token jjFillToken() 610 { 611 Token t = Token.newToken(jjmatchedKind); 612 t.kind = jjmatchedKind; 613 String im = jjstrLiteralImages[jjmatchedKind]; 614 t.image = (im == null) ? input_stream.GetImage() : im; 615 t.beginLine = input_stream.getBeginLine(); 616 t.beginColumn = input_stream.getBeginColumn(); 617 t.endLine = input_stream.getEndLine(); 618 t.endColumn = input_stream.getEndColumn(); 619 return t; 620 } 621 622 int curLexState = 0; 623 int defaultLexState = 0; 624 int jjnewStateCnt; 625 int jjround; 626 int jjmatchedPos; 627 int jjmatchedKind; 628 629 public final Token getNextToken() 630 { 631 int kind; 632 Token specialToken = null; 633 Token matchedToken; 634 int curPos = 0; 635 636 EOFLoop : 637 for (;;) 638 { 639 try 640 { 641 curChar = input_stream.BeginToken(); 642 } 643 catch(java.io.IOException e) 644 { 645 jjmatchedKind = 0; 646 matchedToken = jjFillToken(); 647 return matchedToken; 648 } 649 650 jjmatchedKind = 0x7fffffff; 651 jjmatchedPos = 0; 652 curPos = jjMoveStringLiteralDfa0_0(); 653 if (jjmatchedKind != 0x7fffffff) 654 { 655 if (jjmatchedPos + 1 < curPos) 656 input_stream.backup(curPos - jjmatchedPos - 1); 657 matchedToken = jjFillToken(); 658 return matchedToken; 659 } 660 int error_line = input_stream.getEndLine(); 661 int error_column = input_stream.getEndColumn(); 662 String error_after = null; 663 boolean EOFSeen = false; 664 try { input_stream.readChar(); input_stream.backup(1); } 665 catch (java.io.IOException e1) { 666 EOFSeen = true; 667 error_after = curPos <= 1 ? "" : input_stream.GetImage(); 668 if (curChar == '\n' || curChar == '\r') { 669 error_line++; 670 error_column = 0; 671 } 672 else 673 error_column++; 674 } 675 if (!EOFSeen) { 676 input_stream.backup(1); 677 error_after = curPos <= 1 ? "" : input_stream.GetImage(); 678 } 679 throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR); 680 } 681 } 682 683 } 684 | Popular Tags |