001 /* Generated By:JavaCC: Do not edit this line. JavaParserTokenManager.java */ 002 package javancss.parser.java15.debug; 003 004 import java.io.*; 005 006 public class JavaParser15DebugTokenManager implements JavaParser15DebugConstants 007 { 008 public java.io.PrintStream debugStream = System.out; 009 public void setDebugStream(java.io.PrintStream ds) { debugStream = ds; } 010 private final int jjStopStringLiteralDfa_0(int pos, long active0, long active1, long active2) 011 { 012 switch (pos) 013 { 014 case 0: 015 if ((active0 & 0xfffffffffffff000L) != 0L || (active1 & 0x1L) != 0L) 016 { 017 jjmatchedKind = 76; 018 return 28; 019 } 020 if ((active1 & 0x800000000800000L) != 0L) 021 return 4; 022 if ((active0 & 0x80L) != 0L || (active1 & 0x8040000000000L) != 0L) 023 return 47; 024 return -1; 025 case 1: 026 if ((active0 & 0x803000000L) != 0L) 027 return 28; 028 if ((active0 & 0xfffffff7fcfff000L) != 0L || (active1 & 0x1L) != 0L) 029 { 030 if (jjmatchedPos != 1) 031 { 032 jjmatchedKind = 76; 033 jjmatchedPos = 1; 034 } 035 return 28; 036 } 037 if ((active0 & 0x80L) != 0L) 038 return 45; 039 return -1; 040 case 2: 041 if ((active0 & 0x2000098200000000L) != 0L) 042 return 28; 043 if ((active0 & 0xdffff675fefff000L) != 0L || (active1 & 0x1L) != 0L) 044 { 045 if (jjmatchedPos != 2) 046 { 047 jjmatchedKind = 76; 048 jjmatchedPos = 2; 049 } 050 return 28; 051 } 052 return -1; 053 case 3: 054 if ((active0 & 0x510012040c0b0000L) != 0L) 055 return 28; 056 if ((active0 & 0x8effe571f2f4f000L) != 0L || (active1 & 0x1L) != 0L) 057 { 058 jjmatchedKind = 76; 059 jjmatchedPos = 3; 060 return 28; 061 } 062 return -1; 063 case 4: 064 if ((active0 & 0x6240001e0348000L) != 0L || (active1 & 0x1L) != 0L) 065 return 28; 066 if ((active0 & 0x88dbe57012c07000L) != 0L) 067 { 068 if (jjmatchedPos != 4) 069 { 070 jjmatchedKind = 76; 071 jjmatchedPos = 4; 072 } 073 return 28; 074 } 075 return -1; 076 case 5: 077 if ((active0 & 0x44b042002002000L) != 0L) 078 return 28; 079 if ((active0 & 0x8890e15090c05000L) != 0L) 080 { 081 jjmatchedKind = 76; 082 jjmatchedPos = 5; 083 return 28; 084 } 085 return -1; 086 case 6: 087 if ((active0 & 0x600090804000L) != 0L) 088 return 28; 089 if ((active0 & 0x8890815000401000L) != 0L) 090 { 091 jjmatchedKind = 76; 092 jjmatchedPos = 6; 093 return 28; 094 } 095 return -1; 096 case 7: 097 if ((active0 & 0x880815000000000L) != 0L) 098 { 099 jjmatchedKind = 76; 100 jjmatchedPos = 7; 101 return 28; 102 } 103 if ((active0 & 0x8010000000401000L) != 0L) 104 return 28; 105 return -1; 106 case 8: 107 if ((active0 & 0x800810000000000L) != 0L) 108 return 28; 109 if ((active0 & 0x80005000000000L) != 0L) 110 { 111 jjmatchedKind = 76; 112 jjmatchedPos = 8; 113 return 28; 114 } 115 return -1; 116 case 9: 117 if ((active0 & 0x5000000000L) != 0L) 118 return 28; 119 if ((active0 & 0x80000000000000L) != 0L) 120 { 121 jjmatchedKind = 76; 122 jjmatchedPos = 9; 123 return 28; 124 } 125 return -1; 126 case 10: 127 if ((active0 & 0x80000000000000L) != 0L) 128 { 129 jjmatchedKind = 76; 130 jjmatchedPos = 10; 131 return 28; 132 } 133 return -1; 134 default : 135 return -1; 136 } 137 } 138 private final int jjStartNfa_0(int pos, long active0, long active1, long active2) 139 { 140 return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0, active1, active2), pos + 1); 141 } 142 private final int jjStopAtPos(int pos, int kind) 143 { 144 jjmatchedKind = kind; 145 jjmatchedPos = pos; 146 return pos + 1; 147 } 148 private final int jjStartNfaWithStates_0(int pos, int kind, int state) 149 { 150 jjmatchedKind = kind; 151 jjmatchedPos = pos; 152 try { curChar = input_stream.readChar(); } 153 catch(java.io.IOException e) { return pos + 1; } 154 return jjMoveNfa_0(state, pos + 1); 155 } 156 private final int jjMoveStringLiteralDfa0_0() 157 { 158 switch(curChar) 159 { 160 case 26: 161 return jjStopAtPos(0, 127); 162 case 33: 163 jjmatchedKind = 91; 164 return jjMoveStringLiteralDfa1_0(0x0L, 0x400000000L); 165 case 37: 166 jjmatchedKind = 110; 167 return jjMoveStringLiteralDfa1_0(0x0L, 0x80000000000000L); 168 case 38: 169 jjmatchedKind = 107; 170 return jjMoveStringLiteralDfa1_0(0x0L, 0x10001000000000L); 171 case 40: 172 return jjStopAtPos(0, 79); 173 case 41: 174 return jjStopAtPos(0, 80); 175 case 42: 176 jjmatchedKind = 105; 177 return jjMoveStringLiteralDfa1_0(0x0L, 0x4000000000000L); 178 case 43: 179 jjmatchedKind = 103; 180 return jjMoveStringLiteralDfa1_0(0x0L, 0x1002000000000L); 181 case 44: 182 return jjStopAtPos(0, 86); 183 case 45: 184 jjmatchedKind = 104; 185 return jjMoveStringLiteralDfa1_0(0x0L, 0x2004000000000L); 186 case 46: 187 jjmatchedKind = 87; 188 return jjMoveStringLiteralDfa1_0(0x0L, 0x800000000000000L); 189 case 47: 190 jjmatchedKind = 106; 191 return jjMoveStringLiteralDfa1_0(0x80L, 0x8000000000000L); 192 case 58: 193 return jjStopAtPos(0, 94); 194 case 59: 195 return jjStopAtPos(0, 85); 196 case 60: 197 jjmatchedKind = 90; 198 return jjMoveStringLiteralDfa1_0(0x0L, 0x100800100000000L); 199 case 61: 200 jjmatchedKind = 89; 201 return jjMoveStringLiteralDfa1_0(0x0L, 0x80000000L); 202 case 62: 203 jjmatchedKind = 126; 204 return jjMoveStringLiteralDfa1_0(0x0L, 0x3600000200000000L); 205 case 63: 206 return jjStopAtPos(0, 93); 207 case 64: 208 return jjStopAtPos(0, 88); 209 case 91: 210 return jjStopAtPos(0, 83); 211 case 93: 212 return jjStopAtPos(0, 84); 213 case 94: 214 jjmatchedKind = 109; 215 return jjMoveStringLiteralDfa1_0(0x0L, 0x40000000000000L); 216 case 97: 217 return jjMoveStringLiteralDfa1_0(0x3000L, 0x0L); 218 case 98: 219 return jjMoveStringLiteralDfa1_0(0x1c000L, 0x0L); 220 case 99: 221 return jjMoveStringLiteralDfa1_0(0x7e0000L, 0x0L); 222 case 100: 223 return jjMoveStringLiteralDfa1_0(0x3800000L, 0x0L); 224 case 101: 225 return jjMoveStringLiteralDfa1_0(0x1c000000L, 0x0L); 226 case 102: 227 return jjMoveStringLiteralDfa1_0(0x3e0000000L, 0x0L); 228 case 103: 229 return jjMoveStringLiteralDfa1_0(0x400000000L, 0x0L); 230 case 105: 231 return jjMoveStringLiteralDfa1_0(0x1f800000000L, 0x0L); 232 case 108: 233 return jjMoveStringLiteralDfa1_0(0x20000000000L, 0x0L); 234 case 110: 235 return jjMoveStringLiteralDfa1_0(0x1c0000000000L, 0x0L); 236 case 112: 237 return jjMoveStringLiteralDfa1_0(0x1e00000000000L, 0x0L); 238 case 114: 239 return jjMoveStringLiteralDfa1_0(0x2000000000000L, 0x0L); 240 case 115: 241 return jjMoveStringLiteralDfa1_0(0xfc000000000000L, 0x0L); 242 case 116: 243 return jjMoveStringLiteralDfa1_0(0x3f00000000000000L, 0x0L); 244 case 118: 245 return jjMoveStringLiteralDfa1_0(0xc000000000000000L, 0x0L); 246 case 119: 247 return jjMoveStringLiteralDfa1_0(0x0L, 0x1L); 248 case 123: 249 return jjStopAtPos(0, 81); 250 case 124: 251 jjmatchedKind = 108; 252 return jjMoveStringLiteralDfa1_0(0x0L, 0x20000800000000L); 253 case 125: 254 return jjStopAtPos(0, 82); 255 case 126: 256 return jjStopAtPos(0, 92); 257 default : 258 return jjMoveNfa_0(0, 0); 259 } 260 } 261 private final int jjMoveStringLiteralDfa1_0(long active0, long active1) 262 { 263 try { curChar = input_stream.readChar(); } 264 catch(java.io.IOException e) { 265 jjStopStringLiteralDfa_0(0, active0, active1, 0L); 266 return 1; 267 } 268 switch(curChar) 269 { 270 case 38: 271 if ((active1 & 0x1000000000L) != 0L) 272 return jjStopAtPos(1, 100); 273 break; 274 case 42: 275 if ((active0 & 0x80L) != 0L) 276 return jjStartNfaWithStates_0(1, 7, 45); 277 break; 278 case 43: 279 if ((active1 & 0x2000000000L) != 0L) 280 return jjStopAtPos(1, 101); 281 break; 282 case 45: 283 if ((active1 & 0x4000000000L) != 0L) 284 return jjStopAtPos(1, 102); 285 break; 286 case 46: 287 return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x800000000000000L); 288 case 60: 289 if ((active1 & 0x800000000000L) != 0L) 290 { 291 jjmatchedKind = 111; 292 jjmatchedPos = 1; 293 } 294 return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x100000000000000L); 295 case 61: 296 if ((active1 & 0x80000000L) != 0L) 297 return jjStopAtPos(1, 95); 298 else if ((active1 & 0x100000000L) != 0L) 299 return jjStopAtPos(1, 96); 300 else if ((active1 & 0x200000000L) != 0L) 301 return jjStopAtPos(1, 97); 302 else if ((active1 & 0x400000000L) != 0L) 303 return jjStopAtPos(1, 98); 304 else if ((active1 & 0x1000000000000L) != 0L) 305 return jjStopAtPos(1, 112); 306 else if ((active1 & 0x2000000000000L) != 0L) 307 return jjStopAtPos(1, 113); 308 else if ((active1 & 0x4000000000000L) != 0L) 309 return jjStopAtPos(1, 114); 310 else if ((active1 & 0x8000000000000L) != 0L) 311 return jjStopAtPos(1, 115); 312 else if ((active1 & 0x10000000000000L) != 0L) 313 return jjStopAtPos(1, 116); 314 else if ((active1 & 0x20000000000000L) != 0L) 315 return jjStopAtPos(1, 117); 316 else if ((active1 & 0x40000000000000L) != 0L) 317 return jjStopAtPos(1, 118); 318 else if ((active1 & 0x80000000000000L) != 0L) 319 return jjStopAtPos(1, 119); 320 break; 321 case 62: 322 if ((active1 & 0x2000000000000000L) != 0L) 323 { 324 jjmatchedKind = 125; 325 jjmatchedPos = 1; 326 } 327 return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x1600000000000000L); 328 case 97: 329 return jjMoveStringLiteralDfa2_0(active0, 0x240020060000L, active1, 0L); 330 case 98: 331 return jjMoveStringLiteralDfa2_0(active0, 0x1000L, active1, 0L); 332 case 101: 333 return jjMoveStringLiteralDfa2_0(active0, 0x2080000800000L, active1, 0L); 334 case 102: 335 if ((active0 & 0x800000000L) != 0L) 336 return jjStartNfaWithStates_0(1, 35, 28); 337 break; 338 case 104: 339 return jjMoveStringLiteralDfa2_0(active0, 0x704000000080000L, active1, 0x1L); 340 case 105: 341 return jjMoveStringLiteralDfa2_0(active0, 0xc0000000L, active1, 0L); 342 case 108: 343 return jjMoveStringLiteralDfa2_0(active0, 0x104100000L, active1, 0L); 344 case 109: 345 return jjMoveStringLiteralDfa2_0(active0, 0x3000000000L, active1, 0L); 346 case 110: 347 return jjMoveStringLiteralDfa2_0(active0, 0x1c008000000L, active1, 0L); 348 case 111: 349 if ((active0 & 0x1000000L) != 0L) 350 { 351 jjmatchedKind = 24; 352 jjmatchedPos = 1; 353 } 354 return jjMoveStringLiteralDfa2_0(active0, 0xc000020602604000L, active1, 0L); 355 case 114: 356 return jjMoveStringLiteralDfa2_0(active0, 0x3800c00000008000L, active1, 0L); 357 case 115: 358 return jjMoveStringLiteralDfa2_0(active0, 0x2000L, active1, 0L); 359 case 116: 360 return jjMoveStringLiteralDfa2_0(active0, 0x18000000000000L, active1, 0L); 361 case 117: 362 return jjMoveStringLiteralDfa2_0(active0, 0x21100000000000L, active1, 0L); 363 case 119: 364 return jjMoveStringLiteralDfa2_0(active0, 0x40000000000000L, active1, 0L); 365 case 120: 366 return jjMoveStringLiteralDfa2_0(active0, 0x10000000L, active1, 0L); 367 case 121: 368 return jjMoveStringLiteralDfa2_0(active0, 0x80000000010000L, active1, 0L); 369 case 124: 370 if ((active1 & 0x800000000L) != 0L) 371 return jjStopAtPos(1, 99); 372 break; 373 default : 374 break; 375 } 376 return jjStartNfa_0(0, active0, active1, 0L); 377 } 378 private final int jjMoveStringLiteralDfa2_0(long old0, long active0, long old1, long active1) 379 { 380 if (((active0 &= old0) | (active1 &= old1)) == 0L) 381 return jjStartNfa_0(0, old0, old1, 0L); 382 try { curChar = input_stream.readChar(); } 383 catch(java.io.IOException e) { 384 jjStopStringLiteralDfa_0(1, active0, active1, 0L); 385 return 2; 386 } 387 switch(curChar) 388 { 389 case 46: 390 if ((active1 & 0x800000000000000L) != 0L) 391 return jjStopAtPos(2, 123); 392 break; 393 case 61: 394 if ((active1 & 0x100000000000000L) != 0L) 395 return jjStopAtPos(2, 120); 396 else if ((active1 & 0x200000000000000L) != 0L) 397 return jjStopAtPos(2, 121); 398 break; 399 case 62: 400 if ((active1 & 0x1000000000000000L) != 0L) 401 { 402 jjmatchedKind = 124; 403 jjmatchedPos = 2; 404 } 405 return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x400000000000000L); 406 case 97: 407 return jjMoveStringLiteralDfa3_0(active0, 0x808000000180000L, active1, 0L); 408 case 98: 409 return jjMoveStringLiteralDfa3_0(active0, 0x1000000000000L, active1, 0L); 410 case 99: 411 return jjMoveStringLiteralDfa3_0(active0, 0x200000000000L, active1, 0L); 412 case 101: 413 return jjMoveStringLiteralDfa3_0(active0, 0x8000L, active1, 0L); 414 case 102: 415 return jjMoveStringLiteralDfa3_0(active0, 0x800000L, active1, 0L); 416 case 105: 417 return jjMoveStringLiteralDfa3_0(active0, 0x4140400000000000L, active1, 0x1L); 418 case 108: 419 return jjMoveStringLiteralDfa3_0(active0, 0x8000100020000000L, active1, 0L); 420 case 110: 421 return jjMoveStringLiteralDfa3_0(active0, 0x800200c0600000L, active1, 0L); 422 case 111: 423 return jjMoveStringLiteralDfa3_0(active0, 0x4800100004000L, active1, 0L); 424 case 112: 425 return jjMoveStringLiteralDfa3_0(active0, 0x20003000000000L, active1, 0L); 426 case 114: 427 if ((active0 & 0x200000000L) != 0L) 428 return jjStartNfaWithStates_0(2, 33, 28); 429 return jjMoveStringLiteralDfa3_0(active0, 0x610000000000000L, active1, 0L); 430 case 115: 431 return jjMoveStringLiteralDfa3_0(active0, 0x4004023000L, active1, 0L); 432 case 116: 433 if ((active0 & 0x8000000000L) != 0L) 434 { 435 jjmatchedKind = 39; 436 jjmatchedPos = 2; 437 } 438 return jjMoveStringLiteralDfa3_0(active0, 0x2050410050000L, active1, 0L); 439 case 117: 440 return jjMoveStringLiteralDfa3_0(active0, 0x100000000a000000L, active1, 0L); 441 case 119: 442 if ((active0 & 0x80000000000L) != 0L) 443 return jjStartNfaWithStates_0(2, 43, 28); 444 break; 445 case 121: 446 if ((active0 & 0x2000000000000000L) != 0L) 447 return jjStartNfaWithStates_0(2, 61, 28); 448 break; 449 default : 450 break; 451 } 452 return jjStartNfa_0(1, active0, active1, 0L); 453 } 454 private final int jjMoveStringLiteralDfa3_0(long old0, long active0, long old1, long active1) 455 { 456 if (((active0 &= old0) | (active1 &= old1)) == 0L) 457 return jjStartNfa_0(1, old0, old1, 0L); 458 try { curChar = input_stream.readChar(); } 459 catch(java.io.IOException e) { 460 jjStopStringLiteralDfa_0(2, active0, active1, 0L); 461 return 3; 462 } 463 switch(curChar) 464 { 465 case 61: 466 if ((active1 & 0x400000000000000L) != 0L) 467 return jjStopAtPos(3, 122); 468 break; 469 case 97: 470 return jjMoveStringLiteralDfa4_0(active0, 0x80000001c0808000L, active1, 0L); 471 case 98: 472 return jjMoveStringLiteralDfa4_0(active0, 0x2000000L, active1, 0L); 473 case 99: 474 return jjMoveStringLiteralDfa4_0(active0, 0x80000000040000L, active1, 0L); 475 case 100: 476 if ((active0 & 0x4000000000000000L) != 0L) 477 return jjStartNfaWithStates_0(3, 62, 28); 478 break; 479 case 101: 480 if ((active0 & 0x10000L) != 0L) 481 return jjStartNfaWithStates_0(3, 16, 28); 482 else if ((active0 & 0x20000L) != 0L) 483 return jjStartNfaWithStates_0(3, 17, 28); 484 else if ((active0 & 0x4000000L) != 0L) 485 return jjStartNfaWithStates_0(3, 26, 28); 486 else if ((active0 & 0x1000000000000000L) != 0L) 487 return jjStartNfaWithStates_0(3, 60, 28); 488 return jjMoveStringLiteralDfa4_0(active0, 0x20010010002000L, active1, 0L); 489 case 103: 490 if ((active0 & 0x20000000000L) != 0L) 491 return jjStartNfaWithStates_0(3, 41, 28); 492 break; 493 case 105: 494 return jjMoveStringLiteralDfa4_0(active0, 0x10040000000000L, active1, 0L); 495 case 107: 496 return jjMoveStringLiteralDfa4_0(active0, 0x200000000000L, active1, 0L); 497 case 108: 498 if ((active0 & 0x100000000000L) != 0L) 499 return jjStartNfaWithStates_0(3, 44, 28); 500 return jjMoveStringLiteralDfa4_0(active0, 0x1001000004000L, active1, 0x1L); 501 case 109: 502 if ((active0 & 0x8000000L) != 0L) 503 return jjStartNfaWithStates_0(3, 27, 28); 504 break; 505 case 110: 506 return jjMoveStringLiteralDfa4_0(active0, 0x800000000000000L, active1, 0L); 507 case 111: 508 if ((active0 & 0x400000000L) != 0L) 509 return jjStartNfaWithStates_0(3, 34, 28); 510 return jjMoveStringLiteralDfa4_0(active0, 0x600002000000000L, active1, 0L); 511 case 114: 512 if ((active0 & 0x80000L) != 0L) 513 return jjStartNfaWithStates_0(3, 19, 28); 514 return jjMoveStringLiteralDfa4_0(active0, 0x4000000000000L, active1, 0L); 515 case 115: 516 if ((active0 & 0x100000000000000L) != 0L) 517 return jjStartNfaWithStates_0(3, 56, 28); 518 return jjMoveStringLiteralDfa4_0(active0, 0x20300000L, active1, 0L); 519 case 116: 520 return jjMoveStringLiteralDfa4_0(active0, 0x48804000401000L, active1, 0L); 521 case 117: 522 return jjMoveStringLiteralDfa4_0(active0, 0x2000000000000L, active1, 0L); 523 case 118: 524 return jjMoveStringLiteralDfa4_0(active0, 0x400000000000L, active1, 0L); 525 default : 526 break; 527 } 528 return jjStartNfa_0(2, active0, active1, 0L); 529 } 530 private final int jjMoveStringLiteralDfa4_0(long old0, long active0, long old1, long active1) 531 { 532 if (((active0 &= old0) | (active1 &= old1)) == 0L) 533 return jjStartNfa_0(2, old0, old1, 0L); 534 try { curChar = input_stream.readChar(); } 535 catch(java.io.IOException e) { 536 jjStopStringLiteralDfa_0(3, active0, active1, 0L); 537 return 4; 538 } 539 switch(curChar) 540 { 541 case 97: 542 return jjMoveStringLiteralDfa5_0(active0, 0x604000000000L, active1, 0L); 543 case 99: 544 return jjMoveStringLiteralDfa5_0(active0, 0x50000000000000L, active1, 0L); 545 case 101: 546 if ((active0 & 0x20000000L) != 0L) 547 return jjStartNfaWithStates_0(4, 29, 28); 548 else if ((active1 & 0x1L) != 0L) 549 return jjStartNfaWithStates_0(4, 64, 28); 550 return jjMoveStringLiteralDfa5_0(active0, 0x801000004000L, active1, 0L); 551 case 104: 552 if ((active0 & 0x40000L) != 0L) 553 return jjStartNfaWithStates_0(4, 18, 28); 554 return jjMoveStringLiteralDfa5_0(active0, 0x80000000000000L, active1, 0L); 555 case 105: 556 return jjMoveStringLiteralDfa5_0(active0, 0x9000000400000L, active1, 0L); 557 case 107: 558 if ((active0 & 0x8000L) != 0L) 559 return jjStartNfaWithStates_0(4, 15, 28); 560 break; 561 case 108: 562 if ((active0 & 0x40000000L) != 0L) 563 { 564 jjmatchedKind = 30; 565 jjmatchedPos = 4; 566 } 567 return jjMoveStringLiteralDfa5_0(active0, 0x82000000L, active1, 0L); 568 case 110: 569 return jjMoveStringLiteralDfa5_0(active0, 0x10000000L, active1, 0L); 570 case 114: 571 if ((active0 & 0x20000000000000L) != 0L) 572 return jjStartNfaWithStates_0(4, 53, 28); 573 return jjMoveStringLiteralDfa5_0(active0, 0x2012000003000L, active1, 0L); 574 case 115: 575 if ((active0 & 0x100000L) != 0L) 576 return jjStartNfaWithStates_0(4, 20, 28); 577 return jjMoveStringLiteralDfa5_0(active0, 0x800000000000000L, active1, 0L); 578 case 116: 579 if ((active0 & 0x200000L) != 0L) 580 return jjStartNfaWithStates_0(4, 21, 28); 581 else if ((active0 & 0x100000000L) != 0L) 582 return jjStartNfaWithStates_0(4, 32, 28); 583 else if ((active0 & 0x4000000000000L) != 0L) 584 return jjStartNfaWithStates_0(4, 50, 28); 585 return jjMoveStringLiteralDfa5_0(active0, 0x8000000000000000L, active1, 0L); 586 case 117: 587 return jjMoveStringLiteralDfa5_0(active0, 0x800000L, active1, 0L); 588 case 118: 589 return jjMoveStringLiteralDfa5_0(active0, 0x40000000000L, active1, 0L); 590 case 119: 591 if ((active0 & 0x200000000000000L) != 0L) 592 { 593 jjmatchedKind = 57; 594 jjmatchedPos = 4; 595 } 596 return jjMoveStringLiteralDfa5_0(active0, 0x400000000000000L, active1, 0L); 597 default : 598 break; 599 } 600 return jjStartNfa_0(3, active0, active1, 0L); 601 } 602 private final int jjMoveStringLiteralDfa5_0(long old0, long active0, long old1, long active1) 603 { 604 if (((active0 &= old0) | (active1 &= old1)) == 0L) 605 return jjStartNfa_0(3, old0, old1, 0L); 606 try { curChar = input_stream.readChar(); } 607 catch(java.io.IOException e) { 608 jjStopStringLiteralDfa_0(4, active0, 0L, 0L); 609 return 5; 610 } 611 switch(curChar) 612 { 613 case 97: 614 return jjMoveStringLiteralDfa6_0(active0, 0x5000L); 615 case 99: 616 if ((active0 & 0x1000000000000L) != 0L) 617 return jjStartNfaWithStates_0(5, 48, 28); 618 else if ((active0 & 0x8000000000000L) != 0L) 619 return jjStartNfaWithStates_0(5, 51, 28); 620 return jjMoveStringLiteralDfa6_0(active0, 0x800000000000L); 621 case 100: 622 return jjMoveStringLiteralDfa6_0(active0, 0x10000000L); 623 case 101: 624 if ((active0 & 0x2000000L) != 0L) 625 return jjStartNfaWithStates_0(5, 25, 28); 626 else if ((active0 & 0x40000000000L) != 0L) 627 return jjStartNfaWithStates_0(5, 42, 28); 628 break; 629 case 102: 630 return jjMoveStringLiteralDfa6_0(active0, 0x10000000000L); 631 case 103: 632 return jjMoveStringLiteralDfa6_0(active0, 0x200000000000L); 633 case 104: 634 if ((active0 & 0x40000000000000L) != 0L) 635 return jjStartNfaWithStates_0(5, 54, 28); 636 break; 637 case 105: 638 return jjMoveStringLiteralDfa6_0(active0, 0x8800000000000000L); 639 case 108: 640 return jjMoveStringLiteralDfa6_0(active0, 0x80800000L); 641 case 109: 642 return jjMoveStringLiteralDfa6_0(active0, 0x1000000000L); 643 case 110: 644 if ((active0 & 0x2000000000000L) != 0L) 645 return jjStartNfaWithStates_0(5, 49, 28); 646 return jjMoveStringLiteralDfa6_0(active0, 0x4000400000L); 647 case 114: 648 return jjMoveStringLiteralDfa6_0(active0, 0x80000000000000L); 649 case 115: 650 if ((active0 & 0x400000000000000L) != 0L) 651 return jjStartNfaWithStates_0(5, 58, 28); 652 break; 653 case 116: 654 if ((active0 & 0x2000L) != 0L) 655 return jjStartNfaWithStates_0(5, 13, 28); 656 else if ((active0 & 0x2000000000L) != 0L) 657 return jjStartNfaWithStates_0(5, 37, 28); 658 return jjMoveStringLiteralDfa6_0(active0, 0x10400000000000L); 659 default : 660 break; 661 } 662 return jjStartNfa_0(4, active0, 0L, 0L); 663 } 664 private final int jjMoveStringLiteralDfa6_0(long old0, long active0) 665 { 666 if (((active0 &= old0)) == 0L) 667 return jjStartNfa_0(4, old0, 0L, 0L); 668 try { curChar = input_stream.readChar(); } 669 catch(java.io.IOException e) { 670 jjStopStringLiteralDfa_0(5, active0, 0L, 0L); 671 return 6; 672 } 673 switch(curChar) 674 { 675 case 97: 676 return jjMoveStringLiteralDfa7_0(active0, 0x10000000000L); 677 case 99: 678 return jjMoveStringLiteralDfa7_0(active0, 0x4000001000L); 679 case 101: 680 if ((active0 & 0x200000000000L) != 0L) 681 return jjStartNfaWithStates_0(6, 45, 28); 682 else if ((active0 & 0x400000000000L) != 0L) 683 return jjStartNfaWithStates_0(6, 46, 28); 684 return jjMoveStringLiteralDfa7_0(active0, 0x800001000000000L); 685 case 102: 686 return jjMoveStringLiteralDfa7_0(active0, 0x10000000000000L); 687 case 108: 688 return jjMoveStringLiteralDfa7_0(active0, 0x8000000000000000L); 689 case 110: 690 if ((active0 & 0x4000L) != 0L) 691 return jjStartNfaWithStates_0(6, 14, 28); 692 break; 693 case 111: 694 return jjMoveStringLiteralDfa7_0(active0, 0x80000000000000L); 695 case 115: 696 if ((active0 & 0x10000000L) != 0L) 697 return jjStartNfaWithStates_0(6, 28, 28); 698 break; 699 case 116: 700 if ((active0 & 0x800000L) != 0L) 701 return jjStartNfaWithStates_0(6, 23, 28); 702 return jjMoveStringLiteralDfa7_0(active0, 0x800000000000L); 703 case 117: 704 return jjMoveStringLiteralDfa7_0(active0, 0x400000L); 705 case 121: 706 if ((active0 & 0x80000000L) != 0L) 707 return jjStartNfaWithStates_0(6, 31, 28); 708 break; 709 default : 710 break; 711 } 712 return jjStartNfa_0(5, active0, 0L, 0L); 713 } 714 private final int jjMoveStringLiteralDfa7_0(long old0, long active0) 715 { 716 if (((active0 &= old0)) == 0L) 717 return jjStartNfa_0(5, old0, 0L, 0L); 718 try { curChar = input_stream.readChar(); } 719 catch(java.io.IOException e) { 720 jjStopStringLiteralDfa_0(6, active0, 0L, 0L); 721 return 7; 722 } 723 switch(curChar) 724 { 725 case 99: 726 return jjMoveStringLiteralDfa8_0(active0, 0x10000000000L); 727 case 101: 728 if ((active0 & 0x400000L) != 0L) 729 return jjStartNfaWithStates_0(7, 22, 28); 730 else if ((active0 & 0x8000000000000000L) != 0L) 731 return jjStartNfaWithStates_0(7, 63, 28); 732 return jjMoveStringLiteralDfa8_0(active0, 0x804000000000L); 733 case 110: 734 return jjMoveStringLiteralDfa8_0(active0, 0x880001000000000L); 735 case 112: 736 if ((active0 & 0x10000000000000L) != 0L) 737 return jjStartNfaWithStates_0(7, 52, 28); 738 break; 739 case 116: 740 if ((active0 & 0x1000L) != 0L) 741 return jjStartNfaWithStates_0(7, 12, 28); 742 break; 743 default : 744 break; 745 } 746 return jjStartNfa_0(6, active0, 0L, 0L); 747 } 748 private final int jjMoveStringLiteralDfa8_0(long old0, long active0) 749 { 750 if (((active0 &= old0)) == 0L) 751 return jjStartNfa_0(6, old0, 0L, 0L); 752 try { curChar = input_stream.readChar(); } 753 catch(java.io.IOException e) { 754 jjStopStringLiteralDfa_0(7, active0, 0L, 0L); 755 return 8; 756 } 757 switch(curChar) 758 { 759 case 100: 760 if ((active0 & 0x800000000000L) != 0L) 761 return jjStartNfaWithStates_0(8, 47, 28); 762 break; 763 case 101: 764 if ((active0 & 0x10000000000L) != 0L) 765 return jjStartNfaWithStates_0(8, 40, 28); 766 break; 767 case 105: 768 return jjMoveStringLiteralDfa9_0(active0, 0x80000000000000L); 769 case 111: 770 return jjMoveStringLiteralDfa9_0(active0, 0x4000000000L); 771 case 116: 772 if ((active0 & 0x800000000000000L) != 0L) 773 return jjStartNfaWithStates_0(8, 59, 28); 774 return jjMoveStringLiteralDfa9_0(active0, 0x1000000000L); 775 default : 776 break; 777 } 778 return jjStartNfa_0(7, active0, 0L, 0L); 779 } 780 private final int jjMoveStringLiteralDfa9_0(long old0, long active0) 781 { 782 if (((active0 &= old0)) == 0L) 783 return jjStartNfa_0(7, old0, 0L, 0L); 784 try { curChar = input_stream.readChar(); } 785 catch(java.io.IOException e) { 786 jjStopStringLiteralDfa_0(8, active0, 0L, 0L); 787 return 9; 788 } 789 switch(curChar) 790 { 791 case 102: 792 if ((active0 & 0x4000000000L) != 0L) 793 return jjStartNfaWithStates_0(9, 38, 28); 794 break; 795 case 115: 796 if ((active0 & 0x1000000000L) != 0L) 797 return jjStartNfaWithStates_0(9, 36, 28); 798 break; 799 case 122: 800 return jjMoveStringLiteralDfa10_0(active0, 0x80000000000000L); 801 default : 802 break; 803 } 804 return jjStartNfa_0(8, active0, 0L, 0L); 805 } 806 private final int jjMoveStringLiteralDfa10_0(long old0, long active0) 807 { 808 if (((active0 &= old0)) == 0L) 809 return jjStartNfa_0(8, old0, 0L, 0L); 810 try { curChar = input_stream.readChar(); } 811 catch(java.io.IOException e) { 812 jjStopStringLiteralDfa_0(9, active0, 0L, 0L); 813 return 10; 814 } 815 switch(curChar) 816 { 817 case 101: 818 return jjMoveStringLiteralDfa11_0(active0, 0x80000000000000L); 819 default : 820 break; 821 } 822 return jjStartNfa_0(9, active0, 0L, 0L); 823 } 824 private final int jjMoveStringLiteralDfa11_0(long old0, long active0) 825 { 826 if (((active0 &= old0)) == 0L) 827 return jjStartNfa_0(9, old0, 0L, 0L); 828 try { curChar = input_stream.readChar(); } 829 catch(java.io.IOException e) { 830 jjStopStringLiteralDfa_0(10, active0, 0L, 0L); 831 return 11; 832 } 833 switch(curChar) 834 { 835 case 100: 836 if ((active0 & 0x80000000000000L) != 0L) 837 return jjStartNfaWithStates_0(11, 55, 28); 838 break; 839 default : 840 break; 841 } 842 return jjStartNfa_0(10, active0, 0L, 0L); 843 } 844 private final void jjCheckNAdd(int state) 845 { 846 if (jjrounds[state] != jjround) 847 { 848 jjstateSet[jjnewStateCnt++] = state; 849 jjrounds[state] = jjround; 850 } 851 } 852 private final void jjAddStates(int start, int end) 853 { 854 do { 855 jjstateSet[jjnewStateCnt++] = jjnextStates[start]; 856 } while (start++ != end); 857 } 858 private final void jjCheckNAddTwoStates(int state1, int state2) 859 { 860 jjCheckNAdd(state1); 861 jjCheckNAdd(state2); 862 } 863 private final void jjCheckNAddStates(int start, int end) 864 { 865 do { 866 jjCheckNAdd(jjnextStates[start]); 867 } while (start++ != end); 868 } 869 private final void jjCheckNAddStates(int start) 870 { 871 jjCheckNAdd(jjnextStates[start]); 872 jjCheckNAdd(jjnextStates[start + 1]); 873 } 874 static final long[] jjbitVec0 = { 875 0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL 876 }; 877 static final long[] jjbitVec2 = { 878 0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL 879 }; 880 static final long[] jjbitVec3 = { 881 0xfff0000000200002L, 0xffffffffffffdfffL, 0xfffff00f7fffffffL, 0x12000000007fffffL 882 }; 883 static final long[] jjbitVec4 = { 884 0x0L, 0x0L, 0x420043c00000000L, 0xff7fffffff7fffffL 885 }; 886 static final long[] jjbitVec5 = { 887 0xffffcffffffffL, 0xffffffffffff0000L, 0xf9ff3fffffffffffL, 0x401f00030003L 888 }; 889 static final long[] jjbitVec6 = { 890 0x0L, 0x400000000000000L, 0xfffffffbffffd740L, 0xffffffcff7fffL 891 }; 892 static final long[] jjbitVec7 = { 893 0xffffffffffffffffL, 0xffffffffffffffffL, 0xfffffffffffff003L, 0x33fffffffff199fL 894 }; 895 static final long[] jjbitVec8 = { 896 0xfffe000000000000L, 0xfffffffe027fffffL, 0xffL, 0x707ffffff0000L 897 }; 898 static final long[] jjbitVec9 = { 899 0x7fffffe00000000L, 0xfffe0000000007ffL, 0xffffffffffffffffL, 0x1c000060002fffffL 900 }; 901 static final long[] jjbitVec10 = { 902 0x1ffffffd0000L, 0x0L, 0x3fffffffffL, 0x0L 903 }; 904 static final long[] jjbitVec11 = { 905 0x23ffffffffffffe0L, 0x3ff010000L, 0x3c5fdfffff99fe0L, 0xf0003b0000000L 906 }; 907 static final long[] jjbitVec12 = { 908 0x36dfdfffff987e0L, 0x1c00005e000000L, 0x23edfdfffffbafe0L, 0x100010000L 909 }; 910 static final long[] jjbitVec13 = { 911 0x23cdfdfffff99fe0L, 0x3b0000000L, 0x3bfc718d63dc7e0L, 0x0L 912 }; 913 static final long[] jjbitVec14 = { 914 0x3effdfffffddfe0L, 0x300000000L, 0x3effdfffffddfe0L, 0x340000000L 915 }; 916 static final long[] jjbitVec15 = { 917 0x3fffdfffffddfe0L, 0x300000000L, 0x2ffbfffffc7fffe0L, 0x7fL 918 }; 919 static final long[] jjbitVec16 = { 920 0x800dfffffffffffeL, 0x7fL, 0x200decaefef02596L, 0x3000005fL 921 }; 922 static final long[] jjbitVec17 = { 923 0x1L, 0x7fffffffeffL, 0xf00L, 0x0L 924 }; 925 static final long[] jjbitVec18 = { 926 0x6fbffffffffL, 0x3f0000L, 0xffffffff00000000L, 0x7fffffffff003fL 927 }; 928 static final long[] jjbitVec19 = { 929 0xffffffffffffffffL, 0xffffffff83ffffffL, 0xffffff07ffffffffL, 0x3ffffffffffffffL 930 }; 931 static final long[] jjbitVec20 = { 932 0xffffffffffffff7fL, 0xffffffff3d7f3d7fL, 0x7f3d7fffffff3d7fL, 0xffff7fffff7f7f3dL 933 }; 934 static final long[] jjbitVec21 = { 935 0xffffffff7f3d7fffL, 0x7ffff7fL, 0xffffffff00000000L, 0x1fffffffffffffL 936 }; 937 static final long[] jjbitVec22 = { 938 0xffffffffffffffffL, 0x7f9fffffffffffL, 0xffffffff07fffffeL, 0x7ffffffffffL 939 }; 940 static final long[] jjbitVec23 = { 941 0x0L, 0x0L, 0xfffffffffffffL, 0x8000000L 942 }; 943 static final long[] jjbitVec24 = { 944 0xffffffff00000000L, 0xffffffffffffffL, 0x1ffffffffffL, 0x0L 945 }; 946 static final long[] jjbitVec25 = { 947 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffff0fffffffL, 0x3ffffffffffffffL 948 }; 949 static final long[] jjbitVec26 = { 950 0xffffffff3f3fffffL, 0x3fffffffaaff3f3fL, 0x5fdfffffffffffffL, 0x1fdc1fff0fcf1fdcL 951 }; 952 static final long[] jjbitVec27 = { 953 0x8000000000000000L, 0x8000000000000001L, 0xffff00000000L, 0x0L 954 }; 955 static final long[] jjbitVec28 = { 956 0x3fbbd503e2ffc84L, 0xffffffff00000000L, 0xfL, 0x0L 957 }; 958 static final long[] jjbitVec29 = { 959 0x73e03fe000000e0L, 0xfffffffffffffffeL, 0xfffffffe601fffffL, 0x7fffffffffffffffL 960 }; 961 static final long[] jjbitVec30 = { 962 0xfffe1fffffffffe0L, 0xffffffffffffffffL, 0xffffff00007fffL, 0x0L 963 }; 964 static final long[] jjbitVec31 = { 965 0xffffffffffffffffL, 0xffffffffffffffffL, 0x3fffffffffffffL, 0x0L 966 }; 967 static final long[] jjbitVec32 = { 968 0xffffffffffffffffL, 0xffffffffffffffffL, 0x3fffffffffL, 0x0L 969 }; 970 static final long[] jjbitVec33 = { 971 0xffffffffffffffffL, 0xffffffffffffffffL, 0x1fffL, 0x0L 972 }; 973 static final long[] jjbitVec34 = { 974 0xffffffffffffffffL, 0xffffffffffffffffL, 0xfffffffffL, 0x0L 975 }; 976 static final long[] jjbitVec35 = { 977 0x3fffffffffffL, 0x0L, 0x0L, 0x0L 978 }; 979 static final long[] jjbitVec36 = { 980 0x5f7ffdffa0f8007fL, 0xffffffffffffffdbL, 0x3ffffffffffffL, 0xfffffffffff80000L 981 }; 982 static final long[] jjbitVec37 = { 983 0x3fffffffffffffffL, 0xffffffffffff0000L, 0xfffffffffffcffffL, 0xfff0000000000ffL 984 }; 985 static final long[] jjbitVec38 = { 986 0x18000000000000L, 0xffd702000000e000L, 0xffffffffffffffffL, 0x1fffffffffffffffL 987 }; 988 static final long[] jjbitVec39 = { 989 0x87fffffe00000010L, 0xffffffe007fffffeL, 0x7fffffffffffffffL, 0x631cfcfcfcL 990 }; 991 static final long[] jjbitVec40 = { 992 0x0L, 0x0L, 0x420043cffffffffL, 0xff7fffffff7fffffL 993 }; 994 static final long[] jjbitVec41 = { 995 0xffffffffffffffffL, 0x400000700007fffL, 0xfffffffbffffd740L, 0xffffffcff7fffL 996 }; 997 static final long[] jjbitVec42 = { 998 0xffffffffffffffffL, 0xffffffffffffffffL, 0xfffffffffffff07bL, 0x33fffffffff199fL 999 }; 1000 static final long[] jjbitVec43 = { 1001 0xfffe000000000000L, 0xfffffffe027fffffL, 0xbbfffffbfffe00ffL, 0x707ffffff0016L 1002 }; 1003 static final long[] jjbitVec44 = { 1004 0x7fffffe00000000L, 0xffff03ff003fffffL, 0xffffffffffffffffL, 0x1fff3dff9fefffffL 1005 }; 1006 static final long[] jjbitVec45 = { 1007 0xffff1fffffff8000L, 0x7ffL, 0x1ffffffffffffL, 0x0L 1008 }; 1009 static final long[] jjbitVec46 = { 1010 0xf3ffffffffffffeeL, 0xffcfff1f3fffL, 0xd3c5fdfffff99feeL, 0xfffcfb080399fL 1011 }; 1012 static final long[] jjbitVec47 = { 1013 0xd36dfdfffff987e4L, 0x1fffc05e003987L, 0xf3edfdfffffbafeeL, 0xffc100013bbfL 1014 }; 1015 static final long[] jjbitVec48 = { 1016 0xf3cdfdfffff99feeL, 0xffc3b0c0398fL, 0xc3bfc718d63dc7ecL, 0xff8000803dc7L 1017 }; 1018 static final long[] jjbitVec49 = { 1019 0xc3effdfffffddfeeL, 0xffc300603ddfL, 0xc3effdfffffddfecL, 0xffc340603ddfL 1020 }; 1021 static final long[] jjbitVec50 = { 1022 0xc3fffdfffffddfecL, 0xffc300803dcfL, 0x2ffbfffffc7fffecL, 0xc0000ff5f847fL 1023 }; 1024 static final long[] jjbitVec51 = { 1025 0x87fffffffffffffeL, 0x3ff7fffL, 0x3bffecaefef02596L, 0x33ff3f5fL 1026 }; 1027 static final long[] jjbitVec52 = { 1028 0xc2a003ff03000001L, 0xfffe07fffffffeffL, 0x1ffffffffeff0fdfL, 0x40L 1029 }; 1030 static final long[] jjbitVec53 = { 1031 0x3c7f6fbffffffffL, 0x3ff03ffL, 0xffffffff00000000L, 0x7fffffffff003fL 1032 }; 1033 static final long[] jjbitVec54 = { 1034 0xffffffff7f3d7fffL, 0x3fe0007ffff7fL, 0xffffffff00000000L, 0x1fffffffffffffL 1035 }; 1036 static final long[] jjbitVec55 = { 1037 0x0L, 0x0L, 0xffffffffffffffffL, 0x3ff080fffffL 1038 }; 1039 static final long[] jjbitVec56 = { 1040 0xffffffff03ff7800L, 0xffffffffffffffL, 0x3ffffffffffL, 0x0L 1041 }; 1042 static final long[] jjbitVec57 = { 1043 0x80007c000000f000L, 0x8000fc0000000001L, 0xffff00000000L, 0x21fff0000L 1044 }; 1045 static final long[] jjbitVec58 = { 1046 0x73efffe000000e0L, 0xfffffffffffffffeL, 0xfffffffe661fffffL, 0x7fffffffffffffffL 1047 }; 1048 static final long[] jjbitVec59 = { 1049 0x5f7ffdffe0f8007fL, 0xffffffffffffffdbL, 0x3ffffffffffffL, 0xfffffffffff80000L 1050 }; 1051 static final long[] jjbitVec60 = { 1052 0x18000f00000000L, 0xffd702000000e000L, 0xffffffffffffffffL, 0x9fffffffffffffffL 1053 }; 1054 static final long[] jjbitVec61 = { 1055 0x87fffffe03ff0010L, 0xffffffe007fffffeL, 0x7fffffffffffffffL, 0xe0000631cfcfcfcL 1056 }; 1057 private final int jjMoveNfa_0(int startState, int curPos) 1058 { 1059 int[] nextStates; 1060 int startsAt = 0; 1061 jjnewStateCnt = 70; 1062 int i = 1; 1063 jjstateSet[0] = startState; 1064 int j, kind = 0x7fffffff; 1065 for (;;) 1066 { 1067 if (++jjround == 0x7fffffff) 1068 ReInitRounds(); 1069 if (curChar < 64) 1070 { 1071 long l = 1L << curChar; 1072 MatchLoop: do 1073 { 1074 switch(jjstateSet[--i]) 1075 { 1076 case 47: 1077 if (curChar == 47) 1078 { 1079 if (kind > 8) 1080 kind = 8; 1081 jjCheckNAddStates(0, 2); 1082 } 1083 else if (curChar == 42) 1084 jjstateSet[jjnewStateCnt++] = 45; 1085 break; 1086 case 0: 1087 if ((0x3ff000000000000L & l) != 0L) 1088 jjCheckNAddStates(3, 9); 1089 else if (curChar == 47) 1090 jjAddStates(10, 11); 1091 else if (curChar == 36) 1092 { 1093 if (kind > 76) 1094 kind = 76; 1095 jjCheckNAdd(28); 1096 } 1097 else if (curChar == 34) 1098 jjCheckNAddStates(12, 14); 1099 else if (curChar == 39) 1100 jjAddStates(15, 16); 1101 else if (curChar == 46) 1102 jjCheckNAdd(4); 1103 if ((0x3fe000000000000L & l) != 0L) 1104 { 1105 if (kind > 65) 1106 kind = 65; 1107 jjCheckNAddTwoStates(1, 2); 1108 } 1109 else if (curChar == 48) 1110 { 1111 if (kind > 65) 1112 kind = 65; 1113 jjCheckNAddStates(17, 21); 1114 } 1115 break; 1116 case 1: 1117 if ((0x3ff000000000000L & l) == 0L) 1118 break; 1119 if (kind > 65) 1120 kind = 65; 1121 jjCheckNAddTwoStates(1, 2); 1122 break; 1123 case 3: 1124 if (curChar == 46) 1125 jjCheckNAdd(4); 1126 break; 1127 case 4: 1128 if ((0x3ff000000000000L & l) == 0L) 1129 break; 1130 if (kind > 69) 1131 kind = 69; 1132 jjCheckNAddStates(22, 24); 1133 break; 1134 case 6: 1135 if ((0x280000000000L & l) != 0L) 1136 jjCheckNAdd(7); 1137 break; 1138 case 7: 1139 if ((0x3ff000000000000L & l) == 0L) 1140 break; 1141 if (kind > 69) 1142 kind = 69; 1143 jjCheckNAddTwoStates(7, 8); 1144 break; 1145 case 9: 1146 if (curChar == 39) 1147 jjAddStates(15, 16); 1148 break; 1149 case 10: 1150 if ((0xffffff7fffffdbffL & l) != 0L) 1151 jjCheckNAdd(11); 1152 break; 1153 case 11: 1154 if (curChar == 39 && kind > 74) 1155 kind = 74; 1156 break; 1157 case 13: 1158 if ((0x8400000000L & l) != 0L) 1159 jjCheckNAdd(11); 1160 break; 1161 case 14: 1162 if ((0xff000000000000L & l) != 0L) 1163 jjCheckNAddTwoStates(15, 11); 1164 break; 1165 case 15: 1166 if ((0xff000000000000L & l) != 0L) 1167 jjCheckNAdd(11); 1168 break; 1169 case 16: 1170 if ((0xf000000000000L & l) != 0L) 1171 jjstateSet[jjnewStateCnt++] = 17; 1172 break; 1173 case 17: 1174 if ((0xff000000000000L & l) != 0L) 1175 jjCheckNAdd(15); 1176 break; 1177 case 18: 1178 if (curChar == 34) 1179 jjCheckNAddStates(12, 14); 1180 break; 1181 case 19: 1182 if ((0xfffffffbffffdbffL & l) != 0L) 1183 jjCheckNAddStates(12, 14); 1184 break; 1185 case 21: 1186 if ((0x8400000000L & l) != 0L) 1187 jjCheckNAddStates(12, 14); 1188 break; 1189 case 22: 1190 if (curChar == 34 && kind > 75) 1191 kind = 75; 1192 break; 1193 case 23: 1194 if ((0xff000000000000L & l) != 0L) 1195 jjCheckNAddStates(25, 28); 1196 break; 1197 case 24: 1198 if ((0xff000000000000L & l) != 0L) 1199 jjCheckNAddStates(12, 14); 1200 break; 1201 case 25: 1202 if ((0xf000000000000L & l) != 0L) 1203 jjstateSet[jjnewStateCnt++] = 26; 1204 break; 1205 case 26: 1206 if ((0xff000000000000L & l) != 0L) 1207 jjCheckNAdd(24); 1208 break; 1209 case 27: 1210 if (curChar != 36) 1211 break; 1212 if (kind > 76) 1213 kind = 76; 1214 jjCheckNAdd(28); 1215 break; 1216 case 28: 1217 if ((0x3ff00100fffc1ffL & l) == 0L) 1218 break; 1219 if (kind > 76) 1220 kind = 76; 1221 jjCheckNAdd(28); 1222 break; 1223 case 29: 1224 if ((0x3ff000000000000L & l) != 0L) 1225 jjCheckNAddStates(3, 9); 1226 break; 1227 case 30: 1228 if ((0x3ff000000000000L & l) != 0L) 1229 jjCheckNAddStates(29, 31); 1230 break; 1231 case 32: 1232 if ((0x280000000000L & l) != 0L) 1233 jjCheckNAdd(33); 1234 break; 1235 case 33: 1236 if ((0x3ff000000000000L & l) != 0L) 1237 jjCheckNAddTwoStates(33, 8); 1238 break; 1239 case 34: 1240 if ((0x3ff000000000000L & l) != 0L) 1241 jjCheckNAddTwoStates(34, 35); 1242 break; 1243 case 36: 1244 if ((0x280000000000L & l) != 0L) 1245 jjCheckNAdd(37); 1246 break; 1247 case 37: 1248 if ((0x3ff000000000000L & l) == 0L) 1249 break; 1250 if (kind > 69) 1251 kind = 69; 1252 jjCheckNAddTwoStates(37, 8); 1253 break; 1254 case 38: 1255 if ((0x3ff000000000000L & l) != 0L) 1256 jjCheckNAddTwoStates(38, 39); 1257 break; 1258 case 39: 1259 if (curChar != 46) 1260 break; 1261 if (kind > 69) 1262 kind = 69; 1263 jjCheckNAddStates(32, 34); 1264 break; 1265 case 40: 1266 if ((0x3ff000000000000L & l) == 0L) 1267 break; 1268 if (kind > 69) 1269 kind = 69; 1270 jjCheckNAddStates(32, 34); 1271 break; 1272 case 42: 1273 if ((0x280000000000L & l) != 0L) 1274 jjCheckNAdd(43); 1275 break; 1276 case 43: 1277 if ((0x3ff000000000000L & l) == 0L) 1278 break; 1279 if (kind > 69) 1280 kind = 69; 1281 jjCheckNAddTwoStates(43, 8); 1282 break; 1283 case 44: 1284 if (curChar == 47) 1285 jjAddStates(10, 11); 1286 break; 1287 case 45: 1288 if (curChar == 42) 1289 jjstateSet[jjnewStateCnt++] = 46; 1290 break; 1291 case 46: 1292 if ((0xffff7fffffffffffL & l) != 0L && kind > 6) 1293 kind = 6; 1294 break; 1295 case 48: 1296 if (curChar != 47) 1297 break; 1298 if (kind > 8) 1299 kind = 8; 1300 jjCheckNAddStates(0, 2); 1301 break; 1302 case 49: 1303 if ((0xffffffffffffdbffL & l) == 0L) 1304 break; 1305 if (kind > 8) 1306 kind = 8; 1307 jjCheckNAddStates(0, 2); 1308 break; 1309 case 50: 1310 if ((0x2400L & l) != 0L && kind > 8) 1311 kind = 8; 1312 break; 1313 case 51: 1314 if (curChar == 10 && kind > 8) 1315 kind = 8; 1316 break; 1317 case 52: 1318 if (curChar == 13) 1319 jjstateSet[jjnewStateCnt++] = 51; 1320 break; 1321 case 53: 1322 if (curChar != 48) 1323 break; 1324 if (kind > 65) 1325 kind = 65; 1326 jjCheckNAddStates(17, 21); 1327 break; 1328 case 55: 1329 if ((0x3ff000000000000L & l) == 0L) 1330 break; 1331 if (kind > 65) 1332 kind = 65; 1333 jjCheckNAddTwoStates(55, 2); 1334 break; 1335 case 56: 1336 if ((0xff000000000000L & l) == 0L) 1337 break; 1338 if (kind > 65) 1339 kind = 65; 1340 jjCheckNAddTwoStates(56, 2); 1341 break; 1342 case 58: 1343 if ((0x3ff000000000000L & l) != 0L) 1344 jjAddStates(35, 36); 1345 break; 1346 case 59: 1347 if (curChar == 46) 1348 jjCheckNAdd(60); 1349 break; 1350 case 60: 1351 if ((0x3ff000000000000L & l) != 0L) 1352 jjCheckNAddTwoStates(60, 61); 1353 break; 1354 case 62: 1355 if ((0x280000000000L & l) != 0L) 1356 jjCheckNAdd(63); 1357 break; 1358 case 63: 1359 if ((0x3ff000000000000L & l) == 0L) 1360 break; 1361 if (kind > 69) 1362 kind = 69; 1363 jjCheckNAddTwoStates(63, 8); 1364 break; 1365 case 65: 1366 if ((0x3ff000000000000L & l) != 0L) 1367 jjCheckNAddStates(37, 39); 1368 break; 1369 case 66: 1370 if (curChar == 46) 1371 jjCheckNAdd(67); 1372 break; 1373 case 68: 1374 if ((0x280000000000L & l) != 0L) 1375 jjCheckNAdd(69); 1376 break; 1377 case 69: 1378 if ((0x3ff000000000000L & l) == 0L) 1379 break; 1380 if (kind > 69) 1381 kind = 69; 1382 jjCheckNAddTwoStates(69, 8); 1383 break; 1384 default : break; 1385 } 1386 } while(i != startsAt); 1387 } 1388 else if (curChar < 128) 1389 { 1390 long l = 1L << (curChar & 077); 1391 MatchLoop: do 1392 { 1393 switch(jjstateSet[--i]) 1394 { 1395 case 0: 1396 if ((0x7fffffe87fffffeL & l) == 0L) 1397 break; 1398 if (kind > 76) 1399 kind = 76; 1400 jjCheckNAdd(28); 1401 break; 1402 case 2: 1403 if ((0x100000001000L & l) != 0L && kind > 65) 1404 kind = 65; 1405 break; 1406 case 5: 1407 if ((0x2000000020L & l) != 0L) 1408 jjAddStates(40, 41); 1409 break; 1410 case 8: 1411 if ((0x5000000050L & l) != 0L && kind > 69) 1412 kind = 69; 1413 break; 1414 case 10: 1415 if ((0xffffffffefffffffL & l) != 0L) 1416 jjCheckNAdd(11); 1417 break; 1418 case 12: 1419 if (curChar == 92) 1420 jjAddStates(42, 44); 1421 break; 1422 case 13: 1423 if ((0x14404410000000L & l) != 0L) 1424 jjCheckNAdd(11); 1425 break; 1426 case 19: 1427 if ((0xffffffffefffffffL & l) != 0L) 1428 jjCheckNAddStates(12, 14); 1429 break; 1430 case 20: 1431 if (curChar == 92) 1432 jjAddStates(45, 47); 1433 break; 1434 case 21: 1435 if ((0x14404410000000L & l) != 0L) 1436 jjCheckNAddStates(12, 14); 1437 break; 1438 case 28: 1439 if ((0x87fffffe87fffffeL & l) == 0L) 1440 break; 1441 if (kind > 76) 1442 kind = 76; 1443 jjCheckNAdd(28); 1444 break; 1445 case 31: 1446 if ((0x2000000020L & l) != 0L) 1447 jjAddStates(48, 49); 1448 break; 1449 case 35: 1450 if ((0x2000000020L & l) != 0L) 1451 jjAddStates(50, 51); 1452 break; 1453 case 41: 1454 if ((0x2000000020L & l) != 0L) 1455 jjAddStates(52, 53); 1456 break; 1457 case 46: 1458 if (kind > 6) 1459 kind = 6; 1460 break; 1461 case 49: 1462 if (kind > 8) 1463 kind = 8; 1464 jjAddStates(0, 2); 1465 break; 1466 case 54: 1467 if ((0x100000001000000L & l) != 0L) 1468 jjCheckNAdd(55); 1469 break; 1470 case 55: 1471 if ((0x7e0000007eL & l) == 0L) 1472 break; 1473 if (kind > 65) 1474 kind = 65; 1475 jjCheckNAddTwoStates(55, 2); 1476 break; 1477 case 57: 1478 if ((0x100000001000000L & l) != 0L) 1479 jjCheckNAddTwoStates(58, 59); 1480 break; 1481 case 58: 1482 if ((0x7e0000007eL & l) != 0L) 1483 jjCheckNAddTwoStates(58, 59); 1484 break; 1485 case 60: 1486 if ((0x7e0000007eL & l) != 0L) 1487 jjAddStates(54, 55); 1488 break; 1489 case 61: 1490 if ((0x1000000010000L & l) != 0L) 1491 jjAddStates(56, 57); 1492 break; 1493 case 64: 1494 if ((0x100000001000000L & l) != 0L) 1495 jjCheckNAdd(65); 1496 break; 1497 case 65: 1498 if ((0x7e0000007eL & l) != 0L) 1499 jjCheckNAddStates(37, 39); 1500 break; 1501 case 67: 1502 if ((0x1000000010000L & l) != 0L) 1503 jjAddStates(58, 59); 1504 break; 1505 default : break; 1506 } 1507 } while(i != startsAt); 1508 } 1509 else 1510 { 1511 int hiByte = (int)(curChar >> 8); 1512 int i1 = hiByte >> 6; 1513 long l1 = 1L << (hiByte & 077); 1514 int i2 = (curChar & 0xff) >> 6; 1515 long l2 = 1L << (curChar & 077); 1516 MatchLoop: do 1517 { 1518 switch(jjstateSet[--i]) 1519 { 1520 case 0: 1521 if (!jjCanMove_1(hiByte, i1, i2, l1, l2)) 1522 break; 1523 if (kind > 76) 1524 kind = 76; 1525 jjCheckNAdd(28); 1526 break; 1527 case 10: 1528 if (jjCanMove_0(hiByte, i1, i2, l1, l2)) 1529 jjstateSet[jjnewStateCnt++] = 11; 1530 break; 1531 case 19: 1532 if (jjCanMove_0(hiByte, i1, i2, l1, l2)) 1533 jjAddStates(12, 14); 1534 break; 1535 case 28: 1536 if (!jjCanMove_2(hiByte, i1, i2, l1, l2)) 1537 break; 1538 if (kind > 76) 1539 kind = 76; 1540 jjCheckNAdd(28); 1541 break; 1542 case 46: 1543 if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 6) 1544 kind = 6; 1545 break; 1546 case 49: 1547 if (!jjCanMove_0(hiByte, i1, i2, l1, l2)) 1548 break; 1549 if (kind > 8) 1550 kind = 8; 1551 jjAddStates(0, 2); 1552 break; 1553 default : break; 1554 } 1555 } while(i != startsAt); 1556 } 1557 if (kind != 0x7fffffff) 1558 { 1559 jjmatchedKind = kind; 1560 jjmatchedPos = curPos; 1561 kind = 0x7fffffff; 1562 } 1563 ++curPos; 1564 if ((i = jjnewStateCnt) == (startsAt = 70 - (jjnewStateCnt = startsAt))) 1565 return curPos; 1566 try { curChar = input_stream.readChar(); } 1567 catch(java.io.IOException e) { return curPos; } 1568 } 1569 } 1570 private final int jjMoveStringLiteralDfa0_2() 1571 { 1572 switch(curChar) 1573 { 1574 case 42: 1575 return jjMoveStringLiteralDfa1_2(0x400L); 1576 default : 1577 return 1; 1578 } 1579 } 1580 private final int jjMoveStringLiteralDfa1_2(long active0) 1581 { 1582 try { curChar = input_stream.readChar(); } 1583 catch(java.io.IOException e) { 1584 return 1; 1585 } 1586 switch(curChar) 1587 { 1588 case 47: 1589 if ((active0 & 0x400L) != 0L) 1590 return jjStopAtPos(1, 10); 1591 break; 1592 default : 1593 return 2; 1594 } 1595 return 2; 1596 } 1597 private final int jjMoveStringLiteralDfa0_1() 1598 { 1599 switch(curChar) 1600 { 1601 case 42: 1602 return jjMoveStringLiteralDfa1_1(0x200L); 1603 default : 1604 return 1; 1605 } 1606 } 1607 private final int jjMoveStringLiteralDfa1_1(long active0) 1608 { 1609 try { curChar = input_stream.readChar(); } 1610 catch(java.io.IOException e) { 1611 return 1; 1612 } 1613 switch(curChar) 1614 { 1615 case 47: 1616 if ((active0 & 0x200L) != 0L) 1617 return jjStopAtPos(1, 9); 1618 break; 1619 default : 1620 return 2; 1621 } 1622 return 2; 1623 } 1624 static final int[] jjnextStates = { 1625 49, 50, 52, 30, 31, 8, 34, 35, 38, 39, 47, 48, 19, 20, 22, 10, 1626 12, 54, 56, 2, 57, 64, 4, 5, 8, 19, 20, 24, 22, 30, 31, 8, 1627 40, 41, 8, 58, 59, 65, 66, 67, 6, 7, 13, 14, 16, 21, 23, 25, 1628 32, 33, 36, 37, 42, 43, 60, 61, 62, 63, 68, 69, 1629 }; 1630 private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2) 1631 { 1632 switch(hiByte) 1633 { 1634 case 0: 1635 return ((jjbitVec2[i2] & l2) != 0L); 1636 default : 1637 if ((jjbitVec0[i1] & l1) != 0L) 1638 return true; 1639 return false; 1640 } 1641 } 1642 private static final boolean jjCanMove_1(int hiByte, int i1, int i2, long l1, long l2) 1643 { 1644 switch(hiByte) 1645 { 1646 case 0: 1647 return ((jjbitVec4[i2] & l2) != 0L); 1648 case 2: 1649 return ((jjbitVec5[i2] & l2) != 0L); 1650 case 3: 1651 return ((jjbitVec6[i2] & l2) != 0L); 1652 case 4: 1653 return ((jjbitVec7[i2] & l2) != 0L); 1654 case 5: 1655 return ((jjbitVec8[i2] & l2) != 0L); 1656 case 6: 1657 return ((jjbitVec9[i2] & l2) != 0L); 1658 case 7: 1659 return ((jjbitVec10[i2] & l2) != 0L); 1660 case 9: 1661 return ((jjbitVec11[i2] & l2) != 0L); 1662 case 10: 1663 return ((jjbitVec12[i2] & l2) != 0L); 1664 case 11: 1665 return ((jjbitVec13[i2] & l2) != 0L); 1666 case 12: 1667 return ((jjbitVec14[i2] & l2) != 0L); 1668 case 13: 1669 return ((jjbitVec15[i2] & l2) != 0L); 1670 case 14: 1671 return ((jjbitVec16[i2] & l2) != 0L); 1672 case 15: 1673 return ((jjbitVec17[i2] & l2) != 0L); 1674 case 16: 1675 return ((jjbitVec18[i2] & l2) != 0L); 1676 case 17: 1677 return ((jjbitVec19[i2] & l2) != 0L); 1678 case 18: 1679 return ((jjbitVec20[i2] & l2) != 0L); 1680 case 19: 1681 return ((jjbitVec21[i2] & l2) != 0L); 1682 case 20: 1683 return ((jjbitVec0[i2] & l2) != 0L); 1684 case 22: 1685 return ((jjbitVec22[i2] & l2) != 0L); 1686 case 23: 1687 return ((jjbitVec23[i2] & l2) != 0L); 1688 case 24: 1689 return ((jjbitVec24[i2] & l2) != 0L); 1690 case 30: 1691 return ((jjbitVec25[i2] & l2) != 0L); 1692 case 31: 1693 return ((jjbitVec26[i2] & l2) != 0L); 1694 case 32: 1695 return ((jjbitVec27[i2] & l2) != 0L); 1696 case 33: 1697 return ((jjbitVec28[i2] & l2) != 0L); 1698 case 48: 1699 return ((jjbitVec29[i2] & l2) != 0L); 1700 case 49: 1701 return ((jjbitVec30[i2] & l2) != 0L); 1702 case 77: 1703 return ((jjbitVec31[i2] & l2) != 0L); 1704 case 159: 1705 return ((jjbitVec32[i2] & l2) != 0L); 1706 case 164: 1707 return ((jjbitVec33[i2] & l2) != 0L); 1708 case 215: 1709 return ((jjbitVec34[i2] & l2) != 0L); 1710 case 250: 1711 return ((jjbitVec35[i2] & l2) != 0L); 1712 case 251: 1713 return ((jjbitVec36[i2] & l2) != 0L); 1714 case 253: 1715 return ((jjbitVec37[i2] & l2) != 0L); 1716 case 254: 1717 return ((jjbitVec38[i2] & l2) != 0L); 1718 case 255: 1719 return ((jjbitVec39[i2] & l2) != 0L); 1720 default : 1721 if ((jjbitVec3[i1] & l1) != 0L) 1722 return true; 1723 return false; 1724 } 1725 } 1726 private static final boolean jjCanMove_2(int hiByte, int i1, int i2, long l1, long l2) 1727 { 1728 switch(hiByte) 1729 { 1730 case 0: 1731 return ((jjbitVec40[i2] & l2) != 0L); 1732 case 2: 1733 return ((jjbitVec5[i2] & l2) != 0L); 1734 case 3: 1735 return ((jjbitVec41[i2] & l2) != 0L); 1736 case 4: 1737 return ((jjbitVec42[i2] & l2) != 0L); 1738 case 5: 1739 return ((jjbitVec43[i2] & l2) != 0L); 1740 case 6: 1741 return ((jjbitVec44[i2] & l2) != 0L); 1742 case 7: 1743 return ((jjbitVec45[i2] & l2) != 0L); 1744 case 9: 1745 return ((jjbitVec46[i2] & l2) != 0L); 1746 case 10: 1747 return ((jjbitVec47[i2] & l2) != 0L); 1748 case 11: 1749 return ((jjbitVec48[i2] & l2) != 0L); 1750 case 12: 1751 return ((jjbitVec49[i2] & l2) != 0L); 1752 case 13: 1753 return ((jjbitVec50[i2] & l2) != 0L); 1754 case 14: 1755 return ((jjbitVec51[i2] & l2) != 0L); 1756 case 15: 1757 return ((jjbitVec52[i2] & l2) != 0L); 1758 case 16: 1759 return ((jjbitVec53[i2] & l2) != 0L); 1760 case 17: 1761 return ((jjbitVec19[i2] & l2) != 0L); 1762 case 18: 1763 return ((jjbitVec20[i2] & l2) != 0L); 1764 case 19: 1765 return ((jjbitVec54[i2] & l2) != 0L); 1766 case 20: 1767 return ((jjbitVec0[i2] & l2) != 0L); 1768 case 22: 1769 return ((jjbitVec22[i2] & l2) != 0L); 1770 case 23: 1771 return ((jjbitVec55[i2] & l2) != 0L); 1772 case 24: 1773 return ((jjbitVec56[i2] & l2) != 0L); 1774 case 30: 1775 return ((jjbitVec25[i2] & l2) != 0L); 1776 case 31: 1777 return ((jjbitVec26[i2] & l2) != 0L); 1778 case 32: 1779 return ((jjbitVec57[i2] & l2) != 0L); 1780 case 33: 1781 return ((jjbitVec28[i2] & l2) != 0L); 1782 case 48: 1783 return ((jjbitVec58[i2] & l2) != 0L); 1784 case 49: 1785 return ((jjbitVec30[i2] & l2) != 0L); 1786 case 77: 1787 return ((jjbitVec31[i2] & l2) != 0L); 1788 case 159: 1789 return ((jjbitVec32[i2] & l2) != 0L); 1790 case 164: 1791 return ((jjbitVec33[i2] & l2) != 0L); 1792 case 215: 1793 return ((jjbitVec34[i2] & l2) != 0L); 1794 case 250: 1795 return ((jjbitVec35[i2] & l2) != 0L); 1796 case 251: 1797 return ((jjbitVec59[i2] & l2) != 0L); 1798 case 253: 1799 return ((jjbitVec37[i2] & l2) != 0L); 1800 case 254: 1801 return ((jjbitVec60[i2] & l2) != 0L); 1802 case 255: 1803 return ((jjbitVec61[i2] & l2) != 0L); 1804 default : 1805 if ((jjbitVec3[i1] & l1) != 0L) 1806 return true; 1807 return false; 1808 } 1809 } 1810 public static final String[] jjstrLiteralImages = { 1811 "", null, null, null, null, null, null, null, null, null, null, null, 1812 "\141\142\163\164\162\141\143\164", "\141\163\163\145\162\164", "\142\157\157\154\145\141\156", 1813 "\142\162\145\141\153", "\142\171\164\145", "\143\141\163\145", "\143\141\164\143\150", 1814 "\143\150\141\162", "\143\154\141\163\163", "\143\157\156\163\164", 1815 "\143\157\156\164\151\156\165\145", "\144\145\146\141\165\154\164", "\144\157", "\144\157\165\142\154\145", 1816 "\145\154\163\145", "\145\156\165\155", "\145\170\164\145\156\144\163", "\146\141\154\163\145", 1817 "\146\151\156\141\154", "\146\151\156\141\154\154\171", "\146\154\157\141\164", "\146\157\162", 1818 "\147\157\164\157", "\151\146", "\151\155\160\154\145\155\145\156\164\163", 1819 "\151\155\160\157\162\164", "\151\156\163\164\141\156\143\145\157\146", "\151\156\164", 1820 "\151\156\164\145\162\146\141\143\145", "\154\157\156\147", "\156\141\164\151\166\145", "\156\145\167", 1821 "\156\165\154\154", "\160\141\143\153\141\147\145", "\160\162\151\166\141\164\145", 1822 "\160\162\157\164\145\143\164\145\144", "\160\165\142\154\151\143", "\162\145\164\165\162\156", 1823 "\163\150\157\162\164", "\163\164\141\164\151\143", "\163\164\162\151\143\164\146\160", 1824 "\163\165\160\145\162", "\163\167\151\164\143\150", 1825 "\163\171\156\143\150\162\157\156\151\172\145\144", "\164\150\151\163", "\164\150\162\157\167", "\164\150\162\157\167\163", 1826 "\164\162\141\156\163\151\145\156\164", "\164\162\165\145", "\164\162\171", "\166\157\151\144", 1827 "\166\157\154\141\164\151\154\145", "\167\150\151\154\145", null, null, null, null, null, null, null, null, null, 1828 null, null, null, null, null, "\50", "\51", "\173", "\175", "\133", "\135", "\73", 1829 "\54", "\56", "\100", "\75", "\74", "\41", "\176", "\77", "\72", "\75\75", "\74\75", 1830 "\76\75", "\41\75", "\174\174", "\46\46", "\53\53", "\55\55", "\53", "\55", "\52", 1831 "\57", "\46", "\174", "\136", "\45", "\74\74", "\53\75", "\55\75", "\52\75", 1832 "\57\75", "\46\75", "\174\75", "\136\75", "\45\75", "\74\74\75", "\76\76\75", 1833 "\76\76\76\75", "\56\56\56", "\76\76\76", "\76\76", "\76", "\32", null, }; 1834 public static final String[] lexStateNames = { 1835 "DEFAULT", 1836 "IN_FORMAL_COMMENT", 1837 "IN_MULTI_LINE_COMMENT", 1838 }; 1839 public static final int[] jjnewLexState = { 1840 -1, -1, -1, -1, -1, -1, 1, 2, -1, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1841 -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, 1842 -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, 1843 -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, 1844 -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, 1845 -1, -1, -1, -1, 1846 }; 1847 static final long[] jjtoToken = { 1848 0xfffffffffffff001L, 0xffffffffffff9c23L, 0x1L, 1849 }; 1850 static final long[] jjtoSkip = { 1851 0x73eL, 0x0L, 0x0L, 1852 }; 1853 static final long[] jjtoSpecial = { 1854 0x700L, 0x0L, 0x0L, 1855 }; 1856 static final long[] jjtoMore = { 1857 0x8c0L, 0x0L, 0x0L, 1858 }; 1859 protected JavaCharStream input_stream; 1860 private final int[] jjrounds = new int[70]; 1861 private final int[] jjstateSet = new int[140]; 1862 StringBuffer image; 1863 int jjimageLen; 1864 int lengthOfMatch; 1865 protected char curChar; 1866 public JavaParser15DebugTokenManager(JavaCharStream stream){ 1867 if (JavaCharStream.staticFlag) 1868 throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer."); 1869 input_stream = stream; 1870 } 1871 public JavaParser15DebugTokenManager(JavaCharStream stream, int lexState){ 1872 this(stream); 1873 SwitchTo(lexState); 1874 } 1875 public void ReInit(JavaCharStream stream) 1876 { 1877 jjmatchedPos = jjnewStateCnt = 0; 1878 curLexState = defaultLexState; 1879 input_stream = stream; 1880 ReInitRounds(); 1881 } 1882 private final void ReInitRounds() 1883 { 1884 int i; 1885 jjround = 0x80000001; 1886 for (i = 70; i-- > 0;) 1887 jjrounds[i] = 0x80000000; 1888 } 1889 public void ReInit(JavaCharStream stream, int lexState) 1890 { 1891 ReInit(stream); 1892 SwitchTo(lexState); 1893 } 1894 public void SwitchTo(int lexState) 1895 { 1896 if (lexState >= 3 || lexState < 0) 1897 throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE); 1898 else 1899 curLexState = lexState; 1900 } 1901 1902 protected Token jjFillToken() 1903 { 1904 Token t = Token.newToken(jjmatchedKind); 1905 t.kind = jjmatchedKind; 1906 String im = jjstrLiteralImages[jjmatchedKind]; 1907 t.image = (im == null) ? input_stream.GetImage() : im; 1908 t.beginLine = input_stream.getBeginLine(); 1909 t.beginColumn = input_stream.getBeginColumn(); 1910 t.endLine = input_stream.getEndLine(); 1911 t.endColumn = input_stream.getEndColumn(); 1912 return t; 1913 } 1914 1915 int curLexState = 0; 1916 int defaultLexState = 0; 1917 int jjnewStateCnt; 1918 int jjround; 1919 int jjmatchedPos; 1920 int jjmatchedKind; 1921 1922 public Token getNextToken() 1923 { 1924 int kind; 1925 Token specialToken = null; 1926 Token matchedToken; 1927 int curPos = 0; 1928 1929 EOFLoop : 1930 for (;;) 1931 { 1932 try 1933 { 1934 curChar = input_stream.BeginToken(); 1935 } 1936 catch(java.io.IOException e) 1937 { 1938 jjmatchedKind = 0; 1939 matchedToken = jjFillToken(); 1940 matchedToken.specialToken = specialToken; 1941 return matchedToken; 1942 } 1943 image = null; 1944 jjimageLen = 0; 1945 1946 for (;;) 1947 { 1948 switch(curLexState) 1949 { 1950 case 0: 1951 try { input_stream.backup(0); 1952 while (curChar <= 32 && (0x100003600L & (1L << curChar)) != 0L) 1953 curChar = input_stream.BeginToken(); 1954 } 1955 catch (java.io.IOException e1) { continue EOFLoop; } 1956 jjmatchedKind = 0x7fffffff; 1957 jjmatchedPos = 0; 1958 curPos = jjMoveStringLiteralDfa0_0(); 1959 if (jjmatchedPos == 0 && jjmatchedKind > 128) 1960 { 1961 jjmatchedKind = 128; 1962 } 1963 break; 1964 case 1: 1965 jjmatchedKind = 0x7fffffff; 1966 jjmatchedPos = 0; 1967 curPos = jjMoveStringLiteralDfa0_1(); 1968 if (jjmatchedPos == 0 && jjmatchedKind > 11) 1969 { 1970 jjmatchedKind = 11; 1971 } 1972 break; 1973 case 2: 1974 jjmatchedKind = 0x7fffffff; 1975 jjmatchedPos = 0; 1976 curPos = jjMoveStringLiteralDfa0_2(); 1977 if (jjmatchedPos == 0 && jjmatchedKind > 11) 1978 { 1979 jjmatchedKind = 11; 1980 } 1981 break; 1982 } 1983 if (jjmatchedKind != 0x7fffffff) 1984 { 1985 if (jjmatchedPos + 1 < curPos) 1986 input_stream.backup(curPos - jjmatchedPos - 1); 1987 if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) 1988 { 1989 matchedToken = jjFillToken(); 1990 matchedToken.specialToken = specialToken; 1991 TokenLexicalActions(matchedToken); 1992 if (jjnewLexState[jjmatchedKind] != -1) 1993 curLexState = jjnewLexState[jjmatchedKind]; 1994 return matchedToken; 1995 } 1996 else if ((jjtoSkip[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) 1997 { 1998 if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) 1999 { 2000 matchedToken = jjFillToken(); 2001 if (specialToken == null) 2002 specialToken = matchedToken; 2003 else 2004 { 2005 matchedToken.specialToken = specialToken; 2006 specialToken = (specialToken.next = matchedToken); 2007 } 2008 SkipLexicalActions(matchedToken); 2009 } 2010 else 2011 SkipLexicalActions(null); 2012 if (jjnewLexState[jjmatchedKind] != -1) 2013 curLexState = jjnewLexState[jjmatchedKind]; 2014 continue EOFLoop; 2015 } 2016 MoreLexicalActions(); 2017 if (jjnewLexState[jjmatchedKind] != -1) 2018 curLexState = jjnewLexState[jjmatchedKind]; 2019 curPos = 0; 2020 jjmatchedKind = 0x7fffffff; 2021 try { 2022 curChar = input_stream.readChar(); 2023 continue; 2024 } 2025 catch (java.io.IOException e1) { } 2026 } 2027 int error_line = input_stream.getEndLine(); 2028 int error_column = input_stream.getEndColumn(); 2029 String error_after = null; 2030 boolean EOFSeen = false; 2031 try { input_stream.readChar(); input_stream.backup(1); } 2032 catch (java.io.IOException e1) { 2033 EOFSeen = true; 2034 error_after = curPos <= 1 ? "" : input_stream.GetImage(); 2035 if (curChar == '\n' || curChar == '\r') { 2036 error_line++; 2037 error_column = 0; 2038 } 2039 else 2040 error_column++; 2041 } 2042 if (!EOFSeen) { 2043 input_stream.backup(1); 2044 error_after = curPos <= 1 ? "" : input_stream.GetImage(); 2045 } 2046 throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR); 2047 } 2048 } 2049 } 2050 2051 void SkipLexicalActions(Token matchedToken) 2052 { 2053 switch(jjmatchedKind) 2054 { 2055 default : 2056 break; 2057 } 2058 } 2059 void MoreLexicalActions() 2060 { 2061 jjimageLen += (lengthOfMatch = jjmatchedPos + 1); 2062 switch(jjmatchedKind) 2063 { 2064 case 6 : 2065 if (image == null) 2066 image = new StringBuffer(); 2067 image.append(input_stream.GetSuffix(jjimageLen)); 2068 jjimageLen = 0; 2069 input_stream.backup(1); 2070 break; 2071 default : 2072 break; 2073 } 2074 } 2075 void TokenLexicalActions(Token matchedToken) 2076 { 2077 switch(jjmatchedKind) 2078 { 2079 case 124 : 2080 if (image == null) 2081 image = new StringBuffer(); 2082 image.append(jjstrLiteralImages[124]); 2083 matchedToken.kind = GT; 2084 ((Token.GTToken)matchedToken).realKind = RUNSIGNEDSHIFT; 2085 input_stream.backup(2); 2086 matchedToken.image = ">"; 2087 break; 2088 case 125 : 2089 if (image == null) 2090 image = new StringBuffer(); 2091 image.append(jjstrLiteralImages[125]); 2092 matchedToken.kind = GT; 2093 ((Token.GTToken)matchedToken).realKind = RSIGNEDSHIFT; 2094 input_stream.backup(1); 2095 matchedToken.image = ">"; 2096 break; 2097 default : 2098 break; 2099 } 2100 } 2101 }