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