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