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