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