001/* 002 * Copyright 2006 - 2013 003 * Stefan Balev <stefan.balev@graphstream-project.org> 004 * Julien Baudry <julien.baudry@graphstream-project.org> 005 * Antoine Dutot <antoine.dutot@graphstream-project.org> 006 * Yoann Pigné <yoann.pigne@graphstream-project.org> 007 * Guilhelm Savin <guilhelm.savin@graphstream-project.org> 008 * 009 * This file is part of GraphStream <http://graphstream-project.org>. 010 * 011 * GraphStream is a library whose purpose is to handle static or dynamic 012 * graph, create them from scratch, file or any source and display them. 013 * 014 * This program is free software distributed under the terms of two licenses, the 015 * CeCILL-C license that fits European law, and the GNU Lesser General Public 016 * License. You can use, modify and/ or redistribute the software under the terms 017 * of the CeCILL-C license as circulated by CEA, CNRS and INRIA at the following 018 * URL <http://www.cecill.info> or under the terms of the GNU LGPL as published by 019 * the Free Software Foundation, either version 3 of the License, or (at your 020 * option) any later version. 021 * 022 * This program is distributed in the hope that it will be useful, but WITHOUT ANY 023 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A 024 * PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. 025 * 026 * You should have received a copy of the GNU Lesser General Public License 027 * along with this program. If not, see <http://www.gnu.org/licenses/>. 028 * 029 * The fact that you are presently reading this means that you have had 030 * knowledge of the CeCILL-C and LGPL licenses and that you accept their terms. 031 */ 032package org.graphstream.stream.file.pajek; 033 034import java.io.InputStream; 035import java.io.IOException; 036import java.io.Reader; 037 038import java.util.ArrayList; 039 040import org.graphstream.stream.file.FileSourcePajek; 041import org.graphstream.util.parser.ParseException; 042import org.graphstream.util.parser.Parser; 043import org.graphstream.util.parser.SimpleCharStream; 044import org.graphstream.util.parser.Token; 045import org.graphstream.util.parser.TokenMgrError; 046 047@SuppressWarnings("unused") 048public class PajekParser implements Parser, PajekParserConstants { 049 // The node count. 050 int nodeCount; 051 // If true we are parsing the vertices labels. 052 // False as soon as we encounter the arcs. 053 boolean inVertices = true; 054 // If true the list of edges is a edge list. 055 boolean edgeListMode = true; 056 057 PajekContext ctx; 058 059 public PajekParser(FileSourcePajek pajek, InputStream stream) { 060 this(stream); 061 this.ctx = new PajekContext(pajek); 062 } 063 064 public PajekParser(FileSourcePajek pajek, Reader stream) { 065 this(stream); 066 this.ctx = new PajekContext(pajek); 067 } 068 069 public void open() { 070 } 071 072 /** 073 * Closes the parser, closing the opened stream. 074 */ 075 public void close() throws IOException { 076 jj_input_stream.close(); 077 } 078 079 /*****************************************************************/ 080 /* The parser. */ 081 /*****************************************************************/ 082 083 /** Unused rule, call it to slurp in the whole file. */ 084 final public void all() throws ParseException { 085 label_1: while (true) { 086 if (jj_2_1(2)) { 087 network(); 088 } else if (jj_2_2(2)) { 089 vertices(); 090 } else if (jj_2_3(2)) { 091 edges(); 092 } else if (jj_2_4(2)) { 093 jj_consume_token(COMMENT); 094 } else if (jj_2_5(2)) { 095 jj_consume_token(EOL); 096 } else { 097 jj_consume_token(-1); 098 throw new ParseException(); 099 } 100 if (jj_2_6(2)) { 101 ; 102 } else { 103 break label_1; 104 } 105 } 106 jj_consume_token(0); 107 } 108 109 final public boolean next() throws ParseException { 110 boolean ok = true; 111 Token k; 112 if (jj_2_7(2)) { 113 network(); 114 } else if (jj_2_8(2)) { 115 vertices(); 116 } else if (jj_2_9(2)) { 117 edges(); 118 } else if (jj_2_10(2)) { 119 k = jj_consume_token(COMMENT); 120 System.err.printf("got comment %s%n", k.image); 121 } else if (jj_2_11(2)) { 122 jj_consume_token(EOL); 123 } else if (jj_2_12(2)) { 124 jj_consume_token(0); 125 ok = false; 126 } else { 127 jj_consume_token(-1); 128 throw new ParseException(); 129 } 130 131 return ok; 132 } 133 134 final public void network() throws ParseException { 135 Token k; 136 StringBuffer buf = new StringBuffer(); 137 boolean first = true; 138 jj_consume_token(NETWORK); 139 label_2: while (true) { 140 if (jj_2_13(2)) { 141 ; 142 } else { 143 break label_2; 144 } 145 if (jj_2_14(2)) { 146 k = jj_consume_token(STRING); 147 if (!first) 148 buf.append(" "); 149 buf.append(k.image.substring(1, k.image.length() - 1)); 150 first = false; 151 } else if (jj_2_15(2)) { 152 k = jj_consume_token(KEY); 153 if (!first) 154 buf.append(" "); 155 buf.append(k.image); 156 first = false; 157 } else { 158 jj_consume_token(-1); 159 throw new ParseException(); 160 } 161 } 162 ctx.addGraphAttribute("ui.label", buf.toString()); 163 EO(); 164 } 165 166 // Vertices 167 final public void vertices() throws ParseException { 168 Token n; 169 jj_consume_token(VERTICES); 170 n = jj_consume_token(INT); 171 EO(); 172 nodeCount = ctx.addNodes(n); 173 label_3: while (true) { 174 if (jj_2_16(2)) { 175 ; 176 } else { 177 break label_3; 178 } 179 if (jj_2_17(2)) { 180 vertex(); 181 } else if (jj_2_18(2)) { 182 jj_consume_token(COMMENT); 183 } else { 184 jj_consume_token(-1); 185 throw new ParseException(); 186 } 187 } 188 } 189 190 final public void vertex() throws ParseException { 191 Token id, k, x, y, z = null, sh; 192 String label = null, value; 193 NodeGraphics graphics = null; 194 id = jj_consume_token(INT); 195 if (jj_2_53(2)) { 196 k = validIdentifier(); 197 label = k.image; 198 if (jj_2_52(2)) { 199 if (jj_2_19(2)) { 200 x = jj_consume_token(REAL); 201 } else if (jj_2_20(2)) { 202 x = jj_consume_token(INT); 203 } else { 204 jj_consume_token(-1); 205 throw new ParseException(); 206 } 207 if (jj_2_21(2)) { 208 y = jj_consume_token(REAL); 209 } else if (jj_2_22(2)) { 210 y = jj_consume_token(INT); 211 } else { 212 jj_consume_token(-1); 213 throw new ParseException(); 214 } 215 if (jj_2_25(2)) { 216 if (jj_2_23(2)) { 217 z = jj_consume_token(REAL); 218 } else if (jj_2_24(2)) { 219 z = jj_consume_token(INT); 220 } else { 221 jj_consume_token(-1); 222 throw new ParseException(); 223 } 224 } else { 225 ; 226 } 227 ctx.addNodePosition(id.image, x, y, z); 228 if (jj_2_32(2)) { 229 if (jj_2_26(2)) { 230 k = jj_consume_token(ELLIPSE); 231 if (graphics == null) 232 graphics = new NodeGraphics(); 233 graphics.addKey("shape", "circle", k); 234 } else if (jj_2_27(2)) { 235 k = jj_consume_token(BOX); 236 if (graphics == null) 237 graphics = new NodeGraphics(); 238 graphics.addKey("shape", "box", k); 239 } else if (jj_2_28(2)) { 240 k = jj_consume_token(TRIANGLE); 241 if (graphics == null) 242 graphics = new NodeGraphics(); 243 graphics.addKey("shape", "triangle", k); 244 } else if (jj_2_29(2)) { 245 k = jj_consume_token(CROSS); 246 if (graphics == null) 247 graphics = new NodeGraphics(); 248 graphics.addKey("shape", "cross", k); 249 } else if (jj_2_30(2)) { 250 k = jj_consume_token(DIAMOND); 251 if (graphics == null) 252 graphics = new NodeGraphics(); 253 graphics.addKey("shape", "diamond", k); 254 } else if (jj_2_31(2)) { 255 k = jj_consume_token(EMPTY); 256 if (graphics == null) 257 graphics = new NodeGraphics(); 258 graphics.addKey("shape", "circle", k); 259 } else { 260 jj_consume_token(-1); 261 throw new ParseException(); 262 } 263 } else { 264 ; 265 } 266 label_4: while (true) { 267 if (jj_2_33(2)) { 268 ; 269 } else { 270 break label_4; 271 } 272 if (jj_2_34(2)) { 273 k = jj_consume_token(SIZE); 274 value = number(); 275 if (graphics == null) 276 graphics = new NodeGraphics(); 277 graphics.addKey("s_size", value, k); 278 } else if (jj_2_35(2)) { 279 k = jj_consume_token(XFACT); 280 value = number(); 281 282 } else if (jj_2_36(2)) { 283 k = jj_consume_token(YFACT); 284 value = number(); 285 286 } else if (jj_2_37(2)) { 287 k = jj_consume_token(PHI); 288 value = number(); 289 290 } else if (jj_2_38(2)) { 291 k = jj_consume_token(R); 292 value = number(); 293 294 } else if (jj_2_39(2)) { 295 k = jj_consume_token(Q); 296 value = number(); 297 298 } else if (jj_2_40(2)) { 299 k = jj_consume_token(IC); 300 value = color(); 301 if (graphics == null) 302 graphics = new NodeGraphics(); 303 graphics.addKey("ic", value, k); 304 } else if (jj_2_41(2)) { 305 k = jj_consume_token(BC); 306 value = color(); 307 if (graphics == null) 308 graphics = new NodeGraphics(); 309 graphics.addKey("bc", value, k); 310 } else if (jj_2_42(2)) { 311 k = jj_consume_token(BW); 312 value = number(); 313 if (graphics == null) 314 graphics = new NodeGraphics(); 315 graphics.addKey("bw", value, k); 316 } else if (jj_2_43(2)) { 317 k = jj_consume_token(LC); 318 value = color(); 319 if (graphics == null) 320 graphics = new NodeGraphics(); 321 graphics.addKey("lc", value, k); 322 } else if (jj_2_44(2)) { 323 k = jj_consume_token(LA); 324 value = number(); 325 326 } else if (jj_2_45(2)) { 327 k = jj_consume_token(LR); 328 value = number(); 329 330 } else if (jj_2_46(2)) { 331 k = jj_consume_token(LPHI); 332 value = number(); 333 334 } else if (jj_2_47(2)) { 335 k = jj_consume_token(FOS); 336 value = number(); 337 if (graphics == null) 338 graphics = new NodeGraphics(); 339 graphics.addKey("fos", value, k); 340 } else if (jj_2_48(2)) { 341 k = jj_consume_token(FONT); 342 value = keyOrString(); 343 if (graphics == null) 344 graphics = new NodeGraphics(); 345 graphics.addKey("font", value, k); 346 } else { 347 jj_consume_token(-1); 348 throw new ParseException(); 349 } 350 } 351 label_5: while (true) { 352 if (jj_2_49(2)) { 353 ; 354 } else { 355 break label_5; 356 } 357 if (jj_2_50(2)) { 358 k = validIdentifier(); 359 } else if (jj_2_51(2)) { 360 k = jj_consume_token(REAL); 361 } else { 362 jj_consume_token(-1); 363 throw new ParseException(); 364 } 365 System.err.printf("%d:%d: unparsed garbage in .net (%s)%n", 366 k.beginLine, k.beginColumn, k.image); 367 } 368 } else { 369 ; 370 } 371 } else { 372 ; 373 } 374 EO(); 375 if (label != null) { 376 if (label.startsWith("\u005c"")) 377 label = label.substring(1, label.length() - 1); 378 ctx.addNodeLabel(id.image, label); 379 } 380 if (graphics != null) 381 ctx.addNodeGraphics(id.image, graphics); 382 } 383 384 // Edges and edge lists. 385 final public void edges() throws ParseException { 386 if (jj_2_66(2)) { 387 jj_consume_token(ARCS); 388 EO(); 389 edgeListMode = false; 390 inVertices = false; 391 ctx.setDirected(true); 392 label_6: while (true) { 393 if (jj_2_54(2)) { 394 ; 395 } else { 396 break label_6; 397 } 398 if (jj_2_55(2)) { 399 edge(); 400 } else if (jj_2_56(2)) { 401 jj_consume_token(COMMENT); 402 } else { 403 jj_consume_token(-1); 404 throw new ParseException(); 405 } 406 } 407 } else if (jj_2_67(2)) { 408 jj_consume_token(EDGES); 409 EO(); 410 edgeListMode = false; 411 inVertices = false; 412 ctx.setDirected(false); 413 label_7: while (true) { 414 if (jj_2_57(2)) { 415 ; 416 } else { 417 break label_7; 418 } 419 if (jj_2_58(2)) { 420 edge(); 421 } else if (jj_2_59(2)) { 422 jj_consume_token(COMMENT); 423 } else { 424 jj_consume_token(-1); 425 throw new ParseException(); 426 } 427 } 428 } else if (jj_2_68(2)) { 429 jj_consume_token(ARCSLIST); 430 EO(); 431 edgeListMode = true; 432 inVertices = false; 433 ctx.setDirected(true); 434 label_8: while (true) { 435 if (jj_2_60(2)) { 436 ; 437 } else { 438 break label_8; 439 } 440 if (jj_2_61(2)) { 441 edgeList(); 442 } else if (jj_2_62(2)) { 443 jj_consume_token(COMMENT); 444 } else { 445 jj_consume_token(-1); 446 throw new ParseException(); 447 } 448 } 449 } else if (jj_2_69(2)) { 450 jj_consume_token(EDGESLIST); 451 EO(); 452 edgeListMode = true; 453 inVertices = false; 454 ctx.setDirected(false); 455 label_9: while (true) { 456 if (jj_2_63(2)) { 457 ; 458 } else { 459 break label_9; 460 } 461 if (jj_2_64(2)) { 462 edgeList(); 463 } else if (jj_2_65(2)) { 464 jj_consume_token(COMMENT); 465 } else { 466 jj_consume_token(-1); 467 throw new ParseException(); 468 } 469 } 470 } else if (jj_2_70(2)) { 471 matrix(); 472 } else if (jj_2_71(2)) { 473 jj_consume_token(COMMENT); 474 } else { 475 jj_consume_token(-1); 476 throw new ParseException(); 477 } 478 } 479 480 final public void edge() throws ParseException { 481 Token src, trg, more, weight, k, sh; 482 String id, value; 483 EdgeGraphics graphics = null; 484 src = jj_consume_token(INT); 485 trg = jj_consume_token(INT); 486 id = ctx.addEdge(src.image, trg.image); 487 if (jj_2_100(2)) { 488 if (jj_2_72(2)) { 489 k = jj_consume_token(INT); 490 } else if (jj_2_73(2)) { 491 k = jj_consume_token(REAL); 492 } else { 493 jj_consume_token(-1); 494 throw new ParseException(); 495 } 496 ctx.addEdgeWeight(id, k); 497 label_10: while (true) { 498 if (jj_2_74(2)) { 499 ; 500 } else { 501 break label_10; 502 } 503 if (jj_2_77(2)) { 504 k = jj_consume_token(P); 505 value = keyOrString(); 506 if (graphics == null) 507 graphics = new EdgeGraphics(); 508 graphics.addKey("p", value, k); 509 } else if (jj_2_78(2)) { 510 k = jj_consume_token(W); 511 value = number(); 512 if (graphics == null) 513 graphics = new EdgeGraphics(); 514 graphics.addKey("w", value, k); 515 } else if (jj_2_79(2)) { 516 k = jj_consume_token(C); 517 value = color(); 518 if (graphics == null) 519 graphics = new EdgeGraphics(); 520 graphics.addKey("c", value, k); 521 } else if (jj_2_80(2)) { 522 k = jj_consume_token(S); 523 value = number(); 524 if (graphics == null) 525 graphics = new EdgeGraphics(); 526 graphics.addKey("s", value, k); 527 } else if (jj_2_81(2)) { 528 k = jj_consume_token(A); 529 if (jj_2_75(2)) { 530 k = jj_consume_token(A); 531 } else if (jj_2_76(2)) { 532 k = jj_consume_token(B); 533 } else { 534 jj_consume_token(-1); 535 throw new ParseException(); 536 } 537 if (graphics == null) 538 graphics = new EdgeGraphics(); 539 graphics.addKey("a", k.image, k); 540 } else if (jj_2_82(2)) { 541 k = jj_consume_token(AP); 542 value = number(); 543 if (graphics == null) 544 graphics = new EdgeGraphics(); 545 graphics.addKey("ap", value, k); 546 } else if (jj_2_83(2)) { 547 k = jj_consume_token(L); 548 value = keyOrString(); 549 if (graphics == null) 550 graphics = new EdgeGraphics(); 551 graphics.addKey("l", value, k); 552 } else if (jj_2_84(2)) { 553 k = jj_consume_token(LP); 554 value = number(); 555 if (graphics == null) 556 graphics = new EdgeGraphics(); 557 graphics.addKey("lp", value, k); 558 } else if (jj_2_85(2)) { 559 k = jj_consume_token(LR); 560 value = number(); 561 if (graphics == null) 562 graphics = new EdgeGraphics(); 563 graphics.addKey("lr", value, k); 564 } else if (jj_2_86(2)) { 565 k = jj_consume_token(LPHI); 566 value = number(); 567 if (graphics == null) 568 graphics = new EdgeGraphics(); 569 graphics.addKey("lphi", value, k); 570 } else if (jj_2_87(2)) { 571 k = jj_consume_token(LC); 572 value = color(); 573 if (graphics == null) 574 graphics = new EdgeGraphics(); 575 graphics.addKey("lc", value, k); 576 } else if (jj_2_88(2)) { 577 k = jj_consume_token(LA); 578 value = number(); 579 if (graphics == null) 580 graphics = new EdgeGraphics(); 581 graphics.addKey("la", value, k); 582 } else if (jj_2_89(2)) { 583 k = jj_consume_token(FOS); 584 value = number(); 585 if (graphics == null) 586 graphics = new EdgeGraphics(); 587 graphics.addKey("fos", value, k); 588 } else if (jj_2_90(2)) { 589 k = jj_consume_token(FONT); 590 value = keyOrString(); 591 if (graphics == null) 592 graphics = new EdgeGraphics(); 593 graphics.addKey("font", value, k); 594 } else if (jj_2_91(2)) { 595 k = jj_consume_token(H1); 596 value = number(); 597 if (graphics == null) 598 graphics = new EdgeGraphics(); 599 graphics.addKey("h1", value, k); 600 } else if (jj_2_92(2)) { 601 k = jj_consume_token(H2); 602 value = number(); 603 if (graphics == null) 604 graphics = new EdgeGraphics(); 605 graphics.addKey("h2", value, k); 606 } else if (jj_2_93(2)) { 607 k = jj_consume_token(A1); 608 value = number(); 609 if (graphics == null) 610 graphics = new EdgeGraphics(); 611 graphics.addKey("a1", value, k); 612 } else if (jj_2_94(2)) { 613 k = jj_consume_token(A2); 614 value = number(); 615 if (graphics == null) 616 graphics = new EdgeGraphics(); 617 graphics.addKey("a2", value, k); 618 } else if (jj_2_95(2)) { 619 k = jj_consume_token(K1); 620 value = number(); 621 if (graphics == null) 622 graphics = new EdgeGraphics(); 623 graphics.addKey("k1", value, k); 624 } else if (jj_2_96(2)) { 625 k = jj_consume_token(K2); 626 value = number(); 627 if (graphics == null) 628 graphics = new EdgeGraphics(); 629 graphics.addKey("k2", value, k); 630 } else { 631 jj_consume_token(-1); 632 throw new ParseException(); 633 } 634 } 635 label_11: while (true) { 636 if (jj_2_97(2)) { 637 ; 638 } else { 639 break label_11; 640 } 641 if (jj_2_98(2)) { 642 k = validIdentifier(); 643 } else if (jj_2_99(2)) { 644 k = jj_consume_token(REAL); 645 } else { 646 jj_consume_token(-1); 647 throw new ParseException(); 648 } 649 System.err.printf("%d:%d: unparsed garbage in .net (%s)%n", 650 k.beginLine, k.beginColumn, k.image); 651 } 652 } else { 653 ; 654 } 655 EO(); 656 if (graphics != null) 657 ctx.addEdgeGraphics(id, graphics); 658 } 659 660 final public void edgeList() throws ParseException { 661 Token src, trg, more; 662 String id; 663 src = jj_consume_token(INT); 664 trg = jj_consume_token(INT); 665 id = ctx.addEdge(src.image, trg.image); 666 label_12: while (true) { 667 if (jj_2_101(2)) { 668 ; 669 } else { 670 break label_12; 671 } 672 more = jj_consume_token(INT); 673 if (edgeListMode) 674 ctx.addEdge(src.image, more.image); 675 } 676 EO(); 677 } 678 679 // The awful *matrix notation. 680 final public void matrix() throws ParseException { 681 EdgeMatrix mat = new EdgeMatrix(nodeCount); 682 ArrayList<String> line; 683 jj_consume_token(MATRIX); 684 label_13: while (true) { 685 jj_consume_token(EOL); 686 if (jj_2_102(2)) { 687 ; 688 } else { 689 break label_13; 690 } 691 } 692 label_14: while (true) { 693 if (jj_2_103(2)) { 694 line = matrixline(mat); 695 mat.addLine(line); 696 } else if (jj_2_104(2)) { 697 jj_consume_token(COMMENT); 698 } else { 699 jj_consume_token(-1); 700 throw new ParseException(); 701 } 702 if (jj_2_105(2)) { 703 ; 704 } else { 705 break label_14; 706 } 707 } 708 ctx.addEdges(mat); 709 } 710 711 final public ArrayList<String> matrixline(EdgeMatrix mat) 712 throws ParseException { 713 Token k; 714 ArrayList<String> line = new ArrayList<String>(nodeCount); 715 label_15: while (true) { 716 k = jj_consume_token(INT); 717 line.add(k.image); 718 if (jj_2_106(2)) { 719 ; 720 } else { 721 break label_15; 722 } 723 } 724 EO(); 725 726 return line; 727 } 728 729 // Various 730 final public String keyOrString() throws ParseException { 731 Token k; 732 String value; 733 if (jj_2_107(2)) { 734 k = jj_consume_token(KEY); 735 value = k.image; 736 } else if (jj_2_108(2)) { 737 k = jj_consume_token(STRING); 738 value = k.image.substring(1, k.image.length() - 1); 739 } else { 740 jj_consume_token(-1); 741 throw new ParseException(); 742 } 743 744 return value; 745 } 746 747 final public String number() throws ParseException { 748 Token k; 749 if (jj_2_109(2)) { 750 k = jj_consume_token(INT); 751 } else if (jj_2_110(2)) { 752 k = jj_consume_token(REAL); 753 } else { 754 jj_consume_token(-1); 755 throw new ParseException(); 756 } 757 758 return k.image; 759 } 760 761 final public String color() throws ParseException { 762 String value; 763 Token r, g, b; 764 if (jj_2_111(2)) { 765 value = keyOrString(); 766 } else if (jj_2_112(2)) { 767 r = jj_consume_token(REAL); 768 g = jj_consume_token(REAL); 769 b = jj_consume_token(REAL); 770 value = PajekContext.toColorValue(r, g, b); 771 } else if (jj_2_113(2)) { 772 r = jj_consume_token(INT); 773 g = jj_consume_token(INT); 774 b = jj_consume_token(INT); 775 value = PajekContext.toColorValue(r, g, b); 776 } else { 777 jj_consume_token(-1); 778 throw new ParseException(); 779 } 780 781 return value; 782 } 783 784 final public void EO() throws ParseException { 785 if (jj_2_115(2)) { 786 label_16: while (true) { 787 jj_consume_token(EOL); 788 if (jj_2_114(2)) { 789 ; 790 } else { 791 break label_16; 792 } 793 } 794 } else if (jj_2_116(2)) { 795 jj_consume_token(0); 796 } else { 797 jj_consume_token(-1); 798 throw new ParseException(); 799 } 800 } 801 802 final public Token anyGraphicAttribute() throws ParseException { 803 Token k; 804 if (jj_2_117(2)) { 805 k = jj_consume_token(INT); 806 } else if (jj_2_118(2)) { 807 k = jj_consume_token(REAL); 808 } else if (jj_2_119(2)) { 809 k = jj_consume_token(KEY); 810 } else if (jj_2_120(2)) { 811 k = jj_consume_token(STRING); 812 } else if (jj_2_121(2)) { 813 k = jj_consume_token(SIZE); 814 } else if (jj_2_122(2)) { 815 k = jj_consume_token(XFACT); 816 } else if (jj_2_123(2)) { 817 k = jj_consume_token(YFACT); 818 } else if (jj_2_124(2)) { 819 k = jj_consume_token(PHI); 820 } else if (jj_2_125(2)) { 821 k = jj_consume_token(R); 822 } else if (jj_2_126(2)) { 823 k = jj_consume_token(Q); 824 } else if (jj_2_127(2)) { 825 k = jj_consume_token(IC); 826 } else if (jj_2_128(2)) { 827 k = jj_consume_token(BC); 828 } else if (jj_2_129(2)) { 829 k = jj_consume_token(BW); 830 } else if (jj_2_130(2)) { 831 k = jj_consume_token(LC); 832 } else if (jj_2_131(2)) { 833 k = jj_consume_token(LA); 834 } else if (jj_2_132(2)) { 835 k = jj_consume_token(LR); 836 } else if (jj_2_133(2)) { 837 k = jj_consume_token(LPHI); 838 } else if (jj_2_134(2)) { 839 k = jj_consume_token(FOS); 840 } else if (jj_2_135(2)) { 841 k = jj_consume_token(FONT); 842 } else if (jj_2_136(2)) { 843 k = jj_consume_token(C); 844 } else if (jj_2_137(2)) { 845 k = jj_consume_token(P); 846 } else if (jj_2_138(2)) { 847 k = jj_consume_token(W); 848 } else if (jj_2_139(2)) { 849 k = jj_consume_token(A); 850 } else if (jj_2_140(2)) { 851 k = jj_consume_token(B); 852 } else if (jj_2_141(2)) { 853 k = jj_consume_token(AP); 854 } else if (jj_2_142(2)) { 855 k = jj_consume_token(L); 856 } else if (jj_2_143(2)) { 857 k = jj_consume_token(LP); 858 } else if (jj_2_144(2)) { 859 k = jj_consume_token(H1); 860 } else if (jj_2_145(2)) { 861 k = jj_consume_token(H2); 862 } else if (jj_2_146(2)) { 863 k = jj_consume_token(K1); 864 } else if (jj_2_147(2)) { 865 k = jj_consume_token(K2); 866 } else if (jj_2_148(2)) { 867 k = jj_consume_token(A1); 868 } else if (jj_2_149(2)) { 869 k = jj_consume_token(A2); 870 } else { 871 jj_consume_token(-1); 872 throw new ParseException(); 873 } 874 875 return k; 876 } 877 878 final public Token validIdentifier() throws ParseException { 879 Token k = null; 880 if (jj_2_150(2)) { 881 k = jj_consume_token(KEY); 882 } else if (jj_2_151(2)) { 883 k = jj_consume_token(STRING); 884 } else if (jj_2_152(2)) { 885 k = jj_consume_token(INT); 886 } else if (jj_2_153(2)) { 887 k = jj_consume_token(A); 888 } else if (jj_2_154(2)) { 889 k = jj_consume_token(A1); 890 } else if (jj_2_155(2)) { 891 k = jj_consume_token(A2); 892 } else if (jj_2_156(2)) { 893 k = jj_consume_token(AP); 894 } else if (jj_2_157(2)) { 895 k = jj_consume_token(B); 896 } else if (jj_2_158(2)) { 897 k = jj_consume_token(BC); 898 } else if (jj_2_159(2)) { 899 k = jj_consume_token(BW); 900 } else if (jj_2_160(2)) { 901 k = jj_consume_token(C); 902 } else if (jj_2_161(2)) { 903 k = jj_consume_token(FONT); 904 } else if (jj_2_162(2)) { 905 k = jj_consume_token(FOS); 906 } else if (jj_2_163(2)) { 907 k = jj_consume_token(H1); 908 } else if (jj_2_164(2)) { 909 k = jj_consume_token(H2); 910 } else if (jj_2_165(2)) { 911 k = jj_consume_token(IC); 912 } else if (jj_2_166(2)) { 913 k = jj_consume_token(K1); 914 } else if (jj_2_167(2)) { 915 k = jj_consume_token(K2); 916 } else if (jj_2_168(2)) { 917 k = jj_consume_token(L); 918 } else if (jj_2_169(2)) { 919 k = jj_consume_token(LA); 920 } else if (jj_2_170(2)) { 921 k = jj_consume_token(LC); 922 } else if (jj_2_171(2)) { 923 k = jj_consume_token(LP); 924 } else if (jj_2_172(2)) { 925 k = jj_consume_token(LPHI); 926 } else if (jj_2_173(2)) { 927 k = jj_consume_token(LR); 928 } else if (jj_2_174(2)) { 929 k = jj_consume_token(P); 930 } else if (jj_2_175(2)) { 931 k = jj_consume_token(PHI); 932 } else if (jj_2_176(2)) { 933 k = jj_consume_token(Q); 934 } else if (jj_2_177(2)) { 935 k = jj_consume_token(R); 936 } else if (jj_2_178(2)) { 937 k = jj_consume_token(S); 938 } else if (jj_2_179(2)) { 939 k = jj_consume_token(SIZE); 940 } else if (jj_2_180(2)) { 941 k = jj_consume_token(W); 942 } else if (jj_2_181(2)) { 943 k = jj_consume_token(XFACT); 944 } else if (jj_2_182(2)) { 945 k = jj_consume_token(YFACT); 946 } else { 947 jj_consume_token(-1); 948 throw new ParseException(); 949 } 950 951 return k; 952 } 953 954 private boolean jj_2_1(int xla) { 955 jj_la = xla; 956 jj_lastpos = jj_scanpos = token; 957 try { 958 return !jj_3_1(); 959 } catch (LookaheadSuccess ls) { 960 return true; 961 } finally { 962 jj_save(0, xla); 963 } 964 } 965 966 private boolean jj_2_2(int xla) { 967 jj_la = xla; 968 jj_lastpos = jj_scanpos = token; 969 try { 970 return !jj_3_2(); 971 } catch (LookaheadSuccess ls) { 972 return true; 973 } finally { 974 jj_save(1, xla); 975 } 976 } 977 978 private boolean jj_2_3(int xla) { 979 jj_la = xla; 980 jj_lastpos = jj_scanpos = token; 981 try { 982 return !jj_3_3(); 983 } catch (LookaheadSuccess ls) { 984 return true; 985 } finally { 986 jj_save(2, xla); 987 } 988 } 989 990 private boolean jj_2_4(int xla) { 991 jj_la = xla; 992 jj_lastpos = jj_scanpos = token; 993 try { 994 return !jj_3_4(); 995 } catch (LookaheadSuccess ls) { 996 return true; 997 } finally { 998 jj_save(3, xla); 999 } 1000 } 1001 1002 private boolean jj_2_5(int xla) { 1003 jj_la = xla; 1004 jj_lastpos = jj_scanpos = token; 1005 try { 1006 return !jj_3_5(); 1007 } catch (LookaheadSuccess ls) { 1008 return true; 1009 } finally { 1010 jj_save(4, xla); 1011 } 1012 } 1013 1014 private boolean jj_2_6(int xla) { 1015 jj_la = xla; 1016 jj_lastpos = jj_scanpos = token; 1017 try { 1018 return !jj_3_6(); 1019 } catch (LookaheadSuccess ls) { 1020 return true; 1021 } finally { 1022 jj_save(5, xla); 1023 } 1024 } 1025 1026 private boolean jj_2_7(int xla) { 1027 jj_la = xla; 1028 jj_lastpos = jj_scanpos = token; 1029 try { 1030 return !jj_3_7(); 1031 } catch (LookaheadSuccess ls) { 1032 return true; 1033 } finally { 1034 jj_save(6, xla); 1035 } 1036 } 1037 1038 private boolean jj_2_8(int xla) { 1039 jj_la = xla; 1040 jj_lastpos = jj_scanpos = token; 1041 try { 1042 return !jj_3_8(); 1043 } catch (LookaheadSuccess ls) { 1044 return true; 1045 } finally { 1046 jj_save(7, xla); 1047 } 1048 } 1049 1050 private boolean jj_2_9(int xla) { 1051 jj_la = xla; 1052 jj_lastpos = jj_scanpos = token; 1053 try { 1054 return !jj_3_9(); 1055 } catch (LookaheadSuccess ls) { 1056 return true; 1057 } finally { 1058 jj_save(8, xla); 1059 } 1060 } 1061 1062 private boolean jj_2_10(int xla) { 1063 jj_la = xla; 1064 jj_lastpos = jj_scanpos = token; 1065 try { 1066 return !jj_3_10(); 1067 } catch (LookaheadSuccess ls) { 1068 return true; 1069 } finally { 1070 jj_save(9, xla); 1071 } 1072 } 1073 1074 private boolean jj_2_11(int xla) { 1075 jj_la = xla; 1076 jj_lastpos = jj_scanpos = token; 1077 try { 1078 return !jj_3_11(); 1079 } catch (LookaheadSuccess ls) { 1080 return true; 1081 } finally { 1082 jj_save(10, xla); 1083 } 1084 } 1085 1086 private boolean jj_2_12(int xla) { 1087 jj_la = xla; 1088 jj_lastpos = jj_scanpos = token; 1089 try { 1090 return !jj_3_12(); 1091 } catch (LookaheadSuccess ls) { 1092 return true; 1093 } finally { 1094 jj_save(11, xla); 1095 } 1096 } 1097 1098 private boolean jj_2_13(int xla) { 1099 jj_la = xla; 1100 jj_lastpos = jj_scanpos = token; 1101 try { 1102 return !jj_3_13(); 1103 } catch (LookaheadSuccess ls) { 1104 return true; 1105 } finally { 1106 jj_save(12, xla); 1107 } 1108 } 1109 1110 private boolean jj_2_14(int xla) { 1111 jj_la = xla; 1112 jj_lastpos = jj_scanpos = token; 1113 try { 1114 return !jj_3_14(); 1115 } catch (LookaheadSuccess ls) { 1116 return true; 1117 } finally { 1118 jj_save(13, xla); 1119 } 1120 } 1121 1122 private boolean jj_2_15(int xla) { 1123 jj_la = xla; 1124 jj_lastpos = jj_scanpos = token; 1125 try { 1126 return !jj_3_15(); 1127 } catch (LookaheadSuccess ls) { 1128 return true; 1129 } finally { 1130 jj_save(14, xla); 1131 } 1132 } 1133 1134 private boolean jj_2_16(int xla) { 1135 jj_la = xla; 1136 jj_lastpos = jj_scanpos = token; 1137 try { 1138 return !jj_3_16(); 1139 } catch (LookaheadSuccess ls) { 1140 return true; 1141 } finally { 1142 jj_save(15, xla); 1143 } 1144 } 1145 1146 private boolean jj_2_17(int xla) { 1147 jj_la = xla; 1148 jj_lastpos = jj_scanpos = token; 1149 try { 1150 return !jj_3_17(); 1151 } catch (LookaheadSuccess ls) { 1152 return true; 1153 } finally { 1154 jj_save(16, xla); 1155 } 1156 } 1157 1158 private boolean jj_2_18(int xla) { 1159 jj_la = xla; 1160 jj_lastpos = jj_scanpos = token; 1161 try { 1162 return !jj_3_18(); 1163 } catch (LookaheadSuccess ls) { 1164 return true; 1165 } finally { 1166 jj_save(17, xla); 1167 } 1168 } 1169 1170 private boolean jj_2_19(int xla) { 1171 jj_la = xla; 1172 jj_lastpos = jj_scanpos = token; 1173 try { 1174 return !jj_3_19(); 1175 } catch (LookaheadSuccess ls) { 1176 return true; 1177 } finally { 1178 jj_save(18, xla); 1179 } 1180 } 1181 1182 private boolean jj_2_20(int xla) { 1183 jj_la = xla; 1184 jj_lastpos = jj_scanpos = token; 1185 try { 1186 return !jj_3_20(); 1187 } catch (LookaheadSuccess ls) { 1188 return true; 1189 } finally { 1190 jj_save(19, xla); 1191 } 1192 } 1193 1194 private boolean jj_2_21(int xla) { 1195 jj_la = xla; 1196 jj_lastpos = jj_scanpos = token; 1197 try { 1198 return !jj_3_21(); 1199 } catch (LookaheadSuccess ls) { 1200 return true; 1201 } finally { 1202 jj_save(20, xla); 1203 } 1204 } 1205 1206 private boolean jj_2_22(int xla) { 1207 jj_la = xla; 1208 jj_lastpos = jj_scanpos = token; 1209 try { 1210 return !jj_3_22(); 1211 } catch (LookaheadSuccess ls) { 1212 return true; 1213 } finally { 1214 jj_save(21, xla); 1215 } 1216 } 1217 1218 private boolean jj_2_23(int xla) { 1219 jj_la = xla; 1220 jj_lastpos = jj_scanpos = token; 1221 try { 1222 return !jj_3_23(); 1223 } catch (LookaheadSuccess ls) { 1224 return true; 1225 } finally { 1226 jj_save(22, xla); 1227 } 1228 } 1229 1230 private boolean jj_2_24(int xla) { 1231 jj_la = xla; 1232 jj_lastpos = jj_scanpos = token; 1233 try { 1234 return !jj_3_24(); 1235 } catch (LookaheadSuccess ls) { 1236 return true; 1237 } finally { 1238 jj_save(23, xla); 1239 } 1240 } 1241 1242 private boolean jj_2_25(int xla) { 1243 jj_la = xla; 1244 jj_lastpos = jj_scanpos = token; 1245 try { 1246 return !jj_3_25(); 1247 } catch (LookaheadSuccess ls) { 1248 return true; 1249 } finally { 1250 jj_save(24, xla); 1251 } 1252 } 1253 1254 private boolean jj_2_26(int xla) { 1255 jj_la = xla; 1256 jj_lastpos = jj_scanpos = token; 1257 try { 1258 return !jj_3_26(); 1259 } catch (LookaheadSuccess ls) { 1260 return true; 1261 } finally { 1262 jj_save(25, xla); 1263 } 1264 } 1265 1266 private boolean jj_2_27(int xla) { 1267 jj_la = xla; 1268 jj_lastpos = jj_scanpos = token; 1269 try { 1270 return !jj_3_27(); 1271 } catch (LookaheadSuccess ls) { 1272 return true; 1273 } finally { 1274 jj_save(26, xla); 1275 } 1276 } 1277 1278 private boolean jj_2_28(int xla) { 1279 jj_la = xla; 1280 jj_lastpos = jj_scanpos = token; 1281 try { 1282 return !jj_3_28(); 1283 } catch (LookaheadSuccess ls) { 1284 return true; 1285 } finally { 1286 jj_save(27, xla); 1287 } 1288 } 1289 1290 private boolean jj_2_29(int xla) { 1291 jj_la = xla; 1292 jj_lastpos = jj_scanpos = token; 1293 try { 1294 return !jj_3_29(); 1295 } catch (LookaheadSuccess ls) { 1296 return true; 1297 } finally { 1298 jj_save(28, xla); 1299 } 1300 } 1301 1302 private boolean jj_2_30(int xla) { 1303 jj_la = xla; 1304 jj_lastpos = jj_scanpos = token; 1305 try { 1306 return !jj_3_30(); 1307 } catch (LookaheadSuccess ls) { 1308 return true; 1309 } finally { 1310 jj_save(29, xla); 1311 } 1312 } 1313 1314 private boolean jj_2_31(int xla) { 1315 jj_la = xla; 1316 jj_lastpos = jj_scanpos = token; 1317 try { 1318 return !jj_3_31(); 1319 } catch (LookaheadSuccess ls) { 1320 return true; 1321 } finally { 1322 jj_save(30, xla); 1323 } 1324 } 1325 1326 private boolean jj_2_32(int xla) { 1327 jj_la = xla; 1328 jj_lastpos = jj_scanpos = token; 1329 try { 1330 return !jj_3_32(); 1331 } catch (LookaheadSuccess ls) { 1332 return true; 1333 } finally { 1334 jj_save(31, xla); 1335 } 1336 } 1337 1338 private boolean jj_2_33(int xla) { 1339 jj_la = xla; 1340 jj_lastpos = jj_scanpos = token; 1341 try { 1342 return !jj_3_33(); 1343 } catch (LookaheadSuccess ls) { 1344 return true; 1345 } finally { 1346 jj_save(32, xla); 1347 } 1348 } 1349 1350 private boolean jj_2_34(int xla) { 1351 jj_la = xla; 1352 jj_lastpos = jj_scanpos = token; 1353 try { 1354 return !jj_3_34(); 1355 } catch (LookaheadSuccess ls) { 1356 return true; 1357 } finally { 1358 jj_save(33, xla); 1359 } 1360 } 1361 1362 private boolean jj_2_35(int xla) { 1363 jj_la = xla; 1364 jj_lastpos = jj_scanpos = token; 1365 try { 1366 return !jj_3_35(); 1367 } catch (LookaheadSuccess ls) { 1368 return true; 1369 } finally { 1370 jj_save(34, xla); 1371 } 1372 } 1373 1374 private boolean jj_2_36(int xla) { 1375 jj_la = xla; 1376 jj_lastpos = jj_scanpos = token; 1377 try { 1378 return !jj_3_36(); 1379 } catch (LookaheadSuccess ls) { 1380 return true; 1381 } finally { 1382 jj_save(35, xla); 1383 } 1384 } 1385 1386 private boolean jj_2_37(int xla) { 1387 jj_la = xla; 1388 jj_lastpos = jj_scanpos = token; 1389 try { 1390 return !jj_3_37(); 1391 } catch (LookaheadSuccess ls) { 1392 return true; 1393 } finally { 1394 jj_save(36, xla); 1395 } 1396 } 1397 1398 private boolean jj_2_38(int xla) { 1399 jj_la = xla; 1400 jj_lastpos = jj_scanpos = token; 1401 try { 1402 return !jj_3_38(); 1403 } catch (LookaheadSuccess ls) { 1404 return true; 1405 } finally { 1406 jj_save(37, xla); 1407 } 1408 } 1409 1410 private boolean jj_2_39(int xla) { 1411 jj_la = xla; 1412 jj_lastpos = jj_scanpos = token; 1413 try { 1414 return !jj_3_39(); 1415 } catch (LookaheadSuccess ls) { 1416 return true; 1417 } finally { 1418 jj_save(38, xla); 1419 } 1420 } 1421 1422 private boolean jj_2_40(int xla) { 1423 jj_la = xla; 1424 jj_lastpos = jj_scanpos = token; 1425 try { 1426 return !jj_3_40(); 1427 } catch (LookaheadSuccess ls) { 1428 return true; 1429 } finally { 1430 jj_save(39, xla); 1431 } 1432 } 1433 1434 private boolean jj_2_41(int xla) { 1435 jj_la = xla; 1436 jj_lastpos = jj_scanpos = token; 1437 try { 1438 return !jj_3_41(); 1439 } catch (LookaheadSuccess ls) { 1440 return true; 1441 } finally { 1442 jj_save(40, xla); 1443 } 1444 } 1445 1446 private boolean jj_2_42(int xla) { 1447 jj_la = xla; 1448 jj_lastpos = jj_scanpos = token; 1449 try { 1450 return !jj_3_42(); 1451 } catch (LookaheadSuccess ls) { 1452 return true; 1453 } finally { 1454 jj_save(41, xla); 1455 } 1456 } 1457 1458 private boolean jj_2_43(int xla) { 1459 jj_la = xla; 1460 jj_lastpos = jj_scanpos = token; 1461 try { 1462 return !jj_3_43(); 1463 } catch (LookaheadSuccess ls) { 1464 return true; 1465 } finally { 1466 jj_save(42, xla); 1467 } 1468 } 1469 1470 private boolean jj_2_44(int xla) { 1471 jj_la = xla; 1472 jj_lastpos = jj_scanpos = token; 1473 try { 1474 return !jj_3_44(); 1475 } catch (LookaheadSuccess ls) { 1476 return true; 1477 } finally { 1478 jj_save(43, xla); 1479 } 1480 } 1481 1482 private boolean jj_2_45(int xla) { 1483 jj_la = xla; 1484 jj_lastpos = jj_scanpos = token; 1485 try { 1486 return !jj_3_45(); 1487 } catch (LookaheadSuccess ls) { 1488 return true; 1489 } finally { 1490 jj_save(44, xla); 1491 } 1492 } 1493 1494 private boolean jj_2_46(int xla) { 1495 jj_la = xla; 1496 jj_lastpos = jj_scanpos = token; 1497 try { 1498 return !jj_3_46(); 1499 } catch (LookaheadSuccess ls) { 1500 return true; 1501 } finally { 1502 jj_save(45, xla); 1503 } 1504 } 1505 1506 private boolean jj_2_47(int xla) { 1507 jj_la = xla; 1508 jj_lastpos = jj_scanpos = token; 1509 try { 1510 return !jj_3_47(); 1511 } catch (LookaheadSuccess ls) { 1512 return true; 1513 } finally { 1514 jj_save(46, xla); 1515 } 1516 } 1517 1518 private boolean jj_2_48(int xla) { 1519 jj_la = xla; 1520 jj_lastpos = jj_scanpos = token; 1521 try { 1522 return !jj_3_48(); 1523 } catch (LookaheadSuccess ls) { 1524 return true; 1525 } finally { 1526 jj_save(47, xla); 1527 } 1528 } 1529 1530 private boolean jj_2_49(int xla) { 1531 jj_la = xla; 1532 jj_lastpos = jj_scanpos = token; 1533 try { 1534 return !jj_3_49(); 1535 } catch (LookaheadSuccess ls) { 1536 return true; 1537 } finally { 1538 jj_save(48, xla); 1539 } 1540 } 1541 1542 private boolean jj_2_50(int xla) { 1543 jj_la = xla; 1544 jj_lastpos = jj_scanpos = token; 1545 try { 1546 return !jj_3_50(); 1547 } catch (LookaheadSuccess ls) { 1548 return true; 1549 } finally { 1550 jj_save(49, xla); 1551 } 1552 } 1553 1554 private boolean jj_2_51(int xla) { 1555 jj_la = xla; 1556 jj_lastpos = jj_scanpos = token; 1557 try { 1558 return !jj_3_51(); 1559 } catch (LookaheadSuccess ls) { 1560 return true; 1561 } finally { 1562 jj_save(50, xla); 1563 } 1564 } 1565 1566 private boolean jj_2_52(int xla) { 1567 jj_la = xla; 1568 jj_lastpos = jj_scanpos = token; 1569 try { 1570 return !jj_3_52(); 1571 } catch (LookaheadSuccess ls) { 1572 return true; 1573 } finally { 1574 jj_save(51, xla); 1575 } 1576 } 1577 1578 private boolean jj_2_53(int xla) { 1579 jj_la = xla; 1580 jj_lastpos = jj_scanpos = token; 1581 try { 1582 return !jj_3_53(); 1583 } catch (LookaheadSuccess ls) { 1584 return true; 1585 } finally { 1586 jj_save(52, xla); 1587 } 1588 } 1589 1590 private boolean jj_2_54(int xla) { 1591 jj_la = xla; 1592 jj_lastpos = jj_scanpos = token; 1593 try { 1594 return !jj_3_54(); 1595 } catch (LookaheadSuccess ls) { 1596 return true; 1597 } finally { 1598 jj_save(53, xla); 1599 } 1600 } 1601 1602 private boolean jj_2_55(int xla) { 1603 jj_la = xla; 1604 jj_lastpos = jj_scanpos = token; 1605 try { 1606 return !jj_3_55(); 1607 } catch (LookaheadSuccess ls) { 1608 return true; 1609 } finally { 1610 jj_save(54, xla); 1611 } 1612 } 1613 1614 private boolean jj_2_56(int xla) { 1615 jj_la = xla; 1616 jj_lastpos = jj_scanpos = token; 1617 try { 1618 return !jj_3_56(); 1619 } catch (LookaheadSuccess ls) { 1620 return true; 1621 } finally { 1622 jj_save(55, xla); 1623 } 1624 } 1625 1626 private boolean jj_2_57(int xla) { 1627 jj_la = xla; 1628 jj_lastpos = jj_scanpos = token; 1629 try { 1630 return !jj_3_57(); 1631 } catch (LookaheadSuccess ls) { 1632 return true; 1633 } finally { 1634 jj_save(56, xla); 1635 } 1636 } 1637 1638 private boolean jj_2_58(int xla) { 1639 jj_la = xla; 1640 jj_lastpos = jj_scanpos = token; 1641 try { 1642 return !jj_3_58(); 1643 } catch (LookaheadSuccess ls) { 1644 return true; 1645 } finally { 1646 jj_save(57, xla); 1647 } 1648 } 1649 1650 private boolean jj_2_59(int xla) { 1651 jj_la = xla; 1652 jj_lastpos = jj_scanpos = token; 1653 try { 1654 return !jj_3_59(); 1655 } catch (LookaheadSuccess ls) { 1656 return true; 1657 } finally { 1658 jj_save(58, xla); 1659 } 1660 } 1661 1662 private boolean jj_2_60(int xla) { 1663 jj_la = xla; 1664 jj_lastpos = jj_scanpos = token; 1665 try { 1666 return !jj_3_60(); 1667 } catch (LookaheadSuccess ls) { 1668 return true; 1669 } finally { 1670 jj_save(59, xla); 1671 } 1672 } 1673 1674 private boolean jj_2_61(int xla) { 1675 jj_la = xla; 1676 jj_lastpos = jj_scanpos = token; 1677 try { 1678 return !jj_3_61(); 1679 } catch (LookaheadSuccess ls) { 1680 return true; 1681 } finally { 1682 jj_save(60, xla); 1683 } 1684 } 1685 1686 private boolean jj_2_62(int xla) { 1687 jj_la = xla; 1688 jj_lastpos = jj_scanpos = token; 1689 try { 1690 return !jj_3_62(); 1691 } catch (LookaheadSuccess ls) { 1692 return true; 1693 } finally { 1694 jj_save(61, xla); 1695 } 1696 } 1697 1698 private boolean jj_2_63(int xla) { 1699 jj_la = xla; 1700 jj_lastpos = jj_scanpos = token; 1701 try { 1702 return !jj_3_63(); 1703 } catch (LookaheadSuccess ls) { 1704 return true; 1705 } finally { 1706 jj_save(62, xla); 1707 } 1708 } 1709 1710 private boolean jj_2_64(int xla) { 1711 jj_la = xla; 1712 jj_lastpos = jj_scanpos = token; 1713 try { 1714 return !jj_3_64(); 1715 } catch (LookaheadSuccess ls) { 1716 return true; 1717 } finally { 1718 jj_save(63, xla); 1719 } 1720 } 1721 1722 private boolean jj_2_65(int xla) { 1723 jj_la = xla; 1724 jj_lastpos = jj_scanpos = token; 1725 try { 1726 return !jj_3_65(); 1727 } catch (LookaheadSuccess ls) { 1728 return true; 1729 } finally { 1730 jj_save(64, xla); 1731 } 1732 } 1733 1734 private boolean jj_2_66(int xla) { 1735 jj_la = xla; 1736 jj_lastpos = jj_scanpos = token; 1737 try { 1738 return !jj_3_66(); 1739 } catch (LookaheadSuccess ls) { 1740 return true; 1741 } finally { 1742 jj_save(65, xla); 1743 } 1744 } 1745 1746 private boolean jj_2_67(int xla) { 1747 jj_la = xla; 1748 jj_lastpos = jj_scanpos = token; 1749 try { 1750 return !jj_3_67(); 1751 } catch (LookaheadSuccess ls) { 1752 return true; 1753 } finally { 1754 jj_save(66, xla); 1755 } 1756 } 1757 1758 private boolean jj_2_68(int xla) { 1759 jj_la = xla; 1760 jj_lastpos = jj_scanpos = token; 1761 try { 1762 return !jj_3_68(); 1763 } catch (LookaheadSuccess ls) { 1764 return true; 1765 } finally { 1766 jj_save(67, xla); 1767 } 1768 } 1769 1770 private boolean jj_2_69(int xla) { 1771 jj_la = xla; 1772 jj_lastpos = jj_scanpos = token; 1773 try { 1774 return !jj_3_69(); 1775 } catch (LookaheadSuccess ls) { 1776 return true; 1777 } finally { 1778 jj_save(68, xla); 1779 } 1780 } 1781 1782 private boolean jj_2_70(int xla) { 1783 jj_la = xla; 1784 jj_lastpos = jj_scanpos = token; 1785 try { 1786 return !jj_3_70(); 1787 } catch (LookaheadSuccess ls) { 1788 return true; 1789 } finally { 1790 jj_save(69, xla); 1791 } 1792 } 1793 1794 private boolean jj_2_71(int xla) { 1795 jj_la = xla; 1796 jj_lastpos = jj_scanpos = token; 1797 try { 1798 return !jj_3_71(); 1799 } catch (LookaheadSuccess ls) { 1800 return true; 1801 } finally { 1802 jj_save(70, xla); 1803 } 1804 } 1805 1806 private boolean jj_2_72(int xla) { 1807 jj_la = xla; 1808 jj_lastpos = jj_scanpos = token; 1809 try { 1810 return !jj_3_72(); 1811 } catch (LookaheadSuccess ls) { 1812 return true; 1813 } finally { 1814 jj_save(71, xla); 1815 } 1816 } 1817 1818 private boolean jj_2_73(int xla) { 1819 jj_la = xla; 1820 jj_lastpos = jj_scanpos = token; 1821 try { 1822 return !jj_3_73(); 1823 } catch (LookaheadSuccess ls) { 1824 return true; 1825 } finally { 1826 jj_save(72, xla); 1827 } 1828 } 1829 1830 private boolean jj_2_74(int xla) { 1831 jj_la = xla; 1832 jj_lastpos = jj_scanpos = token; 1833 try { 1834 return !jj_3_74(); 1835 } catch (LookaheadSuccess ls) { 1836 return true; 1837 } finally { 1838 jj_save(73, xla); 1839 } 1840 } 1841 1842 private boolean jj_2_75(int xla) { 1843 jj_la = xla; 1844 jj_lastpos = jj_scanpos = token; 1845 try { 1846 return !jj_3_75(); 1847 } catch (LookaheadSuccess ls) { 1848 return true; 1849 } finally { 1850 jj_save(74, xla); 1851 } 1852 } 1853 1854 private boolean jj_2_76(int xla) { 1855 jj_la = xla; 1856 jj_lastpos = jj_scanpos = token; 1857 try { 1858 return !jj_3_76(); 1859 } catch (LookaheadSuccess ls) { 1860 return true; 1861 } finally { 1862 jj_save(75, xla); 1863 } 1864 } 1865 1866 private boolean jj_2_77(int xla) { 1867 jj_la = xla; 1868 jj_lastpos = jj_scanpos = token; 1869 try { 1870 return !jj_3_77(); 1871 } catch (LookaheadSuccess ls) { 1872 return true; 1873 } finally { 1874 jj_save(76, xla); 1875 } 1876 } 1877 1878 private boolean jj_2_78(int xla) { 1879 jj_la = xla; 1880 jj_lastpos = jj_scanpos = token; 1881 try { 1882 return !jj_3_78(); 1883 } catch (LookaheadSuccess ls) { 1884 return true; 1885 } finally { 1886 jj_save(77, xla); 1887 } 1888 } 1889 1890 private boolean jj_2_79(int xla) { 1891 jj_la = xla; 1892 jj_lastpos = jj_scanpos = token; 1893 try { 1894 return !jj_3_79(); 1895 } catch (LookaheadSuccess ls) { 1896 return true; 1897 } finally { 1898 jj_save(78, xla); 1899 } 1900 } 1901 1902 private boolean jj_2_80(int xla) { 1903 jj_la = xla; 1904 jj_lastpos = jj_scanpos = token; 1905 try { 1906 return !jj_3_80(); 1907 } catch (LookaheadSuccess ls) { 1908 return true; 1909 } finally { 1910 jj_save(79, xla); 1911 } 1912 } 1913 1914 private boolean jj_2_81(int xla) { 1915 jj_la = xla; 1916 jj_lastpos = jj_scanpos = token; 1917 try { 1918 return !jj_3_81(); 1919 } catch (LookaheadSuccess ls) { 1920 return true; 1921 } finally { 1922 jj_save(80, xla); 1923 } 1924 } 1925 1926 private boolean jj_2_82(int xla) { 1927 jj_la = xla; 1928 jj_lastpos = jj_scanpos = token; 1929 try { 1930 return !jj_3_82(); 1931 } catch (LookaheadSuccess ls) { 1932 return true; 1933 } finally { 1934 jj_save(81, xla); 1935 } 1936 } 1937 1938 private boolean jj_2_83(int xla) { 1939 jj_la = xla; 1940 jj_lastpos = jj_scanpos = token; 1941 try { 1942 return !jj_3_83(); 1943 } catch (LookaheadSuccess ls) { 1944 return true; 1945 } finally { 1946 jj_save(82, xla); 1947 } 1948 } 1949 1950 private boolean jj_2_84(int xla) { 1951 jj_la = xla; 1952 jj_lastpos = jj_scanpos = token; 1953 try { 1954 return !jj_3_84(); 1955 } catch (LookaheadSuccess ls) { 1956 return true; 1957 } finally { 1958 jj_save(83, xla); 1959 } 1960 } 1961 1962 private boolean jj_2_85(int xla) { 1963 jj_la = xla; 1964 jj_lastpos = jj_scanpos = token; 1965 try { 1966 return !jj_3_85(); 1967 } catch (LookaheadSuccess ls) { 1968 return true; 1969 } finally { 1970 jj_save(84, xla); 1971 } 1972 } 1973 1974 private boolean jj_2_86(int xla) { 1975 jj_la = xla; 1976 jj_lastpos = jj_scanpos = token; 1977 try { 1978 return !jj_3_86(); 1979 } catch (LookaheadSuccess ls) { 1980 return true; 1981 } finally { 1982 jj_save(85, xla); 1983 } 1984 } 1985 1986 private boolean jj_2_87(int xla) { 1987 jj_la = xla; 1988 jj_lastpos = jj_scanpos = token; 1989 try { 1990 return !jj_3_87(); 1991 } catch (LookaheadSuccess ls) { 1992 return true; 1993 } finally { 1994 jj_save(86, xla); 1995 } 1996 } 1997 1998 private boolean jj_2_88(int xla) { 1999 jj_la = xla; 2000 jj_lastpos = jj_scanpos = token; 2001 try { 2002 return !jj_3_88(); 2003 } catch (LookaheadSuccess ls) { 2004 return true; 2005 } finally { 2006 jj_save(87, xla); 2007 } 2008 } 2009 2010 private boolean jj_2_89(int xla) { 2011 jj_la = xla; 2012 jj_lastpos = jj_scanpos = token; 2013 try { 2014 return !jj_3_89(); 2015 } catch (LookaheadSuccess ls) { 2016 return true; 2017 } finally { 2018 jj_save(88, xla); 2019 } 2020 } 2021 2022 private boolean jj_2_90(int xla) { 2023 jj_la = xla; 2024 jj_lastpos = jj_scanpos = token; 2025 try { 2026 return !jj_3_90(); 2027 } catch (LookaheadSuccess ls) { 2028 return true; 2029 } finally { 2030 jj_save(89, xla); 2031 } 2032 } 2033 2034 private boolean jj_2_91(int xla) { 2035 jj_la = xla; 2036 jj_lastpos = jj_scanpos = token; 2037 try { 2038 return !jj_3_91(); 2039 } catch (LookaheadSuccess ls) { 2040 return true; 2041 } finally { 2042 jj_save(90, xla); 2043 } 2044 } 2045 2046 private boolean jj_2_92(int xla) { 2047 jj_la = xla; 2048 jj_lastpos = jj_scanpos = token; 2049 try { 2050 return !jj_3_92(); 2051 } catch (LookaheadSuccess ls) { 2052 return true; 2053 } finally { 2054 jj_save(91, xla); 2055 } 2056 } 2057 2058 private boolean jj_2_93(int xla) { 2059 jj_la = xla; 2060 jj_lastpos = jj_scanpos = token; 2061 try { 2062 return !jj_3_93(); 2063 } catch (LookaheadSuccess ls) { 2064 return true; 2065 } finally { 2066 jj_save(92, xla); 2067 } 2068 } 2069 2070 private boolean jj_2_94(int xla) { 2071 jj_la = xla; 2072 jj_lastpos = jj_scanpos = token; 2073 try { 2074 return !jj_3_94(); 2075 } catch (LookaheadSuccess ls) { 2076 return true; 2077 } finally { 2078 jj_save(93, xla); 2079 } 2080 } 2081 2082 private boolean jj_2_95(int xla) { 2083 jj_la = xla; 2084 jj_lastpos = jj_scanpos = token; 2085 try { 2086 return !jj_3_95(); 2087 } catch (LookaheadSuccess ls) { 2088 return true; 2089 } finally { 2090 jj_save(94, xla); 2091 } 2092 } 2093 2094 private boolean jj_2_96(int xla) { 2095 jj_la = xla; 2096 jj_lastpos = jj_scanpos = token; 2097 try { 2098 return !jj_3_96(); 2099 } catch (LookaheadSuccess ls) { 2100 return true; 2101 } finally { 2102 jj_save(95, xla); 2103 } 2104 } 2105 2106 private boolean jj_2_97(int xla) { 2107 jj_la = xla; 2108 jj_lastpos = jj_scanpos = token; 2109 try { 2110 return !jj_3_97(); 2111 } catch (LookaheadSuccess ls) { 2112 return true; 2113 } finally { 2114 jj_save(96, xla); 2115 } 2116 } 2117 2118 private boolean jj_2_98(int xla) { 2119 jj_la = xla; 2120 jj_lastpos = jj_scanpos = token; 2121 try { 2122 return !jj_3_98(); 2123 } catch (LookaheadSuccess ls) { 2124 return true; 2125 } finally { 2126 jj_save(97, xla); 2127 } 2128 } 2129 2130 private boolean jj_2_99(int xla) { 2131 jj_la = xla; 2132 jj_lastpos = jj_scanpos = token; 2133 try { 2134 return !jj_3_99(); 2135 } catch (LookaheadSuccess ls) { 2136 return true; 2137 } finally { 2138 jj_save(98, xla); 2139 } 2140 } 2141 2142 private boolean jj_2_100(int xla) { 2143 jj_la = xla; 2144 jj_lastpos = jj_scanpos = token; 2145 try { 2146 return !jj_3_100(); 2147 } catch (LookaheadSuccess ls) { 2148 return true; 2149 } finally { 2150 jj_save(99, xla); 2151 } 2152 } 2153 2154 private boolean jj_2_101(int xla) { 2155 jj_la = xla; 2156 jj_lastpos = jj_scanpos = token; 2157 try { 2158 return !jj_3_101(); 2159 } catch (LookaheadSuccess ls) { 2160 return true; 2161 } finally { 2162 jj_save(100, xla); 2163 } 2164 } 2165 2166 private boolean jj_2_102(int xla) { 2167 jj_la = xla; 2168 jj_lastpos = jj_scanpos = token; 2169 try { 2170 return !jj_3_102(); 2171 } catch (LookaheadSuccess ls) { 2172 return true; 2173 } finally { 2174 jj_save(101, xla); 2175 } 2176 } 2177 2178 private boolean jj_2_103(int xla) { 2179 jj_la = xla; 2180 jj_lastpos = jj_scanpos = token; 2181 try { 2182 return !jj_3_103(); 2183 } catch (LookaheadSuccess ls) { 2184 return true; 2185 } finally { 2186 jj_save(102, xla); 2187 } 2188 } 2189 2190 private boolean jj_2_104(int xla) { 2191 jj_la = xla; 2192 jj_lastpos = jj_scanpos = token; 2193 try { 2194 return !jj_3_104(); 2195 } catch (LookaheadSuccess ls) { 2196 return true; 2197 } finally { 2198 jj_save(103, xla); 2199 } 2200 } 2201 2202 private boolean jj_2_105(int xla) { 2203 jj_la = xla; 2204 jj_lastpos = jj_scanpos = token; 2205 try { 2206 return !jj_3_105(); 2207 } catch (LookaheadSuccess ls) { 2208 return true; 2209 } finally { 2210 jj_save(104, xla); 2211 } 2212 } 2213 2214 private boolean jj_2_106(int xla) { 2215 jj_la = xla; 2216 jj_lastpos = jj_scanpos = token; 2217 try { 2218 return !jj_3_106(); 2219 } catch (LookaheadSuccess ls) { 2220 return true; 2221 } finally { 2222 jj_save(105, xla); 2223 } 2224 } 2225 2226 private boolean jj_2_107(int xla) { 2227 jj_la = xla; 2228 jj_lastpos = jj_scanpos = token; 2229 try { 2230 return !jj_3_107(); 2231 } catch (LookaheadSuccess ls) { 2232 return true; 2233 } finally { 2234 jj_save(106, xla); 2235 } 2236 } 2237 2238 private boolean jj_2_108(int xla) { 2239 jj_la = xla; 2240 jj_lastpos = jj_scanpos = token; 2241 try { 2242 return !jj_3_108(); 2243 } catch (LookaheadSuccess ls) { 2244 return true; 2245 } finally { 2246 jj_save(107, xla); 2247 } 2248 } 2249 2250 private boolean jj_2_109(int xla) { 2251 jj_la = xla; 2252 jj_lastpos = jj_scanpos = token; 2253 try { 2254 return !jj_3_109(); 2255 } catch (LookaheadSuccess ls) { 2256 return true; 2257 } finally { 2258 jj_save(108, xla); 2259 } 2260 } 2261 2262 private boolean jj_2_110(int xla) { 2263 jj_la = xla; 2264 jj_lastpos = jj_scanpos = token; 2265 try { 2266 return !jj_3_110(); 2267 } catch (LookaheadSuccess ls) { 2268 return true; 2269 } finally { 2270 jj_save(109, xla); 2271 } 2272 } 2273 2274 private boolean jj_2_111(int xla) { 2275 jj_la = xla; 2276 jj_lastpos = jj_scanpos = token; 2277 try { 2278 return !jj_3_111(); 2279 } catch (LookaheadSuccess ls) { 2280 return true; 2281 } finally { 2282 jj_save(110, xla); 2283 } 2284 } 2285 2286 private boolean jj_2_112(int xla) { 2287 jj_la = xla; 2288 jj_lastpos = jj_scanpos = token; 2289 try { 2290 return !jj_3_112(); 2291 } catch (LookaheadSuccess ls) { 2292 return true; 2293 } finally { 2294 jj_save(111, xla); 2295 } 2296 } 2297 2298 private boolean jj_2_113(int xla) { 2299 jj_la = xla; 2300 jj_lastpos = jj_scanpos = token; 2301 try { 2302 return !jj_3_113(); 2303 } catch (LookaheadSuccess ls) { 2304 return true; 2305 } finally { 2306 jj_save(112, xla); 2307 } 2308 } 2309 2310 private boolean jj_2_114(int xla) { 2311 jj_la = xla; 2312 jj_lastpos = jj_scanpos = token; 2313 try { 2314 return !jj_3_114(); 2315 } catch (LookaheadSuccess ls) { 2316 return true; 2317 } finally { 2318 jj_save(113, xla); 2319 } 2320 } 2321 2322 private boolean jj_2_115(int xla) { 2323 jj_la = xla; 2324 jj_lastpos = jj_scanpos = token; 2325 try { 2326 return !jj_3_115(); 2327 } catch (LookaheadSuccess ls) { 2328 return true; 2329 } finally { 2330 jj_save(114, xla); 2331 } 2332 } 2333 2334 private boolean jj_2_116(int xla) { 2335 jj_la = xla; 2336 jj_lastpos = jj_scanpos = token; 2337 try { 2338 return !jj_3_116(); 2339 } catch (LookaheadSuccess ls) { 2340 return true; 2341 } finally { 2342 jj_save(115, xla); 2343 } 2344 } 2345 2346 private boolean jj_2_117(int xla) { 2347 jj_la = xla; 2348 jj_lastpos = jj_scanpos = token; 2349 try { 2350 return !jj_3_117(); 2351 } catch (LookaheadSuccess ls) { 2352 return true; 2353 } finally { 2354 jj_save(116, xla); 2355 } 2356 } 2357 2358 private boolean jj_2_118(int xla) { 2359 jj_la = xla; 2360 jj_lastpos = jj_scanpos = token; 2361 try { 2362 return !jj_3_118(); 2363 } catch (LookaheadSuccess ls) { 2364 return true; 2365 } finally { 2366 jj_save(117, xla); 2367 } 2368 } 2369 2370 private boolean jj_2_119(int xla) { 2371 jj_la = xla; 2372 jj_lastpos = jj_scanpos = token; 2373 try { 2374 return !jj_3_119(); 2375 } catch (LookaheadSuccess ls) { 2376 return true; 2377 } finally { 2378 jj_save(118, xla); 2379 } 2380 } 2381 2382 private boolean jj_2_120(int xla) { 2383 jj_la = xla; 2384 jj_lastpos = jj_scanpos = token; 2385 try { 2386 return !jj_3_120(); 2387 } catch (LookaheadSuccess ls) { 2388 return true; 2389 } finally { 2390 jj_save(119, xla); 2391 } 2392 } 2393 2394 private boolean jj_2_121(int xla) { 2395 jj_la = xla; 2396 jj_lastpos = jj_scanpos = token; 2397 try { 2398 return !jj_3_121(); 2399 } catch (LookaheadSuccess ls) { 2400 return true; 2401 } finally { 2402 jj_save(120, xla); 2403 } 2404 } 2405 2406 private boolean jj_2_122(int xla) { 2407 jj_la = xla; 2408 jj_lastpos = jj_scanpos = token; 2409 try { 2410 return !jj_3_122(); 2411 } catch (LookaheadSuccess ls) { 2412 return true; 2413 } finally { 2414 jj_save(121, xla); 2415 } 2416 } 2417 2418 private boolean jj_2_123(int xla) { 2419 jj_la = xla; 2420 jj_lastpos = jj_scanpos = token; 2421 try { 2422 return !jj_3_123(); 2423 } catch (LookaheadSuccess ls) { 2424 return true; 2425 } finally { 2426 jj_save(122, xla); 2427 } 2428 } 2429 2430 private boolean jj_2_124(int xla) { 2431 jj_la = xla; 2432 jj_lastpos = jj_scanpos = token; 2433 try { 2434 return !jj_3_124(); 2435 } catch (LookaheadSuccess ls) { 2436 return true; 2437 } finally { 2438 jj_save(123, xla); 2439 } 2440 } 2441 2442 private boolean jj_2_125(int xla) { 2443 jj_la = xla; 2444 jj_lastpos = jj_scanpos = token; 2445 try { 2446 return !jj_3_125(); 2447 } catch (LookaheadSuccess ls) { 2448 return true; 2449 } finally { 2450 jj_save(124, xla); 2451 } 2452 } 2453 2454 private boolean jj_2_126(int xla) { 2455 jj_la = xla; 2456 jj_lastpos = jj_scanpos = token; 2457 try { 2458 return !jj_3_126(); 2459 } catch (LookaheadSuccess ls) { 2460 return true; 2461 } finally { 2462 jj_save(125, xla); 2463 } 2464 } 2465 2466 private boolean jj_2_127(int xla) { 2467 jj_la = xla; 2468 jj_lastpos = jj_scanpos = token; 2469 try { 2470 return !jj_3_127(); 2471 } catch (LookaheadSuccess ls) { 2472 return true; 2473 } finally { 2474 jj_save(126, xla); 2475 } 2476 } 2477 2478 private boolean jj_2_128(int xla) { 2479 jj_la = xla; 2480 jj_lastpos = jj_scanpos = token; 2481 try { 2482 return !jj_3_128(); 2483 } catch (LookaheadSuccess ls) { 2484 return true; 2485 } finally { 2486 jj_save(127, xla); 2487 } 2488 } 2489 2490 private boolean jj_2_129(int xla) { 2491 jj_la = xla; 2492 jj_lastpos = jj_scanpos = token; 2493 try { 2494 return !jj_3_129(); 2495 } catch (LookaheadSuccess ls) { 2496 return true; 2497 } finally { 2498 jj_save(128, xla); 2499 } 2500 } 2501 2502 private boolean jj_2_130(int xla) { 2503 jj_la = xla; 2504 jj_lastpos = jj_scanpos = token; 2505 try { 2506 return !jj_3_130(); 2507 } catch (LookaheadSuccess ls) { 2508 return true; 2509 } finally { 2510 jj_save(129, xla); 2511 } 2512 } 2513 2514 private boolean jj_2_131(int xla) { 2515 jj_la = xla; 2516 jj_lastpos = jj_scanpos = token; 2517 try { 2518 return !jj_3_131(); 2519 } catch (LookaheadSuccess ls) { 2520 return true; 2521 } finally { 2522 jj_save(130, xla); 2523 } 2524 } 2525 2526 private boolean jj_2_132(int xla) { 2527 jj_la = xla; 2528 jj_lastpos = jj_scanpos = token; 2529 try { 2530 return !jj_3_132(); 2531 } catch (LookaheadSuccess ls) { 2532 return true; 2533 } finally { 2534 jj_save(131, xla); 2535 } 2536 } 2537 2538 private boolean jj_2_133(int xla) { 2539 jj_la = xla; 2540 jj_lastpos = jj_scanpos = token; 2541 try { 2542 return !jj_3_133(); 2543 } catch (LookaheadSuccess ls) { 2544 return true; 2545 } finally { 2546 jj_save(132, xla); 2547 } 2548 } 2549 2550 private boolean jj_2_134(int xla) { 2551 jj_la = xla; 2552 jj_lastpos = jj_scanpos = token; 2553 try { 2554 return !jj_3_134(); 2555 } catch (LookaheadSuccess ls) { 2556 return true; 2557 } finally { 2558 jj_save(133, xla); 2559 } 2560 } 2561 2562 private boolean jj_2_135(int xla) { 2563 jj_la = xla; 2564 jj_lastpos = jj_scanpos = token; 2565 try { 2566 return !jj_3_135(); 2567 } catch (LookaheadSuccess ls) { 2568 return true; 2569 } finally { 2570 jj_save(134, xla); 2571 } 2572 } 2573 2574 private boolean jj_2_136(int xla) { 2575 jj_la = xla; 2576 jj_lastpos = jj_scanpos = token; 2577 try { 2578 return !jj_3_136(); 2579 } catch (LookaheadSuccess ls) { 2580 return true; 2581 } finally { 2582 jj_save(135, xla); 2583 } 2584 } 2585 2586 private boolean jj_2_137(int xla) { 2587 jj_la = xla; 2588 jj_lastpos = jj_scanpos = token; 2589 try { 2590 return !jj_3_137(); 2591 } catch (LookaheadSuccess ls) { 2592 return true; 2593 } finally { 2594 jj_save(136, xla); 2595 } 2596 } 2597 2598 private boolean jj_2_138(int xla) { 2599 jj_la = xla; 2600 jj_lastpos = jj_scanpos = token; 2601 try { 2602 return !jj_3_138(); 2603 } catch (LookaheadSuccess ls) { 2604 return true; 2605 } finally { 2606 jj_save(137, xla); 2607 } 2608 } 2609 2610 private boolean jj_2_139(int xla) { 2611 jj_la = xla; 2612 jj_lastpos = jj_scanpos = token; 2613 try { 2614 return !jj_3_139(); 2615 } catch (LookaheadSuccess ls) { 2616 return true; 2617 } finally { 2618 jj_save(138, xla); 2619 } 2620 } 2621 2622 private boolean jj_2_140(int xla) { 2623 jj_la = xla; 2624 jj_lastpos = jj_scanpos = token; 2625 try { 2626 return !jj_3_140(); 2627 } catch (LookaheadSuccess ls) { 2628 return true; 2629 } finally { 2630 jj_save(139, xla); 2631 } 2632 } 2633 2634 private boolean jj_2_141(int xla) { 2635 jj_la = xla; 2636 jj_lastpos = jj_scanpos = token; 2637 try { 2638 return !jj_3_141(); 2639 } catch (LookaheadSuccess ls) { 2640 return true; 2641 } finally { 2642 jj_save(140, xla); 2643 } 2644 } 2645 2646 private boolean jj_2_142(int xla) { 2647 jj_la = xla; 2648 jj_lastpos = jj_scanpos = token; 2649 try { 2650 return !jj_3_142(); 2651 } catch (LookaheadSuccess ls) { 2652 return true; 2653 } finally { 2654 jj_save(141, xla); 2655 } 2656 } 2657 2658 private boolean jj_2_143(int xla) { 2659 jj_la = xla; 2660 jj_lastpos = jj_scanpos = token; 2661 try { 2662 return !jj_3_143(); 2663 } catch (LookaheadSuccess ls) { 2664 return true; 2665 } finally { 2666 jj_save(142, xla); 2667 } 2668 } 2669 2670 private boolean jj_2_144(int xla) { 2671 jj_la = xla; 2672 jj_lastpos = jj_scanpos = token; 2673 try { 2674 return !jj_3_144(); 2675 } catch (LookaheadSuccess ls) { 2676 return true; 2677 } finally { 2678 jj_save(143, xla); 2679 } 2680 } 2681 2682 private boolean jj_2_145(int xla) { 2683 jj_la = xla; 2684 jj_lastpos = jj_scanpos = token; 2685 try { 2686 return !jj_3_145(); 2687 } catch (LookaheadSuccess ls) { 2688 return true; 2689 } finally { 2690 jj_save(144, xla); 2691 } 2692 } 2693 2694 private boolean jj_2_146(int xla) { 2695 jj_la = xla; 2696 jj_lastpos = jj_scanpos = token; 2697 try { 2698 return !jj_3_146(); 2699 } catch (LookaheadSuccess ls) { 2700 return true; 2701 } finally { 2702 jj_save(145, xla); 2703 } 2704 } 2705 2706 private boolean jj_2_147(int xla) { 2707 jj_la = xla; 2708 jj_lastpos = jj_scanpos = token; 2709 try { 2710 return !jj_3_147(); 2711 } catch (LookaheadSuccess ls) { 2712 return true; 2713 } finally { 2714 jj_save(146, xla); 2715 } 2716 } 2717 2718 private boolean jj_2_148(int xla) { 2719 jj_la = xla; 2720 jj_lastpos = jj_scanpos = token; 2721 try { 2722 return !jj_3_148(); 2723 } catch (LookaheadSuccess ls) { 2724 return true; 2725 } finally { 2726 jj_save(147, xla); 2727 } 2728 } 2729 2730 private boolean jj_2_149(int xla) { 2731 jj_la = xla; 2732 jj_lastpos = jj_scanpos = token; 2733 try { 2734 return !jj_3_149(); 2735 } catch (LookaheadSuccess ls) { 2736 return true; 2737 } finally { 2738 jj_save(148, xla); 2739 } 2740 } 2741 2742 private boolean jj_2_150(int xla) { 2743 jj_la = xla; 2744 jj_lastpos = jj_scanpos = token; 2745 try { 2746 return !jj_3_150(); 2747 } catch (LookaheadSuccess ls) { 2748 return true; 2749 } finally { 2750 jj_save(149, xla); 2751 } 2752 } 2753 2754 private boolean jj_2_151(int xla) { 2755 jj_la = xla; 2756 jj_lastpos = jj_scanpos = token; 2757 try { 2758 return !jj_3_151(); 2759 } catch (LookaheadSuccess ls) { 2760 return true; 2761 } finally { 2762 jj_save(150, xla); 2763 } 2764 } 2765 2766 private boolean jj_2_152(int xla) { 2767 jj_la = xla; 2768 jj_lastpos = jj_scanpos = token; 2769 try { 2770 return !jj_3_152(); 2771 } catch (LookaheadSuccess ls) { 2772 return true; 2773 } finally { 2774 jj_save(151, xla); 2775 } 2776 } 2777 2778 private boolean jj_2_153(int xla) { 2779 jj_la = xla; 2780 jj_lastpos = jj_scanpos = token; 2781 try { 2782 return !jj_3_153(); 2783 } catch (LookaheadSuccess ls) { 2784 return true; 2785 } finally { 2786 jj_save(152, xla); 2787 } 2788 } 2789 2790 private boolean jj_2_154(int xla) { 2791 jj_la = xla; 2792 jj_lastpos = jj_scanpos = token; 2793 try { 2794 return !jj_3_154(); 2795 } catch (LookaheadSuccess ls) { 2796 return true; 2797 } finally { 2798 jj_save(153, xla); 2799 } 2800 } 2801 2802 private boolean jj_2_155(int xla) { 2803 jj_la = xla; 2804 jj_lastpos = jj_scanpos = token; 2805 try { 2806 return !jj_3_155(); 2807 } catch (LookaheadSuccess ls) { 2808 return true; 2809 } finally { 2810 jj_save(154, xla); 2811 } 2812 } 2813 2814 private boolean jj_2_156(int xla) { 2815 jj_la = xla; 2816 jj_lastpos = jj_scanpos = token; 2817 try { 2818 return !jj_3_156(); 2819 } catch (LookaheadSuccess ls) { 2820 return true; 2821 } finally { 2822 jj_save(155, xla); 2823 } 2824 } 2825 2826 private boolean jj_2_157(int xla) { 2827 jj_la = xla; 2828 jj_lastpos = jj_scanpos = token; 2829 try { 2830 return !jj_3_157(); 2831 } catch (LookaheadSuccess ls) { 2832 return true; 2833 } finally { 2834 jj_save(156, xla); 2835 } 2836 } 2837 2838 private boolean jj_2_158(int xla) { 2839 jj_la = xla; 2840 jj_lastpos = jj_scanpos = token; 2841 try { 2842 return !jj_3_158(); 2843 } catch (LookaheadSuccess ls) { 2844 return true; 2845 } finally { 2846 jj_save(157, xla); 2847 } 2848 } 2849 2850 private boolean jj_2_159(int xla) { 2851 jj_la = xla; 2852 jj_lastpos = jj_scanpos = token; 2853 try { 2854 return !jj_3_159(); 2855 } catch (LookaheadSuccess ls) { 2856 return true; 2857 } finally { 2858 jj_save(158, xla); 2859 } 2860 } 2861 2862 private boolean jj_2_160(int xla) { 2863 jj_la = xla; 2864 jj_lastpos = jj_scanpos = token; 2865 try { 2866 return !jj_3_160(); 2867 } catch (LookaheadSuccess ls) { 2868 return true; 2869 } finally { 2870 jj_save(159, xla); 2871 } 2872 } 2873 2874 private boolean jj_2_161(int xla) { 2875 jj_la = xla; 2876 jj_lastpos = jj_scanpos = token; 2877 try { 2878 return !jj_3_161(); 2879 } catch (LookaheadSuccess ls) { 2880 return true; 2881 } finally { 2882 jj_save(160, xla); 2883 } 2884 } 2885 2886 private boolean jj_2_162(int xla) { 2887 jj_la = xla; 2888 jj_lastpos = jj_scanpos = token; 2889 try { 2890 return !jj_3_162(); 2891 } catch (LookaheadSuccess ls) { 2892 return true; 2893 } finally { 2894 jj_save(161, xla); 2895 } 2896 } 2897 2898 private boolean jj_2_163(int xla) { 2899 jj_la = xla; 2900 jj_lastpos = jj_scanpos = token; 2901 try { 2902 return !jj_3_163(); 2903 } catch (LookaheadSuccess ls) { 2904 return true; 2905 } finally { 2906 jj_save(162, xla); 2907 } 2908 } 2909 2910 private boolean jj_2_164(int xla) { 2911 jj_la = xla; 2912 jj_lastpos = jj_scanpos = token; 2913 try { 2914 return !jj_3_164(); 2915 } catch (LookaheadSuccess ls) { 2916 return true; 2917 } finally { 2918 jj_save(163, xla); 2919 } 2920 } 2921 2922 private boolean jj_2_165(int xla) { 2923 jj_la = xla; 2924 jj_lastpos = jj_scanpos = token; 2925 try { 2926 return !jj_3_165(); 2927 } catch (LookaheadSuccess ls) { 2928 return true; 2929 } finally { 2930 jj_save(164, xla); 2931 } 2932 } 2933 2934 private boolean jj_2_166(int xla) { 2935 jj_la = xla; 2936 jj_lastpos = jj_scanpos = token; 2937 try { 2938 return !jj_3_166(); 2939 } catch (LookaheadSuccess ls) { 2940 return true; 2941 } finally { 2942 jj_save(165, xla); 2943 } 2944 } 2945 2946 private boolean jj_2_167(int xla) { 2947 jj_la = xla; 2948 jj_lastpos = jj_scanpos = token; 2949 try { 2950 return !jj_3_167(); 2951 } catch (LookaheadSuccess ls) { 2952 return true; 2953 } finally { 2954 jj_save(166, xla); 2955 } 2956 } 2957 2958 private boolean jj_2_168(int xla) { 2959 jj_la = xla; 2960 jj_lastpos = jj_scanpos = token; 2961 try { 2962 return !jj_3_168(); 2963 } catch (LookaheadSuccess ls) { 2964 return true; 2965 } finally { 2966 jj_save(167, xla); 2967 } 2968 } 2969 2970 private boolean jj_2_169(int xla) { 2971 jj_la = xla; 2972 jj_lastpos = jj_scanpos = token; 2973 try { 2974 return !jj_3_169(); 2975 } catch (LookaheadSuccess ls) { 2976 return true; 2977 } finally { 2978 jj_save(168, xla); 2979 } 2980 } 2981 2982 private boolean jj_2_170(int xla) { 2983 jj_la = xla; 2984 jj_lastpos = jj_scanpos = token; 2985 try { 2986 return !jj_3_170(); 2987 } catch (LookaheadSuccess ls) { 2988 return true; 2989 } finally { 2990 jj_save(169, xla); 2991 } 2992 } 2993 2994 private boolean jj_2_171(int xla) { 2995 jj_la = xla; 2996 jj_lastpos = jj_scanpos = token; 2997 try { 2998 return !jj_3_171(); 2999 } catch (LookaheadSuccess ls) { 3000 return true; 3001 } finally { 3002 jj_save(170, xla); 3003 } 3004 } 3005 3006 private boolean jj_2_172(int xla) { 3007 jj_la = xla; 3008 jj_lastpos = jj_scanpos = token; 3009 try { 3010 return !jj_3_172(); 3011 } catch (LookaheadSuccess ls) { 3012 return true; 3013 } finally { 3014 jj_save(171, xla); 3015 } 3016 } 3017 3018 private boolean jj_2_173(int xla) { 3019 jj_la = xla; 3020 jj_lastpos = jj_scanpos = token; 3021 try { 3022 return !jj_3_173(); 3023 } catch (LookaheadSuccess ls) { 3024 return true; 3025 } finally { 3026 jj_save(172, xla); 3027 } 3028 } 3029 3030 private boolean jj_2_174(int xla) { 3031 jj_la = xla; 3032 jj_lastpos = jj_scanpos = token; 3033 try { 3034 return !jj_3_174(); 3035 } catch (LookaheadSuccess ls) { 3036 return true; 3037 } finally { 3038 jj_save(173, xla); 3039 } 3040 } 3041 3042 private boolean jj_2_175(int xla) { 3043 jj_la = xla; 3044 jj_lastpos = jj_scanpos = token; 3045 try { 3046 return !jj_3_175(); 3047 } catch (LookaheadSuccess ls) { 3048 return true; 3049 } finally { 3050 jj_save(174, xla); 3051 } 3052 } 3053 3054 private boolean jj_2_176(int xla) { 3055 jj_la = xla; 3056 jj_lastpos = jj_scanpos = token; 3057 try { 3058 return !jj_3_176(); 3059 } catch (LookaheadSuccess ls) { 3060 return true; 3061 } finally { 3062 jj_save(175, xla); 3063 } 3064 } 3065 3066 private boolean jj_2_177(int xla) { 3067 jj_la = xla; 3068 jj_lastpos = jj_scanpos = token; 3069 try { 3070 return !jj_3_177(); 3071 } catch (LookaheadSuccess ls) { 3072 return true; 3073 } finally { 3074 jj_save(176, xla); 3075 } 3076 } 3077 3078 private boolean jj_2_178(int xla) { 3079 jj_la = xla; 3080 jj_lastpos = jj_scanpos = token; 3081 try { 3082 return !jj_3_178(); 3083 } catch (LookaheadSuccess ls) { 3084 return true; 3085 } finally { 3086 jj_save(177, xla); 3087 } 3088 } 3089 3090 private boolean jj_2_179(int xla) { 3091 jj_la = xla; 3092 jj_lastpos = jj_scanpos = token; 3093 try { 3094 return !jj_3_179(); 3095 } catch (LookaheadSuccess ls) { 3096 return true; 3097 } finally { 3098 jj_save(178, xla); 3099 } 3100 } 3101 3102 private boolean jj_2_180(int xla) { 3103 jj_la = xla; 3104 jj_lastpos = jj_scanpos = token; 3105 try { 3106 return !jj_3_180(); 3107 } catch (LookaheadSuccess ls) { 3108 return true; 3109 } finally { 3110 jj_save(179, xla); 3111 } 3112 } 3113 3114 private boolean jj_2_181(int xla) { 3115 jj_la = xla; 3116 jj_lastpos = jj_scanpos = token; 3117 try { 3118 return !jj_3_181(); 3119 } catch (LookaheadSuccess ls) { 3120 return true; 3121 } finally { 3122 jj_save(180, xla); 3123 } 3124 } 3125 3126 private boolean jj_2_182(int xla) { 3127 jj_la = xla; 3128 jj_lastpos = jj_scanpos = token; 3129 try { 3130 return !jj_3_182(); 3131 } catch (LookaheadSuccess ls) { 3132 return true; 3133 } finally { 3134 jj_save(181, xla); 3135 } 3136 } 3137 3138 private boolean jj_3R_29() { 3139 Token xsp; 3140 if (jj_3_106()) 3141 return true; 3142 while (true) { 3143 xsp = jj_scanpos; 3144 if (jj_3_106()) { 3145 jj_scanpos = xsp; 3146 break; 3147 } 3148 } 3149 if (jj_3R_27()) 3150 return true; 3151 return false; 3152 } 3153 3154 private boolean jj_3_102() { 3155 if (jj_scan_token(EOL)) 3156 return true; 3157 return false; 3158 } 3159 3160 private boolean jj_3_103() { 3161 if (jj_3R_29()) 3162 return true; 3163 return false; 3164 } 3165 3166 private boolean jj_3_105() { 3167 Token xsp; 3168 xsp = jj_scanpos; 3169 if (jj_3_103()) { 3170 jj_scanpos = xsp; 3171 if (jj_3_104()) 3172 return true; 3173 } 3174 return false; 3175 } 3176 3177 private boolean jj_3R_28() { 3178 if (jj_scan_token(MATRIX)) 3179 return true; 3180 Token xsp; 3181 if (jj_3_102()) 3182 return true; 3183 while (true) { 3184 xsp = jj_scanpos; 3185 if (jj_3_102()) { 3186 jj_scanpos = xsp; 3187 break; 3188 } 3189 } 3190 return false; 3191 } 3192 3193 private boolean jj_3_99() { 3194 if (jj_scan_token(REAL)) 3195 return true; 3196 return false; 3197 } 3198 3199 private boolean jj_3_101() { 3200 if (jj_scan_token(INT)) 3201 return true; 3202 return false; 3203 } 3204 3205 private boolean jj_3R_26() { 3206 if (jj_scan_token(INT)) 3207 return true; 3208 if (jj_scan_token(INT)) 3209 return true; 3210 return false; 3211 } 3212 3213 private boolean jj_3_76() { 3214 if (jj_scan_token(B)) 3215 return true; 3216 return false; 3217 } 3218 3219 private boolean jj_3_98() { 3220 if (jj_3R_24()) 3221 return true; 3222 return false; 3223 } 3224 3225 private boolean jj_3_97() { 3226 Token xsp; 3227 xsp = jj_scanpos; 3228 if (jj_3_98()) { 3229 jj_scanpos = xsp; 3230 if (jj_3_99()) 3231 return true; 3232 } 3233 return false; 3234 } 3235 3236 private boolean jj_3_96() { 3237 if (jj_scan_token(K2)) 3238 return true; 3239 if (jj_3R_21()) 3240 return true; 3241 return false; 3242 } 3243 3244 private boolean jj_3_95() { 3245 if (jj_scan_token(K1)) 3246 return true; 3247 if (jj_3R_21()) 3248 return true; 3249 return false; 3250 } 3251 3252 private boolean jj_3_94() { 3253 if (jj_scan_token(A2)) 3254 return true; 3255 if (jj_3R_21()) 3256 return true; 3257 return false; 3258 } 3259 3260 private boolean jj_3_75() { 3261 if (jj_scan_token(A)) 3262 return true; 3263 return false; 3264 } 3265 3266 private boolean jj_3_93() { 3267 if (jj_scan_token(A1)) 3268 return true; 3269 if (jj_3R_21()) 3270 return true; 3271 return false; 3272 } 3273 3274 private boolean jj_3_92() { 3275 if (jj_scan_token(H2)) 3276 return true; 3277 if (jj_3R_21()) 3278 return true; 3279 return false; 3280 } 3281 3282 private boolean jj_3_91() { 3283 if (jj_scan_token(H1)) 3284 return true; 3285 if (jj_3R_21()) 3286 return true; 3287 return false; 3288 } 3289 3290 private boolean jj_3_90() { 3291 if (jj_scan_token(FONT)) 3292 return true; 3293 if (jj_3R_23()) 3294 return true; 3295 return false; 3296 } 3297 3298 private boolean jj_3_89() { 3299 if (jj_scan_token(FOS)) 3300 return true; 3301 if (jj_3R_21()) 3302 return true; 3303 return false; 3304 } 3305 3306 private boolean jj_3_88() { 3307 if (jj_scan_token(LA)) 3308 return true; 3309 if (jj_3R_21()) 3310 return true; 3311 return false; 3312 } 3313 3314 private boolean jj_3_87() { 3315 if (jj_scan_token(LC)) 3316 return true; 3317 if (jj_3R_22()) 3318 return true; 3319 return false; 3320 } 3321 3322 private boolean jj_3_86() { 3323 if (jj_scan_token(LPHI)) 3324 return true; 3325 if (jj_3R_21()) 3326 return true; 3327 return false; 3328 } 3329 3330 private boolean jj_3_85() { 3331 if (jj_scan_token(LR)) 3332 return true; 3333 if (jj_3R_21()) 3334 return true; 3335 return false; 3336 } 3337 3338 private boolean jj_3_84() { 3339 if (jj_scan_token(LP)) 3340 return true; 3341 if (jj_3R_21()) 3342 return true; 3343 return false; 3344 } 3345 3346 private boolean jj_3_83() { 3347 if (jj_scan_token(L)) 3348 return true; 3349 if (jj_3R_23()) 3350 return true; 3351 return false; 3352 } 3353 3354 private boolean jj_3_73() { 3355 if (jj_scan_token(REAL)) 3356 return true; 3357 return false; 3358 } 3359 3360 private boolean jj_3_82() { 3361 if (jj_scan_token(AP)) 3362 return true; 3363 if (jj_3R_21()) 3364 return true; 3365 return false; 3366 } 3367 3368 private boolean jj_3_81() { 3369 if (jj_scan_token(A)) 3370 return true; 3371 Token xsp; 3372 xsp = jj_scanpos; 3373 if (jj_3_75()) { 3374 jj_scanpos = xsp; 3375 if (jj_3_76()) 3376 return true; 3377 } 3378 return false; 3379 } 3380 3381 private boolean jj_3_80() { 3382 if (jj_scan_token(S)) 3383 return true; 3384 if (jj_3R_21()) 3385 return true; 3386 return false; 3387 } 3388 3389 private boolean jj_3_79() { 3390 if (jj_scan_token(C)) 3391 return true; 3392 if (jj_3R_22()) 3393 return true; 3394 return false; 3395 } 3396 3397 private boolean jj_3_78() { 3398 if (jj_scan_token(W)) 3399 return true; 3400 if (jj_3R_21()) 3401 return true; 3402 return false; 3403 } 3404 3405 private boolean jj_3_74() { 3406 Token xsp; 3407 xsp = jj_scanpos; 3408 if (jj_3_77()) { 3409 jj_scanpos = xsp; 3410 if (jj_3_78()) { 3411 jj_scanpos = xsp; 3412 if (jj_3_79()) { 3413 jj_scanpos = xsp; 3414 if (jj_3_80()) { 3415 jj_scanpos = xsp; 3416 if (jj_3_81()) { 3417 jj_scanpos = xsp; 3418 if (jj_3_82()) { 3419 jj_scanpos = xsp; 3420 if (jj_3_83()) { 3421 jj_scanpos = xsp; 3422 if (jj_3_84()) { 3423 jj_scanpos = xsp; 3424 if (jj_3_85()) { 3425 jj_scanpos = xsp; 3426 if (jj_3_86()) { 3427 jj_scanpos = xsp; 3428 if (jj_3_87()) { 3429 jj_scanpos = xsp; 3430 if (jj_3_88()) { 3431 jj_scanpos = xsp; 3432 if (jj_3_89()) { 3433 jj_scanpos = xsp; 3434 if (jj_3_90()) { 3435 jj_scanpos = xsp; 3436 if (jj_3_91()) { 3437 jj_scanpos = xsp; 3438 if (jj_3_92()) { 3439 jj_scanpos = xsp; 3440 if (jj_3_93()) { 3441 jj_scanpos = xsp; 3442 if (jj_3_94()) { 3443 jj_scanpos = xsp; 3444 if (jj_3_95()) { 3445 jj_scanpos = xsp; 3446 if (jj_3_96()) 3447 return true; 3448 } 3449 } 3450 } 3451 } 3452 } 3453 } 3454 } 3455 } 3456 } 3457 } 3458 } 3459 } 3460 } 3461 } 3462 } 3463 } 3464 } 3465 } 3466 } 3467 return false; 3468 } 3469 3470 private boolean jj_3_77() { 3471 if (jj_scan_token(P)) 3472 return true; 3473 if (jj_3R_23()) 3474 return true; 3475 return false; 3476 } 3477 3478 private boolean jj_3_72() { 3479 if (jj_scan_token(INT)) 3480 return true; 3481 return false; 3482 } 3483 3484 private boolean jj_3_100() { 3485 Token xsp; 3486 xsp = jj_scanpos; 3487 if (jj_3_72()) { 3488 jj_scanpos = xsp; 3489 if (jj_3_73()) 3490 return true; 3491 } 3492 while (true) { 3493 xsp = jj_scanpos; 3494 if (jj_3_74()) { 3495 jj_scanpos = xsp; 3496 break; 3497 } 3498 } 3499 while (true) { 3500 xsp = jj_scanpos; 3501 if (jj_3_97()) { 3502 jj_scanpos = xsp; 3503 break; 3504 } 3505 } 3506 return false; 3507 } 3508 3509 private boolean jj_3R_25() { 3510 if (jj_scan_token(INT)) 3511 return true; 3512 if (jj_scan_token(INT)) 3513 return true; 3514 return false; 3515 } 3516 3517 private boolean jj_3_51() { 3518 if (jj_scan_token(REAL)) 3519 return true; 3520 return false; 3521 } 3522 3523 private boolean jj_3_24() { 3524 if (jj_scan_token(INT)) 3525 return true; 3526 return false; 3527 } 3528 3529 private boolean jj_3_71() { 3530 if (jj_scan_token(COMMENT)) 3531 return true; 3532 return false; 3533 } 3534 3535 private boolean jj_3_23() { 3536 if (jj_scan_token(REAL)) 3537 return true; 3538 return false; 3539 } 3540 3541 private boolean jj_3_25() { 3542 Token xsp; 3543 xsp = jj_scanpos; 3544 if (jj_3_23()) { 3545 jj_scanpos = xsp; 3546 if (jj_3_24()) 3547 return true; 3548 } 3549 return false; 3550 } 3551 3552 private boolean jj_3_70() { 3553 if (jj_3R_28()) 3554 return true; 3555 return false; 3556 } 3557 3558 private boolean jj_3_69() { 3559 if (jj_scan_token(EDGESLIST)) 3560 return true; 3561 if (jj_3R_27()) 3562 return true; 3563 return false; 3564 } 3565 3566 private boolean jj_3_68() { 3567 if (jj_scan_token(ARCSLIST)) 3568 return true; 3569 if (jj_3R_27()) 3570 return true; 3571 return false; 3572 } 3573 3574 private boolean jj_3_67() { 3575 if (jj_scan_token(EDGES)) 3576 return true; 3577 if (jj_3R_27()) 3578 return true; 3579 return false; 3580 } 3581 3582 private boolean jj_3_66() { 3583 if (jj_scan_token(ARCS)) 3584 return true; 3585 if (jj_3R_27()) 3586 return true; 3587 return false; 3588 } 3589 3590 private boolean jj_3R_19() { 3591 Token xsp; 3592 xsp = jj_scanpos; 3593 if (jj_3_66()) { 3594 jj_scanpos = xsp; 3595 if (jj_3_67()) { 3596 jj_scanpos = xsp; 3597 if (jj_3_68()) { 3598 jj_scanpos = xsp; 3599 if (jj_3_69()) { 3600 jj_scanpos = xsp; 3601 if (jj_3_70()) { 3602 jj_scanpos = xsp; 3603 if (jj_3_71()) 3604 return true; 3605 } 3606 } 3607 } 3608 } 3609 } 3610 return false; 3611 } 3612 3613 private boolean jj_3_22() { 3614 if (jj_scan_token(INT)) 3615 return true; 3616 return false; 3617 } 3618 3619 private boolean jj_3_50() { 3620 if (jj_3R_24()) 3621 return true; 3622 return false; 3623 } 3624 3625 private boolean jj_3_49() { 3626 Token xsp; 3627 xsp = jj_scanpos; 3628 if (jj_3_50()) { 3629 jj_scanpos = xsp; 3630 if (jj_3_51()) 3631 return true; 3632 } 3633 return false; 3634 } 3635 3636 private boolean jj_3_48() { 3637 if (jj_scan_token(FONT)) 3638 return true; 3639 if (jj_3R_23()) 3640 return true; 3641 return false; 3642 } 3643 3644 private boolean jj_3_47() { 3645 if (jj_scan_token(FOS)) 3646 return true; 3647 if (jj_3R_21()) 3648 return true; 3649 return false; 3650 } 3651 3652 private boolean jj_3_46() { 3653 if (jj_scan_token(LPHI)) 3654 return true; 3655 if (jj_3R_21()) 3656 return true; 3657 return false; 3658 } 3659 3660 private boolean jj_3_45() { 3661 if (jj_scan_token(LR)) 3662 return true; 3663 if (jj_3R_21()) 3664 return true; 3665 return false; 3666 } 3667 3668 private boolean jj_3_44() { 3669 if (jj_scan_token(LA)) 3670 return true; 3671 if (jj_3R_21()) 3672 return true; 3673 return false; 3674 } 3675 3676 private boolean jj_3_43() { 3677 if (jj_scan_token(LC)) 3678 return true; 3679 if (jj_3R_22()) 3680 return true; 3681 return false; 3682 } 3683 3684 private boolean jj_3_21() { 3685 if (jj_scan_token(REAL)) 3686 return true; 3687 return false; 3688 } 3689 3690 private boolean jj_3_42() { 3691 if (jj_scan_token(BW)) 3692 return true; 3693 if (jj_3R_21()) 3694 return true; 3695 return false; 3696 } 3697 3698 private boolean jj_3_41() { 3699 if (jj_scan_token(BC)) 3700 return true; 3701 if (jj_3R_22()) 3702 return true; 3703 return false; 3704 } 3705 3706 private boolean jj_3_40() { 3707 if (jj_scan_token(IC)) 3708 return true; 3709 if (jj_3R_22()) 3710 return true; 3711 return false; 3712 } 3713 3714 private boolean jj_3_39() { 3715 if (jj_scan_token(Q)) 3716 return true; 3717 if (jj_3R_21()) 3718 return true; 3719 return false; 3720 } 3721 3722 private boolean jj_3_38() { 3723 if (jj_scan_token(R)) 3724 return true; 3725 if (jj_3R_21()) 3726 return true; 3727 return false; 3728 } 3729 3730 private boolean jj_3_37() { 3731 if (jj_scan_token(PHI)) 3732 return true; 3733 if (jj_3R_21()) 3734 return true; 3735 return false; 3736 } 3737 3738 private boolean jj_3_36() { 3739 if (jj_scan_token(YFACT)) 3740 return true; 3741 if (jj_3R_21()) 3742 return true; 3743 return false; 3744 } 3745 3746 private boolean jj_3_35() { 3747 if (jj_scan_token(XFACT)) 3748 return true; 3749 if (jj_3R_21()) 3750 return true; 3751 return false; 3752 } 3753 3754 private boolean jj_3_33() { 3755 Token xsp; 3756 xsp = jj_scanpos; 3757 if (jj_3_34()) { 3758 jj_scanpos = xsp; 3759 if (jj_3_35()) { 3760 jj_scanpos = xsp; 3761 if (jj_3_36()) { 3762 jj_scanpos = xsp; 3763 if (jj_3_37()) { 3764 jj_scanpos = xsp; 3765 if (jj_3_38()) { 3766 jj_scanpos = xsp; 3767 if (jj_3_39()) { 3768 jj_scanpos = xsp; 3769 if (jj_3_40()) { 3770 jj_scanpos = xsp; 3771 if (jj_3_41()) { 3772 jj_scanpos = xsp; 3773 if (jj_3_42()) { 3774 jj_scanpos = xsp; 3775 if (jj_3_43()) { 3776 jj_scanpos = xsp; 3777 if (jj_3_44()) { 3778 jj_scanpos = xsp; 3779 if (jj_3_45()) { 3780 jj_scanpos = xsp; 3781 if (jj_3_46()) { 3782 jj_scanpos = xsp; 3783 if (jj_3_47()) { 3784 jj_scanpos = xsp; 3785 if (jj_3_48()) 3786 return true; 3787 } 3788 } 3789 } 3790 } 3791 } 3792 } 3793 } 3794 } 3795 } 3796 } 3797 } 3798 } 3799 } 3800 } 3801 return false; 3802 } 3803 3804 private boolean jj_3_34() { 3805 if (jj_scan_token(SIZE)) 3806 return true; 3807 if (jj_3R_21()) 3808 return true; 3809 return false; 3810 } 3811 3812 private boolean jj_3_20() { 3813 if (jj_scan_token(INT)) 3814 return true; 3815 return false; 3816 } 3817 3818 private boolean jj_3_31() { 3819 if (jj_scan_token(EMPTY)) 3820 return true; 3821 return false; 3822 } 3823 3824 private boolean jj_3_30() { 3825 if (jj_scan_token(DIAMOND)) 3826 return true; 3827 return false; 3828 } 3829 3830 private boolean jj_3_29() { 3831 if (jj_scan_token(CROSS)) 3832 return true; 3833 return false; 3834 } 3835 3836 private boolean jj_3_28() { 3837 if (jj_scan_token(TRIANGLE)) 3838 return true; 3839 return false; 3840 } 3841 3842 private boolean jj_3_27() { 3843 if (jj_scan_token(BOX)) 3844 return true; 3845 return false; 3846 } 3847 3848 private boolean jj_3_26() { 3849 if (jj_scan_token(ELLIPSE)) 3850 return true; 3851 return false; 3852 } 3853 3854 private boolean jj_3_32() { 3855 Token xsp; 3856 xsp = jj_scanpos; 3857 if (jj_3_26()) { 3858 jj_scanpos = xsp; 3859 if (jj_3_27()) { 3860 jj_scanpos = xsp; 3861 if (jj_3_28()) { 3862 jj_scanpos = xsp; 3863 if (jj_3_29()) { 3864 jj_scanpos = xsp; 3865 if (jj_3_30()) { 3866 jj_scanpos = xsp; 3867 if (jj_3_31()) 3868 return true; 3869 } 3870 } 3871 } 3872 } 3873 } 3874 return false; 3875 } 3876 3877 private boolean jj_3_19() { 3878 if (jj_scan_token(REAL)) 3879 return true; 3880 return false; 3881 } 3882 3883 private boolean jj_3_52() { 3884 Token xsp; 3885 xsp = jj_scanpos; 3886 if (jj_3_19()) { 3887 jj_scanpos = xsp; 3888 if (jj_3_20()) 3889 return true; 3890 } 3891 xsp = jj_scanpos; 3892 if (jj_3_21()) { 3893 jj_scanpos = xsp; 3894 if (jj_3_22()) 3895 return true; 3896 } 3897 return false; 3898 } 3899 3900 private boolean jj_3_53() { 3901 if (jj_3R_24()) 3902 return true; 3903 Token xsp; 3904 xsp = jj_scanpos; 3905 if (jj_3_52()) 3906 jj_scanpos = xsp; 3907 return false; 3908 } 3909 3910 private boolean jj_3R_20() { 3911 if (jj_scan_token(INT)) 3912 return true; 3913 Token xsp; 3914 xsp = jj_scanpos; 3915 if (jj_3_53()) 3916 jj_scanpos = xsp; 3917 if (jj_3R_27()) 3918 return true; 3919 return false; 3920 } 3921 3922 private boolean jj_3_18() { 3923 if (jj_scan_token(COMMENT)) 3924 return true; 3925 return false; 3926 } 3927 3928 private boolean jj_3_17() { 3929 if (jj_3R_20()) 3930 return true; 3931 return false; 3932 } 3933 3934 private boolean jj_3_16() { 3935 Token xsp; 3936 xsp = jj_scanpos; 3937 if (jj_3_17()) { 3938 jj_scanpos = xsp; 3939 if (jj_3_18()) 3940 return true; 3941 } 3942 return false; 3943 } 3944 3945 private boolean jj_3R_18() { 3946 if (jj_scan_token(VERTICES)) 3947 return true; 3948 if (jj_scan_token(INT)) 3949 return true; 3950 return false; 3951 } 3952 3953 private boolean jj_3_15() { 3954 if (jj_scan_token(KEY)) 3955 return true; 3956 return false; 3957 } 3958 3959 private boolean jj_3_14() { 3960 if (jj_scan_token(STRING)) 3961 return true; 3962 return false; 3963 } 3964 3965 private boolean jj_3_13() { 3966 Token xsp; 3967 xsp = jj_scanpos; 3968 if (jj_3_14()) { 3969 jj_scanpos = xsp; 3970 if (jj_3_15()) 3971 return true; 3972 } 3973 return false; 3974 } 3975 3976 private boolean jj_3R_17() { 3977 if (jj_scan_token(NETWORK)) 3978 return true; 3979 Token xsp; 3980 while (true) { 3981 xsp = jj_scanpos; 3982 if (jj_3_13()) { 3983 jj_scanpos = xsp; 3984 break; 3985 } 3986 } 3987 if (jj_3R_27()) 3988 return true; 3989 return false; 3990 } 3991 3992 private boolean jj_3_12() { 3993 if (jj_scan_token(0)) 3994 return true; 3995 return false; 3996 } 3997 3998 private boolean jj_3_11() { 3999 if (jj_scan_token(EOL)) 4000 return true; 4001 return false; 4002 } 4003 4004 private boolean jj_3_10() { 4005 if (jj_scan_token(COMMENT)) 4006 return true; 4007 return false; 4008 } 4009 4010 private boolean jj_3_9() { 4011 if (jj_3R_19()) 4012 return true; 4013 return false; 4014 } 4015 4016 private boolean jj_3_8() { 4017 if (jj_3R_18()) 4018 return true; 4019 return false; 4020 } 4021 4022 private boolean jj_3_7() { 4023 if (jj_3R_17()) 4024 return true; 4025 return false; 4026 } 4027 4028 private boolean jj_3_5() { 4029 if (jj_scan_token(EOL)) 4030 return true; 4031 return false; 4032 } 4033 4034 private boolean jj_3_4() { 4035 if (jj_scan_token(COMMENT)) 4036 return true; 4037 return false; 4038 } 4039 4040 private boolean jj_3_3() { 4041 if (jj_3R_19()) 4042 return true; 4043 return false; 4044 } 4045 4046 private boolean jj_3_2() { 4047 if (jj_3R_18()) 4048 return true; 4049 return false; 4050 } 4051 4052 private boolean jj_3_1() { 4053 if (jj_3R_17()) 4054 return true; 4055 return false; 4056 } 4057 4058 private boolean jj_3_6() { 4059 Token xsp; 4060 xsp = jj_scanpos; 4061 if (jj_3_1()) { 4062 jj_scanpos = xsp; 4063 if (jj_3_2()) { 4064 jj_scanpos = xsp; 4065 if (jj_3_3()) { 4066 jj_scanpos = xsp; 4067 if (jj_3_4()) { 4068 jj_scanpos = xsp; 4069 if (jj_3_5()) 4070 return true; 4071 } 4072 } 4073 } 4074 } 4075 return false; 4076 } 4077 4078 private boolean jj_3_182() { 4079 if (jj_scan_token(YFACT)) 4080 return true; 4081 return false; 4082 } 4083 4084 private boolean jj_3_181() { 4085 if (jj_scan_token(XFACT)) 4086 return true; 4087 return false; 4088 } 4089 4090 private boolean jj_3_180() { 4091 if (jj_scan_token(W)) 4092 return true; 4093 return false; 4094 } 4095 4096 private boolean jj_3_179() { 4097 if (jj_scan_token(SIZE)) 4098 return true; 4099 return false; 4100 } 4101 4102 private boolean jj_3_178() { 4103 if (jj_scan_token(S)) 4104 return true; 4105 return false; 4106 } 4107 4108 private boolean jj_3_177() { 4109 if (jj_scan_token(R)) 4110 return true; 4111 return false; 4112 } 4113 4114 private boolean jj_3_176() { 4115 if (jj_scan_token(Q)) 4116 return true; 4117 return false; 4118 } 4119 4120 private boolean jj_3_175() { 4121 if (jj_scan_token(PHI)) 4122 return true; 4123 return false; 4124 } 4125 4126 private boolean jj_3_174() { 4127 if (jj_scan_token(P)) 4128 return true; 4129 return false; 4130 } 4131 4132 private boolean jj_3_173() { 4133 if (jj_scan_token(LR)) 4134 return true; 4135 return false; 4136 } 4137 4138 private boolean jj_3_172() { 4139 if (jj_scan_token(LPHI)) 4140 return true; 4141 return false; 4142 } 4143 4144 private boolean jj_3_171() { 4145 if (jj_scan_token(LP)) 4146 return true; 4147 return false; 4148 } 4149 4150 private boolean jj_3_170() { 4151 if (jj_scan_token(LC)) 4152 return true; 4153 return false; 4154 } 4155 4156 private boolean jj_3_169() { 4157 if (jj_scan_token(LA)) 4158 return true; 4159 return false; 4160 } 4161 4162 private boolean jj_3_168() { 4163 if (jj_scan_token(L)) 4164 return true; 4165 return false; 4166 } 4167 4168 private boolean jj_3_167() { 4169 if (jj_scan_token(K2)) 4170 return true; 4171 return false; 4172 } 4173 4174 private boolean jj_3_166() { 4175 if (jj_scan_token(K1)) 4176 return true; 4177 return false; 4178 } 4179 4180 private boolean jj_3_165() { 4181 if (jj_scan_token(IC)) 4182 return true; 4183 return false; 4184 } 4185 4186 private boolean jj_3_164() { 4187 if (jj_scan_token(H2)) 4188 return true; 4189 return false; 4190 } 4191 4192 private boolean jj_3_163() { 4193 if (jj_scan_token(H1)) 4194 return true; 4195 return false; 4196 } 4197 4198 private boolean jj_3_162() { 4199 if (jj_scan_token(FOS)) 4200 return true; 4201 return false; 4202 } 4203 4204 private boolean jj_3_161() { 4205 if (jj_scan_token(FONT)) 4206 return true; 4207 return false; 4208 } 4209 4210 private boolean jj_3_160() { 4211 if (jj_scan_token(C)) 4212 return true; 4213 return false; 4214 } 4215 4216 private boolean jj_3_159() { 4217 if (jj_scan_token(BW)) 4218 return true; 4219 return false; 4220 } 4221 4222 private boolean jj_3_158() { 4223 if (jj_scan_token(BC)) 4224 return true; 4225 return false; 4226 } 4227 4228 private boolean jj_3_157() { 4229 if (jj_scan_token(B)) 4230 return true; 4231 return false; 4232 } 4233 4234 private boolean jj_3_156() { 4235 if (jj_scan_token(AP)) 4236 return true; 4237 return false; 4238 } 4239 4240 private boolean jj_3_155() { 4241 if (jj_scan_token(A2)) 4242 return true; 4243 return false; 4244 } 4245 4246 private boolean jj_3_154() { 4247 if (jj_scan_token(A1)) 4248 return true; 4249 return false; 4250 } 4251 4252 private boolean jj_3_153() { 4253 if (jj_scan_token(A)) 4254 return true; 4255 return false; 4256 } 4257 4258 private boolean jj_3_152() { 4259 if (jj_scan_token(INT)) 4260 return true; 4261 return false; 4262 } 4263 4264 private boolean jj_3_151() { 4265 if (jj_scan_token(STRING)) 4266 return true; 4267 return false; 4268 } 4269 4270 private boolean jj_3_150() { 4271 if (jj_scan_token(KEY)) 4272 return true; 4273 return false; 4274 } 4275 4276 private boolean jj_3R_24() { 4277 Token xsp; 4278 xsp = jj_scanpos; 4279 if (jj_3_150()) { 4280 jj_scanpos = xsp; 4281 if (jj_3_151()) { 4282 jj_scanpos = xsp; 4283 if (jj_3_152()) { 4284 jj_scanpos = xsp; 4285 if (jj_3_153()) { 4286 jj_scanpos = xsp; 4287 if (jj_3_154()) { 4288 jj_scanpos = xsp; 4289 if (jj_3_155()) { 4290 jj_scanpos = xsp; 4291 if (jj_3_156()) { 4292 jj_scanpos = xsp; 4293 if (jj_3_157()) { 4294 jj_scanpos = xsp; 4295 if (jj_3_158()) { 4296 jj_scanpos = xsp; 4297 if (jj_3_159()) { 4298 jj_scanpos = xsp; 4299 if (jj_3_160()) { 4300 jj_scanpos = xsp; 4301 if (jj_3_161()) { 4302 jj_scanpos = xsp; 4303 if (jj_3_162()) { 4304 jj_scanpos = xsp; 4305 if (jj_3_163()) { 4306 jj_scanpos = xsp; 4307 if (jj_3_164()) { 4308 jj_scanpos = xsp; 4309 if (jj_3_165()) { 4310 jj_scanpos = xsp; 4311 if (jj_3_166()) { 4312 jj_scanpos = xsp; 4313 if (jj_3_167()) { 4314 jj_scanpos = xsp; 4315 if (jj_3_168()) { 4316 jj_scanpos = xsp; 4317 if (jj_3_169()) { 4318 jj_scanpos = xsp; 4319 if (jj_3_170()) { 4320 jj_scanpos = xsp; 4321 if (jj_3_171()) { 4322 jj_scanpos = xsp; 4323 if (jj_3_172()) { 4324 jj_scanpos = xsp; 4325 if (jj_3_173()) { 4326 jj_scanpos = xsp; 4327 if (jj_3_174()) { 4328 jj_scanpos = xsp; 4329 if (jj_3_175()) { 4330 jj_scanpos = xsp; 4331 if (jj_3_176()) { 4332 jj_scanpos = xsp; 4333 if (jj_3_177()) { 4334 jj_scanpos = xsp; 4335 if (jj_3_178()) { 4336 jj_scanpos = xsp; 4337 if (jj_3_179()) { 4338 jj_scanpos = xsp; 4339 if (jj_3_180()) { 4340 jj_scanpos = xsp; 4341 if (jj_3_181()) { 4342 jj_scanpos = xsp; 4343 if (jj_3_182()) 4344 return true; 4345 } 4346 } 4347 } 4348 } 4349 } 4350 } 4351 } 4352 } 4353 } 4354 } 4355 } 4356 } 4357 } 4358 } 4359 } 4360 } 4361 } 4362 } 4363 } 4364 } 4365 } 4366 } 4367 } 4368 } 4369 } 4370 } 4371 } 4372 } 4373 } 4374 } 4375 } 4376 } 4377 return false; 4378 } 4379 4380 private boolean jj_3_149() { 4381 if (jj_scan_token(A2)) 4382 return true; 4383 return false; 4384 } 4385 4386 private boolean jj_3_148() { 4387 if (jj_scan_token(A1)) 4388 return true; 4389 return false; 4390 } 4391 4392 private boolean jj_3_147() { 4393 if (jj_scan_token(K2)) 4394 return true; 4395 return false; 4396 } 4397 4398 private boolean jj_3_146() { 4399 if (jj_scan_token(K1)) 4400 return true; 4401 return false; 4402 } 4403 4404 private boolean jj_3_145() { 4405 if (jj_scan_token(H2)) 4406 return true; 4407 return false; 4408 } 4409 4410 private boolean jj_3_144() { 4411 if (jj_scan_token(H1)) 4412 return true; 4413 return false; 4414 } 4415 4416 private boolean jj_3_143() { 4417 if (jj_scan_token(LP)) 4418 return true; 4419 return false; 4420 } 4421 4422 private boolean jj_3_142() { 4423 if (jj_scan_token(L)) 4424 return true; 4425 return false; 4426 } 4427 4428 private boolean jj_3_141() { 4429 if (jj_scan_token(AP)) 4430 return true; 4431 return false; 4432 } 4433 4434 private boolean jj_3_140() { 4435 if (jj_scan_token(B)) 4436 return true; 4437 return false; 4438 } 4439 4440 private boolean jj_3_139() { 4441 if (jj_scan_token(A)) 4442 return true; 4443 return false; 4444 } 4445 4446 private boolean jj_3_138() { 4447 if (jj_scan_token(W)) 4448 return true; 4449 return false; 4450 } 4451 4452 private boolean jj_3_137() { 4453 if (jj_scan_token(P)) 4454 return true; 4455 return false; 4456 } 4457 4458 private boolean jj_3_136() { 4459 if (jj_scan_token(C)) 4460 return true; 4461 return false; 4462 } 4463 4464 private boolean jj_3_135() { 4465 if (jj_scan_token(FONT)) 4466 return true; 4467 return false; 4468 } 4469 4470 private boolean jj_3_134() { 4471 if (jj_scan_token(FOS)) 4472 return true; 4473 return false; 4474 } 4475 4476 private boolean jj_3_133() { 4477 if (jj_scan_token(LPHI)) 4478 return true; 4479 return false; 4480 } 4481 4482 private boolean jj_3_132() { 4483 if (jj_scan_token(LR)) 4484 return true; 4485 return false; 4486 } 4487 4488 private boolean jj_3_131() { 4489 if (jj_scan_token(LA)) 4490 return true; 4491 return false; 4492 } 4493 4494 private boolean jj_3_130() { 4495 if (jj_scan_token(LC)) 4496 return true; 4497 return false; 4498 } 4499 4500 private boolean jj_3_129() { 4501 if (jj_scan_token(BW)) 4502 return true; 4503 return false; 4504 } 4505 4506 private boolean jj_3_128() { 4507 if (jj_scan_token(BC)) 4508 return true; 4509 return false; 4510 } 4511 4512 private boolean jj_3_127() { 4513 if (jj_scan_token(IC)) 4514 return true; 4515 return false; 4516 } 4517 4518 private boolean jj_3_126() { 4519 if (jj_scan_token(Q)) 4520 return true; 4521 return false; 4522 } 4523 4524 private boolean jj_3_125() { 4525 if (jj_scan_token(R)) 4526 return true; 4527 return false; 4528 } 4529 4530 private boolean jj_3_124() { 4531 if (jj_scan_token(PHI)) 4532 return true; 4533 return false; 4534 } 4535 4536 private boolean jj_3_123() { 4537 if (jj_scan_token(YFACT)) 4538 return true; 4539 return false; 4540 } 4541 4542 private boolean jj_3_122() { 4543 if (jj_scan_token(XFACT)) 4544 return true; 4545 return false; 4546 } 4547 4548 private boolean jj_3_121() { 4549 if (jj_scan_token(SIZE)) 4550 return true; 4551 return false; 4552 } 4553 4554 private boolean jj_3_120() { 4555 if (jj_scan_token(STRING)) 4556 return true; 4557 return false; 4558 } 4559 4560 private boolean jj_3_119() { 4561 if (jj_scan_token(KEY)) 4562 return true; 4563 return false; 4564 } 4565 4566 private boolean jj_3_118() { 4567 if (jj_scan_token(REAL)) 4568 return true; 4569 return false; 4570 } 4571 4572 private boolean jj_3_117() { 4573 if (jj_scan_token(INT)) 4574 return true; 4575 return false; 4576 } 4577 4578 private boolean jj_3_114() { 4579 if (jj_scan_token(EOL)) 4580 return true; 4581 return false; 4582 } 4583 4584 private boolean jj_3_116() { 4585 if (jj_scan_token(0)) 4586 return true; 4587 return false; 4588 } 4589 4590 private boolean jj_3_115() { 4591 Token xsp; 4592 if (jj_3_114()) 4593 return true; 4594 while (true) { 4595 xsp = jj_scanpos; 4596 if (jj_3_114()) { 4597 jj_scanpos = xsp; 4598 break; 4599 } 4600 } 4601 return false; 4602 } 4603 4604 private boolean jj_3R_27() { 4605 Token xsp; 4606 xsp = jj_scanpos; 4607 if (jj_3_115()) { 4608 jj_scanpos = xsp; 4609 if (jj_3_116()) 4610 return true; 4611 } 4612 return false; 4613 } 4614 4615 private boolean jj_3_104() { 4616 if (jj_scan_token(COMMENT)) 4617 return true; 4618 return false; 4619 } 4620 4621 private boolean jj_3_113() { 4622 if (jj_scan_token(INT)) 4623 return true; 4624 if (jj_scan_token(INT)) 4625 return true; 4626 return false; 4627 } 4628 4629 private boolean jj_3_110() { 4630 if (jj_scan_token(REAL)) 4631 return true; 4632 return false; 4633 } 4634 4635 private boolean jj_3_112() { 4636 if (jj_scan_token(REAL)) 4637 return true; 4638 if (jj_scan_token(REAL)) 4639 return true; 4640 return false; 4641 } 4642 4643 private boolean jj_3_111() { 4644 if (jj_3R_23()) 4645 return true; 4646 return false; 4647 } 4648 4649 private boolean jj_3R_22() { 4650 Token xsp; 4651 xsp = jj_scanpos; 4652 if (jj_3_111()) { 4653 jj_scanpos = xsp; 4654 if (jj_3_112()) { 4655 jj_scanpos = xsp; 4656 if (jj_3_113()) 4657 return true; 4658 } 4659 } 4660 return false; 4661 } 4662 4663 private boolean jj_3_109() { 4664 if (jj_scan_token(INT)) 4665 return true; 4666 return false; 4667 } 4668 4669 private boolean jj_3R_21() { 4670 Token xsp; 4671 xsp = jj_scanpos; 4672 if (jj_3_109()) { 4673 jj_scanpos = xsp; 4674 if (jj_3_110()) 4675 return true; 4676 } 4677 return false; 4678 } 4679 4680 private boolean jj_3_65() { 4681 if (jj_scan_token(COMMENT)) 4682 return true; 4683 return false; 4684 } 4685 4686 private boolean jj_3_62() { 4687 if (jj_scan_token(COMMENT)) 4688 return true; 4689 return false; 4690 } 4691 4692 private boolean jj_3_59() { 4693 if (jj_scan_token(COMMENT)) 4694 return true; 4695 return false; 4696 } 4697 4698 private boolean jj_3_56() { 4699 if (jj_scan_token(COMMENT)) 4700 return true; 4701 return false; 4702 } 4703 4704 private boolean jj_3_108() { 4705 if (jj_scan_token(STRING)) 4706 return true; 4707 return false; 4708 } 4709 4710 private boolean jj_3_107() { 4711 if (jj_scan_token(KEY)) 4712 return true; 4713 return false; 4714 } 4715 4716 private boolean jj_3R_23() { 4717 Token xsp; 4718 xsp = jj_scanpos; 4719 if (jj_3_107()) { 4720 jj_scanpos = xsp; 4721 if (jj_3_108()) 4722 return true; 4723 } 4724 return false; 4725 } 4726 4727 private boolean jj_3_64() { 4728 if (jj_3R_26()) 4729 return true; 4730 return false; 4731 } 4732 4733 private boolean jj_3_63() { 4734 Token xsp; 4735 xsp = jj_scanpos; 4736 if (jj_3_64()) { 4737 jj_scanpos = xsp; 4738 if (jj_3_65()) 4739 return true; 4740 } 4741 return false; 4742 } 4743 4744 private boolean jj_3_61() { 4745 if (jj_3R_26()) 4746 return true; 4747 return false; 4748 } 4749 4750 private boolean jj_3_60() { 4751 Token xsp; 4752 xsp = jj_scanpos; 4753 if (jj_3_61()) { 4754 jj_scanpos = xsp; 4755 if (jj_3_62()) 4756 return true; 4757 } 4758 return false; 4759 } 4760 4761 private boolean jj_3_58() { 4762 if (jj_3R_25()) 4763 return true; 4764 return false; 4765 } 4766 4767 private boolean jj_3_57() { 4768 Token xsp; 4769 xsp = jj_scanpos; 4770 if (jj_3_58()) { 4771 jj_scanpos = xsp; 4772 if (jj_3_59()) 4773 return true; 4774 } 4775 return false; 4776 } 4777 4778 private boolean jj_3_55() { 4779 if (jj_3R_25()) 4780 return true; 4781 return false; 4782 } 4783 4784 private boolean jj_3_54() { 4785 Token xsp; 4786 xsp = jj_scanpos; 4787 if (jj_3_55()) { 4788 jj_scanpos = xsp; 4789 if (jj_3_56()) 4790 return true; 4791 } 4792 return false; 4793 } 4794 4795 private boolean jj_3_106() { 4796 if (jj_scan_token(INT)) 4797 return true; 4798 return false; 4799 } 4800 4801 /** Generated Token Manager. */ 4802 public PajekParserTokenManager token_source; 4803 SimpleCharStream jj_input_stream; 4804 /** Current token. */ 4805 public Token token; 4806 /** Next token. */ 4807 public Token jj_nt; 4808 private int jj_ntk; 4809 private Token jj_scanpos, jj_lastpos; 4810 private int jj_la; 4811 private int jj_gen; 4812 final private int[] jj_la1 = new int[0]; 4813 static private int[] jj_la1_0; 4814 static private int[] jj_la1_1; 4815 static { 4816 jj_la1_init_0(); 4817 jj_la1_init_1(); 4818 } 4819 4820 private static void jj_la1_init_0() { 4821 jj_la1_0 = new int[] {}; 4822 } 4823 4824 private static void jj_la1_init_1() { 4825 jj_la1_1 = new int[] {}; 4826 } 4827 4828 final private JJCalls[] jj_2_rtns = new JJCalls[182]; 4829 private boolean jj_rescan = false; 4830 private int jj_gc = 0; 4831 4832 /** Constructor with InputStream. */ 4833 public PajekParser(java.io.InputStream stream) { 4834 this(stream, null); 4835 } 4836 4837 /** Constructor with InputStream and supplied encoding */ 4838 public PajekParser(java.io.InputStream stream, String encoding) { 4839 try { 4840 jj_input_stream = new SimpleCharStream(stream, encoding, 1, 1); 4841 } catch (java.io.UnsupportedEncodingException e) { 4842 throw new RuntimeException(e); 4843 } 4844 token_source = new PajekParserTokenManager(jj_input_stream); 4845 token = new Token(); 4846 jj_ntk = -1; 4847 jj_gen = 0; 4848 for (int i = 0; i < 0; i++) 4849 jj_la1[i] = -1; 4850 for (int i = 0; i < jj_2_rtns.length; i++) 4851 jj_2_rtns[i] = new JJCalls(); 4852 } 4853 4854 /** Reinitialise. */ 4855 public void ReInit(java.io.InputStream stream) { 4856 ReInit(stream, null); 4857 } 4858 4859 /** Reinitialise. */ 4860 public void ReInit(java.io.InputStream stream, String encoding) { 4861 try { 4862 jj_input_stream.ReInit(stream, encoding, 1, 1); 4863 } catch (java.io.UnsupportedEncodingException e) { 4864 throw new RuntimeException(e); 4865 } 4866 token_source.ReInit(jj_input_stream); 4867 token = new Token(); 4868 jj_ntk = -1; 4869 jj_gen = 0; 4870 for (int i = 0; i < 0; i++) 4871 jj_la1[i] = -1; 4872 for (int i = 0; i < jj_2_rtns.length; i++) 4873 jj_2_rtns[i] = new JJCalls(); 4874 } 4875 4876 /** Constructor. */ 4877 public PajekParser(java.io.Reader stream) { 4878 jj_input_stream = new SimpleCharStream(stream, 1, 1); 4879 token_source = new PajekParserTokenManager(jj_input_stream); 4880 token = new Token(); 4881 jj_ntk = -1; 4882 jj_gen = 0; 4883 for (int i = 0; i < 0; i++) 4884 jj_la1[i] = -1; 4885 for (int i = 0; i < jj_2_rtns.length; i++) 4886 jj_2_rtns[i] = new JJCalls(); 4887 } 4888 4889 /** Reinitialise. */ 4890 public void ReInit(java.io.Reader stream) { 4891 jj_input_stream.ReInit(stream, 1, 1); 4892 token_source.ReInit(jj_input_stream); 4893 token = new Token(); 4894 jj_ntk = -1; 4895 jj_gen = 0; 4896 for (int i = 0; i < 0; i++) 4897 jj_la1[i] = -1; 4898 for (int i = 0; i < jj_2_rtns.length; i++) 4899 jj_2_rtns[i] = new JJCalls(); 4900 } 4901 4902 /** Constructor with generated Token Manager. */ 4903 public PajekParser(PajekParserTokenManager tm) { 4904 token_source = tm; 4905 token = new Token(); 4906 jj_ntk = -1; 4907 jj_gen = 0; 4908 for (int i = 0; i < 0; i++) 4909 jj_la1[i] = -1; 4910 for (int i = 0; i < jj_2_rtns.length; i++) 4911 jj_2_rtns[i] = new JJCalls(); 4912 } 4913 4914 /** Reinitialise. */ 4915 public void ReInit(PajekParserTokenManager tm) { 4916 token_source = tm; 4917 token = new Token(); 4918 jj_ntk = -1; 4919 jj_gen = 0; 4920 for (int i = 0; i < 0; i++) 4921 jj_la1[i] = -1; 4922 for (int i = 0; i < jj_2_rtns.length; i++) 4923 jj_2_rtns[i] = new JJCalls(); 4924 } 4925 4926 private Token jj_consume_token(int kind) throws ParseException { 4927 Token oldToken; 4928 if ((oldToken = token).next != null) 4929 token = token.next; 4930 else 4931 token = token.next = token_source.getNextToken(); 4932 jj_ntk = -1; 4933 if (token.kind == kind) { 4934 jj_gen++; 4935 if (++jj_gc > 100) { 4936 jj_gc = 0; 4937 for (int i = 0; i < jj_2_rtns.length; i++) { 4938 JJCalls c = jj_2_rtns[i]; 4939 while (c != null) { 4940 if (c.gen < jj_gen) 4941 c.first = null; 4942 c = c.next; 4943 } 4944 } 4945 } 4946 return token; 4947 } 4948 token = oldToken; 4949 jj_kind = kind; 4950 throw generateParseException(); 4951 } 4952 4953 static private final class LookaheadSuccess extends java.lang.Error { 4954 private static final long serialVersionUID = 8265735293607656893L; 4955 } 4956 4957 final private LookaheadSuccess jj_ls = new LookaheadSuccess(); 4958 4959 private boolean jj_scan_token(int kind) { 4960 if (jj_scanpos == jj_lastpos) { 4961 jj_la--; 4962 if (jj_scanpos.next == null) { 4963 jj_lastpos = jj_scanpos = jj_scanpos.next = token_source 4964 .getNextToken(); 4965 } else { 4966 jj_lastpos = jj_scanpos = jj_scanpos.next; 4967 } 4968 } else { 4969 jj_scanpos = jj_scanpos.next; 4970 } 4971 if (jj_rescan) { 4972 int i = 0; 4973 Token tok = token; 4974 while (tok != null && tok != jj_scanpos) { 4975 i++; 4976 tok = tok.next; 4977 } 4978 if (tok != null) 4979 jj_add_error_token(kind, i); 4980 } 4981 if (jj_scanpos.kind != kind) 4982 return true; 4983 if (jj_la == 0 && jj_scanpos == jj_lastpos) 4984 throw jj_ls; 4985 return false; 4986 } 4987 4988 /** Get the next Token. */ 4989 final public Token getNextToken() { 4990 if (token.next != null) 4991 token = token.next; 4992 else 4993 token = token.next = token_source.getNextToken(); 4994 jj_ntk = -1; 4995 jj_gen++; 4996 return token; 4997 } 4998 4999 /** Get the specific Token. */ 5000 final public Token getToken(int index) { 5001 Token t = token; 5002 for (int i = 0; i < index; i++) { 5003 if (t.next != null) 5004 t = t.next; 5005 else 5006 t = t.next = token_source.getNextToken(); 5007 } 5008 return t; 5009 } 5010 5011 private int jj_ntk() { 5012 if ((jj_nt = token.next) == null) 5013 return (jj_ntk = (token.next = token_source.getNextToken()).kind); 5014 else 5015 return (jj_ntk = jj_nt.kind); 5016 } 5017 5018 private java.util.List<int[]> jj_expentries = new java.util.ArrayList<int[]>(); 5019 private int[] jj_expentry; 5020 private int jj_kind = -1; 5021 private int[] jj_lasttokens = new int[100]; 5022 private int jj_endpos; 5023 5024 private void jj_add_error_token(int kind, int pos) { 5025 if (pos >= 100) 5026 return; 5027 if (pos == jj_endpos + 1) { 5028 jj_lasttokens[jj_endpos++] = kind; 5029 } else if (jj_endpos != 0) { 5030 jj_expentry = new int[jj_endpos]; 5031 for (int i = 0; i < jj_endpos; i++) { 5032 jj_expentry[i] = jj_lasttokens[i]; 5033 } 5034 jj_entries_loop: for (java.util.Iterator<?> it = jj_expentries 5035 .iterator(); it.hasNext();) { 5036 int[] oldentry = (int[]) (it.next()); 5037 if (oldentry.length == jj_expentry.length) { 5038 for (int i = 0; i < jj_expentry.length; i++) { 5039 if (oldentry[i] != jj_expentry[i]) { 5040 continue jj_entries_loop; 5041 } 5042 } 5043 jj_expentries.add(jj_expentry); 5044 break jj_entries_loop; 5045 } 5046 } 5047 if (pos != 0) 5048 jj_lasttokens[(jj_endpos = pos) - 1] = kind; 5049 } 5050 } 5051 5052 /** Generate ParseException. */ 5053 public ParseException generateParseException() { 5054 jj_expentries.clear(); 5055 boolean[] la1tokens = new boolean[54]; 5056 if (jj_kind >= 0) { 5057 la1tokens[jj_kind] = true; 5058 jj_kind = -1; 5059 } 5060 for (int i = 0; i < 0; i++) { 5061 if (jj_la1[i] == jj_gen) { 5062 for (int j = 0; j < 32; j++) { 5063 if ((jj_la1_0[i] & (1 << j)) != 0) { 5064 la1tokens[j] = true; 5065 } 5066 if ((jj_la1_1[i] & (1 << j)) != 0) { 5067 la1tokens[32 + j] = true; 5068 } 5069 } 5070 } 5071 } 5072 for (int i = 0; i < 54; i++) { 5073 if (la1tokens[i]) { 5074 jj_expentry = new int[1]; 5075 jj_expentry[0] = i; 5076 jj_expentries.add(jj_expentry); 5077 } 5078 } 5079 jj_endpos = 0; 5080 jj_rescan_token(); 5081 jj_add_error_token(0, 0); 5082 int[][] exptokseq = new int[jj_expentries.size()][]; 5083 for (int i = 0; i < jj_expentries.size(); i++) { 5084 exptokseq[i] = jj_expentries.get(i); 5085 } 5086 return new ParseException(token, exptokseq, tokenImage); 5087 } 5088 5089 /** Enable tracing. */ 5090 final public void enable_tracing() { 5091 } 5092 5093 /** Disable tracing. */ 5094 final public void disable_tracing() { 5095 } 5096 5097 private void jj_rescan_token() { 5098 jj_rescan = true; 5099 for (int i = 0; i < 182; i++) { 5100 try { 5101 JJCalls p = jj_2_rtns[i]; 5102 do { 5103 if (p.gen > jj_gen) { 5104 jj_la = p.arg; 5105 jj_lastpos = jj_scanpos = p.first; 5106 switch (i) { 5107 case 0: 5108 jj_3_1(); 5109 break; 5110 case 1: 5111 jj_3_2(); 5112 break; 5113 case 2: 5114 jj_3_3(); 5115 break; 5116 case 3: 5117 jj_3_4(); 5118 break; 5119 case 4: 5120 jj_3_5(); 5121 break; 5122 case 5: 5123 jj_3_6(); 5124 break; 5125 case 6: 5126 jj_3_7(); 5127 break; 5128 case 7: 5129 jj_3_8(); 5130 break; 5131 case 8: 5132 jj_3_9(); 5133 break; 5134 case 9: 5135 jj_3_10(); 5136 break; 5137 case 10: 5138 jj_3_11(); 5139 break; 5140 case 11: 5141 jj_3_12(); 5142 break; 5143 case 12: 5144 jj_3_13(); 5145 break; 5146 case 13: 5147 jj_3_14(); 5148 break; 5149 case 14: 5150 jj_3_15(); 5151 break; 5152 case 15: 5153 jj_3_16(); 5154 break; 5155 case 16: 5156 jj_3_17(); 5157 break; 5158 case 17: 5159 jj_3_18(); 5160 break; 5161 case 18: 5162 jj_3_19(); 5163 break; 5164 case 19: 5165 jj_3_20(); 5166 break; 5167 case 20: 5168 jj_3_21(); 5169 break; 5170 case 21: 5171 jj_3_22(); 5172 break; 5173 case 22: 5174 jj_3_23(); 5175 break; 5176 case 23: 5177 jj_3_24(); 5178 break; 5179 case 24: 5180 jj_3_25(); 5181 break; 5182 case 25: 5183 jj_3_26(); 5184 break; 5185 case 26: 5186 jj_3_27(); 5187 break; 5188 case 27: 5189 jj_3_28(); 5190 break; 5191 case 28: 5192 jj_3_29(); 5193 break; 5194 case 29: 5195 jj_3_30(); 5196 break; 5197 case 30: 5198 jj_3_31(); 5199 break; 5200 case 31: 5201 jj_3_32(); 5202 break; 5203 case 32: 5204 jj_3_33(); 5205 break; 5206 case 33: 5207 jj_3_34(); 5208 break; 5209 case 34: 5210 jj_3_35(); 5211 break; 5212 case 35: 5213 jj_3_36(); 5214 break; 5215 case 36: 5216 jj_3_37(); 5217 break; 5218 case 37: 5219 jj_3_38(); 5220 break; 5221 case 38: 5222 jj_3_39(); 5223 break; 5224 case 39: 5225 jj_3_40(); 5226 break; 5227 case 40: 5228 jj_3_41(); 5229 break; 5230 case 41: 5231 jj_3_42(); 5232 break; 5233 case 42: 5234 jj_3_43(); 5235 break; 5236 case 43: 5237 jj_3_44(); 5238 break; 5239 case 44: 5240 jj_3_45(); 5241 break; 5242 case 45: 5243 jj_3_46(); 5244 break; 5245 case 46: 5246 jj_3_47(); 5247 break; 5248 case 47: 5249 jj_3_48(); 5250 break; 5251 case 48: 5252 jj_3_49(); 5253 break; 5254 case 49: 5255 jj_3_50(); 5256 break; 5257 case 50: 5258 jj_3_51(); 5259 break; 5260 case 51: 5261 jj_3_52(); 5262 break; 5263 case 52: 5264 jj_3_53(); 5265 break; 5266 case 53: 5267 jj_3_54(); 5268 break; 5269 case 54: 5270 jj_3_55(); 5271 break; 5272 case 55: 5273 jj_3_56(); 5274 break; 5275 case 56: 5276 jj_3_57(); 5277 break; 5278 case 57: 5279 jj_3_58(); 5280 break; 5281 case 58: 5282 jj_3_59(); 5283 break; 5284 case 59: 5285 jj_3_60(); 5286 break; 5287 case 60: 5288 jj_3_61(); 5289 break; 5290 case 61: 5291 jj_3_62(); 5292 break; 5293 case 62: 5294 jj_3_63(); 5295 break; 5296 case 63: 5297 jj_3_64(); 5298 break; 5299 case 64: 5300 jj_3_65(); 5301 break; 5302 case 65: 5303 jj_3_66(); 5304 break; 5305 case 66: 5306 jj_3_67(); 5307 break; 5308 case 67: 5309 jj_3_68(); 5310 break; 5311 case 68: 5312 jj_3_69(); 5313 break; 5314 case 69: 5315 jj_3_70(); 5316 break; 5317 case 70: 5318 jj_3_71(); 5319 break; 5320 case 71: 5321 jj_3_72(); 5322 break; 5323 case 72: 5324 jj_3_73(); 5325 break; 5326 case 73: 5327 jj_3_74(); 5328 break; 5329 case 74: 5330 jj_3_75(); 5331 break; 5332 case 75: 5333 jj_3_76(); 5334 break; 5335 case 76: 5336 jj_3_77(); 5337 break; 5338 case 77: 5339 jj_3_78(); 5340 break; 5341 case 78: 5342 jj_3_79(); 5343 break; 5344 case 79: 5345 jj_3_80(); 5346 break; 5347 case 80: 5348 jj_3_81(); 5349 break; 5350 case 81: 5351 jj_3_82(); 5352 break; 5353 case 82: 5354 jj_3_83(); 5355 break; 5356 case 83: 5357 jj_3_84(); 5358 break; 5359 case 84: 5360 jj_3_85(); 5361 break; 5362 case 85: 5363 jj_3_86(); 5364 break; 5365 case 86: 5366 jj_3_87(); 5367 break; 5368 case 87: 5369 jj_3_88(); 5370 break; 5371 case 88: 5372 jj_3_89(); 5373 break; 5374 case 89: 5375 jj_3_90(); 5376 break; 5377 case 90: 5378 jj_3_91(); 5379 break; 5380 case 91: 5381 jj_3_92(); 5382 break; 5383 case 92: 5384 jj_3_93(); 5385 break; 5386 case 93: 5387 jj_3_94(); 5388 break; 5389 case 94: 5390 jj_3_95(); 5391 break; 5392 case 95: 5393 jj_3_96(); 5394 break; 5395 case 96: 5396 jj_3_97(); 5397 break; 5398 case 97: 5399 jj_3_98(); 5400 break; 5401 case 98: 5402 jj_3_99(); 5403 break; 5404 case 99: 5405 jj_3_100(); 5406 break; 5407 case 100: 5408 jj_3_101(); 5409 break; 5410 case 101: 5411 jj_3_102(); 5412 break; 5413 case 102: 5414 jj_3_103(); 5415 break; 5416 case 103: 5417 jj_3_104(); 5418 break; 5419 case 104: 5420 jj_3_105(); 5421 break; 5422 case 105: 5423 jj_3_106(); 5424 break; 5425 case 106: 5426 jj_3_107(); 5427 break; 5428 case 107: 5429 jj_3_108(); 5430 break; 5431 case 108: 5432 jj_3_109(); 5433 break; 5434 case 109: 5435 jj_3_110(); 5436 break; 5437 case 110: 5438 jj_3_111(); 5439 break; 5440 case 111: 5441 jj_3_112(); 5442 break; 5443 case 112: 5444 jj_3_113(); 5445 break; 5446 case 113: 5447 jj_3_114(); 5448 break; 5449 case 114: 5450 jj_3_115(); 5451 break; 5452 case 115: 5453 jj_3_116(); 5454 break; 5455 case 116: 5456 jj_3_117(); 5457 break; 5458 case 117: 5459 jj_3_118(); 5460 break; 5461 case 118: 5462 jj_3_119(); 5463 break; 5464 case 119: 5465 jj_3_120(); 5466 break; 5467 case 120: 5468 jj_3_121(); 5469 break; 5470 case 121: 5471 jj_3_122(); 5472 break; 5473 case 122: 5474 jj_3_123(); 5475 break; 5476 case 123: 5477 jj_3_124(); 5478 break; 5479 case 124: 5480 jj_3_125(); 5481 break; 5482 case 125: 5483 jj_3_126(); 5484 break; 5485 case 126: 5486 jj_3_127(); 5487 break; 5488 case 127: 5489 jj_3_128(); 5490 break; 5491 case 128: 5492 jj_3_129(); 5493 break; 5494 case 129: 5495 jj_3_130(); 5496 break; 5497 case 130: 5498 jj_3_131(); 5499 break; 5500 case 131: 5501 jj_3_132(); 5502 break; 5503 case 132: 5504 jj_3_133(); 5505 break; 5506 case 133: 5507 jj_3_134(); 5508 break; 5509 case 134: 5510 jj_3_135(); 5511 break; 5512 case 135: 5513 jj_3_136(); 5514 break; 5515 case 136: 5516 jj_3_137(); 5517 break; 5518 case 137: 5519 jj_3_138(); 5520 break; 5521 case 138: 5522 jj_3_139(); 5523 break; 5524 case 139: 5525 jj_3_140(); 5526 break; 5527 case 140: 5528 jj_3_141(); 5529 break; 5530 case 141: 5531 jj_3_142(); 5532 break; 5533 case 142: 5534 jj_3_143(); 5535 break; 5536 case 143: 5537 jj_3_144(); 5538 break; 5539 case 144: 5540 jj_3_145(); 5541 break; 5542 case 145: 5543 jj_3_146(); 5544 break; 5545 case 146: 5546 jj_3_147(); 5547 break; 5548 case 147: 5549 jj_3_148(); 5550 break; 5551 case 148: 5552 jj_3_149(); 5553 break; 5554 case 149: 5555 jj_3_150(); 5556 break; 5557 case 150: 5558 jj_3_151(); 5559 break; 5560 case 151: 5561 jj_3_152(); 5562 break; 5563 case 152: 5564 jj_3_153(); 5565 break; 5566 case 153: 5567 jj_3_154(); 5568 break; 5569 case 154: 5570 jj_3_155(); 5571 break; 5572 case 155: 5573 jj_3_156(); 5574 break; 5575 case 156: 5576 jj_3_157(); 5577 break; 5578 case 157: 5579 jj_3_158(); 5580 break; 5581 case 158: 5582 jj_3_159(); 5583 break; 5584 case 159: 5585 jj_3_160(); 5586 break; 5587 case 160: 5588 jj_3_161(); 5589 break; 5590 case 161: 5591 jj_3_162(); 5592 break; 5593 case 162: 5594 jj_3_163(); 5595 break; 5596 case 163: 5597 jj_3_164(); 5598 break; 5599 case 164: 5600 jj_3_165(); 5601 break; 5602 case 165: 5603 jj_3_166(); 5604 break; 5605 case 166: 5606 jj_3_167(); 5607 break; 5608 case 167: 5609 jj_3_168(); 5610 break; 5611 case 168: 5612 jj_3_169(); 5613 break; 5614 case 169: 5615 jj_3_170(); 5616 break; 5617 case 170: 5618 jj_3_171(); 5619 break; 5620 case 171: 5621 jj_3_172(); 5622 break; 5623 case 172: 5624 jj_3_173(); 5625 break; 5626 case 173: 5627 jj_3_174(); 5628 break; 5629 case 174: 5630 jj_3_175(); 5631 break; 5632 case 175: 5633 jj_3_176(); 5634 break; 5635 case 176: 5636 jj_3_177(); 5637 break; 5638 case 177: 5639 jj_3_178(); 5640 break; 5641 case 178: 5642 jj_3_179(); 5643 break; 5644 case 179: 5645 jj_3_180(); 5646 break; 5647 case 180: 5648 jj_3_181(); 5649 break; 5650 case 181: 5651 jj_3_182(); 5652 break; 5653 } 5654 } 5655 p = p.next; 5656 } while (p != null); 5657 } catch (LookaheadSuccess ls) { 5658 } 5659 } 5660 jj_rescan = false; 5661 } 5662 5663 private void jj_save(int index, int xla) { 5664 JJCalls p = jj_2_rtns[index]; 5665 while (p.gen > jj_gen) { 5666 if (p.next == null) { 5667 p = p.next = new JJCalls(); 5668 break; 5669 } 5670 p = p.next; 5671 } 5672 p.gen = jj_gen + xla - jj_la; 5673 p.first = token; 5674 p.arg = xla; 5675 } 5676 5677 static final class JJCalls { 5678 int gen; 5679 Token first; 5680 int arg; 5681 JJCalls next; 5682 } 5683 5684}