001/* SRCPClientParser.java */ 002/* Generated By:JJTree&JavaCC: Do not edit this line. SRCPClientParser.java */ 003package jmri.jmrix.srcp.parser; 004 005import org.slf4j.Logger; 006import org.slf4j.LoggerFactory; 007 008/* 009 * This file defines a JavaTree/JavaCC parser implementation for 010 * the SRCP protocol responses to the client. 011 * 012 * @author Paul Bender Copyright (C) 2011 013 */ 014 015// This is generated code. DO NOT ATTEMPT TO FIX ANY FINDBUGS WARNINGS 016@edu.umd.cs.findbugs.annotations.SuppressFBWarnings({ 017 "NM_METHOD_NAMING_CONVENTION","RCN_REDUNDANT_NULLCHECK_OF_NONNULL_VALUE", 018 "SLF4J_FORMAT_SHOULD_BE_CONST","THROWS_METHOD_THROWS_RUNTIMEEXCEPTION"}) 019 020public class SRCPClientParser/*@bgen(jjtree)*/implements SRCPClientParserTreeConstants, SRCPClientParserConstants {/*@bgen(jjtree)*/ 021 protected JJTSRCPClientParserState jjtree = new JJTSRCPClientParserState(); 022 private final static Logger log = LoggerFactory.getLogger(SRCPClientParser.class.getName()); 023 024// Lexical specifications begin here 025 final public 026SimpleNode handshakeresponse() throws ParseException {/*@bgen(jjtree) handshakeresponse */ 027 ASThandshakeresponse jjtn000 = new ASThandshakeresponse(JJTHANDSHAKERESPONSE); 028 boolean jjtc000 = true; 029 jjtree.openNodeScope(jjtn000); 030 jjtn000.jjtSetFirstToken(getToken(1));SimpleNode t; SimpleNode s; 031 try { 032 // this should match any valid response to the client in handshake 033 // mode. 034 t = timestamp(); 035 switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { 036 case SRCP:{ 037 s = serviceversion(); 038 break; 039 } 040 case ZEROADDR: 041 case NONZEROADDR:{ 042 s = inforesponse(); 043 break; 044 } 045 default: 046 jj_la1[0] = jj_gen; 047 jj_consume_token(-1); 048 throw new ParseException(); 049 } 050jjtree.closeNodeScope(jjtn000, true); 051 jjtc000 = false; 052 jjtn000.jjtSetLastToken(getToken(0)); 053jjtn000.jjtSetValue(s.jjtGetValue()); 054 log.debug("Handshake Response Production: "+jjtn000.jjtGetValue()); 055 {if ("" != null) return jjtn000;} 056 } catch (Throwable jjte000) { 057if (jjtc000) { 058 jjtree.clearNodeScope(jjtn000); 059 jjtc000 = false; 060 } else { 061 jjtree.popNode(); 062 } 063 if (jjte000 instanceof RuntimeException) { 064 {if (true) throw (RuntimeException)jjte000;} 065 } 066 if (jjte000 instanceof ParseException) { 067 {if (true) throw (ParseException)jjte000;} 068 } 069 {if (true) throw (Error)jjte000;} 070 } finally { 071if (jjtc000) { 072 jjtree.closeNodeScope(jjtn000, true); 073 jjtn000.jjtSetLastToken(getToken(0)); 074 } 075 } 076 throw new Error("Missing return statement in function"); 077} 078 079 final public SimpleNode timestamp() throws ParseException {/*@bgen(jjtree) timestamp */ 080 ASTtimestamp jjtn000 = new ASTtimestamp(JJTTIMESTAMP); 081 boolean jjtc000 = true; 082 jjtree.openNodeScope(jjtn000); 083 jjtn000.jjtSetFirstToken(getToken(1));Token t; 084 try { 085 switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { 086 case TIMESTAMP:{ 087 t = jj_consume_token(TIMESTAMP); 088 break; 089 } 090 case NONZEROADDR:{ 091 t = jj_consume_token(NONZEROADDR); 092 break; 093 } 094 case ZEROADDR:{ 095 t = jj_consume_token(ZEROADDR); 096 break; 097 } 098 default: 099 jj_la1[1] = jj_gen; 100 jj_consume_token(-1); 101 throw new ParseException(); 102 } 103jjtree.closeNodeScope(jjtn000, true); 104 jjtc000 = false; 105 jjtn000.jjtSetLastToken(getToken(0)); 106jjtn000.jjtSetValue(t.image); 107 log.debug("Timestamp Production: "+jjtn000.jjtGetValue()); 108 {if ("" != null) return jjtn000;} 109 } finally { 110if (jjtc000) { 111 jjtree.closeNodeScope(jjtn000, true); 112 jjtn000.jjtSetLastToken(getToken(0)); 113 } 114 } 115 throw new Error("Missing return statement in function"); 116} 117 118 final public SimpleNode serviceversion() throws ParseException {/*@bgen(jjtree) serviceversion */ 119 ASTserviceversion jjtn000 = new ASTserviceversion(JJTSERVICEVERSION); 120 boolean jjtc000 = true; 121 jjtree.openNodeScope(jjtn000); 122 jjtn000.jjtSetFirstToken(getToken(1));Token t; Token s; 123 try { 124 t = jj_consume_token(SRCP); 125 s = jj_consume_token(VERSION); 126 jj_consume_token(EOL); 127jjtree.closeNodeScope(jjtn000, true); 128 jjtc000 = false; 129 jjtn000.jjtSetLastToken(getToken(0)); 130log.debug("Service Version Production"); 131 jjtn000.jjtSetValue(t.image +" " + s.image); 132 {if ("" != null) return jjtn000;} 133 } finally { 134if (jjtc000) { 135 jjtree.closeNodeScope(jjtn000, true); 136 jjtn000.jjtSetLastToken(getToken(0)); 137 } 138 } 139 throw new Error("Missing return statement in function"); 140} 141 142 final public SimpleNode inforesponse() throws ParseException {/*@bgen(jjtree) inforesponse */ 143 ASTinforesponse jjtn000 = new ASTinforesponse(JJTINFORESPONSE); 144 boolean jjtc000 = true; 145 jjtree.openNodeScope(jjtn000); 146 jjtn000.jjtSetFirstToken(getToken(1));SimpleNode t; SimpleNode s; 147 try { 148 address(); 149 switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { 150 case INFO:{ 151 s = info(); 152 break; 153 } 154 case OK:{ 155 s = ok(); 156 break; 157 } 158 case ERROR:{ 159 s = error(); 160 break; 161 } 162 default: 163 jj_la1[2] = jj_gen; 164 jj_consume_token(-1); 165 throw new ParseException(); 166 } 167jjtree.closeNodeScope(jjtn000, true); 168 jjtc000 = false; 169 jjtn000.jjtSetLastToken(getToken(0)); 170jjtn000.jjtSetValue(""); 171 log.debug("Information Response Production: " + jjtn000.jjtGetValue() ); 172 {if ("" != null) return jjtn000;} 173 } catch (Throwable jjte000) { 174if (jjtc000) { 175 jjtree.clearNodeScope(jjtn000); 176 jjtc000 = false; 177 } else { 178 jjtree.popNode(); 179 } 180 if (jjte000 instanceof RuntimeException) { 181 {if (true) throw (RuntimeException)jjte000;} 182 } 183 if (jjte000 instanceof ParseException) { 184 {if (true) throw (ParseException)jjte000;} 185 } 186 {if (true) throw (Error)jjte000;} 187 } finally { 188if (jjtc000) { 189 jjtree.closeNodeScope(jjtn000, true); 190 jjtn000.jjtSetLastToken(getToken(0)); 191 } 192 } 193 throw new Error("Missing return statement in function"); 194} 195 196 final public SimpleNode info() throws ParseException {/*@bgen(jjtree) info */ 197 ASTinfo jjtn000 = new ASTinfo(JJTINFO); 198 boolean jjtc000 = true; 199 jjtree.openNodeScope(jjtn000); 200 jjtn000.jjtSetFirstToken(getToken(1));Token t;SimpleNode s; SimpleNode r; 201 try { 202 t = jj_consume_token(INFO); 203 bus(); 204 switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { 205 case FB:{ 206 fb(); 207 jj_consume_token(EOL); 208 break; 209 } 210 case GA:{ 211 ga(); 212 jj_consume_token(EOL); 213 break; 214 } 215 case GL:{ 216 gl(); 217 jj_consume_token(EOL); 218 break; 219 } 220 case SM:{ 221 sm(); 222 break; 223 } 224 case TIME:{ 225 time(); 226 break; 227 } 228 case POWER:{ 229 power(); 230 break; 231 } 232 case SESSION:{ 233 session(); 234 break; 235 } 236 case SERVER:{ 237 server(); 238 break; 239 } 240 case DESCRIPTION:{ 241 description(); 242 break; 243 } 244 case LOCK:{ 245 lock(); 246 break; 247 } 248 default: 249 jj_la1[3] = jj_gen; 250 jj_consume_token(-1); 251 throw new ParseException(); 252 } 253jjtree.closeNodeScope(jjtn000, true); 254 jjtc000 = false; 255 jjtn000.jjtSetLastToken(getToken(0)); 256jjtn000.jjtSetValue(t.image ); 257 log.debug("Information Response Production: " + jjtn000.jjtGetValue() ); 258 {if ("" != null) return jjtn000;} 259 } catch (Throwable jjte000) { 260if (jjtc000) { 261 jjtree.clearNodeScope(jjtn000); 262 jjtc000 = false; 263 } else { 264 jjtree.popNode(); 265 } 266 if (jjte000 instanceof RuntimeException) { 267 {if (true) throw (RuntimeException)jjte000;} 268 } 269 if (jjte000 instanceof ParseException) { 270 {if (true) throw (ParseException)jjte000;} 271 } 272 {if (true) throw (Error)jjte000;} 273 } finally { 274if (jjtc000) { 275 jjtree.closeNodeScope(jjtn000, true); 276 jjtn000.jjtSetLastToken(getToken(0)); 277 } 278 } 279 throw new Error("Missing return statement in function"); 280} 281 282 final public SimpleNode error() throws ParseException {/*@bgen(jjtree) error */ 283 ASTerror jjtn000 = new ASTerror(JJTERROR); 284 boolean jjtc000 = true; 285 jjtree.openNodeScope(jjtn000); 286 jjtn000.jjtSetFirstToken(getToken(1));Token t;Token r; 287 try { 288 t = jj_consume_token(ERROR); 289 r = jj_consume_token(EOL); 290jjtree.closeNodeScope(jjtn000, true); 291 jjtc000 = false; 292 jjtn000.jjtSetLastToken(getToken(0)); 293jjtn000.jjtSetValue(t.image + r.image); 294 //jjtThis.jjtSetValue(r.image); 295 log.debug("Error Response Production: " + jjtn000.jjtGetValue() ); 296 {if ("" != null) return jjtn000;} 297 } finally { 298if (jjtc000) { 299 jjtree.closeNodeScope(jjtn000, true); 300 jjtn000.jjtSetLastToken(getToken(0)); 301 } 302 } 303 throw new Error("Missing return statement in function"); 304} 305 306 final public SimpleNode ok() throws ParseException {/*@bgen(jjtree) ok */ 307 ASTok jjtn000 = new ASTok(JJTOK); 308 boolean jjtc000 = true; 309 jjtree.openNodeScope(jjtn000); 310 jjtn000.jjtSetFirstToken(getToken(1));Token t;Token r; 311 try { 312 t = jj_consume_token(OK); 313 r = jj_consume_token(EOL); 314jjtree.closeNodeScope(jjtn000, true); 315 jjtc000 = false; 316 jjtn000.jjtSetLastToken(getToken(0)); 317jjtn000.jjtSetValue(t.image + " " + r.image); 318 log.debug("OK Response Production: " + jjtn000.jjtGetValue() ); 319 {if ("" != null) return jjtn000;} 320 } finally { 321if (jjtc000) { 322 jjtree.closeNodeScope(jjtn000, true); 323 jjtn000.jjtSetLastToken(getToken(0)); 324 } 325 } 326 throw new Error("Missing return statement in function"); 327} 328 329 final public SimpleNode commandresponse() throws ParseException {/*@bgen(jjtree) commandresponse */ 330 ASTcommandresponse jjtn000 = new ASTcommandresponse(JJTCOMMANDRESPONSE); 331 boolean jjtc000 = true; 332 jjtree.openNodeScope(jjtn000); 333 jjtn000.jjtSetFirstToken(getToken(1));SimpleNode t; SimpleNode s; 334 try { 335 // this should match any valid response to the client in 336 // either command mode or info mode. 337 t = timestamp(); 338 s = inforesponse(); 339jjtree.closeNodeScope(jjtn000, true); 340 jjtc000 = false; 341 jjtn000.jjtSetLastToken(getToken(0)); 342log.debug("Command Mode Response Production"); 343 jjtn000.jjtSetValue(s.jjtGetValue() ); 344 345 {if ("" != null) return jjtn000;} 346 } catch (Throwable jjte000) { 347if (jjtc000) { 348 jjtree.clearNodeScope(jjtn000); 349 jjtc000 = false; 350 } else { 351 jjtree.popNode(); 352 } 353 if (jjte000 instanceof RuntimeException) { 354 {if (true) throw (RuntimeException)jjte000;} 355 } 356 if (jjte000 instanceof ParseException) { 357 {if (true) throw (ParseException)jjte000;} 358 } 359 {if (true) throw (Error)jjte000;} 360 } finally { 361if (jjtc000) { 362 jjtree.closeNodeScope(jjtn000, true); 363 jjtn000.jjtSetLastToken(getToken(0)); 364 } 365 } 366 throw new Error("Missing return statement in function"); 367} 368 369 final public SimpleNode bus() throws ParseException {/*@bgen(jjtree) bus */ 370 ASTbus jjtn000 = new ASTbus(JJTBUS); 371 boolean jjtc000 = true; 372 jjtree.openNodeScope(jjtn000); 373 jjtn000.jjtSetFirstToken(getToken(1));SimpleNode s; 374 try { 375 switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { 376 case ZEROADDR:{ 377 s = zeroaddress(); 378 break; 379 } 380 case NONZEROADDR:{ 381 s = nonzeroaddress(); 382 break; 383 } 384 default: 385 jj_la1[4] = jj_gen; 386 jj_consume_token(-1); 387 throw new ParseException(); 388 } 389jjtree.closeNodeScope(jjtn000, true); 390 jjtc000 = false; 391 jjtn000.jjtSetLastToken(getToken(0)); 392log.debug("BUS Production "+ s.jjtGetValue()); 393 jjtn000.jjtSetValue(s.jjtGetValue()); 394 {if ("" != null) return jjtn000;} 395 } catch (Throwable jjte000) { 396if (jjtc000) { 397 jjtree.clearNodeScope(jjtn000); 398 jjtc000 = false; 399 } else { 400 jjtree.popNode(); 401 } 402 if (jjte000 instanceof RuntimeException) { 403 {if (true) throw (RuntimeException)jjte000;} 404 } 405 if (jjte000 instanceof ParseException) { 406 {if (true) throw (ParseException)jjte000;} 407 } 408 {if (true) throw (Error)jjte000;} 409 } finally { 410if (jjtc000) { 411 jjtree.closeNodeScope(jjtn000, true); 412 jjtn000.jjtSetLastToken(getToken(0)); 413 } 414 } 415 throw new Error("Missing return statement in function"); 416} 417 418 final public SimpleNode power() throws ParseException {/*@bgen(jjtree) power */ 419 ASTpower jjtn000 = new ASTpower(JJTPOWER); 420 boolean jjtc000 = true; 421 jjtree.openNodeScope(jjtn000); 422 jjtn000.jjtSetFirstToken(getToken(1));Token t; SimpleNode r; 423 try { 424 t = jj_consume_token(POWER); 425 switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { 426 case ONOFF:{ 427 r = onoff(); 428 break; 429 } 430 case EOL:{ 431 jj_consume_token(EOL); 432 break; 433 } 434 default: 435 jj_la1[5] = jj_gen; 436 jj_consume_token(-1); 437 throw new ParseException(); 438 } 439jjtree.closeNodeScope(jjtn000, true); 440 jjtc000 = false; 441 jjtn000.jjtSetLastToken(getToken(0)); 442log.debug("POWER Production "+ t.image); 443 //jjtThis.jjtSetValue(t.image + " " + r.jjtGetValue() ); 444 jjtn000.jjtSetValue(t.image ); 445 {if ("" != null) return jjtn000;} 446 } catch (Throwable jjte000) { 447if (jjtc000) { 448 jjtree.clearNodeScope(jjtn000); 449 jjtc000 = false; 450 } else { 451 jjtree.popNode(); 452 } 453 if (jjte000 instanceof RuntimeException) { 454 {if (true) throw (RuntimeException)jjte000;} 455 } 456 if (jjte000 instanceof ParseException) { 457 {if (true) throw (ParseException)jjte000;} 458 } 459 {if (true) throw (Error)jjte000;} 460 } finally { 461if (jjtc000) { 462 jjtree.closeNodeScope(jjtn000, true); 463 jjtn000.jjtSetLastToken(getToken(0)); 464 } 465 } 466 throw new Error("Missing return statement in function"); 467} 468 469 final public void address() throws ParseException {SimpleNode s; 470 switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { 471 case ZEROADDR:{ 472 s = zeroaddress(); 473 break; 474 } 475 case NONZEROADDR:{ 476 s = nonzeroaddress(); 477 break; 478 } 479 default: 480 jj_la1[6] = jj_gen; 481 jj_consume_token(-1); 482 throw new ParseException(); 483 } 484log.debug("Address Production "+ s.jjtGetValue()); 485 //jjtThis.jjtSetValue(s.jjtGetValue()); 486 //return jjtThis; 487 488} 489 490 final public SimpleNode zeroaddress() throws ParseException {/*@bgen(jjtree) zeroaddress */ 491 ASTzeroaddress jjtn000 = new ASTzeroaddress(JJTZEROADDRESS); 492 boolean jjtc000 = true; 493 jjtree.openNodeScope(jjtn000); 494 jjtn000.jjtSetFirstToken(getToken(1));Token t; 495 try { 496 t = jj_consume_token(ZEROADDR); 497jjtree.closeNodeScope(jjtn000, true); 498 jjtc000 = false; 499 jjtn000.jjtSetLastToken(getToken(0)); 500//Zero Address allows a leading zero 501 log.debug("ZeroAddress Production "+ t.image); 502 jjtn000.jjtSetValue(t.image); 503 {if ("" != null) return jjtn000;} 504 } finally { 505if (jjtc000) { 506 jjtree.closeNodeScope(jjtn000, true); 507 jjtn000.jjtSetLastToken(getToken(0)); 508 } 509 } 510 throw new Error("Missing return statement in function"); 511} 512 513 final public SimpleNode nonzeroaddress() throws ParseException {/*@bgen(jjtree) nonzeroaddress */ 514 ASTnonzeroaddress jjtn000 = new ASTnonzeroaddress(JJTNONZEROADDRESS); 515 boolean jjtc000 = true; 516 jjtree.openNodeScope(jjtn000); 517 jjtn000.jjtSetFirstToken(getToken(1));Token t; 518 try { 519 t = jj_consume_token(NONZEROADDR); 520jjtree.closeNodeScope(jjtn000, true); 521 jjtc000 = false; 522 jjtn000.jjtSetLastToken(getToken(0)); 523//NonZero Address requires a value >=1, without 524 //a leading zero 525 log.debug("NonZeroAddress Production "+ t.image); 526 jjtn000.jjtSetValue(t.image); 527 {if ("" != null) return jjtn000;} 528 } finally { 529if (jjtc000) { 530 jjtree.closeNodeScope(jjtn000, true); 531 jjtn000.jjtSetLastToken(getToken(0)); 532 } 533 } 534 throw new Error("Missing return statement in function"); 535} 536 537 final public SimpleNode port() throws ParseException {/*@bgen(jjtree) port */ 538 ASTport jjtn000 = new ASTport(JJTPORT); 539 boolean jjtc000 = true; 540 jjtree.openNodeScope(jjtn000); 541 jjtn000.jjtSetFirstToken(getToken(1));SimpleNode s; 542 try { 543 switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { 544 case ZEROADDR:{ 545 s = zeroaddress(); 546 break; 547 } 548 case NONZEROADDR:{ 549 s = nonzeroaddress(); 550 break; 551 } 552 default: 553 jj_la1[7] = jj_gen; 554 jj_consume_token(-1); 555 throw new ParseException(); 556 } 557jjtree.closeNodeScope(jjtn000, true); 558 jjtc000 = false; 559 jjtn000.jjtSetLastToken(getToken(0)); 560log.debug("PORT Production "+ s.jjtGetValue()); 561 jjtn000.jjtSetValue(s.jjtGetValue()); 562 {if ("" != null) return jjtn000;} 563 } catch (Throwable jjte000) { 564if (jjtc000) { 565 jjtree.clearNodeScope(jjtn000); 566 jjtc000 = false; 567 } else { 568 jjtree.popNode(); 569 } 570 if (jjte000 instanceof RuntimeException) { 571 {if (true) throw (RuntimeException)jjte000;} 572 } 573 if (jjte000 instanceof ParseException) { 574 {if (true) throw (ParseException)jjte000;} 575 } 576 {if (true) throw (Error)jjte000;} 577 } finally { 578if (jjtc000) { 579 jjtree.closeNodeScope(jjtn000, true); 580 jjtn000.jjtSetLastToken(getToken(0)); 581 } 582 } 583 throw new Error("Missing return statement in function"); 584} 585 586 final public SimpleNode devicegroup() throws ParseException {/*@bgen(jjtree) devicegroup */ 587 ASTdevicegroup jjtn000 = new ASTdevicegroup(JJTDEVICEGROUP); 588 boolean jjtc000 = true; 589 jjtree.openNodeScope(jjtn000); 590 jjtn000.jjtSetFirstToken(getToken(1));Token t; 591 try { 592 switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { 593 case FB:{ 594 t = jj_consume_token(FB); 595 break; 596 } 597 case GA:{ 598 t = jj_consume_token(GA); 599 break; 600 } 601 case GL:{ 602 t = jj_consume_token(GL); 603 break; 604 } 605 case SM:{ 606 t = jj_consume_token(SM); 607 break; 608 } 609 case TIME:{ 610 t = jj_consume_token(TIME); 611 break; 612 } 613 case SESSION:{ 614 t = jj_consume_token(SESSION); 615 break; 616 } 617 case SERVER:{ 618 t = jj_consume_token(SERVER); 619 break; 620 } 621 case LOCK:{ 622 t = jj_consume_token(LOCK); 623 break; 624 } 625 case POWER:{ 626 t = jj_consume_token(POWER); 627 break; 628 } 629 case DESCRIPTION:{ 630 t = jj_consume_token(DESCRIPTION); 631 break; 632 } 633 default: 634 jj_la1[8] = jj_gen; 635 jj_consume_token(-1); 636 throw new ParseException(); 637 } 638jjtree.closeNodeScope(jjtn000, true); 639 jjtc000 = false; 640 jjtn000.jjtSetLastToken(getToken(0)); 641log.debug("DeviceGroup Production"); 642 jjtn000.jjtSetValue(t.image); 643 {if ("" != null) return jjtn000;} 644 } finally { 645if (jjtc000) { 646 jjtree.closeNodeScope(jjtn000, true); 647 jjtn000.jjtSetLastToken(getToken(0)); 648 } 649 } 650 throw new Error("Missing return statement in function"); 651} 652 653 final public SimpleNode gl() throws ParseException {/*@bgen(jjtree) gl */ 654 ASTgl jjtn000 = new ASTgl(JJTGL); 655 boolean jjtc000 = true; 656 jjtree.openNodeScope(jjtn000); 657 jjtn000.jjtSetFirstToken(getToken(1));Token t; 658 try { 659 t = jj_consume_token(GL); 660 address(); 661 switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { 662 case ZEROADDR: 663 case NONZEROADDR: 664 case DRIVEMODE: 665 case PROTOCOL:{ 666 switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { 667 case ZEROADDR: 668 case NONZEROADDR: 669 case DRIVEMODE:{ 670 switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { 671 case DRIVEMODE:{ 672 jj_consume_token(DRIVEMODE); 673 break; 674 } 675 case ZEROADDR: 676 case NONZEROADDR:{ 677 address(); 678 break; 679 } 680 default: 681 jj_la1[9] = jj_gen; 682 jj_consume_token(-1); 683 throw new ParseException(); 684 } 685 label_1: 686 while (true) { 687 address(); 688 switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { 689 case ZEROADDR: 690 case NONZEROADDR:{ 691 ; 692 break; 693 } 694 default: 695 jj_la1[10] = jj_gen; 696 break label_1; 697 } 698 } 699 break; 700 } 701 case PROTOCOL:{ 702 jj_consume_token(PROTOCOL); 703 switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { 704 case ZEROADDR: 705 case NONZEROADDR:{ 706 address(); 707 address(); 708 break; 709 } 710 default: 711 jj_la1[11] = jj_gen; 712 ; 713 } 714 break; 715 } 716 default: 717 jj_la1[12] = jj_gen; 718 jj_consume_token(-1); 719 throw new ParseException(); 720 } 721 break; 722 } 723 default: 724 jj_la1[13] = jj_gen; 725 ; 726 } 727jjtree.closeNodeScope(jjtn000, true); 728 jjtc000 = false; 729 jjtn000.jjtSetLastToken(getToken(0)); 730jjtn000.jjtSetValue(t.image); 731 {if ("" != null) return jjtn000;} 732 } catch (Throwable jjte000) { 733if (jjtc000) { 734 jjtree.clearNodeScope(jjtn000); 735 jjtc000 = false; 736 } else { 737 jjtree.popNode(); 738 } 739 if (jjte000 instanceof RuntimeException) { 740 {if (true) throw (RuntimeException)jjte000;} 741 } 742 if (jjte000 instanceof ParseException) { 743 {if (true) throw (ParseException)jjte000;} 744 } 745 {if (true) throw (Error)jjte000;} 746 } finally { 747if (jjtc000) { 748 jjtree.closeNodeScope(jjtn000, true); 749 jjtn000.jjtSetLastToken(getToken(0)); 750 } 751 } 752 throw new Error("Missing return statement in function"); 753} 754 755 final public SimpleNode sm() throws ParseException {/*@bgen(jjtree) sm */ 756 ASTsm jjtn000 = new ASTsm(JJTSM); 757 boolean jjtc000 = true; 758 jjtree.openNodeScope(jjtn000); 759 jjtn000.jjtSetFirstToken(getToken(1));Token t; 760 try { 761 t = jj_consume_token(SM); 762jjtree.closeNodeScope(jjtn000, true); 763 jjtc000 = false; 764 jjtn000.jjtSetLastToken(getToken(0)); 765jjtn000.jjtSetValue(t.image); 766 {if ("" != null) return jjtn000;} 767 } finally { 768if (jjtc000) { 769 jjtree.closeNodeScope(jjtn000, true); 770 jjtn000.jjtSetLastToken(getToken(0)); 771 } 772 } 773 throw new Error("Missing return statement in function"); 774} 775 776 final public SimpleNode ga() throws ParseException {/*@bgen(jjtree) ga */ 777 ASTga jjtn000 = new ASTga(JJTGA); 778 boolean jjtc000 = true; 779 jjtree.openNodeScope(jjtn000); 780 jjtn000.jjtSetFirstToken(getToken(1));Token t; 781 try { 782 t = jj_consume_token(GA); 783 address(); 784 switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { 785 case ZEROADDR: 786 case NONZEROADDR: 787 case PROTOCOL:{ 788 switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { 789 case PROTOCOL:{ 790 jj_consume_token(PROTOCOL); 791 break; 792 } 793 case ZEROADDR: 794 case NONZEROADDR:{ 795 port(); 796 zeroone(); 797 break; 798 } 799 default: 800 jj_la1[14] = jj_gen; 801 jj_consume_token(-1); 802 throw new ParseException(); 803 } 804 break; 805 } 806 default: 807 jj_la1[15] = jj_gen; 808 ; 809 } 810jjtree.closeNodeScope(jjtn000, true); 811 jjtc000 = false; 812 jjtn000.jjtSetLastToken(getToken(0)); 813jjtn000.jjtSetValue(t.image); 814 {if ("" != null) return jjtn000;} 815 } catch (Throwable jjte000) { 816if (jjtc000) { 817 jjtree.clearNodeScope(jjtn000); 818 jjtc000 = false; 819 } else { 820 jjtree.popNode(); 821 } 822 if (jjte000 instanceof RuntimeException) { 823 {if (true) throw (RuntimeException)jjte000;} 824 } 825 if (jjte000 instanceof ParseException) { 826 {if (true) throw (ParseException)jjte000;} 827 } 828 {if (true) throw (Error)jjte000;} 829 } finally { 830if (jjtc000) { 831 jjtree.closeNodeScope(jjtn000, true); 832 jjtn000.jjtSetLastToken(getToken(0)); 833 } 834 } 835 throw new Error("Missing return statement in function"); 836} 837 838 final public SimpleNode fb() throws ParseException {/*@bgen(jjtree) fb */ 839 ASTfb jjtn000 = new ASTfb(JJTFB); 840 boolean jjtc000 = true; 841 jjtree.openNodeScope(jjtn000); 842 jjtn000.jjtSetFirstToken(getToken(1));Token t; 843 try { 844 t = jj_consume_token(FB); 845 switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { 846 case ZEROADDR: 847 case NONZEROADDR:{ 848 address(); 849 zeroone(); 850 break; 851 } 852 default: 853 jj_la1[16] = jj_gen; 854 ; 855 } 856jjtree.closeNodeScope(jjtn000, true); 857 jjtc000 = false; 858 jjtn000.jjtSetLastToken(getToken(0)); 859jjtn000.jjtSetValue(t.image); 860 {if ("" != null) return jjtn000;} 861 } catch (Throwable jjte000) { 862if (jjtc000) { 863 jjtree.clearNodeScope(jjtn000); 864 jjtc000 = false; 865 } else { 866 jjtree.popNode(); 867 } 868 if (jjte000 instanceof RuntimeException) { 869 {if (true) throw (RuntimeException)jjte000;} 870 } 871 if (jjte000 instanceof ParseException) { 872 {if (true) throw (ParseException)jjte000;} 873 } 874 {if (true) throw (Error)jjte000;} 875 } finally { 876if (jjtc000) { 877 jjtree.closeNodeScope(jjtn000, true); 878 jjtn000.jjtSetLastToken(getToken(0)); 879 } 880 } 881 throw new Error("Missing return statement in function"); 882} 883 884 final public SimpleNode time() throws ParseException {/*@bgen(jjtree) time */ 885 ASTtime jjtn000 = new ASTtime(JJTTIME); 886 boolean jjtc000 = true; 887 jjtree.openNodeScope(jjtn000); 888 jjtn000.jjtSetFirstToken(getToken(1));Token t; 889 try { 890 t = jj_consume_token(TIME); 891jjtree.closeNodeScope(jjtn000, true); 892 jjtc000 = false; 893 jjtn000.jjtSetLastToken(getToken(0)); 894jjtn000.jjtSetValue(t.image); 895 {if ("" != null) return jjtn000;} 896 } finally { 897if (jjtc000) { 898 jjtree.closeNodeScope(jjtn000, true); 899 jjtn000.jjtSetLastToken(getToken(0)); 900 } 901 } 902 throw new Error("Missing return statement in function"); 903} 904 905 final public SimpleNode server() throws ParseException {/*@bgen(jjtree) server */ 906 ASTserver jjtn000 = new ASTserver(JJTSERVER); 907 boolean jjtc000 = true; 908 jjtree.openNodeScope(jjtn000); 909 jjtn000.jjtSetFirstToken(getToken(1));Token t;Token r; 910 try { 911 t = jj_consume_token(SERVER); 912 r = jj_consume_token(EOL); 913jjtree.closeNodeScope(jjtn000, true); 914 jjtc000 = false; 915 jjtn000.jjtSetLastToken(getToken(0)); 916jjtn000.jjtSetValue(t.image + " " + r.image); 917 {if ("" != null) return jjtn000;} 918 } finally { 919if (jjtc000) { 920 jjtree.closeNodeScope(jjtn000, true); 921 jjtn000.jjtSetLastToken(getToken(0)); 922 } 923 } 924 throw new Error("Missing return statement in function"); 925} 926 927 final public SimpleNode session() throws ParseException {/*@bgen(jjtree) session */ 928 ASTsession jjtn000 = new ASTsession(JJTSESSION); 929 boolean jjtc000 = true; 930 jjtree.openNodeScope(jjtn000); 931 jjtn000.jjtSetFirstToken(getToken(1));Token t; 932 try { 933 t = jj_consume_token(SESSION); 934 address(); 935 jj_consume_token(EOL); 936jjtree.closeNodeScope(jjtn000, true); 937 jjtc000 = false; 938 jjtn000.jjtSetLastToken(getToken(0)); 939jjtn000.jjtSetValue(t.image); 940 {if ("" != null) return jjtn000;} 941 } catch (Throwable jjte000) { 942if (jjtc000) { 943 jjtree.clearNodeScope(jjtn000); 944 jjtc000 = false; 945 } else { 946 jjtree.popNode(); 947 } 948 if (jjte000 instanceof RuntimeException) { 949 {if (true) throw (RuntimeException)jjte000;} 950 } 951 if (jjte000 instanceof ParseException) { 952 {if (true) throw (ParseException)jjte000;} 953 } 954 {if (true) throw (Error)jjte000;} 955 } finally { 956if (jjtc000) { 957 jjtree.closeNodeScope(jjtn000, true); 958 jjtn000.jjtSetLastToken(getToken(0)); 959 } 960 } 961 throw new Error("Missing return statement in function"); 962} 963 964 final public SimpleNode lock() throws ParseException {/*@bgen(jjtree) lock */ 965 ASTlock jjtn000 = new ASTlock(JJTLOCK); 966 boolean jjtc000 = true; 967 jjtree.openNodeScope(jjtn000); 968 jjtn000.jjtSetFirstToken(getToken(1));Token t; 969 try { 970 t = jj_consume_token(LOCK); 971 devicegroup(); 972 label_2: 973 while (true) { 974 address(); 975 switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { 976 case ZEROADDR: 977 case NONZEROADDR:{ 978 ; 979 break; 980 } 981 default: 982 jj_la1[17] = jj_gen; 983 break label_2; 984 } 985 } 986 jj_consume_token(EOL); 987jjtree.closeNodeScope(jjtn000, true); 988 jjtc000 = false; 989 jjtn000.jjtSetLastToken(getToken(0)); 990jjtn000.jjtSetValue(t.image); 991 {if ("" != null) return jjtn000;} 992 } catch (Throwable jjte000) { 993if (jjtc000) { 994 jjtree.clearNodeScope(jjtn000); 995 jjtc000 = false; 996 } else { 997 jjtree.popNode(); 998 } 999 if (jjte000 instanceof RuntimeException) { 1000 {if (true) throw (RuntimeException)jjte000;} 1001 } 1002 if (jjte000 instanceof ParseException) { 1003 {if (true) throw (ParseException)jjte000;} 1004 } 1005 {if (true) throw (Error)jjte000;} 1006 } finally { 1007if (jjtc000) { 1008 jjtree.closeNodeScope(jjtn000, true); 1009 jjtn000.jjtSetLastToken(getToken(0)); 1010 } 1011 } 1012 throw new Error("Missing return statement in function"); 1013} 1014 1015 final public SimpleNode description() throws ParseException {/*@bgen(jjtree) description */ 1016 ASTdescription jjtn000 = new ASTdescription(JJTDESCRIPTION); 1017 boolean jjtc000 = true; 1018 jjtree.openNodeScope(jjtn000); 1019 jjtn000.jjtSetFirstToken(getToken(1));Token t; 1020 try { 1021 t = jj_consume_token(DESCRIPTION); 1022 if (jj_2_1(3)) { 1023 label_3: 1024 while (true) { 1025 devicegroup(); 1026 switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { 1027 case FB: 1028 case GA: 1029 case GL: 1030 case SM: 1031 case LOCK: 1032 case TIME: 1033 case POWER: 1034 case SESSION: 1035 case DESCRIPTION: 1036 case SERVER:{ 1037 ; 1038 break; 1039 } 1040 default: 1041 jj_la1[18] = jj_gen; 1042 break label_3; 1043 } 1044 } 1045 jj_consume_token(EOL); 1046 } else { 1047 switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { 1048 case FB: 1049 case GA: 1050 case GL: 1051 case SM: 1052 case LOCK: 1053 case TIME: 1054 case POWER: 1055 case SESSION: 1056 case SERVER:{ 1057 switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { 1058 case FB:{ 1059 fb(); 1060 jj_consume_token(EOL); 1061 break; 1062 } 1063 case GA:{ 1064 ga(); 1065 jj_consume_token(EOL); 1066 break; 1067 } 1068 case GL:{ 1069 gl(); 1070 jj_consume_token(EOL); 1071 break; 1072 } 1073 case SM:{ 1074 sm(); 1075 break; 1076 } 1077 case TIME:{ 1078 time(); 1079 break; 1080 } 1081 case POWER:{ 1082 power(); 1083 break; 1084 } 1085 case SESSION:{ 1086 session(); 1087 break; 1088 } 1089 case SERVER:{ 1090 server(); 1091 break; 1092 } 1093 case LOCK:{ 1094 lock(); 1095 break; 1096 } 1097 default: 1098 jj_la1[19] = jj_gen; 1099 jj_consume_token(-1); 1100 throw new ParseException(); 1101 } 1102 break; 1103 } 1104 default: 1105 jj_la1[20] = jj_gen; 1106 jj_consume_token(-1); 1107 throw new ParseException(); 1108 } 1109 } 1110jjtree.closeNodeScope(jjtn000, true); 1111 jjtc000 = false; 1112 jjtn000.jjtSetLastToken(getToken(0)); 1113jjtn000.jjtSetValue(t.image); 1114 {if ("" != null) return jjtn000;} 1115 } catch (Throwable jjte000) { 1116if (jjtc000) { 1117 jjtree.clearNodeScope(jjtn000); 1118 jjtc000 = false; 1119 } else { 1120 jjtree.popNode(); 1121 } 1122 if (jjte000 instanceof RuntimeException) { 1123 {if (true) throw (RuntimeException)jjte000;} 1124 } 1125 if (jjte000 instanceof ParseException) { 1126 {if (true) throw (ParseException)jjte000;} 1127 } 1128 {if (true) throw (Error)jjte000;} 1129 } finally { 1130if (jjtc000) { 1131 jjtree.closeNodeScope(jjtn000, true); 1132 jjtn000.jjtSetLastToken(getToken(0)); 1133 } 1134 } 1135 throw new Error("Missing return statement in function"); 1136} 1137 1138 final public SimpleNode onoff() throws ParseException {/*@bgen(jjtree) onoff */ 1139 ASTonoff jjtn000 = new ASTonoff(JJTONOFF); 1140 boolean jjtc000 = true; 1141 jjtree.openNodeScope(jjtn000); 1142 jjtn000.jjtSetFirstToken(getToken(1));Token t; Token r; 1143 try { 1144 t = jj_consume_token(ONOFF); 1145 r = jj_consume_token(EOL); 1146jjtree.closeNodeScope(jjtn000, true); 1147 jjtc000 = false; 1148 jjtn000.jjtSetLastToken(getToken(0)); 1149log.debug("OnOff Production " +t.image + " " + r.image); 1150 jjtn000.jjtSetValue(t.image); 1151 {if ("" != null) return jjtn000;} 1152 } finally { 1153if (jjtc000) { 1154 jjtree.closeNodeScope(jjtn000, true); 1155 jjtn000.jjtSetLastToken(getToken(0)); 1156 } 1157 } 1158 throw new Error("Missing return statement in function"); 1159} 1160 1161 final public void zeroone() throws ParseException {SimpleNode s; 1162 switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) { 1163 case ZEROADDR:{ 1164 s = zeroaddress(); 1165 break; 1166 } 1167 case NONZEROADDR:{ 1168 s = nonzeroaddress(); 1169 break; 1170 } 1171 default: 1172 jj_la1[21] = jj_gen; 1173 jj_consume_token(-1); 1174 throw new ParseException(); 1175 } 1176log.debug("ZeroOne Production "); 1177 //return jjtThis; 1178 1179} 1180 1181 private boolean jj_2_1(int xla) 1182 { 1183 jj_la = xla; jj_lastpos = jj_scanpos = token; 1184 try { return (!jj_3_1()); } 1185 catch(LookaheadSuccess ls) { return true; } 1186 finally { jj_save(0, xla); } 1187 } 1188 1189 private boolean jj_3R_4() 1190 { 1191 if (jj_3R_5()) return true; 1192 return false; 1193 } 1194 1195 private boolean jj_3R_5() 1196 { 1197 Token xsp; 1198 xsp = jj_scanpos; 1199 if (jj_scan_token(17)) { 1200 jj_scanpos = xsp; 1201 if (jj_scan_token(18)) { 1202 jj_scanpos = xsp; 1203 if (jj_scan_token(19)) { 1204 jj_scanpos = xsp; 1205 if (jj_scan_token(21)) { 1206 jj_scanpos = xsp; 1207 if (jj_scan_token(23)) { 1208 jj_scanpos = xsp; 1209 if (jj_scan_token(25)) { 1210 jj_scanpos = xsp; 1211 if (jj_scan_token(27)) { 1212 jj_scanpos = xsp; 1213 if (jj_scan_token(22)) { 1214 jj_scanpos = xsp; 1215 if (jj_scan_token(24)) { 1216 jj_scanpos = xsp; 1217 if (jj_scan_token(26)) return true; 1218 } 1219 } 1220 } 1221 } 1222 } 1223 } 1224 } 1225 } 1226 } 1227 return false; 1228 } 1229 1230 private boolean jj_3_1() 1231 { 1232 Token xsp; 1233 if (jj_3R_4()) return true; 1234 while (true) { 1235 xsp = jj_scanpos; 1236 if (jj_3R_4()) { jj_scanpos = xsp; break; } 1237 } 1238 if (jj_scan_token(EOL)) return true; 1239 return false; 1240 } 1241 1242 /* Generated Token Manager. */ 1243 public SRCPClientParserTokenManager token_source; 1244 SimpleCharStream jj_input_stream; 1245 /* Current token. */ 1246 public Token token; 1247 /* Next token. */ 1248 public Token jj_nt; 1249 private int jj_ntk; 1250 private Token jj_scanpos, jj_lastpos; 1251 private int jj_la; 1252 private int jj_gen; 1253 final private int[] jj_la1 = new int[22]; 1254 static private int[] jj_la1_0; 1255 static private int[] jj_la1_1; 1256 static { 1257 jj_la1_init_0(); 1258 jj_la1_init_1(); 1259 } 1260 private static void jj_la1_init_0() { 1261 jj_la1_0 = new int[] {0x100000c0,0x10c0,0xc0000000,0xfee0000,0xc0,0x2004,0xc0,0xc0,0xfee0000,0x1c0,0xc0,0xc0,0x101c0,0x101c0,0x100c0,0x100c0,0xc0,0xc0,0xfee0000,0xbee0000,0xbee0000,0xc0,}; 1262 } 1263 private static void jj_la1_init_1() { 1264 jj_la1_1 = new int[] {0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,}; 1265 } 1266 final private JJCalls[] jj_2_rtns = new JJCalls[1]; 1267 private boolean jj_rescan = false; 1268 private int jj_gc = 0; 1269 1270 /* Constructor with InputStream. */ 1271 public SRCPClientParser(java.io.InputStream stream) { 1272 this(stream, null); 1273 } 1274 /* Constructor with InputStream and supplied encoding */ 1275 public SRCPClientParser(java.io.InputStream stream, String encoding) { 1276 try { jj_input_stream = new SimpleCharStream(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); } 1277 token_source = new SRCPClientParserTokenManager(jj_input_stream); 1278 token = new Token(); 1279 jj_ntk = -1; 1280 jj_gen = 0; 1281 for (int i = 0; i < 22; i++) jj_la1[i] = -1; 1282 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); 1283 } 1284 1285 /* Reinitialise. */ 1286 public void ReInit(java.io.InputStream stream) { 1287 ReInit(stream, null); 1288 } 1289 /* Reinitialise. */ 1290 public void ReInit(java.io.InputStream stream, String encoding) { 1291 try { jj_input_stream.ReInit(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); } 1292 token_source.ReInit(jj_input_stream); 1293 token = new Token(); 1294 jj_ntk = -1; 1295 jjtree.reset(); 1296 jj_gen = 0; 1297 for (int i = 0; i < 22; i++) jj_la1[i] = -1; 1298 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); 1299 } 1300 1301 /* Constructor. */ 1302 public SRCPClientParser(java.io.Reader stream) { 1303 jj_input_stream = new SimpleCharStream(stream, 1, 1); 1304 token_source = new SRCPClientParserTokenManager(jj_input_stream); 1305 token = new Token(); 1306 jj_ntk = -1; 1307 jj_gen = 0; 1308 for (int i = 0; i < 22; i++) jj_la1[i] = -1; 1309 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); 1310 } 1311 1312 /* Reinitialise. */ 1313 public void ReInit(java.io.Reader stream) { 1314 if (jj_input_stream == null) { 1315 jj_input_stream = new SimpleCharStream(stream, 1, 1); 1316 } else { 1317 jj_input_stream.ReInit(stream, 1, 1); 1318 } 1319 if (token_source == null) { 1320 token_source = new SRCPClientParserTokenManager(jj_input_stream); 1321 } 1322 1323 token_source.ReInit(jj_input_stream); 1324 token = new Token(); 1325 jj_ntk = -1; 1326 jjtree.reset(); 1327 jj_gen = 0; 1328 for (int i = 0; i < 22; i++) jj_la1[i] = -1; 1329 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); 1330 } 1331 1332 /* Constructor with generated Token Manager. */ 1333 public SRCPClientParser(SRCPClientParserTokenManager tm) { 1334 token_source = tm; 1335 token = new Token(); 1336 jj_ntk = -1; 1337 jj_gen = 0; 1338 for (int i = 0; i < 22; i++) jj_la1[i] = -1; 1339 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); 1340 } 1341 1342 /* Reinitialise. */ 1343 public void ReInit(SRCPClientParserTokenManager tm) { 1344 token_source = tm; 1345 token = new Token(); 1346 jj_ntk = -1; 1347 jjtree.reset(); 1348 jj_gen = 0; 1349 for (int i = 0; i < 22; i++) jj_la1[i] = -1; 1350 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); 1351 } 1352 1353 private Token jj_consume_token(int kind) throws ParseException { 1354 Token oldToken; 1355 if ((oldToken = token).next != null) token = token.next; 1356 else token = token.next = token_source.getNextToken(); 1357 jj_ntk = -1; 1358 if (token.kind == kind) { 1359 jj_gen++; 1360 if (++jj_gc > 100) { 1361 jj_gc = 0; 1362 for (int i = 0; i < jj_2_rtns.length; i++) { 1363 JJCalls c = jj_2_rtns[i]; 1364 while (c != null) { 1365 if (c.gen < jj_gen) c.first = null; 1366 c = c.next; 1367 } 1368 } 1369 } 1370 return token; 1371 } 1372 token = oldToken; 1373 jj_kind = kind; 1374 throw generateParseException(); 1375 } 1376 1377 @SuppressWarnings("serial") 1378 static private final class LookaheadSuccess extends java.lang.Error { } 1379 final private LookaheadSuccess jj_ls = new LookaheadSuccess(); 1380 private boolean jj_scan_token(int kind) { 1381 if (jj_scanpos == jj_lastpos) { 1382 jj_la--; 1383 if (jj_scanpos.next == null) { 1384 jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken(); 1385 } else { 1386 jj_lastpos = jj_scanpos = jj_scanpos.next; 1387 } 1388 } else { 1389 jj_scanpos = jj_scanpos.next; 1390 } 1391 if (jj_rescan) { 1392 int i = 0; Token tok = token; 1393 while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; } 1394 if (tok != null) jj_add_error_token(kind, i); 1395 } 1396 if (jj_scanpos.kind != kind) return true; 1397 if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls; 1398 return false; 1399 } 1400 1401 1402/* Get the next Token. */ 1403 final public Token getNextToken() { 1404 if (token.next != null) token = token.next; 1405 else token = token.next = token_source.getNextToken(); 1406 jj_ntk = -1; 1407 jj_gen++; 1408 return token; 1409 } 1410 1411/* Get the specific Token. */ 1412 final public Token getToken(int index) { 1413 Token t = token; 1414 for (int i = 0; i < index; i++) { 1415 if (t.next != null) t = t.next; 1416 else t = t.next = token_source.getNextToken(); 1417 } 1418 return t; 1419 } 1420 1421 private int jj_ntk_f() { 1422 if ((jj_nt=token.next) == null) 1423 return (jj_ntk = (token.next=token_source.getNextToken()).kind); 1424 else 1425 return (jj_ntk = jj_nt.kind); 1426 } 1427 1428 private java.util.List<int[]> jj_expentries = new java.util.ArrayList<int[]>(); 1429 private int[] jj_expentry; 1430 private int jj_kind = -1; 1431 private int[] jj_lasttokens = new int[100]; 1432 private int jj_endpos; 1433 1434 private void jj_add_error_token(int kind, int pos) { 1435 if (pos >= 100) { 1436 return; 1437 } 1438 1439 if (pos == jj_endpos + 1) { 1440 jj_lasttokens[jj_endpos++] = kind; 1441 } else if (jj_endpos != 0) { 1442 jj_expentry = new int[jj_endpos]; 1443 1444 for (int i = 0; i < jj_endpos; i++) { 1445 jj_expentry[i] = jj_lasttokens[i]; 1446 } 1447 1448 for (int[] oldentry : jj_expentries) { 1449 if (oldentry.length == jj_expentry.length) { 1450 boolean isMatched = true; 1451 1452 for (int i = 0; i < jj_expentry.length; i++) { 1453 if (oldentry[i] != jj_expentry[i]) { 1454 isMatched = false; 1455 break; 1456 } 1457 1458 } 1459 if (isMatched) { 1460 jj_expentries.add(jj_expentry); 1461 break; 1462 } 1463 } 1464 } 1465 1466 if (pos != 0) { 1467 jj_lasttokens[(jj_endpos = pos) - 1] = kind; 1468 } 1469 } 1470 } 1471 1472 /* Generate ParseException. */ 1473 public ParseException generateParseException() { 1474 jj_expentries.clear(); 1475 boolean[] la1tokens = new boolean[63]; 1476 if (jj_kind >= 0) { 1477 la1tokens[jj_kind] = true; 1478 jj_kind = -1; 1479 } 1480 for (int i = 0; i < 22; i++) { 1481 if (jj_la1[i] == jj_gen) { 1482 for (int j = 0; j < 32; j++) { 1483 if ((jj_la1_0[i] & (1<<j)) != 0) { 1484 la1tokens[j] = true; 1485 } 1486 if ((jj_la1_1[i] & (1<<j)) != 0) { 1487 la1tokens[32+j] = true; 1488 } 1489 } 1490 } 1491 } 1492 for (int i = 0; i < 63; i++) { 1493 if (la1tokens[i]) { 1494 jj_expentry = new int[1]; 1495 jj_expentry[0] = i; 1496 jj_expentries.add(jj_expentry); 1497 } 1498 } 1499 jj_endpos = 0; 1500 jj_rescan_token(); 1501 jj_add_error_token(0, 0); 1502 int[][] exptokseq = new int[jj_expentries.size()][]; 1503 for (int i = 0; i < jj_expentries.size(); i++) { 1504 exptokseq[i] = jj_expentries.get(i); 1505 } 1506 return new ParseException(token, exptokseq, tokenImage); 1507 } 1508 1509 private int trace_indent = 0; 1510 private boolean trace_enabled; 1511 1512/* Trace enabled. */ 1513 final public boolean trace_enabled() { 1514 return trace_enabled; 1515 } 1516 1517 /* Enable tracing. */ 1518 final public void enable_tracing() { 1519 } 1520 1521 /* Disable tracing. */ 1522 final public void disable_tracing() { 1523 } 1524 1525 private void jj_rescan_token() { 1526 jj_rescan = true; 1527 for (int i = 0; i < 1; i++) { 1528 try { 1529 JJCalls p = jj_2_rtns[i]; 1530 1531 do { 1532 if (p.gen > jj_gen) { 1533 jj_la = p.arg; jj_lastpos = jj_scanpos = p.first; 1534 switch (i) { 1535 case 0: jj_3_1(); break; 1536 } 1537 } 1538 p = p.next; 1539 } while (p != null); 1540 1541 } catch(LookaheadSuccess ls) { } 1542 } 1543 jj_rescan = false; 1544 } 1545 1546 private void jj_save(int index, int xla) { 1547 JJCalls p = jj_2_rtns[index]; 1548 while (p.gen > jj_gen) { 1549 if (p.next == null) { p = p.next = new JJCalls(); break; } 1550 p = p.next; 1551 } 1552 1553 p.gen = jj_gen + xla - jj_la; 1554 p.first = token; 1555 p.arg = xla; 1556 } 1557 1558 static final class JJCalls { 1559 int gen; 1560 Token first; 1561 int arg; 1562 JJCalls next; 1563 } 1564 1565 }