contrib/gnunet-tree-builder/GNUnetParser.java

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