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