src/monkey/seaspider/org/gnunet/seaspider/Seaspider.java

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