001/** 002 * Copyright (C) 2007 - 2016, Jens Lehmann 003 * 004 * This file is part of DL-Learner. 005 * 006 * DL-Learner is free software; you can redistribute it and/or modify 007 * it under the terms of the GNU General Public License as published by 008 * the Free Software Foundation; either version 3 of the License, or 009 * (at your option) any later version. 010 * 011 * DL-Learner is distributed in the hope that it will be useful, 012 * but WITHOUT ANY WARRANTY; without even the implied warranty of 013 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 014 * GNU General Public License for more details. 015 * 016 * You should have received a copy of the GNU General Public License 017 * along with this program. If not, see <http://www.gnu.org/licenses/>. 018 */ 019/* Generated By:JavaCC: Do not edit this line. KBParserTokenManager.java */ 020package org.dllearner.parser; 021 022/** Token Manager. */ 023@SuppressWarnings("all") 024public class KBParserTokenManager implements KBParserConstants 025{ 026 027 /** Debug output. */ 028 public java.io.PrintStream debugStream = System.out; 029 /** Set debug output. */ 030 public void setDebugStream(java.io.PrintStream ds) { debugStream = ds; } 031private final int jjStopStringLiteralDfa_0(int pos, long active0) 032{ 033 switch (pos) 034 { 035 case 0: 036 if ((active0 & 0x800034c000000L) != 0L) 037 return 10; 038 if ((active0 & 0x2000020000000L) != 0L) 039 return 18; 040 if ((active0 & 0x4000L) != 0L) 041 return 13; 042 return -1; 043 default : 044 return -1; 045 } 046} 047private final int jjStartNfa_0(int pos, long active0) 048{ 049 return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1); 050} 051private int jjStopAtPos(int pos, int kind) 052{ 053 jjmatchedKind = kind; 054 jjmatchedPos = pos; 055 return pos + 1; 056} 057private int jjMoveStringLiteralDfa0_0() 058{ 059 switch(curChar) 060 { 061 case 40: 062 return jjStopAtPos(0, 22); 063 case 41: 064 return jjStopAtPos(0, 23); 065 case 44: 066 return jjStopAtPos(0, 24); 067 case 46: 068 return jjStopAtPos(0, 8); 069 case 60: 070 return jjMoveStringLiteralDfa1_0(0x100000L); 071 case 61: 072 return jjStopAtPos(0, 25); 073 case 62: 074 return jjMoveStringLiteralDfa1_0(0x80000L); 075 case 65: 076 return jjMoveStringLiteralDfa1_0(0x4000L); 077 case 66: 078 return jjMoveStringLiteralDfa1_0(0x200000002000L); 079 case 68: 080 return jjMoveStringLiteralDfa1_0(0x1c6400000000L); 081 case 70: 082 return jjMoveStringLiteralDfa1_0(0x2000020000000L); 083 case 72: 084 return jjMoveStringLiteralDfa1_0(0x4000000000000L); 085 case 73: 086 return jjMoveStringLiteralDfa1_0(0xc00080000000L); 087 case 79: 088 return jjMoveStringLiteralDfa1_0(0x31800008000L); 089 case 82: 090 return jjMoveStringLiteralDfa1_0(0x8000000000L); 091 case 83: 092 return jjMoveStringLiteralDfa1_0(0x800034c000000L); 093 case 84: 094 return jjMoveStringLiteralDfa1_0(0x1000010001000L); 095 default : 096 return jjMoveNfa_0(0, 0); 097 } 098} 099private int jjMoveStringLiteralDfa1_0(long active0) 100{ 101 try { curChar = input_stream.readChar(); } 102 catch(java.io.IOException e) { 103 jjStopStringLiteralDfa_0(0, active0); 104 return 1; 105 } 106 switch(curChar) 107 { 108 case 61: 109 if ((active0 & 0x80000L) != 0L) 110 return jjStopAtPos(1, 19); 111 else if ((active0 & 0x100000L) != 0L) 112 return jjStopAtPos(1, 20); 113 break; 114 case 65: 115 return jjMoveStringLiteralDfa2_0(active0, 0x608c000000000L); 116 case 66: 117 return jjMoveStringLiteralDfa2_0(active0, 0x21000000000L); 118 case 78: 119 return jjMoveStringLiteralDfa2_0(active0, 0x400000004000L); 120 case 79: 121 return jjMoveStringLiteralDfa2_0(active0, 0x300400003000L); 122 case 80: 123 return jjMoveStringLiteralDfa2_0(active0, 0x52800000000L); 124 case 82: 125 if ((active0 & 0x8000L) != 0L) 126 return jjStopAtPos(1, 15); 127 return jjMoveStringLiteralDfa2_0(active0, 0x1000000000000L); 128 case 83: 129 if ((active0 & 0x800000000000L) != 0L) 130 return jjStopAtPos(1, 47); 131 break; 132 case 84: 133 return jjMoveStringLiteralDfa2_0(active0, 0x8000000000000L); 134 case 85: 135 return jjMoveStringLiteralDfa2_0(active0, 0x20c000000L); 136 case 110: 137 return jjMoveStringLiteralDfa2_0(active0, 0x80000000L); 138 case 114: 139 return jjMoveStringLiteralDfa2_0(active0, 0x10000000L); 140 case 117: 141 return jjMoveStringLiteralDfa2_0(active0, 0x120000000L); 142 case 121: 143 return jjMoveStringLiteralDfa2_0(active0, 0x40000000L); 144 default : 145 break; 146 } 147 return jjStartNfa_0(0, active0); 148} 149private int jjMoveStringLiteralDfa2_0(long old0, long active0) 150{ 151 if (((active0 &= old0)) == 0L) 152 return jjStartNfa_0(0, old0); 153 try { curChar = input_stream.readChar(); } 154 catch(java.io.IOException e) { 155 jjStopStringLiteralDfa_0(1, active0); 156 return 2; 157 } 158 switch(curChar) 159 { 160 case 66: 161 if ((active0 & 0x8000000L) != 0L) 162 { 163 jjmatchedKind = 27; 164 jjmatchedPos = 2; 165 } 166 return jjMoveStringLiteralDfa3_0(active0, 0x204000000L); 167 case 68: 168 if ((active0 & 0x4000L) != 0L) 169 return jjStopAtPos(2, 14); 170 return jjMoveStringLiteralDfa3_0(active0, 0x2800000000L); 171 case 74: 172 return jjMoveStringLiteralDfa3_0(active0, 0x21000000000L); 173 case 76: 174 return jjMoveStringLiteralDfa3_0(active0, 0x2000000000000L); 175 case 77: 176 return jjMoveStringLiteralDfa3_0(active0, 0x400000000L); 177 case 78: 178 return jjMoveStringLiteralDfa3_0(active0, 0x8000000000L); 179 case 79: 180 return jjMoveStringLiteralDfa3_0(active0, 0x200000000000L); 181 case 80: 182 if ((active0 & 0x1000L) != 0L) 183 return jjStopAtPos(2, 12); 184 break; 185 case 82: 186 return jjMoveStringLiteralDfa3_0(active0, 0x8050000000000L); 187 case 83: 188 return jjMoveStringLiteralDfa3_0(active0, 0x4000000000000L); 189 case 84: 190 return jjMoveStringLiteralDfa3_0(active0, 0x484000002000L); 191 case 85: 192 return jjMoveStringLiteralDfa3_0(active0, 0x1100000000000L); 193 case 97: 194 return jjMoveStringLiteralDfa3_0(active0, 0x10000000L); 195 case 98: 196 return jjMoveStringLiteralDfa3_0(active0, 0x100000000L); 197 case 109: 198 return jjMoveStringLiteralDfa3_0(active0, 0x40000000L); 199 case 110: 200 return jjMoveStringLiteralDfa3_0(active0, 0x20000000L); 201 case 118: 202 return jjMoveStringLiteralDfa3_0(active0, 0x80000000L); 203 default : 204 break; 205 } 206 return jjStartNfa_0(1, active0); 207} 208private int jjMoveStringLiteralDfa3_0(long old0, long active0) 209{ 210 if (((active0 &= old0)) == 0L) 211 return jjStartNfa_0(1, old0); 212 try { curChar = input_stream.readChar(); } 213 catch(java.io.IOException e) { 214 jjStopStringLiteralDfa_0(2, active0); 215 return 3; 216 } 217 switch(curChar) 218 { 219 case 65: 220 return jjMoveStringLiteralDfa4_0(active0, 0xd4400000000L); 221 case 66: 222 return jjMoveStringLiteralDfa4_0(active0, 0x100000000000L); 223 case 67: 224 return jjMoveStringLiteralDfa4_0(active0, 0x204000000L); 225 case 69: 226 if ((active0 & 0x1000000000000L) != 0L) 227 return jjStopAtPos(3, 48); 228 return jjMoveStringLiteralDfa4_0(active0, 0x421000000000L); 229 case 71: 230 return jjMoveStringLiteralDfa4_0(active0, 0x8000000000L); 231 case 73: 232 return jjMoveStringLiteralDfa4_0(active0, 0x8000000000000L); 233 case 76: 234 return jjMoveStringLiteralDfa4_0(active0, 0x200000000000L); 235 case 79: 236 return jjMoveStringLiteralDfa4_0(active0, 0x2800000000L); 237 case 83: 238 return jjMoveStringLiteralDfa4_0(active0, 0x2000000000000L); 239 case 84: 240 return jjMoveStringLiteralDfa4_0(active0, 0x2000L); 241 case 86: 242 return jjMoveStringLiteralDfa4_0(active0, 0x4000000000000L); 243 case 99: 244 return jjMoveStringLiteralDfa4_0(active0, 0x20000000L); 245 case 101: 246 return jjMoveStringLiteralDfa4_0(active0, 0x80000000L); 247 case 109: 248 return jjMoveStringLiteralDfa4_0(active0, 0x40000000L); 249 case 110: 250 return jjMoveStringLiteralDfa4_0(active0, 0x10000000L); 251 case 114: 252 return jjMoveStringLiteralDfa4_0(active0, 0x100000000L); 253 default : 254 break; 255 } 256 return jjStartNfa_0(2, active0); 257} 258private int jjMoveStringLiteralDfa4_0(long old0, long active0) 259{ 260 if (((active0 &= old0)) == 0L) 261 return jjStartNfa_0(2, old0); 262 try { curChar = input_stream.readChar(); } 263 catch(java.io.IOException e) { 264 jjStopStringLiteralDfa_0(3, active0); 265 return 4; 266 } 267 switch(curChar) 268 { 269 case 65: 270 return jjMoveStringLiteralDfa5_0(active0, 0x4000000000000L); 271 case 67: 272 return jjMoveStringLiteralDfa5_0(active0, 0x21000000000L); 273 case 69: 274 if ((active0 & 0x8000000000L) != 0L) 275 return jjStopAtPos(4, 39); 276 else if ((active0 & 0x2000000000000L) != 0L) 277 return jjStopAtPos(4, 49); 278 return jjMoveStringLiteralDfa5_0(active0, 0x200000000000L); 279 case 71: 280 return jjMoveStringLiteralDfa5_0(active0, 0x400000000000L); 281 case 73: 282 return jjMoveStringLiteralDfa5_0(active0, 0x400000000L); 283 case 76: 284 return jjMoveStringLiteralDfa5_0(active0, 0x100004000000L); 285 case 77: 286 return jjMoveStringLiteralDfa5_0(active0, 0x2800000000L); 287 case 78: 288 return jjMoveStringLiteralDfa5_0(active0, 0x8050000000000L); 289 case 79: 290 return jjMoveStringLiteralDfa5_0(active0, 0x200002000L); 291 case 84: 292 return jjMoveStringLiteralDfa5_0(active0, 0x84000000000L); 293 case 101: 294 return jjMoveStringLiteralDfa5_0(active0, 0x40000000L); 295 case 111: 296 return jjMoveStringLiteralDfa5_0(active0, 0x100000000L); 297 case 114: 298 return jjMoveStringLiteralDfa5_0(active0, 0x80000000L); 299 case 115: 300 return jjMoveStringLiteralDfa5_0(active0, 0x10000000L); 301 case 116: 302 return jjMoveStringLiteralDfa5_0(active0, 0x20000000L); 303 default : 304 break; 305 } 306 return jjStartNfa_0(3, active0); 307} 308private int jjMoveStringLiteralDfa5_0(long old0, long active0) 309{ 310 if (((active0 &= old0)) == 0L) 311 return jjStartNfa_0(3, old0); 312 try { curChar = input_stream.readChar(); } 313 catch(java.io.IOException e) { 314 jjStopStringLiteralDfa_0(4, active0); 315 return 5; 316 } 317 switch(curChar) 318 { 319 case 65: 320 return jjMoveStringLiteralDfa6_0(active0, 0x202804000000L); 321 case 69: 322 if ((active0 & 0x100000000000L) != 0L) 323 return jjStopAtPos(5, 44); 324 return jjMoveStringLiteralDfa6_0(active0, 0x400000000000L); 325 case 71: 326 return jjMoveStringLiteralDfa6_0(active0, 0x8050000000000L); 327 case 76: 328 return jjMoveStringLiteralDfa6_0(active0, 0x4000000000000L); 329 case 77: 330 if ((active0 & 0x2000L) != 0L) 331 return jjStopAtPos(5, 13); 332 break; 333 case 78: 334 if ((active0 & 0x400000000L) != 0L) 335 return jjStopAtPos(5, 34); 336 return jjMoveStringLiteralDfa6_0(active0, 0x200000000L); 337 case 84: 338 return jjMoveStringLiteralDfa6_0(active0, 0x21000000000L); 339 case 89: 340 return jjMoveStringLiteralDfa6_0(active0, 0x84000000000L); 341 case 105: 342 return jjMoveStringLiteralDfa6_0(active0, 0x30000000L); 343 case 108: 344 return jjMoveStringLiteralDfa6_0(active0, 0x100000000L); 345 case 115: 346 return jjMoveStringLiteralDfa6_0(active0, 0x80000000L); 347 case 116: 348 return jjMoveStringLiteralDfa6_0(active0, 0x40000000L); 349 default : 350 break; 351 } 352 return jjStartNfa_0(4, active0); 353} 354private int jjMoveStringLiteralDfa6_0(long old0, long active0) 355{ 356 if (((active0 &= old0)) == 0L) 357 return jjStartNfa_0(4, old0); 358 try { curChar = input_stream.readChar(); } 359 catch(java.io.IOException e) { 360 jjStopStringLiteralDfa_0(5, active0); 361 return 6; 362 } 363 switch(curChar) 364 { 365 case 67: 366 return jjMoveStringLiteralDfa7_0(active0, 0x200000000L); 367 case 69: 368 if ((active0 & 0x10000000000L) != 0L) 369 return jjStopAtPos(6, 40); 370 else if ((active0 & 0x40000000000L) != 0L) 371 return jjStopAtPos(6, 42); 372 break; 373 case 73: 374 return jjMoveStringLiteralDfa7_0(active0, 0x2800000000L); 375 case 78: 376 if ((active0 & 0x200000000000L) != 0L) 377 return jjStopAtPos(6, 45); 378 break; 379 case 80: 380 return jjMoveStringLiteralDfa7_0(active0, 0xa5000000000L); 381 case 82: 382 if ((active0 & 0x400000000000L) != 0L) 383 return jjStopAtPos(6, 46); 384 break; 385 case 83: 386 return jjMoveStringLiteralDfa7_0(active0, 0x4000000L); 387 case 85: 388 return jjMoveStringLiteralDfa7_0(active0, 0x4000000000000L); 389 case 86: 390 return jjMoveStringLiteralDfa7_0(active0, 0x8000000000000L); 391 case 101: 392 if ((active0 & 0x80000000L) != 0L) 393 return jjStopAtPos(6, 31); 394 else if ((active0 & 0x100000000L) != 0L) 395 return jjStopAtPos(6, 32); 396 break; 397 case 111: 398 return jjMoveStringLiteralDfa7_0(active0, 0x20000000L); 399 case 114: 400 return jjMoveStringLiteralDfa7_0(active0, 0x40000000L); 401 case 116: 402 return jjMoveStringLiteralDfa7_0(active0, 0x10000000L); 403 default : 404 break; 405 } 406 return jjStartNfa_0(5, active0); 407} 408private int jjMoveStringLiteralDfa7_0(long old0, long active0) 409{ 410 if (((active0 &= old0)) == 0L) 411 return jjStartNfa_0(5, old0); 412 try { curChar = input_stream.readChar(); } 413 catch(java.io.IOException e) { 414 jjStopStringLiteralDfa_0(6, active0); 415 return 7; 416 } 417 switch(curChar) 418 { 419 case 65: 420 return jjMoveStringLiteralDfa8_0(active0, 0x8000000000000L); 421 case 69: 422 if ((active0 & 0x4000000000000L) != 0L) 423 return jjStopAtPos(7, 50); 424 return jjMoveStringLiteralDfa8_0(active0, 0x84200000000L); 425 case 78: 426 if ((active0 & 0x800000000L) != 0L) 427 return jjStopAtPos(7, 35); 428 else if ((active0 & 0x2000000000L) != 0L) 429 return jjStopAtPos(7, 37); 430 break; 431 case 82: 432 return jjMoveStringLiteralDfa8_0(active0, 0x21000000000L); 433 case 83: 434 return jjMoveStringLiteralDfa8_0(active0, 0x4000000L); 435 case 105: 436 return jjMoveStringLiteralDfa8_0(active0, 0x50000000L); 437 case 110: 438 return jjMoveStringLiteralDfa8_0(active0, 0x20000000L); 439 default : 440 break; 441 } 442 return jjStartNfa_0(6, active0); 443} 444private int jjMoveStringLiteralDfa8_0(long old0, long active0) 445{ 446 if (((active0 &= old0)) == 0L) 447 return jjStartNfa_0(6, old0); 448 try { curChar = input_stream.readChar(); } 449 catch(java.io.IOException e) { 450 jjStopStringLiteralDfa_0(7, active0); 451 return 8; 452 } 453 switch(curChar) 454 { 455 case 76: 456 return jjMoveStringLiteralDfa9_0(active0, 0x8000000000000L); 457 case 79: 458 return jjMoveStringLiteralDfa9_0(active0, 0x21004000000L); 459 case 80: 460 return jjMoveStringLiteralDfa9_0(active0, 0x84200000000L); 461 case 97: 462 return jjMoveStringLiteralDfa9_0(active0, 0x20000000L); 463 case 99: 464 if ((active0 & 0x40000000L) != 0L) 465 return jjStopAtPos(8, 30); 466 break; 467 case 118: 468 return jjMoveStringLiteralDfa9_0(active0, 0x10000000L); 469 default : 470 break; 471 } 472 return jjStartNfa_0(7, active0); 473} 474private int jjMoveStringLiteralDfa9_0(long old0, long active0) 475{ 476 if (((active0 &= old0)) == 0L) 477 return jjStartNfa_0(7, old0); 478 try { curChar = input_stream.readChar(); } 479 catch(java.io.IOException e) { 480 jjStopStringLiteralDfa_0(8, active0); 481 return 9; 482 } 483 switch(curChar) 484 { 485 case 70: 486 if ((active0 & 0x4000000L) != 0L) 487 return jjStopAtPos(9, 26); 488 break; 489 case 80: 490 return jjMoveStringLiteralDfa10_0(active0, 0x21000000000L); 491 case 82: 492 return jjMoveStringLiteralDfa10_0(active0, 0x84000000000L); 493 case 84: 494 return jjMoveStringLiteralDfa10_0(active0, 0x200000000L); 495 case 85: 496 return jjMoveStringLiteralDfa10_0(active0, 0x8000000000000L); 497 case 101: 498 if ((active0 & 0x10000000L) != 0L) 499 return jjStopAtPos(9, 28); 500 break; 501 case 108: 502 if ((active0 & 0x20000000L) != 0L) 503 return jjStopAtPos(9, 29); 504 break; 505 default : 506 break; 507 } 508 return jjStartNfa_0(8, active0); 509} 510private int jjMoveStringLiteralDfa10_0(long old0, long active0) 511{ 512 if (((active0 &= old0)) == 0L) 513 return jjStartNfa_0(8, old0); 514 try { curChar = input_stream.readChar(); } 515 catch(java.io.IOException e) { 516 jjStopStringLiteralDfa_0(9, active0); 517 return 10; 518 } 519 switch(curChar) 520 { 521 case 69: 522 if ((active0 & 0x8000000000000L) != 0L) 523 return jjStopAtPos(10, 51); 524 return jjMoveStringLiteralDfa11_0(active0, 0x21000000000L); 525 case 79: 526 return jjMoveStringLiteralDfa11_0(active0, 0x84200000000L); 527 default : 528 break; 529 } 530 return jjStartNfa_0(9, active0); 531} 532private int jjMoveStringLiteralDfa11_0(long old0, long active0) 533{ 534 if (((active0 &= old0)) == 0L) 535 return jjStartNfa_0(9, old0); 536 try { curChar = input_stream.readChar(); } 537 catch(java.io.IOException e) { 538 jjStopStringLiteralDfa_0(10, active0); 539 return 11; 540 } 541 switch(curChar) 542 { 543 case 70: 544 if ((active0 & 0x200000000L) != 0L) 545 return jjStopAtPos(11, 33); 546 break; 547 case 80: 548 return jjMoveStringLiteralDfa12_0(active0, 0x84000000000L); 549 case 82: 550 return jjMoveStringLiteralDfa12_0(active0, 0x21000000000L); 551 default : 552 break; 553 } 554 return jjStartNfa_0(10, active0); 555} 556private int jjMoveStringLiteralDfa12_0(long old0, long active0) 557{ 558 if (((active0 &= old0)) == 0L) 559 return jjStartNfa_0(10, old0); 560 try { curChar = input_stream.readChar(); } 561 catch(java.io.IOException e) { 562 jjStopStringLiteralDfa_0(11, active0); 563 return 12; 564 } 565 switch(curChar) 566 { 567 case 69: 568 return jjMoveStringLiteralDfa13_0(active0, 0x84000000000L); 569 case 84: 570 return jjMoveStringLiteralDfa13_0(active0, 0x21000000000L); 571 default : 572 break; 573 } 574 return jjStartNfa_0(11, active0); 575} 576private int jjMoveStringLiteralDfa13_0(long old0, long active0) 577{ 578 if (((active0 &= old0)) == 0L) 579 return jjStartNfa_0(11, old0); 580 try { curChar = input_stream.readChar(); } 581 catch(java.io.IOException e) { 582 jjStopStringLiteralDfa_0(12, active0); 583 return 13; 584 } 585 switch(curChar) 586 { 587 case 82: 588 return jjMoveStringLiteralDfa14_0(active0, 0x84000000000L); 589 case 89: 590 return jjMoveStringLiteralDfa14_0(active0, 0x21000000000L); 591 default : 592 break; 593 } 594 return jjStartNfa_0(12, active0); 595} 596private int jjMoveStringLiteralDfa14_0(long old0, long active0) 597{ 598 if (((active0 &= old0)) == 0L) 599 return jjStartNfa_0(12, old0); 600 try { curChar = input_stream.readChar(); } 601 catch(java.io.IOException e) { 602 jjStopStringLiteralDfa_0(13, active0); 603 return 14; 604 } 605 switch(curChar) 606 { 607 case 68: 608 return jjMoveStringLiteralDfa15_0(active0, 0x1000000000L); 609 case 82: 610 return jjMoveStringLiteralDfa15_0(active0, 0x20000000000L); 611 case 84: 612 return jjMoveStringLiteralDfa15_0(active0, 0x84000000000L); 613 default : 614 break; 615 } 616 return jjStartNfa_0(13, active0); 617} 618private int jjMoveStringLiteralDfa15_0(long old0, long active0) 619{ 620 if (((active0 &= old0)) == 0L) 621 return jjStartNfa_0(13, old0); 622 try { curChar = input_stream.readChar(); } 623 catch(java.io.IOException e) { 624 jjStopStringLiteralDfa_0(14, active0); 625 return 15; 626 } 627 switch(curChar) 628 { 629 case 65: 630 return jjMoveStringLiteralDfa16_0(active0, 0x20000000000L); 631 case 79: 632 return jjMoveStringLiteralDfa16_0(active0, 0x1000000000L); 633 case 89: 634 return jjMoveStringLiteralDfa16_0(active0, 0x84000000000L); 635 default : 636 break; 637 } 638 return jjStartNfa_0(14, active0); 639} 640private int jjMoveStringLiteralDfa16_0(long old0, long active0) 641{ 642 if (((active0 &= old0)) == 0L) 643 return jjStartNfa_0(14, old0); 644 try { curChar = input_stream.readChar(); } 645 catch(java.io.IOException e) { 646 jjStopStringLiteralDfa_0(15, active0); 647 return 16; 648 } 649 switch(curChar) 650 { 651 case 68: 652 return jjMoveStringLiteralDfa17_0(active0, 0x4000000000L); 653 case 77: 654 return jjMoveStringLiteralDfa17_0(active0, 0x1000000000L); 655 case 78: 656 return jjMoveStringLiteralDfa17_0(active0, 0x20000000000L); 657 case 82: 658 return jjMoveStringLiteralDfa17_0(active0, 0x80000000000L); 659 default : 660 break; 661 } 662 return jjStartNfa_0(15, active0); 663} 664private int jjMoveStringLiteralDfa17_0(long old0, long active0) 665{ 666 if (((active0 &= old0)) == 0L) 667 return jjStartNfa_0(15, old0); 668 try { curChar = input_stream.readChar(); } 669 catch(java.io.IOException e) { 670 jjStopStringLiteralDfa_0(16, active0); 671 return 17; 672 } 673 switch(curChar) 674 { 675 case 65: 676 return jjMoveStringLiteralDfa18_0(active0, 0x81000000000L); 677 case 71: 678 return jjMoveStringLiteralDfa18_0(active0, 0x20000000000L); 679 case 79: 680 return jjMoveStringLiteralDfa18_0(active0, 0x4000000000L); 681 default : 682 break; 683 } 684 return jjStartNfa_0(16, active0); 685} 686private int jjMoveStringLiteralDfa18_0(long old0, long active0) 687{ 688 if (((active0 &= old0)) == 0L) 689 return jjStartNfa_0(16, old0); 690 try { curChar = input_stream.readChar(); } 691 catch(java.io.IOException e) { 692 jjStopStringLiteralDfa_0(17, active0); 693 return 18; 694 } 695 switch(curChar) 696 { 697 case 69: 698 if ((active0 & 0x20000000000L) != 0L) 699 return jjStopAtPos(18, 41); 700 break; 701 case 73: 702 return jjMoveStringLiteralDfa19_0(active0, 0x1000000000L); 703 case 77: 704 return jjMoveStringLiteralDfa19_0(active0, 0x4000000000L); 705 case 78: 706 return jjMoveStringLiteralDfa19_0(active0, 0x80000000000L); 707 default : 708 break; 709 } 710 return jjStartNfa_0(17, active0); 711} 712private int jjMoveStringLiteralDfa19_0(long old0, long active0) 713{ 714 if (((active0 &= old0)) == 0L) 715 return jjStartNfa_0(17, old0); 716 try { curChar = input_stream.readChar(); } 717 catch(java.io.IOException e) { 718 jjStopStringLiteralDfa_0(18, active0); 719 return 19; 720 } 721 switch(curChar) 722 { 723 case 65: 724 return jjMoveStringLiteralDfa20_0(active0, 0x4000000000L); 725 case 71: 726 return jjMoveStringLiteralDfa20_0(active0, 0x80000000000L); 727 case 78: 728 if ((active0 & 0x1000000000L) != 0L) 729 return jjStopAtPos(19, 36); 730 break; 731 default : 732 break; 733 } 734 return jjStartNfa_0(18, active0); 735} 736private int jjMoveStringLiteralDfa20_0(long old0, long active0) 737{ 738 if (((active0 &= old0)) == 0L) 739 return jjStartNfa_0(18, old0); 740 try { curChar = input_stream.readChar(); } 741 catch(java.io.IOException e) { 742 jjStopStringLiteralDfa_0(19, active0); 743 return 20; 744 } 745 switch(curChar) 746 { 747 case 69: 748 if ((active0 & 0x80000000000L) != 0L) 749 return jjStopAtPos(20, 43); 750 break; 751 case 73: 752 return jjMoveStringLiteralDfa21_0(active0, 0x4000000000L); 753 default : 754 break; 755 } 756 return jjStartNfa_0(19, active0); 757} 758private int jjMoveStringLiteralDfa21_0(long old0, long active0) 759{ 760 if (((active0 &= old0)) == 0L) 761 return jjStartNfa_0(19, old0); 762 try { curChar = input_stream.readChar(); } 763 catch(java.io.IOException e) { 764 jjStopStringLiteralDfa_0(20, active0); 765 return 21; 766 } 767 switch(curChar) 768 { 769 case 78: 770 if ((active0 & 0x4000000000L) != 0L) 771 return jjStopAtPos(21, 38); 772 break; 773 default : 774 break; 775 } 776 return jjStartNfa_0(20, active0); 777} 778static final long[] jjbitVec0 = { 779 0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL 780}; 781private int jjMoveNfa_0(int startState, int curPos) 782{ 783 int startsAt = 0; 784 jjnewStateCnt = 53; 785 int i = 1; 786 jjstateSet[0] = startState; 787 int kind = 0x7fffffff; 788 for (;;) 789 { 790 if (++jjround == 0x7fffffff) 791 ReInitRounds(); 792 if (curChar < 64) 793 { 794 long l = 1L << curChar; 795 do 796 { 797 switch(jjstateSet[--i]) 798 { 799 case 0: 800 if ((0x3fe000000000000L & l) != 0L) 801 { 802 if (kind > 10) 803 kind = 10; 804 jjCheckNAddStates(0, 2); 805 } 806 else if (curChar == 48) 807 { 808 if (kind > 10) 809 kind = 10; 810 jjCheckNAdd(50); 811 } 812 else if (curChar == 47) 813 jjAddStates(3, 5); 814 else if (curChar == 34) 815 jjCheckNAddTwoStates(21, 22); 816 break; 817 case 1: 818 if ((0x3ff000000000000L & l) == 0L) 819 break; 820 if (kind > 9) 821 kind = 9; 822 jjstateSet[jjnewStateCnt++] = 1; 823 break; 824 case 20: 825 if (curChar == 34) 826 jjCheckNAddTwoStates(21, 22); 827 break; 828 case 21: 829 if ((0xfffffffbffffdbffL & l) != 0L) 830 jjCheckNAddTwoStates(21, 22); 831 break; 832 case 22: 833 if (curChar == 34 && kind > 21) 834 kind = 21; 835 break; 836 case 28: 837 if (curChar == 47) 838 jjAddStates(3, 5); 839 break; 840 case 29: 841 if (curChar == 47) 842 jjCheckNAddStates(6, 8); 843 break; 844 case 30: 845 if ((0xffffffffffffdbffL & l) != 0L) 846 jjCheckNAddStates(6, 8); 847 break; 848 case 31: 849 if ((0x2400L & l) != 0L && kind > 5) 850 kind = 5; 851 break; 852 case 32: 853 if (curChar == 10 && kind > 5) 854 kind = 5; 855 break; 856 case 33: 857 if (curChar == 13) 858 jjstateSet[jjnewStateCnt++] = 32; 859 break; 860 case 34: 861 if (curChar == 42) 862 jjCheckNAddTwoStates(35, 36); 863 break; 864 case 35: 865 if ((0xfffffbffffffffffL & l) != 0L) 866 jjCheckNAddTwoStates(35, 36); 867 break; 868 case 36: 869 if (curChar == 42) 870 jjCheckNAddStates(9, 11); 871 break; 872 case 37: 873 if ((0xffff7bffffffffffL & l) != 0L) 874 jjCheckNAddTwoStates(38, 36); 875 break; 876 case 38: 877 if ((0xfffffbffffffffffL & l) != 0L) 878 jjCheckNAddTwoStates(38, 36); 879 break; 880 case 39: 881 if (curChar == 47 && kind > 6) 882 kind = 6; 883 break; 884 case 40: 885 if (curChar == 42) 886 jjstateSet[jjnewStateCnt++] = 34; 887 break; 888 case 41: 889 if (curChar == 42) 890 jjCheckNAddTwoStates(42, 43); 891 break; 892 case 42: 893 if ((0xfffffbffffffffffL & l) != 0L) 894 jjCheckNAddTwoStates(42, 43); 895 break; 896 case 43: 897 if (curChar == 42) 898 jjCheckNAddStates(12, 14); 899 break; 900 case 44: 901 if ((0xffff7bffffffffffL & l) != 0L) 902 jjCheckNAddTwoStates(45, 43); 903 break; 904 case 45: 905 if ((0xfffffbffffffffffL & l) != 0L) 906 jjCheckNAddTwoStates(45, 43); 907 break; 908 case 46: 909 if (curChar == 47 && kind > 7) 910 kind = 7; 911 break; 912 case 47: 913 if ((0x3fe000000000000L & l) == 0L) 914 break; 915 if (kind > 10) 916 kind = 10; 917 jjCheckNAddStates(0, 2); 918 break; 919 case 48: 920 if ((0x3ff000000000000L & l) == 0L) 921 break; 922 if (kind > 10) 923 kind = 10; 924 jjCheckNAdd(48); 925 break; 926 case 49: 927 if ((0x3ff000000000000L & l) != 0L) 928 jjCheckNAddTwoStates(49, 50); 929 break; 930 case 50: 931 if (curChar != 46) 932 break; 933 if (kind > 11) 934 kind = 11; 935 jjCheckNAdd(51); 936 break; 937 case 51: 938 if ((0x3ff000000000000L & l) == 0L) 939 break; 940 if (kind > 11) 941 kind = 11; 942 jjCheckNAdd(51); 943 break; 944 case 52: 945 if (curChar != 48) 946 break; 947 if (kind > 10) 948 kind = 10; 949 jjCheckNAdd(50); 950 break; 951 default : break; 952 } 953 } while(i != startsAt); 954 } 955 else if (curChar < 128) 956 { 957 long l = 1L << (curChar & 077); 958 do 959 { 960 switch(jjstateSet[--i]) 961 { 962 case 0: 963 if ((0x7fffffe00000000L & l) != 0L) 964 { 965 if (kind > 9) 966 kind = 9; 967 jjCheckNAdd(1); 968 } 969 else if (curChar == 78) 970 jjAddStates(15, 16); 971 else if (curChar == 70) 972 jjstateSet[jjnewStateCnt++] = 18; 973 else if (curChar == 65) 974 jjstateSet[jjnewStateCnt++] = 13; 975 else if (curChar == 83) 976 jjstateSet[jjnewStateCnt++] = 10; 977 else if (curChar == 69) 978 jjstateSet[jjnewStateCnt++] = 6; 979 break; 980 case 1: 981 if ((0x7fffffe87fffffeL & l) == 0L) 982 break; 983 if (kind > 9) 984 kind = 9; 985 jjCheckNAdd(1); 986 break; 987 case 2: 988 if (curChar == 83 && kind > 16) 989 kind = 16; 990 break; 991 case 3: 992 if (curChar == 84) 993 jjstateSet[jjnewStateCnt++] = 2; 994 break; 995 case 4: 996 if (curChar == 83) 997 jjstateSet[jjnewStateCnt++] = 3; 998 break; 999 case 5: 1000 if (curChar == 73) 1001 jjstateSet[jjnewStateCnt++] = 4; 1002 break; 1003 case 6: 1004 if (curChar == 88) 1005 jjstateSet[jjnewStateCnt++] = 5; 1006 break; 1007 case 7: 1008 if (curChar == 69) 1009 jjstateSet[jjnewStateCnt++] = 6; 1010 break; 1011 case 8: 1012 if (curChar == 69 && kind > 16) 1013 kind = 16; 1014 break; 1015 case 9: 1016 if (curChar == 77) 1017 jjstateSet[jjnewStateCnt++] = 8; 1018 break; 1019 case 10: 1020 if (curChar == 79) 1021 jjstateSet[jjnewStateCnt++] = 9; 1022 break; 1023 case 11: 1024 if (curChar == 83) 1025 jjstateSet[jjnewStateCnt++] = 10; 1026 break; 1027 case 12: 1028 if (curChar == 76 && kind > 17) 1029 kind = 17; 1030 break; 1031 case 13: 1032 case 15: 1033 if (curChar == 76) 1034 jjCheckNAdd(12); 1035 break; 1036 case 14: 1037 if (curChar == 65) 1038 jjstateSet[jjnewStateCnt++] = 13; 1039 break; 1040 case 16: 1041 if (curChar == 65) 1042 jjstateSet[jjnewStateCnt++] = 15; 1043 break; 1044 case 17: 1045 if (curChar == 82) 1046 jjstateSet[jjnewStateCnt++] = 16; 1047 break; 1048 case 18: 1049 if (curChar == 79) 1050 jjstateSet[jjnewStateCnt++] = 17; 1051 break; 1052 case 19: 1053 if (curChar == 70) 1054 jjstateSet[jjnewStateCnt++] = 18; 1055 break; 1056 case 21: 1057 if ((0xffffffffefffffffL & l) != 0L) 1058 jjAddStates(17, 18); 1059 break; 1060 case 23: 1061 if (curChar == 78) 1062 jjAddStates(15, 16); 1063 break; 1064 case 24: 1065 if (curChar == 71 && kind > 18) 1066 kind = 18; 1067 break; 1068 case 25: 1069 if (curChar == 69) 1070 jjstateSet[jjnewStateCnt++] = 24; 1071 break; 1072 case 26: 1073 if (curChar == 84 && kind > 18) 1074 kind = 18; 1075 break; 1076 case 27: 1077 if (curChar == 79) 1078 jjstateSet[jjnewStateCnt++] = 26; 1079 break; 1080 case 30: 1081 jjAddStates(6, 8); 1082 break; 1083 case 35: 1084 jjCheckNAddTwoStates(35, 36); 1085 break; 1086 case 37: 1087 case 38: 1088 jjCheckNAddTwoStates(38, 36); 1089 break; 1090 case 42: 1091 jjCheckNAddTwoStates(42, 43); 1092 break; 1093 case 44: 1094 case 45: 1095 jjCheckNAddTwoStates(45, 43); 1096 break; 1097 default : break; 1098 } 1099 } while(i != startsAt); 1100 } 1101 else 1102 { 1103 int i2 = (curChar & 0xff) >> 6; 1104 long l2 = 1L << (curChar & 077); 1105 do 1106 { 1107 switch(jjstateSet[--i]) 1108 { 1109 case 21: 1110 if ((jjbitVec0[i2] & l2) != 0L) 1111 jjAddStates(17, 18); 1112 break; 1113 case 30: 1114 if ((jjbitVec0[i2] & l2) != 0L) 1115 jjAddStates(6, 8); 1116 break; 1117 case 35: 1118 if ((jjbitVec0[i2] & l2) != 0L) 1119 jjCheckNAddTwoStates(35, 36); 1120 break; 1121 case 37: 1122 case 38: 1123 if ((jjbitVec0[i2] & l2) != 0L) 1124 jjCheckNAddTwoStates(38, 36); 1125 break; 1126 case 42: 1127 if ((jjbitVec0[i2] & l2) != 0L) 1128 jjCheckNAddTwoStates(42, 43); 1129 break; 1130 case 44: 1131 case 45: 1132 if ((jjbitVec0[i2] & l2) != 0L) 1133 jjCheckNAddTwoStates(45, 43); 1134 break; 1135 default : break; 1136 } 1137 } while(i != startsAt); 1138 } 1139 if (kind != 0x7fffffff) 1140 { 1141 jjmatchedKind = kind; 1142 jjmatchedPos = curPos; 1143 kind = 0x7fffffff; 1144 } 1145 ++curPos; 1146 if ((i = jjnewStateCnt) == (startsAt = 53 - (jjnewStateCnt = startsAt))) 1147 return curPos; 1148 try { curChar = input_stream.readChar(); } 1149 catch(java.io.IOException e) { return curPos; } 1150 } 1151} 1152static final int[] jjnextStates = { 1153 48, 49, 50, 29, 40, 41, 30, 31, 33, 36, 37, 39, 43, 44, 46, 25, 1154 27, 21, 22, 1155}; 1156 1157/** Token literal values. */ 1158public static final String[] jjstrLiteralImages = { 1159"", null, null, null, null, null, null, null, "\56", null, null, null, 1160"\124\117\120", "\102\117\124\124\117\115", "\101\116\104", "\117\122", null, null, null, 1161"\76\75", "\74\75", null, "\50", "\51", "\54", "\75", 1162"\123\125\102\103\114\101\123\123\117\106", "\123\125\102", "\124\162\141\156\163\151\164\151\166\145", 1163"\106\165\156\143\164\151\157\156\141\154", "\123\171\155\155\145\164\162\151\143", "\111\156\166\145\162\163\145", 1164"\123\165\142\162\157\154\145", "\123\125\102\103\117\116\103\105\120\124\117\106", 1165"\104\117\115\101\111\116", "\117\120\104\117\115\101\111\116", 1166"\117\102\112\105\103\124\120\122\117\120\105\122\124\131\104\117\115\101\111\116", "\104\120\104\117\115\101\111\116", 1167"\104\101\124\101\124\131\120\105\120\122\117\120\105\122\124\131\104\117\115\101\111\116", "\122\101\116\107\105", "\117\120\122\101\116\107\105", 1168"\117\102\112\105\103\124\120\122\117\120\105\122\124\131\122\101\116\107\105", "\104\120\122\101\116\107\105", 1169"\104\101\124\101\124\131\120\105\120\122\117\120\105\122\124\131\122\101\116\107\105", "\104\117\125\102\114\105", "\102\117\117\114\105\101\116", 1170"\111\116\124\105\107\105\122", "\111\123", "\124\122\125\105", "\106\101\114\123\105", 1171"\110\101\123\126\101\114\125\105", "\123\124\122\111\116\107\126\101\114\125\105", }; 1172 1173/** Lexer state names. */ 1174public static final String[] lexStateNames = { 1175 "DEFAULT", 1176}; 1177static final long[] jjtoToken = { 1178 0xfffffffffff01L, 1179}; 1180static final long[] jjtoSkip = { 1181 0xfeL, 1182}; 1183protected SimpleCharStream input_stream; 1184private final int[] jjrounds = new int[53]; 1185private final int[] jjstateSet = new int[106]; 1186protected char curChar; 1187/** Constructor. */ 1188public KBParserTokenManager(SimpleCharStream stream){ 1189 if (SimpleCharStream.staticFlag) 1190 throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer."); 1191 input_stream = stream; 1192} 1193 1194/** Constructor. */ 1195public KBParserTokenManager(SimpleCharStream stream, int lexState){ 1196 this(stream); 1197 SwitchTo(lexState); 1198} 1199 1200/** Reinitialise parser. */ 1201public void ReInit(SimpleCharStream stream) 1202{ 1203 jjmatchedPos = jjnewStateCnt = 0; 1204 curLexState = defaultLexState; 1205 input_stream = stream; 1206 ReInitRounds(); 1207} 1208private void ReInitRounds() 1209{ 1210 int i; 1211 jjround = 0x80000001; 1212 for (i = 53; i-- > 0;) 1213 jjrounds[i] = 0x80000000; 1214} 1215 1216/** Reinitialise parser. */ 1217public void ReInit(SimpleCharStream stream, int lexState) 1218{ 1219 ReInit(stream); 1220 SwitchTo(lexState); 1221} 1222 1223/** Switch to specified lex state. */ 1224public void SwitchTo(int lexState) 1225{ 1226 if (lexState >= 1 || lexState < 0) 1227 throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE); 1228 else 1229 curLexState = lexState; 1230} 1231 1232protected Token jjFillToken() 1233{ 1234 final Token t; 1235 final String curTokenImage; 1236 final int beginLine; 1237 final int endLine; 1238 final int beginColumn; 1239 final int endColumn; 1240 String im = jjstrLiteralImages[jjmatchedKind]; 1241 curTokenImage = (im == null) ? input_stream.GetImage() : im; 1242 beginLine = input_stream.getBeginLine(); 1243 beginColumn = input_stream.getBeginColumn(); 1244 endLine = input_stream.getEndLine(); 1245 endColumn = input_stream.getEndColumn(); 1246 t = Token.newToken(jjmatchedKind, curTokenImage); 1247 1248 t.beginLine = beginLine; 1249 t.endLine = endLine; 1250 t.beginColumn = beginColumn; 1251 t.endColumn = endColumn; 1252 1253 return t; 1254} 1255 1256int curLexState = 0; 1257int defaultLexState = 0; 1258int jjnewStateCnt; 1259int jjround; 1260int jjmatchedPos; 1261int jjmatchedKind; 1262 1263/** Get the next Token. */ 1264public Token getNextToken() 1265{ 1266 Token matchedToken; 1267 int curPos = 0; 1268 1269 EOFLoop : 1270 for (;;) 1271 { 1272 try 1273 { 1274 curChar = input_stream.BeginToken(); 1275 } 1276 catch(java.io.IOException e) 1277 { 1278 jjmatchedKind = 0; 1279 matchedToken = jjFillToken(); 1280 return matchedToken; 1281 } 1282 1283 try { input_stream.backup(0); 1284 while (curChar <= 32 && (0x100002600L & (1L << curChar)) != 0L) 1285 curChar = input_stream.BeginToken(); 1286 } 1287 catch (java.io.IOException e1) { continue EOFLoop; } 1288 jjmatchedKind = 0x7fffffff; 1289 jjmatchedPos = 0; 1290 curPos = jjMoveStringLiteralDfa0_0(); 1291 if (jjmatchedKind != 0x7fffffff) 1292 { 1293 if (jjmatchedPos + 1 < curPos) 1294 input_stream.backup(curPos - jjmatchedPos - 1); 1295 if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) 1296 { 1297 matchedToken = jjFillToken(); 1298 return matchedToken; 1299 } 1300 else 1301 { 1302 continue EOFLoop; 1303 } 1304 } 1305 int error_line = input_stream.getEndLine(); 1306 int error_column = input_stream.getEndColumn(); 1307 String error_after = null; 1308 boolean EOFSeen = false; 1309 try { input_stream.readChar(); input_stream.backup(1); } 1310 catch (java.io.IOException e1) { 1311 EOFSeen = true; 1312 error_after = curPos <= 1 ? "" : input_stream.GetImage(); 1313 if (curChar == '\n' || curChar == '\r') { 1314 error_line++; 1315 error_column = 0; 1316 } 1317 else 1318 error_column++; 1319 } 1320 if (!EOFSeen) { 1321 input_stream.backup(1); 1322 error_after = curPos <= 1 ? "" : input_stream.GetImage(); 1323 } 1324 throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR); 1325 } 1326} 1327 1328private void jjCheckNAdd(int state) 1329{ 1330 if (jjrounds[state] != jjround) 1331 { 1332 jjstateSet[jjnewStateCnt++] = state; 1333 jjrounds[state] = jjround; 1334 } 1335} 1336private void jjAddStates(int start, int end) 1337{ 1338 do { 1339 jjstateSet[jjnewStateCnt++] = jjnextStates[start]; 1340 } while (start++ != end); 1341} 1342private void jjCheckNAddTwoStates(int state1, int state2) 1343{ 1344 jjCheckNAdd(state1); 1345 jjCheckNAdd(state2); 1346} 1347 1348private void jjCheckNAddStates(int start, int end) 1349{ 1350 do { 1351 jjCheckNAdd(jjnextStates[start]); 1352 } while (start++ != end); 1353} 1354 1355}