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