From 5714820bc45334aa17d9613d4f0c864ac368b74b Mon Sep 17 00:00:00 2001 From: "Safey A.Halim" Date: Tue, 14 Sep 2010 12:19:34 +0000 Subject: regenrate: shell script generating a Java Source Tree (using JTB and javacc) from C grammar file in $MAINDIR/src/monkey. gtb: shell script that runs regenerate script. GNUnetParser.java: should replace CParser.java resulted in from running regenerate script. (The program is responsible for parsing GNUnet source code: currently no expression database is generated out of it). --- contrib/gnunet-tree-builder/GNUnetParser.java | 5616 +++++++++++++++++++++++++ contrib/gnunet-tree-builder/gtb | 6 + contrib/gnunet-tree-builder/regenerate | 20 + 3 files changed, 5642 insertions(+) create mode 100644 contrib/gnunet-tree-builder/GNUnetParser.java create mode 100755 contrib/gnunet-tree-builder/gtb create mode 100755 contrib/gnunet-tree-builder/regenerate diff --git a/contrib/gnunet-tree-builder/GNUnetParser.java b/contrib/gnunet-tree-builder/GNUnetParser.java new file mode 100644 index 000000000..d1b204c7d --- /dev/null +++ b/contrib/gnunet-tree-builder/GNUnetParser.java @@ -0,0 +1,5616 @@ +package org.gnunet.monkey.parser; +/* Generated By:JavaCC: Do not edit this line. CParser.java */ +import java.io.File; +import java.io.FileFilter; +import java.io.FileInputStream; +import java.io.FileNotFoundException; +import org.gnunet.monkey.parser.nodes.*; + +public class GNUnetParser implements CParserConstants { + private static final boolean DEBUG = false; + + public static void main(String args[]) + { + GNUnetParser parser = null; + boolean isFirstFile = true; + int fileNotFoundCount = 0; + int successCount = 0; + int failureCount = 0; + System.out.println("C Parser Version 0.1Alpha: Reading from GNUnet source directory . . ."); + String gnunetSourcePath = System.getenv("MAINDIR") + "/src"; + + /* Filtering out files */ + FileFilter filter = new FileFilter() { + public boolean accept(File file) { + return file.isDirectory(); + } + }; + + /* File filter to get only source and header files */ + FileFilter sourceFilter = new FileFilter() { + public boolean accept(File file) { + String fileName = file.getName(); + return (fileName.endsWith(".c") || fileName.endsWith(".h")); + } + }; + + File[] dirArr = (new File(gnunetSourcePath)).listFiles(filter); + for (int i = 0; i < dirArr.length; i++) { + File dir = dirArr[i]; + File[] fileArr = dir.listFiles(sourceFilter); + for (int j = 0; j < fileArr.length; j++) { + try { + if (isFirstFile) { + parser = new GNUnetParser(new FileInputStream(fileArr[j].getPath())); + isFirstFile = false; + } + else + parser.ReInit(new FileInputStream(fileArr[j].getPath())); + } + catch (FileNotFoundException e) { + fileNotFoundCount++; + e.printStackTrace(); + } + try { + parser.TranslationUnit(); + System.out.println("File " + fileArr[j].getName() + " parsed successfully."); + successCount++; + } + catch (ParseException e) { + System.out.println("Encountered errors during parsing file " + fileArr[j].getName()); + failureCount++; + if (DEBUG) + e.printStackTrace(); + } + } + } + System.out.println(successCount + " parsed successfully."); + System.out.println("Failed to parse " + failureCount + " files."); + System.out.println(fileNotFoundCount + " files not found."); + } + + final public TranslationUnit TranslationUnit() throws ParseException { + NodeList n0 = new NodeList(); + ExternalDeclaration n1; + label_1: + while (true) { + n1 = ExternalDeclaration(); + n0.addNode(n1); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case REGISTER: + case UNSIGNED: + case TYPEDEF: + case DOUBLE: + case EXTERN: + case STRUCT: + case STATIC: + case SIGNED: + case UNION: + case CONST: + case FLOAT: + case SHORT: + case LONG: + case ENUM: + case AUTO: + case VOID: + case CHAR: + case INT: + case IDENTIFIER: + ; + break; + default: + jj_la1[0] = jj_gen; + break label_1; + } + } + n0.nodes.trimToSize(); + {if (true) return new TranslationUnit(n0);} + throw new Error("Missing return statement in function"); + } + + final public ExternalDeclaration ExternalDeclaration() throws ParseException { + NodeListOptional n0 = new NodeListOptional(); + StorageClassSpecifier n1; + NodeChoice n2; + FunctionDeclaration n3; + StructOrUnionSpecifier n4; + VariableDeclaration n5; + TypeDeclaration n6; + label_2: + while (true) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case EXTERN: + case STATIC: + ; + break; + default: + jj_la1[1] = jj_gen; + break label_2; + } + n1 = StorageClassSpecifier(); + n0.addNode(n1); + } + n0.nodes.trimToSize(); + if (jj_2_1(2147483647)) { + n3 = FunctionDeclaration(); + n2 = new NodeChoice(n3, 0); + } else if (jj_2_2(2147483647)) { + n4 = StructOrUnionSpecifier(); + n2 = new NodeChoice(n4, 1); + } else if (jj_2_3(2147483647)) { + n5 = VariableDeclaration(); + n2 = new NodeChoice(n5, 2); + } else if (jj_2_4(2147483647)) { + n6 = TypeDeclaration(); + n2 = new NodeChoice(n6, 3); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + {if (true) return new ExternalDeclaration(n0,n2);} + throw new Error("Missing return statement in function"); + } + + final public FunctionDeclaration FunctionDeclaration() throws ParseException { + TypeSpecifier n0; + NodeToken n1; + Token n2; + NodeToken n3; + Token n4; + NodeOptional n5 = new NodeOptional(); + ParameterList n6; + NodeToken n7; + Token n8; + NodeChoice n9; + NodeToken n10; + Token n11; + CompoundStatement n12; + n0 = TypeSpecifier(); + n2 = jj_consume_token(IDENTIFIER); + n1 = JTBToolkit.makeNodeToken(n2); + n4 = jj_consume_token(55); + n3 = JTBToolkit.makeNodeToken(n4); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case UNSIGNED: + case DOUBLE: + case STRUCT: + case SIGNED: + case UNION: + case CONST: + case FLOAT: + case SHORT: + case LONG: + case ENUM: + case VOID: + case CHAR: + case INT: + case IDENTIFIER: + n6 = ParameterList(); + n5.addNode(n6); + break; + default: + jj_la1[2] = jj_gen; + ; + } + n8 = jj_consume_token(56); + n7 = JTBToolkit.makeNodeToken(n8); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case 57: + n11 = jj_consume_token(57); + n10 = JTBToolkit.makeNodeToken(n11); + n9 = new NodeChoice(n10, 0); + break; + case 61: + n12 = CompoundStatement(); + n9 = new NodeChoice(n12, 1); + break; + default: + jj_la1[3] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + {if (true) return new FunctionDeclaration(n0,n1,n3,n5,n7,n9);} + throw new Error("Missing return statement in function"); + } + + final public StorageClassSpecifier StorageClassSpecifier() throws ParseException { + NodeChoice n0; + NodeToken n1; + Token n2; + NodeToken n3; + Token n4; + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case STATIC: + n2 = jj_consume_token(STATIC); + n1 = JTBToolkit.makeNodeToken(n2); + n0 = new NodeChoice(n1, 0); + break; + case EXTERN: + n4 = jj_consume_token(EXTERN); + n3 = JTBToolkit.makeNodeToken(n4); + n0 = new NodeChoice(n3, 1); + break; + default: + jj_la1[4] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + {if (true) return new StorageClassSpecifier(n0);} + throw new Error("Missing return statement in function"); + } + + final public TypeDeclaration TypeDeclaration() throws ParseException { + NodeToken n0; + Token n1; + NodeChoice n2; + DataType n3; + FunctionType n4; + NodeToken n5; + Token n6; + n1 = jj_consume_token(TYPEDEF); + n0 = JTBToolkit.makeNodeToken(n1); + if (jj_2_5(2147483647)) { + n3 = DataType(); + n2 = new NodeChoice(n3, 0); + } else { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case UNSIGNED: + case DOUBLE: + case STRUCT: + case SIGNED: + case UNION: + case CONST: + case FLOAT: + case SHORT: + case LONG: + case ENUM: + case VOID: + case CHAR: + case INT: + case IDENTIFIER: + n4 = FunctionType(); + n2 = new NodeChoice(n4, 1); + break; + default: + jj_la1[5] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + } + n6 = jj_consume_token(57); + n5 = JTBToolkit.makeNodeToken(n6); + {if (true) return new TypeDeclaration(n0,n2,n5);} + throw new Error("Missing return statement in function"); + } + + final public DataType DataType() throws ParseException { + StructOrUnionSpecifier n0; + NodeToken n1; + Token n2; + n0 = StructOrUnionSpecifier(); + n2 = jj_consume_token(IDENTIFIER); + n1 = JTBToolkit.makeNodeToken(n2); + {if (true) return new DataType(n0,n1);} + throw new Error("Missing return statement in function"); + } + + final public FunctionType FunctionType() throws ParseException { + TypeSpecifier n0; + NodeToken n1; + Token n2; + NodeToken n3; + Token n4; + NodeToken n5; + Token n6; + NodeToken n7; + Token n8; + NodeToken n9; + Token n10; + NodeOptional n11 = new NodeOptional(); + ParameterList n12; + NodeToken n13; + Token n14; + n0 = TypeSpecifier(); + n2 = jj_consume_token(55); + n1 = JTBToolkit.makeNodeToken(n2); + n4 = jj_consume_token(58); + n3 = JTBToolkit.makeNodeToken(n4); + n6 = jj_consume_token(IDENTIFIER); + n5 = JTBToolkit.makeNodeToken(n6); + n8 = jj_consume_token(56); + n7 = JTBToolkit.makeNodeToken(n8); + n10 = jj_consume_token(55); + n9 = JTBToolkit.makeNodeToken(n10); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case UNSIGNED: + case DOUBLE: + case STRUCT: + case SIGNED: + case UNION: + case CONST: + case FLOAT: + case SHORT: + case LONG: + case ENUM: + case VOID: + case CHAR: + case INT: + case IDENTIFIER: + n12 = ParameterList(); + n11.addNode(n12); + break; + default: + jj_la1[6] = jj_gen; + ; + } + n14 = jj_consume_token(56); + n13 = JTBToolkit.makeNodeToken(n14); + {if (true) return new FunctionType(n0,n1,n3,n5,n7,n9,n11,n13);} + throw new Error("Missing return statement in function"); + } + + final public ParameterList ParameterList() throws ParseException { + ParameterDeclaration n0; + NodeListOptional n1 = new NodeListOptional(); + NodeSequence n2; + NodeToken n3; + Token n4; + ParameterDeclaration n5; + NodeOptional n6 = new NodeOptional(); + NodeSequence n7; + NodeToken n8; + Token n9; + NodeToken n10; + Token n11; + n0 = ParameterDeclaration(); + label_3: + while (true) { + if (jj_2_6(2)) { + ; + } else { + break label_3; + } + n2 = new NodeSequence(2); + n4 = jj_consume_token(59); + n3 = JTBToolkit.makeNodeToken(n4); + n2.addNode(n3); + n5 = ParameterDeclaration(); + n2.addNode(n5); + n1.addNode(n2); + } + n1.nodes.trimToSize(); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case 59: + n7 = new NodeSequence(2); + n9 = jj_consume_token(59); + n8 = JTBToolkit.makeNodeToken(n9); + n7.addNode(n8); + n11 = jj_consume_token(60); + n10 = JTBToolkit.makeNodeToken(n11); + n7.addNode(n10); + n6.addNode(n7); + break; + default: + jj_la1[7] = jj_gen; + ; + } + {if (true) return new ParameterList(n0,n1,n6);} + throw new Error("Missing return statement in function"); + } + + final public ParameterDeclaration ParameterDeclaration() throws ParseException { + TypeSpecifier n0; + NodeToken n1; + Token n2; + NodeOptional n3 = new NodeOptional(); + Array n4; + n0 = TypeSpecifier(); + n2 = jj_consume_token(IDENTIFIER); + n1 = JTBToolkit.makeNodeToken(n2); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case 65: + n4 = Array(); + n3.addNode(n4); + break; + default: + jj_la1[8] = jj_gen; + ; + } + {if (true) return new ParameterDeclaration(n0,n1,n3);} + throw new Error("Missing return statement in function"); + } + + final public VariableDeclaration VariableDeclaration() throws ParseException { + VariableClassSpecifier n0; + TypeSpecifier n1; + InitDeclaratorList n2; + NodeToken n3; + Token n4; + n0 = VariableClassSpecifier(); + n1 = TypeSpecifier(); + n2 = InitDeclaratorList(); + n4 = jj_consume_token(57); + n3 = JTBToolkit.makeNodeToken(n4); + {if (true) return new VariableDeclaration(n0,n1,n2,n3);} + throw new Error("Missing return statement in function"); + } + + final public LocalVariableDeclaration LocalVariableDeclaration() throws ParseException { + NodeOptional n0 = new NodeOptional(); + NodeToken n1; + Token n2; + VariableDeclaration n3; + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case STATIC: + n2 = jj_consume_token(STATIC); + n1 = JTBToolkit.makeNodeToken(n2); + n0.addNode(n1); + break; + default: + jj_la1[9] = jj_gen; + ; + } + n3 = VariableDeclaration(); + {if (true) return new LocalVariableDeclaration(n0,n3);} + throw new Error("Missing return statement in function"); + } + + final public VariableClassSpecifier VariableClassSpecifier() throws ParseException { + NodeListOptional n0 = new NodeListOptional(); + NodeChoice n1; + NodeToken n2; + Token n3; + NodeToken n4; + Token n5; + label_4: + while (true) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case REGISTER: + case AUTO: + ; + break; + default: + jj_la1[10] = jj_gen; + break label_4; + } + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case AUTO: + n3 = jj_consume_token(AUTO); + n2 = JTBToolkit.makeNodeToken(n3); + n1 = new NodeChoice(n2, 0); + break; + case REGISTER: + n5 = jj_consume_token(REGISTER); + n4 = JTBToolkit.makeNodeToken(n5); + n1 = new NodeChoice(n4, 1); + break; + default: + jj_la1[11] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + n0.addNode(n1); + } + n0.nodes.trimToSize(); + {if (true) return new VariableClassSpecifier(n0);} + throw new Error("Missing return statement in function"); + } + + final public TypeSpecifier TypeSpecifier() throws ParseException { + NodeOptional n0 = new NodeOptional(); + NodeToken n1; + Token n2; + NodeChoice n3; + NodeToken n4; + Token n5; + NodeToken n6; + Token n7; + NodeSequence n8; + NodeToken n9; + Token n10; + NodeOptional n11 = new NodeOptional(); + NodeToken n12; + Token n13; + NodeToken n14; + Token n15; + NodeSequence n16; + NodeToken n17; + Token n18; + NodeOptional n19 = new NodeOptional(); + NodeToken n20; + Token n21; + NodeToken n22; + Token n23; + NodeToken n24; + Token n25; + NodeSequence n26; + NodeChoice n27; + NodeToken n28; + Token n29; + NodeToken n30; + Token n31; + NodeOptional n32 = new NodeOptional(); + NodeChoice n33; + NodeToken n34; + Token n35; + NodeSequence n36; + NodeToken n37; + Token n38; + NodeOptional n39; + NodeToken n40; + Token n41; + NodeToken n42; + Token n43; + NodeSequence n44; + NodeToken n45; + Token n46; + NodeOptional n47; + NodeToken n48; + Token n49; + StructOrUnionSpecifier n50; + EnumSpecifier n51; + NodeToken n52; + Token n53; + NodeOptional n54 = new NodeOptional(); + Pointer n55; + NodeOptional n56 = new NodeOptional(); + Array n57; + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case CONST: + n2 = jj_consume_token(CONST); + n1 = JTBToolkit.makeNodeToken(n2); + n0.addNode(n1); + break; + default: + jj_la1[12] = jj_gen; + ; + } + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case VOID: + n5 = jj_consume_token(VOID); + n4 = JTBToolkit.makeNodeToken(n5); + n3 = new NodeChoice(n4, 0); + break; + case CHAR: + n7 = jj_consume_token(CHAR); + n6 = JTBToolkit.makeNodeToken(n7); + n3 = new NodeChoice(n6, 1); + break; + case SHORT: + n8 = new NodeSequence(2); + n10 = jj_consume_token(SHORT); + n9 = JTBToolkit.makeNodeToken(n10); + n8.addNode(n9); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case INT: + n13 = jj_consume_token(INT); + n12 = JTBToolkit.makeNodeToken(n13); + n11.addNode(n12); + break; + default: + jj_la1[13] = jj_gen; + ; + } + n8.addNode(n11); + n3 = new NodeChoice(n8, 2); + break; + case INT: + n15 = jj_consume_token(INT); + n14 = JTBToolkit.makeNodeToken(n15); + n3 = new NodeChoice(n14, 3); + break; + case LONG: + n16 = new NodeSequence(2); + n18 = jj_consume_token(LONG); + n17 = JTBToolkit.makeNodeToken(n18); + n16.addNode(n17); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case LONG: + n21 = jj_consume_token(LONG); + n20 = JTBToolkit.makeNodeToken(n21); + n19.addNode(n20); + break; + default: + jj_la1[14] = jj_gen; + ; + } + n16.addNode(n19); + n3 = new NodeChoice(n16, 4); + break; + case FLOAT: + n23 = jj_consume_token(FLOAT); + n22 = JTBToolkit.makeNodeToken(n23); + n3 = new NodeChoice(n22, 5); + break; + case DOUBLE: + n25 = jj_consume_token(DOUBLE); + n24 = JTBToolkit.makeNodeToken(n25); + n3 = new NodeChoice(n24, 6); + break; + case UNSIGNED: + case SIGNED: + n26 = new NodeSequence(2); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case SIGNED: + n29 = jj_consume_token(SIGNED); + n28 = JTBToolkit.makeNodeToken(n29); + n27 = new NodeChoice(n28, 0); + break; + case UNSIGNED: + n31 = jj_consume_token(UNSIGNED); + n30 = JTBToolkit.makeNodeToken(n31); + n27 = new NodeChoice(n30, 1); + break; + default: + jj_la1[15] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + n26.addNode(n27); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case SHORT: + case LONG: + case CHAR: + case INT: + n39 = new NodeOptional(); + n47 = new NodeOptional(); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case CHAR: + n35 = jj_consume_token(CHAR); + n34 = JTBToolkit.makeNodeToken(n35); + n33 = new NodeChoice(n34, 0); + break; + case SHORT: + n36 = new NodeSequence(2); + n38 = jj_consume_token(SHORT); + n37 = JTBToolkit.makeNodeToken(n38); + n36.addNode(n37); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case INT: + n41 = jj_consume_token(INT); + n40 = JTBToolkit.makeNodeToken(n41); + n39.addNode(n40); + break; + default: + jj_la1[16] = jj_gen; + ; + } + n36.addNode(n39); + n33 = new NodeChoice(n36, 1); + break; + case INT: + n43 = jj_consume_token(INT); + n42 = JTBToolkit.makeNodeToken(n43); + n33 = new NodeChoice(n42, 2); + break; + case LONG: + n44 = new NodeSequence(2); + n46 = jj_consume_token(LONG); + n45 = JTBToolkit.makeNodeToken(n46); + n44.addNode(n45); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case LONG: + n49 = jj_consume_token(LONG); + n48 = JTBToolkit.makeNodeToken(n49); + n47.addNode(n48); + break; + default: + jj_la1[17] = jj_gen; + ; + } + n44.addNode(n47); + n33 = new NodeChoice(n44, 3); + break; + default: + jj_la1[18] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + n32.addNode(n33); + break; + default: + jj_la1[19] = jj_gen; + ; + } + n26.addNode(n32); + n3 = new NodeChoice(n26, 7); + break; + case STRUCT: + case UNION: + n50 = StructOrUnionSpecifier(); + n3 = new NodeChoice(n50, 8); + break; + case ENUM: + n51 = EnumSpecifier(); + n3 = new NodeChoice(n51, 9); + break; + case IDENTIFIER: + n53 = jj_consume_token(IDENTIFIER); + n52 = JTBToolkit.makeNodeToken(n53); + n3 = new NodeChoice(n52, 10); + break; + default: + jj_la1[20] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case 58: + n55 = Pointer(); + n54.addNode(n55); + break; + default: + jj_la1[21] = jj_gen; + ; + } + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case 65: + n57 = Array(); + n56.addNode(n57); + break; + default: + jj_la1[22] = jj_gen; + ; + } + {if (true) return new TypeSpecifier(n0,n3,n54,n56);} + throw new Error("Missing return statement in function"); + } + + final public NoIdentifierTypeSpecifier NoIdentifierTypeSpecifier() throws ParseException { + NodeOptional n0 = new NodeOptional(); + NodeToken n1; + Token n2; + NodeChoice n3; + NodeToken n4; + Token n5; + NodeToken n6; + Token n7; + NodeSequence n8; + NodeToken n9; + Token n10; + NodeOptional n11 = new NodeOptional(); + NodeToken n12; + Token n13; + NodeToken n14; + Token n15; + NodeSequence n16; + NodeToken n17; + Token n18; + NodeOptional n19 = new NodeOptional(); + NodeToken n20; + Token n21; + NodeToken n22; + Token n23; + NodeToken n24; + Token n25; + NodeSequence n26; + NodeChoice n27; + NodeToken n28; + Token n29; + NodeToken n30; + Token n31; + NodeOptional n32 = new NodeOptional(); + NodeChoice n33; + NodeToken n34; + Token n35; + NodeSequence n36; + NodeToken n37; + Token n38; + NodeOptional n39; + NodeToken n40; + Token n41; + NodeToken n42; + Token n43; + NodeSequence n44; + NodeToken n45; + Token n46; + NodeOptional n47; + NodeToken n48; + Token n49; + StructOrUnionSpecifier n50; + EnumSpecifier n51; + NodeOptional n52 = new NodeOptional(); + Pointer n53; + NodeOptional n54 = new NodeOptional(); + Array n55; + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case CONST: + n2 = jj_consume_token(CONST); + n1 = JTBToolkit.makeNodeToken(n2); + n0.addNode(n1); + break; + default: + jj_la1[23] = jj_gen; + ; + } + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case VOID: + n5 = jj_consume_token(VOID); + n4 = JTBToolkit.makeNodeToken(n5); + n3 = new NodeChoice(n4, 0); + break; + case CHAR: + n7 = jj_consume_token(CHAR); + n6 = JTBToolkit.makeNodeToken(n7); + n3 = new NodeChoice(n6, 1); + break; + case SHORT: + n8 = new NodeSequence(2); + n10 = jj_consume_token(SHORT); + n9 = JTBToolkit.makeNodeToken(n10); + n8.addNode(n9); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case INT: + n13 = jj_consume_token(INT); + n12 = JTBToolkit.makeNodeToken(n13); + n11.addNode(n12); + break; + default: + jj_la1[24] = jj_gen; + ; + } + n8.addNode(n11); + n3 = new NodeChoice(n8, 2); + break; + case INT: + n15 = jj_consume_token(INT); + n14 = JTBToolkit.makeNodeToken(n15); + n3 = new NodeChoice(n14, 3); + break; + case LONG: + n16 = new NodeSequence(2); + n18 = jj_consume_token(LONG); + n17 = JTBToolkit.makeNodeToken(n18); + n16.addNode(n17); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case LONG: + n21 = jj_consume_token(LONG); + n20 = JTBToolkit.makeNodeToken(n21); + n19.addNode(n20); + break; + default: + jj_la1[25] = jj_gen; + ; + } + n16.addNode(n19); + n3 = new NodeChoice(n16, 4); + break; + case FLOAT: + n23 = jj_consume_token(FLOAT); + n22 = JTBToolkit.makeNodeToken(n23); + n3 = new NodeChoice(n22, 5); + break; + case DOUBLE: + n25 = jj_consume_token(DOUBLE); + n24 = JTBToolkit.makeNodeToken(n25); + n3 = new NodeChoice(n24, 6); + break; + case UNSIGNED: + case SIGNED: + n26 = new NodeSequence(2); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case SIGNED: + n29 = jj_consume_token(SIGNED); + n28 = JTBToolkit.makeNodeToken(n29); + n27 = new NodeChoice(n28, 0); + break; + case UNSIGNED: + n31 = jj_consume_token(UNSIGNED); + n30 = JTBToolkit.makeNodeToken(n31); + n27 = new NodeChoice(n30, 1); + break; + default: + jj_la1[26] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + n26.addNode(n27); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case SHORT: + case LONG: + case CHAR: + case INT: + n39 = new NodeOptional(); + n47 = new NodeOptional(); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case CHAR: + n35 = jj_consume_token(CHAR); + n34 = JTBToolkit.makeNodeToken(n35); + n33 = new NodeChoice(n34, 0); + break; + case SHORT: + n36 = new NodeSequence(2); + n38 = jj_consume_token(SHORT); + n37 = JTBToolkit.makeNodeToken(n38); + n36.addNode(n37); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case INT: + n41 = jj_consume_token(INT); + n40 = JTBToolkit.makeNodeToken(n41); + n39.addNode(n40); + break; + default: + jj_la1[27] = jj_gen; + ; + } + n36.addNode(n39); + n33 = new NodeChoice(n36, 1); + break; + case INT: + n43 = jj_consume_token(INT); + n42 = JTBToolkit.makeNodeToken(n43); + n33 = new NodeChoice(n42, 2); + break; + case LONG: + n44 = new NodeSequence(2); + n46 = jj_consume_token(LONG); + n45 = JTBToolkit.makeNodeToken(n46); + n44.addNode(n45); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case LONG: + n49 = jj_consume_token(LONG); + n48 = JTBToolkit.makeNodeToken(n49); + n47.addNode(n48); + break; + default: + jj_la1[28] = jj_gen; + ; + } + n44.addNode(n47); + n33 = new NodeChoice(n44, 3); + break; + default: + jj_la1[29] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + n32.addNode(n33); + break; + default: + jj_la1[30] = jj_gen; + ; + } + n26.addNode(n32); + n3 = new NodeChoice(n26, 7); + break; + case STRUCT: + case UNION: + n50 = StructOrUnionSpecifier(); + n3 = new NodeChoice(n50, 8); + break; + case ENUM: + n51 = EnumSpecifier(); + n3 = new NodeChoice(n51, 9); + break; + default: + jj_la1[31] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case 58: + n53 = Pointer(); + n52.addNode(n53); + break; + default: + jj_la1[32] = jj_gen; + ; + } + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case 65: + n55 = Array(); + n54.addNode(n55); + break; + default: + jj_la1[33] = jj_gen; + ; + } + {if (true) return new NoIdentifierTypeSpecifier(n0,n3,n52,n54);} + throw new Error("Missing return statement in function"); + } + + final public StructOrUnionSpecifier StructOrUnionSpecifier() throws ParseException { + NodeChoice n0; + NodeSequence n1; + StructOrUnion n2; + NodeOptional n3 = new NodeOptional(); + NodeToken n4; + Token n5; + NodeToken n6; + Token n7; + StructDeclarationList n8; + NodeToken n9; + Token n10; + NodeSequence n11; + StructOrUnion n12; + NodeToken n13; + Token n14; + if (jj_2_7(3)) { + n1 = new NodeSequence(6); + n2 = StructOrUnion(); + n1.addNode(n2); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case IDENTIFIER: + n5 = jj_consume_token(IDENTIFIER); + n4 = JTBToolkit.makeNodeToken(n5); + n3.addNode(n4); + break; + default: + jj_la1[34] = jj_gen; + ; + } + n1.addNode(n3); + n7 = jj_consume_token(61); + n6 = JTBToolkit.makeNodeToken(n7); + n1.addNode(n6); + n8 = StructDeclarationList(); + n1.addNode(n8); + n10 = jj_consume_token(62); + n9 = JTBToolkit.makeNodeToken(n10); + n1.addNode(n9); + n0 = new NodeChoice(n1, 0); + } else { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case STRUCT: + case UNION: + n11 = new NodeSequence(2); + n12 = StructOrUnion(); + n11.addNode(n12); + n14 = jj_consume_token(IDENTIFIER); + n13 = JTBToolkit.makeNodeToken(n14); + n11.addNode(n13); + n0 = new NodeChoice(n11, 1); + break; + default: + jj_la1[35] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + } + {if (true) return new StructOrUnionSpecifier(n0);} + throw new Error("Missing return statement in function"); + } + + final public StructOrUnion StructOrUnion() throws ParseException { + NodeChoice n0; + NodeToken n1; + Token n2; + NodeToken n3; + Token n4; + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case STRUCT: + n2 = jj_consume_token(STRUCT); + n1 = JTBToolkit.makeNodeToken(n2); + n0 = new NodeChoice(n1, 0); + break; + case UNION: + n4 = jj_consume_token(UNION); + n3 = JTBToolkit.makeNodeToken(n4); + n0 = new NodeChoice(n3, 1); + break; + default: + jj_la1[36] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + {if (true) return new StructOrUnion(n0);} + throw new Error("Missing return statement in function"); + } + + final public StructDeclarationList StructDeclarationList() throws ParseException { + NodeList n0 = new NodeList(); + StructDeclaration n1; + label_5: + while (true) { + n1 = StructDeclaration(); + n0.addNode(n1); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case UNSIGNED: + case DOUBLE: + case STRUCT: + case SIGNED: + case UNION: + case CONST: + case FLOAT: + case SHORT: + case LONG: + case ENUM: + case VOID: + case CHAR: + case INT: + case IDENTIFIER: + ; + break; + default: + jj_la1[37] = jj_gen; + break label_5; + } + } + n0.nodes.trimToSize(); + {if (true) return new StructDeclarationList(n0);} + throw new Error("Missing return statement in function"); + } + + final public InitDeclaratorList InitDeclaratorList() throws ParseException { + InitDeclarator n0; + NodeListOptional n1 = new NodeListOptional(); + NodeSequence n2; + NodeToken n3; + Token n4; + InitDeclarator n5; + n0 = InitDeclarator(); + label_6: + while (true) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case 59: + ; + break; + default: + jj_la1[38] = jj_gen; + break label_6; + } + n2 = new NodeSequence(2); + n4 = jj_consume_token(59); + n3 = JTBToolkit.makeNodeToken(n4); + n2.addNode(n3); + n5 = InitDeclarator(); + n2.addNode(n5); + n1.addNode(n2); + } + n1.nodes.trimToSize(); + {if (true) return new InitDeclaratorList(n0,n1);} + throw new Error("Missing return statement in function"); + } + + final public InitDeclarator InitDeclarator() throws ParseException { + NodeToken n0; + Token n1; + NodeOptional n2 = new NodeOptional(); + Array n3; + NodeOptional n4 = new NodeOptional(); + NodeSequence n5; + NodeToken n6; + Token n7; + Initializer n8; + n1 = jj_consume_token(IDENTIFIER); + n0 = JTBToolkit.makeNodeToken(n1); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case 65: + n3 = Array(); + n2.addNode(n3); + break; + default: + jj_la1[39] = jj_gen; + ; + } + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case 63: + n5 = new NodeSequence(2); + n7 = jj_consume_token(63); + n6 = JTBToolkit.makeNodeToken(n7); + n5.addNode(n6); + n8 = Initializer(); + n5.addNode(n8); + n4.addNode(n5); + break; + default: + jj_la1[40] = jj_gen; + ; + } + {if (true) return new InitDeclarator(n0,n2,n4);} + throw new Error("Missing return statement in function"); + } + + final public StructDeclaration StructDeclaration() throws ParseException { + TypeSpecifier n0; + NodeToken n1; + Token n2; + NodeOptional n3 = new NodeOptional(); + NodeChoice n4; + Array n5; + NodeSequence n6; + NodeToken n7; + Token n8; + ConstantExpression n9; + NodeOptional n10 = new NodeOptional(); + NodeToken n11; + Token n12; + NodeToken n13; + Token n14; + n0 = TypeSpecifier(); + n2 = jj_consume_token(IDENTIFIER); + n1 = JTBToolkit.makeNodeToken(n2); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case 64: + case 65: + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case 65: + n5 = Array(); + n4 = new NodeChoice(n5, 0); + break; + case 64: + n6 = new NodeSequence(2); + n8 = jj_consume_token(64); + n7 = JTBToolkit.makeNodeToken(n8); + n6.addNode(n7); + n9 = ConstantExpression(); + n6.addNode(n9); + n4 = new NodeChoice(n6, 1); + break; + default: + jj_la1[41] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + n3.addNode(n4); + break; + default: + jj_la1[42] = jj_gen; + ; + } + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case IDENTIFIER: + n12 = jj_consume_token(IDENTIFIER); + n11 = JTBToolkit.makeNodeToken(n12); + n10.addNode(n11); + break; + default: + jj_la1[43] = jj_gen; + ; + } + n14 = jj_consume_token(57); + n13 = JTBToolkit.makeNodeToken(n14); + {if (true) return new StructDeclaration(n0,n1,n3,n10,n13);} + throw new Error("Missing return statement in function"); + } + + final public EnumSpecifier EnumSpecifier() throws ParseException { + NodeToken n0; + Token n1; + NodeChoice n2; + NodeSequence n3; + NodeOptional n4 = new NodeOptional(); + NodeToken n5; + Token n6; + NodeToken n7; + Token n8; + EnumeratorList n9; + NodeToken n10; + Token n11; + NodeToken n12; + Token n13; + n1 = jj_consume_token(ENUM); + n0 = JTBToolkit.makeNodeToken(n1); + if (jj_2_8(3)) { + n3 = new NodeSequence(5); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case IDENTIFIER: + n6 = jj_consume_token(IDENTIFIER); + n5 = JTBToolkit.makeNodeToken(n6); + n4.addNode(n5); + break; + default: + jj_la1[44] = jj_gen; + ; + } + n3.addNode(n4); + n8 = jj_consume_token(61); + n7 = JTBToolkit.makeNodeToken(n8); + n3.addNode(n7); + n9 = EnumeratorList(); + n3.addNode(n9); + n11 = jj_consume_token(62); + n10 = JTBToolkit.makeNodeToken(n11); + n3.addNode(n10); + n2 = new NodeChoice(n3, 0); + } else { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case IDENTIFIER: + n13 = jj_consume_token(IDENTIFIER); + n12 = JTBToolkit.makeNodeToken(n13); + n2 = new NodeChoice(n12, 1); + break; + default: + jj_la1[45] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + } + {if (true) return new EnumSpecifier(n0,n2);} + throw new Error("Missing return statement in function"); + } + + final public EnumeratorList EnumeratorList() throws ParseException { + Enumerator n0; + NodeListOptional n1 = new NodeListOptional(); + NodeSequence n2; + NodeToken n3; + Token n4; + Enumerator n5; + n0 = Enumerator(); + label_7: + while (true) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case 59: + ; + break; + default: + jj_la1[46] = jj_gen; + break label_7; + } + n2 = new NodeSequence(2); + n4 = jj_consume_token(59); + n3 = JTBToolkit.makeNodeToken(n4); + n2.addNode(n3); + n5 = Enumerator(); + n2.addNode(n5); + n1.addNode(n2); + } + n1.nodes.trimToSize(); + {if (true) return new EnumeratorList(n0,n1);} + throw new Error("Missing return statement in function"); + } + + final public Enumerator Enumerator() throws ParseException { + NodeToken n0; + Token n1; + NodeOptional n2 = new NodeOptional(); + NodeSequence n3; + NodeToken n4; + Token n5; + ConstantExpression n6; + n1 = jj_consume_token(IDENTIFIER); + n0 = JTBToolkit.makeNodeToken(n1); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case 63: + n3 = new NodeSequence(2); + n5 = jj_consume_token(63); + n4 = JTBToolkit.makeNodeToken(n5); + n3.addNode(n4); + n6 = ConstantExpression(); + n3.addNode(n6); + n2.addNode(n3); + break; + default: + jj_la1[47] = jj_gen; + ; + } + {if (true) return new Enumerator(n0,n2);} + throw new Error("Missing return statement in function"); + } + + final public Pointer Pointer() throws ParseException { + NodeToken n0; + Token n1; + NodeOptional n2 = new NodeOptional(); + NodeToken n3; + Token n4; + NodeOptional n5 = new NodeOptional(); + Pointer n6; + n1 = jj_consume_token(58); + n0 = JTBToolkit.makeNodeToken(n1); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case CONST: + n4 = jj_consume_token(CONST); + n3 = JTBToolkit.makeNodeToken(n4); + n2.addNode(n3); + break; + default: + jj_la1[48] = jj_gen; + ; + } + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case 58: + n6 = Pointer(); + n5.addNode(n6); + break; + default: + jj_la1[49] = jj_gen; + ; + } + {if (true) return new Pointer(n0,n2,n5);} + throw new Error("Missing return statement in function"); + } + + final public IdentifierList IdentifierList() throws ParseException { + NodeToken n0; + Token n1; + NodeListOptional n2 = new NodeListOptional(); + NodeSequence n3; + NodeToken n4; + Token n5; + NodeToken n6; + Token n7; + n1 = jj_consume_token(IDENTIFIER); + n0 = JTBToolkit.makeNodeToken(n1); + label_8: + while (true) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case 59: + ; + break; + default: + jj_la1[50] = jj_gen; + break label_8; + } + n3 = new NodeSequence(2); + n5 = jj_consume_token(59); + n4 = JTBToolkit.makeNodeToken(n5); + n3.addNode(n4); + n7 = jj_consume_token(IDENTIFIER); + n6 = JTBToolkit.makeNodeToken(n7); + n3.addNode(n6); + n2.addNode(n3); + } + n2.nodes.trimToSize(); + {if (true) return new IdentifierList(n0,n2);} + throw new Error("Missing return statement in function"); + } + + final public Initializer Initializer() throws ParseException { + NodeChoice n0; + AssignmentExpression n1; + NodeSequence n2; + NodeToken n3; + Token n4; + InitializerList n5; + NodeOptional n6 = new NodeOptional(); + NodeToken n7; + Token n8; + NodeToken n9; + Token n10; + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case INTEGER_LITERAL: + case FLOATING_POINT_LITERAL: + case CHARACTER_LITERAL: + case STRING_LITERAL: + case SIZEOF: + case IDENTIFIER: + case 55: + case 58: + case 82: + case 91: + case 92: + case 95: + case 96: + case 97: + case 98: + n1 = AssignmentExpression(); + n0 = new NodeChoice(n1, 0); + break; + case 61: + n2 = new NodeSequence(4); + n4 = jj_consume_token(61); + n3 = JTBToolkit.makeNodeToken(n4); + n2.addNode(n3); + n5 = InitializerList(); + n2.addNode(n5); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case 59: + n8 = jj_consume_token(59); + n7 = JTBToolkit.makeNodeToken(n8); + n6.addNode(n7); + break; + default: + jj_la1[51] = jj_gen; + ; + } + n2.addNode(n6); + n10 = jj_consume_token(62); + n9 = JTBToolkit.makeNodeToken(n10); + n2.addNode(n9); + n0 = new NodeChoice(n2, 1); + break; + default: + jj_la1[52] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + {if (true) return new Initializer(n0);} + throw new Error("Missing return statement in function"); + } + + final public InitializerList InitializerList() throws ParseException { + Initializer n0; + NodeListOptional n1 = new NodeListOptional(); + NodeSequence n2; + NodeToken n3; + Token n4; + Initializer n5; + n0 = Initializer(); + label_9: + while (true) { + if (jj_2_9(2)) { + ; + } else { + break label_9; + } + n2 = new NodeSequence(2); + n4 = jj_consume_token(59); + n3 = JTBToolkit.makeNodeToken(n4); + n2.addNode(n3); + n5 = Initializer(); + n2.addNode(n5); + n1.addNode(n2); + } + n1.nodes.trimToSize(); + {if (true) return new InitializerList(n0,n1);} + throw new Error("Missing return statement in function"); + } + + final public Array Array() throws ParseException { + NodeToken n0; + Token n1; + NodeOptional n2 = new NodeOptional(); + ConstantExpression n3; + NodeToken n4; + Token n5; + n1 = jj_consume_token(65); + n0 = JTBToolkit.makeNodeToken(n1); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case INTEGER_LITERAL: + case FLOATING_POINT_LITERAL: + case CHARACTER_LITERAL: + case STRING_LITERAL: + case SIZEOF: + case IDENTIFIER: + case 55: + case 58: + case 82: + case 91: + case 92: + case 95: + case 96: + case 97: + case 98: + n3 = ConstantExpression(); + n2.addNode(n3); + break; + default: + jj_la1[53] = jj_gen; + ; + } + n5 = jj_consume_token(66); + n4 = JTBToolkit.makeNodeToken(n5); + {if (true) return new Array(n0,n2,n4);} + throw new Error("Missing return statement in function"); + } + + final public Statement Statement() throws ParseException { + NodeChoice n0; + LabeledStatement n1; + ExpressionStatement n2; + CompoundStatement n3; + SelectionStatement n4; + IterationStatement n5; + JumpStatement n6; + if (jj_2_10(2)) { + n1 = LabeledStatement(); + n0 = new NodeChoice(n1, 0); + } else { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case INTEGER_LITERAL: + case FLOATING_POINT_LITERAL: + case CHARACTER_LITERAL: + case STRING_LITERAL: + case SIZEOF: + case IDENTIFIER: + case 55: + case 57: + case 58: + case 82: + case 91: + case 92: + case 95: + case 96: + case 97: + case 98: + n2 = ExpressionStatement(); + n0 = new NodeChoice(n2, 1); + break; + case 61: + n3 = CompoundStatement(); + n0 = new NodeChoice(n3, 2); + break; + case SWITCH: + case IF: + n4 = SelectionStatement(); + n0 = new NodeChoice(n4, 3); + break; + case WHILE: + case FOR: + case DO: + n5 = IterationStatement(); + n0 = new NodeChoice(n5, 4); + break; + case CONTINUE: + case RETURN: + case BREAK: + case GOTO: + n6 = JumpStatement(); + n0 = new NodeChoice(n6, 5); + break; + default: + jj_la1[54] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + } + {if (true) return new Statement(n0);} + throw new Error("Missing return statement in function"); + } + + final public LabeledStatement LabeledStatement() throws ParseException { + NodeChoice n0; + NodeSequence n1; + NodeToken n2; + Token n3; + NodeToken n4; + Token n5; + Statement n6; + NodeSequence n7; + NodeToken n8; + Token n9; + ConstantExpression n10; + NodeToken n11; + Token n12; + Statement n13; + NodeSequence n14; + NodeToken n15; + Token n16; + NodeToken n17; + Token n18; + Statement n19; + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case IDENTIFIER: + n1 = new NodeSequence(3); + n3 = jj_consume_token(IDENTIFIER); + n2 = JTBToolkit.makeNodeToken(n3); + n1.addNode(n2); + n5 = jj_consume_token(64); + n4 = JTBToolkit.makeNodeToken(n5); + n1.addNode(n4); + n6 = Statement(); + n1.addNode(n6); + n0 = new NodeChoice(n1, 0); + break; + case CASE: + n7 = new NodeSequence(4); + n9 = jj_consume_token(CASE); + n8 = JTBToolkit.makeNodeToken(n9); + n7.addNode(n8); + n10 = ConstantExpression(); + n7.addNode(n10); + n12 = jj_consume_token(64); + n11 = JTBToolkit.makeNodeToken(n12); + n7.addNode(n11); + n13 = Statement(); + n7.addNode(n13); + n0 = new NodeChoice(n7, 1); + break; + case DFLT: + n14 = new NodeSequence(3); + n16 = jj_consume_token(DFLT); + n15 = JTBToolkit.makeNodeToken(n16); + n14.addNode(n15); + n18 = jj_consume_token(64); + n17 = JTBToolkit.makeNodeToken(n18); + n14.addNode(n17); + n19 = Statement(); + n14.addNode(n19); + n0 = new NodeChoice(n14, 2); + break; + default: + jj_la1[55] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + {if (true) return new LabeledStatement(n0);} + throw new Error("Missing return statement in function"); + } + + final public ExpressionStatement ExpressionStatement() throws ParseException { + NodeOptional n0 = new NodeOptional(); + Expression n1; + NodeToken n2; + Token n3; + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case INTEGER_LITERAL: + case FLOATING_POINT_LITERAL: + case CHARACTER_LITERAL: + case STRING_LITERAL: + case SIZEOF: + case IDENTIFIER: + case 55: + case 58: + case 82: + case 91: + case 92: + case 95: + case 96: + case 97: + case 98: + n1 = Expression(); + n0.addNode(n1); + break; + default: + jj_la1[56] = jj_gen; + ; + } + n3 = jj_consume_token(57); + n2 = JTBToolkit.makeNodeToken(n3); + {if (true) return new ExpressionStatement(n0,n2);} + throw new Error("Missing return statement in function"); + } + + final public CompoundStatement CompoundStatement() throws ParseException { + NodeToken n0; + Token n1; + NodeListOptional n2 = new NodeListOptional(); + NodeChoice n3; + LocalVariableDeclaration n4; + Statement n5; + NodeToken n6; + Token n7; + n1 = jj_consume_token(61); + n0 = JTBToolkit.makeNodeToken(n1); + label_10: + while (true) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case INTEGER_LITERAL: + case FLOATING_POINT_LITERAL: + case CHARACTER_LITERAL: + case STRING_LITERAL: + case CONTINUE: + case REGISTER: + case UNSIGNED: + case DFLT: + case DOUBLE: + case SIZEOF: + case SWITCH: + case RETURN: + case STRUCT: + case STATIC: + case SIGNED: + case WHILE: + case BREAK: + case UNION: + case CONST: + case FLOAT: + case SHORT: + case CASE: + case LONG: + case ENUM: + case AUTO: + case VOID: + case CHAR: + case GOTO: + case FOR: + case INT: + case IF: + case DO: + case IDENTIFIER: + case 55: + case 57: + case 58: + case 61: + case 82: + case 91: + case 92: + case 95: + case 96: + case 97: + case 98: + ; + break; + default: + jj_la1[57] = jj_gen; + break label_10; + } + if (jj_2_11(2147483647)) { + n4 = LocalVariableDeclaration(); + n3 = new NodeChoice(n4, 0); + } else { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case INTEGER_LITERAL: + case FLOATING_POINT_LITERAL: + case CHARACTER_LITERAL: + case STRING_LITERAL: + case CONTINUE: + case DFLT: + case SIZEOF: + case SWITCH: + case RETURN: + case WHILE: + case BREAK: + case CASE: + case GOTO: + case FOR: + case IF: + case DO: + case IDENTIFIER: + case 55: + case 57: + case 58: + case 61: + case 82: + case 91: + case 92: + case 95: + case 96: + case 97: + case 98: + n5 = Statement(); + n3 = new NodeChoice(n5, 1); + break; + default: + jj_la1[58] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + } + n2.addNode(n3); + } + n2.nodes.trimToSize(); + n7 = jj_consume_token(62); + n6 = JTBToolkit.makeNodeToken(n7); + {if (true) return new CompoundStatement(n0,n2,n6);} + throw new Error("Missing return statement in function"); + } + + final public SelectionStatement SelectionStatement() throws ParseException { + NodeChoice n0; + NodeSequence n1; + NodeToken n2; + Token n3; + NodeToken n4; + Token n5; + Expression n6; + NodeToken n7; + Token n8; + Statement n9; + NodeOptional n10 = new NodeOptional(); + NodeSequence n11; + NodeToken n12; + Token n13; + Statement n14; + NodeSequence n15; + NodeToken n16; + Token n17; + NodeToken n18; + Token n19; + Expression n20; + NodeToken n21; + Token n22; + Statement n23; + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case IF: + n1 = new NodeSequence(6); + n3 = jj_consume_token(IF); + n2 = JTBToolkit.makeNodeToken(n3); + n1.addNode(n2); + n5 = jj_consume_token(55); + n4 = JTBToolkit.makeNodeToken(n5); + n1.addNode(n4); + n6 = Expression(); + n1.addNode(n6); + n8 = jj_consume_token(56); + n7 = JTBToolkit.makeNodeToken(n8); + n1.addNode(n7); + n9 = Statement(); + n1.addNode(n9); + if (jj_2_12(2)) { + n11 = new NodeSequence(2); + n13 = jj_consume_token(ELSE); + n12 = JTBToolkit.makeNodeToken(n13); + n11.addNode(n12); + n14 = Statement(); + n11.addNode(n14); + n10.addNode(n11); + } else { + ; + } + n1.addNode(n10); + n0 = new NodeChoice(n1, 0); + break; + case SWITCH: + n15 = new NodeSequence(5); + n17 = jj_consume_token(SWITCH); + n16 = JTBToolkit.makeNodeToken(n17); + n15.addNode(n16); + n19 = jj_consume_token(55); + n18 = JTBToolkit.makeNodeToken(n19); + n15.addNode(n18); + n20 = Expression(); + n15.addNode(n20); + n22 = jj_consume_token(56); + n21 = JTBToolkit.makeNodeToken(n22); + n15.addNode(n21); + n23 = Statement(); + n15.addNode(n23); + n0 = new NodeChoice(n15, 1); + break; + default: + jj_la1[59] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + {if (true) return new SelectionStatement(n0);} + throw new Error("Missing return statement in function"); + } + + final public IterationStatement IterationStatement() throws ParseException { + NodeChoice n0; + NodeSequence n1; + NodeToken n2; + Token n3; + NodeToken n4; + Token n5; + Expression n6; + NodeToken n7; + Token n8; + Statement n9; + NodeSequence n10; + NodeToken n11; + Token n12; + Statement n13; + NodeToken n14; + Token n15; + NodeToken n16; + Token n17; + Expression n18; + NodeToken n19; + Token n20; + NodeToken n21; + Token n22; + NodeSequence n23; + NodeToken n24; + Token n25; + NodeToken n26; + Token n27; + NodeOptional n28 = new NodeOptional(); + Expression n29; + NodeToken n30; + Token n31; + NodeOptional n32 = new NodeOptional(); + Expression n33; + NodeToken n34; + Token n35; + NodeOptional n36 = new NodeOptional(); + Expression n37; + NodeToken n38; + Token n39; + Statement n40; + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case WHILE: + n1 = new NodeSequence(5); + n3 = jj_consume_token(WHILE); + n2 = JTBToolkit.makeNodeToken(n3); + n1.addNode(n2); + n5 = jj_consume_token(55); + n4 = JTBToolkit.makeNodeToken(n5); + n1.addNode(n4); + n6 = Expression(); + n1.addNode(n6); + n8 = jj_consume_token(56); + n7 = JTBToolkit.makeNodeToken(n8); + n1.addNode(n7); + n9 = Statement(); + n1.addNode(n9); + n0 = new NodeChoice(n1, 0); + break; + case DO: + n10 = new NodeSequence(7); + n12 = jj_consume_token(DO); + n11 = JTBToolkit.makeNodeToken(n12); + n10.addNode(n11); + n13 = Statement(); + n10.addNode(n13); + n15 = jj_consume_token(WHILE); + n14 = JTBToolkit.makeNodeToken(n15); + n10.addNode(n14); + n17 = jj_consume_token(55); + n16 = JTBToolkit.makeNodeToken(n17); + n10.addNode(n16); + n18 = Expression(); + n10.addNode(n18); + n20 = jj_consume_token(56); + n19 = JTBToolkit.makeNodeToken(n20); + n10.addNode(n19); + n22 = jj_consume_token(57); + n21 = JTBToolkit.makeNodeToken(n22); + n10.addNode(n21); + n0 = new NodeChoice(n10, 1); + break; + case FOR: + n23 = new NodeSequence(9); + n25 = jj_consume_token(FOR); + n24 = JTBToolkit.makeNodeToken(n25); + n23.addNode(n24); + n27 = jj_consume_token(55); + n26 = JTBToolkit.makeNodeToken(n27); + n23.addNode(n26); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case INTEGER_LITERAL: + case FLOATING_POINT_LITERAL: + case CHARACTER_LITERAL: + case STRING_LITERAL: + case SIZEOF: + case IDENTIFIER: + case 55: + case 58: + case 82: + case 91: + case 92: + case 95: + case 96: + case 97: + case 98: + n29 = Expression(); + n28.addNode(n29); + break; + default: + jj_la1[60] = jj_gen; + ; + } + n23.addNode(n28); + n31 = jj_consume_token(57); + n30 = JTBToolkit.makeNodeToken(n31); + n23.addNode(n30); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case INTEGER_LITERAL: + case FLOATING_POINT_LITERAL: + case CHARACTER_LITERAL: + case STRING_LITERAL: + case SIZEOF: + case IDENTIFIER: + case 55: + case 58: + case 82: + case 91: + case 92: + case 95: + case 96: + case 97: + case 98: + n33 = Expression(); + n32.addNode(n33); + break; + default: + jj_la1[61] = jj_gen; + ; + } + n23.addNode(n32); + n35 = jj_consume_token(57); + n34 = JTBToolkit.makeNodeToken(n35); + n23.addNode(n34); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case INTEGER_LITERAL: + case FLOATING_POINT_LITERAL: + case CHARACTER_LITERAL: + case STRING_LITERAL: + case SIZEOF: + case IDENTIFIER: + case 55: + case 58: + case 82: + case 91: + case 92: + case 95: + case 96: + case 97: + case 98: + n37 = Expression(); + n36.addNode(n37); + break; + default: + jj_la1[62] = jj_gen; + ; + } + n23.addNode(n36); + n39 = jj_consume_token(56); + n38 = JTBToolkit.makeNodeToken(n39); + n23.addNode(n38); + n40 = Statement(); + n23.addNode(n40); + n0 = new NodeChoice(n23, 2); + break; + default: + jj_la1[63] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + {if (true) return new IterationStatement(n0);} + throw new Error("Missing return statement in function"); + } + + final public JumpStatement JumpStatement() throws ParseException { + NodeChoice n0; + NodeSequence n1; + NodeToken n2; + Token n3; + NodeToken n4; + Token n5; + NodeToken n6; + Token n7; + NodeSequence n8; + NodeToken n9; + Token n10; + NodeToken n11; + Token n12; + NodeSequence n13; + NodeToken n14; + Token n15; + NodeToken n16; + Token n17; + NodeSequence n18; + NodeToken n19; + Token n20; + NodeOptional n21 = new NodeOptional(); + Expression n22; + NodeToken n23; + Token n24; + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case GOTO: + n1 = new NodeSequence(3); + n3 = jj_consume_token(GOTO); + n2 = JTBToolkit.makeNodeToken(n3); + n1.addNode(n2); + n5 = jj_consume_token(IDENTIFIER); + n4 = JTBToolkit.makeNodeToken(n5); + n1.addNode(n4); + n7 = jj_consume_token(57); + n6 = JTBToolkit.makeNodeToken(n7); + n1.addNode(n6); + n0 = new NodeChoice(n1, 0); + break; + case CONTINUE: + n8 = new NodeSequence(2); + n10 = jj_consume_token(CONTINUE); + n9 = JTBToolkit.makeNodeToken(n10); + n8.addNode(n9); + n12 = jj_consume_token(57); + n11 = JTBToolkit.makeNodeToken(n12); + n8.addNode(n11); + n0 = new NodeChoice(n8, 1); + break; + case BREAK: + n13 = new NodeSequence(2); + n15 = jj_consume_token(BREAK); + n14 = JTBToolkit.makeNodeToken(n15); + n13.addNode(n14); + n17 = jj_consume_token(57); + n16 = JTBToolkit.makeNodeToken(n17); + n13.addNode(n16); + n0 = new NodeChoice(n13, 2); + break; + case RETURN: + n18 = new NodeSequence(3); + n20 = jj_consume_token(RETURN); + n19 = JTBToolkit.makeNodeToken(n20); + n18.addNode(n19); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case INTEGER_LITERAL: + case FLOATING_POINT_LITERAL: + case CHARACTER_LITERAL: + case STRING_LITERAL: + case SIZEOF: + case IDENTIFIER: + case 55: + case 58: + case 82: + case 91: + case 92: + case 95: + case 96: + case 97: + case 98: + n22 = Expression(); + n21.addNode(n22); + break; + default: + jj_la1[64] = jj_gen; + ; + } + n18.addNode(n21); + n24 = jj_consume_token(57); + n23 = JTBToolkit.makeNodeToken(n24); + n18.addNode(n23); + n0 = new NodeChoice(n18, 3); + break; + default: + jj_la1[65] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + {if (true) return new JumpStatement(n0);} + throw new Error("Missing return statement in function"); + } + + final public Expression Expression() throws ParseException { + AssignmentExpression n0; + NodeListOptional n1 = new NodeListOptional(); + NodeSequence n2; + NodeToken n3; + Token n4; + AssignmentExpression n5; + n0 = AssignmentExpression(); + label_11: + while (true) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case 59: + ; + break; + default: + jj_la1[66] = jj_gen; + break label_11; + } + n2 = new NodeSequence(2); + n4 = jj_consume_token(59); + n3 = JTBToolkit.makeNodeToken(n4); + n2.addNode(n3); + n5 = AssignmentExpression(); + n2.addNode(n5); + n1.addNode(n2); + } + n1.nodes.trimToSize(); + {if (true) return new Expression(n0,n1);} + throw new Error("Missing return statement in function"); + } + + final public AssignmentExpression AssignmentExpression() throws ParseException { + NodeChoice n0; + NodeSequence n1; + UnaryExpression n2; + AssignmentOperator n3; + AssignmentExpression n4; + ConditionalExpression n5; + if (jj_2_13(2147483647)) { + n1 = new NodeSequence(4); + n2 = UnaryExpression(); + n1.addNode(n2); + n3 = AssignmentOperator(); + n1.addNode(n3); + n4 = AssignmentExpression(); + n1.addNode(n4); + n0 = new NodeChoice(n1, 0); + } else if (jj_2_14(3)) { + n5 = ConditionalExpression(); + n0 = new NodeChoice(n5, 1); + } else { + jj_consume_token(-1); + throw new ParseException(); + } + {if (true) return new AssignmentExpression(n0);} + throw new Error("Missing return statement in function"); + } + + final public AssignmentOperator AssignmentOperator() throws ParseException { + NodeChoice n0; + NodeToken n1; + Token n2; + NodeToken n3; + Token n4; + NodeToken n5; + Token n6; + NodeToken n7; + Token n8; + NodeToken n9; + Token n10; + NodeToken n11; + Token n12; + NodeToken n13; + Token n14; + NodeToken n15; + Token n16; + NodeToken n17; + Token n18; + NodeToken n19; + Token n20; + NodeToken n21; + Token n22; + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case 63: + n2 = jj_consume_token(63); + n1 = JTBToolkit.makeNodeToken(n2); + n0 = new NodeChoice(n1, 0); + break; + case 67: + n4 = jj_consume_token(67); + n3 = JTBToolkit.makeNodeToken(n4); + n0 = new NodeChoice(n3, 1); + break; + case 68: + n6 = jj_consume_token(68); + n5 = JTBToolkit.makeNodeToken(n6); + n0 = new NodeChoice(n5, 2); + break; + case 69: + n8 = jj_consume_token(69); + n7 = JTBToolkit.makeNodeToken(n8); + n0 = new NodeChoice(n7, 3); + break; + case 70: + n10 = jj_consume_token(70); + n9 = JTBToolkit.makeNodeToken(n10); + n0 = new NodeChoice(n9, 4); + break; + case 71: + n12 = jj_consume_token(71); + n11 = JTBToolkit.makeNodeToken(n12); + n0 = new NodeChoice(n11, 5); + break; + case 72: + n14 = jj_consume_token(72); + n13 = JTBToolkit.makeNodeToken(n14); + n0 = new NodeChoice(n13, 6); + break; + case 73: + n16 = jj_consume_token(73); + n15 = JTBToolkit.makeNodeToken(n16); + n0 = new NodeChoice(n15, 7); + break; + case 74: + n18 = jj_consume_token(74); + n17 = JTBToolkit.makeNodeToken(n18); + n0 = new NodeChoice(n17, 8); + break; + case 75: + n20 = jj_consume_token(75); + n19 = JTBToolkit.makeNodeToken(n20); + n0 = new NodeChoice(n19, 9); + break; + case 76: + n22 = jj_consume_token(76); + n21 = JTBToolkit.makeNodeToken(n22); + n0 = new NodeChoice(n21, 10); + break; + default: + jj_la1[67] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + {if (true) return new AssignmentOperator(n0);} + throw new Error("Missing return statement in function"); + } + + final public ConditionalExpression ConditionalExpression() throws ParseException { + LogicalORExpression n0; + NodeOptional n1 = new NodeOptional(); + NodeSequence n2; + NodeToken n3; + Token n4; + Expression n5; + NodeToken n6; + Token n7; + ConditionalExpression n8; + n0 = LogicalORExpression(); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case 77: + n2 = new NodeSequence(4); + n4 = jj_consume_token(77); + n3 = JTBToolkit.makeNodeToken(n4); + n2.addNode(n3); + n5 = Expression(); + n2.addNode(n5); + n7 = jj_consume_token(64); + n6 = JTBToolkit.makeNodeToken(n7); + n2.addNode(n6); + n8 = ConditionalExpression(); + n2.addNode(n8); + n1.addNode(n2); + break; + default: + jj_la1[68] = jj_gen; + ; + } + {if (true) return new ConditionalExpression(n0,n1);} + throw new Error("Missing return statement in function"); + } + + final public ConstantExpression ConstantExpression() throws ParseException { + ConditionalExpression n0; + n0 = ConditionalExpression(); + {if (true) return new ConstantExpression(n0);} + throw new Error("Missing return statement in function"); + } + + final public LogicalORExpression LogicalORExpression() throws ParseException { + LogicalANDExpression n0; + NodeOptional n1 = new NodeOptional(); + NodeSequence n2; + NodeToken n3; + Token n4; + LogicalORExpression n5; + n0 = LogicalANDExpression(); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case 78: + n2 = new NodeSequence(2); + n4 = jj_consume_token(78); + n3 = JTBToolkit.makeNodeToken(n4); + n2.addNode(n3); + n5 = LogicalORExpression(); + n2.addNode(n5); + n1.addNode(n2); + break; + default: + jj_la1[69] = jj_gen; + ; + } + {if (true) return new LogicalORExpression(n0,n1);} + throw new Error("Missing return statement in function"); + } + + final public LogicalANDExpression LogicalANDExpression() throws ParseException { + InclusiveORExpression n0; + NodeOptional n1 = new NodeOptional(); + NodeSequence n2; + NodeToken n3; + Token n4; + LogicalANDExpression n5; + n0 = InclusiveORExpression(); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case 79: + n2 = new NodeSequence(2); + n4 = jj_consume_token(79); + n3 = JTBToolkit.makeNodeToken(n4); + n2.addNode(n3); + n5 = LogicalANDExpression(); + n2.addNode(n5); + n1.addNode(n2); + break; + default: + jj_la1[70] = jj_gen; + ; + } + {if (true) return new LogicalANDExpression(n0,n1);} + throw new Error("Missing return statement in function"); + } + + final public InclusiveORExpression InclusiveORExpression() throws ParseException { + ExclusiveORExpression n0; + NodeOptional n1 = new NodeOptional(); + NodeSequence n2; + NodeToken n3; + Token n4; + InclusiveORExpression n5; + n0 = ExclusiveORExpression(); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case 80: + n2 = new NodeSequence(2); + n4 = jj_consume_token(80); + n3 = JTBToolkit.makeNodeToken(n4); + n2.addNode(n3); + n5 = InclusiveORExpression(); + n2.addNode(n5); + n1.addNode(n2); + break; + default: + jj_la1[71] = jj_gen; + ; + } + {if (true) return new InclusiveORExpression(n0,n1);} + throw new Error("Missing return statement in function"); + } + + final public ExclusiveORExpression ExclusiveORExpression() throws ParseException { + ANDExpression n0; + NodeOptional n1 = new NodeOptional(); + NodeSequence n2; + NodeToken n3; + Token n4; + ExclusiveORExpression n5; + n0 = ANDExpression(); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case 81: + n2 = new NodeSequence(2); + n4 = jj_consume_token(81); + n3 = JTBToolkit.makeNodeToken(n4); + n2.addNode(n3); + n5 = ExclusiveORExpression(); + n2.addNode(n5); + n1.addNode(n2); + break; + default: + jj_la1[72] = jj_gen; + ; + } + {if (true) return new ExclusiveORExpression(n0,n1);} + throw new Error("Missing return statement in function"); + } + + final public ANDExpression ANDExpression() throws ParseException { + EqualityExpression n0; + NodeOptional n1 = new NodeOptional(); + NodeSequence n2; + NodeToken n3; + Token n4; + ANDExpression n5; + n0 = EqualityExpression(); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case 82: + n2 = new NodeSequence(2); + n4 = jj_consume_token(82); + n3 = JTBToolkit.makeNodeToken(n4); + n2.addNode(n3); + n5 = ANDExpression(); + n2.addNode(n5); + n1.addNode(n2); + break; + default: + jj_la1[73] = jj_gen; + ; + } + {if (true) return new ANDExpression(n0,n1);} + throw new Error("Missing return statement in function"); + } + + final public EqualityExpression EqualityExpression() throws ParseException { + RelationalExpression n0; + NodeOptional n1 = new NodeOptional(); + NodeSequence n2; + NodeChoice n3; + NodeToken n4; + Token n5; + NodeToken n6; + Token n7; + EqualityExpression n8; + n0 = RelationalExpression(); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case 83: + case 84: + n2 = new NodeSequence(2); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case 83: + n5 = jj_consume_token(83); + n4 = JTBToolkit.makeNodeToken(n5); + n3 = new NodeChoice(n4, 0); + break; + case 84: + n7 = jj_consume_token(84); + n6 = JTBToolkit.makeNodeToken(n7); + n3 = new NodeChoice(n6, 1); + break; + default: + jj_la1[74] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + n2.addNode(n3); + n8 = EqualityExpression(); + n2.addNode(n8); + n1.addNode(n2); + break; + default: + jj_la1[75] = jj_gen; + ; + } + {if (true) return new EqualityExpression(n0,n1);} + throw new Error("Missing return statement in function"); + } + + final public RelationalExpression RelationalExpression() throws ParseException { + ShiftExpression n0; + NodeOptional n1 = new NodeOptional(); + NodeSequence n2; + NodeChoice n3; + NodeToken n4; + Token n5; + NodeToken n6; + Token n7; + NodeToken n8; + Token n9; + NodeToken n10; + Token n11; + RelationalExpression n12; + n0 = ShiftExpression(); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case 85: + case 86: + case 87: + case 88: + n2 = new NodeSequence(2); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case 85: + n5 = jj_consume_token(85); + n4 = JTBToolkit.makeNodeToken(n5); + n3 = new NodeChoice(n4, 0); + break; + case 86: + n7 = jj_consume_token(86); + n6 = JTBToolkit.makeNodeToken(n7); + n3 = new NodeChoice(n6, 1); + break; + case 87: + n9 = jj_consume_token(87); + n8 = JTBToolkit.makeNodeToken(n9); + n3 = new NodeChoice(n8, 2); + break; + case 88: + n11 = jj_consume_token(88); + n10 = JTBToolkit.makeNodeToken(n11); + n3 = new NodeChoice(n10, 3); + break; + default: + jj_la1[76] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + n2.addNode(n3); + n12 = RelationalExpression(); + n2.addNode(n12); + n1.addNode(n2); + break; + default: + jj_la1[77] = jj_gen; + ; + } + {if (true) return new RelationalExpression(n0,n1);} + throw new Error("Missing return statement in function"); + } + + final public ShiftExpression ShiftExpression() throws ParseException { + AdditiveExpression n0; + NodeOptional n1 = new NodeOptional(); + NodeSequence n2; + NodeChoice n3; + NodeToken n4; + Token n5; + NodeToken n6; + Token n7; + ShiftExpression n8; + n0 = AdditiveExpression(); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case 89: + case 90: + n2 = new NodeSequence(2); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case 89: + n5 = jj_consume_token(89); + n4 = JTBToolkit.makeNodeToken(n5); + n3 = new NodeChoice(n4, 0); + break; + case 90: + n7 = jj_consume_token(90); + n6 = JTBToolkit.makeNodeToken(n7); + n3 = new NodeChoice(n6, 1); + break; + default: + jj_la1[78] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + n2.addNode(n3); + n8 = ShiftExpression(); + n2.addNode(n8); + n1.addNode(n2); + break; + default: + jj_la1[79] = jj_gen; + ; + } + {if (true) return new ShiftExpression(n0,n1);} + throw new Error("Missing return statement in function"); + } + + final public AdditiveExpression AdditiveExpression() throws ParseException { + MultiplicativeExpression n0; + NodeOptional n1 = new NodeOptional(); + NodeSequence n2; + NodeChoice n3; + NodeToken n4; + Token n5; + NodeToken n6; + Token n7; + AdditiveExpression n8; + n0 = MultiplicativeExpression(); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case 91: + case 92: + n2 = new NodeSequence(2); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case 91: + n5 = jj_consume_token(91); + n4 = JTBToolkit.makeNodeToken(n5); + n3 = new NodeChoice(n4, 0); + break; + case 92: + n7 = jj_consume_token(92); + n6 = JTBToolkit.makeNodeToken(n7); + n3 = new NodeChoice(n6, 1); + break; + default: + jj_la1[80] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + n2.addNode(n3); + n8 = AdditiveExpression(); + n2.addNode(n8); + n1.addNode(n2); + break; + default: + jj_la1[81] = jj_gen; + ; + } + {if (true) return new AdditiveExpression(n0,n1);} + throw new Error("Missing return statement in function"); + } + + final public MultiplicativeExpression MultiplicativeExpression() throws ParseException { + CastExpression n0; + NodeOptional n1 = new NodeOptional(); + NodeSequence n2; + NodeChoice n3; + NodeToken n4; + Token n5; + NodeToken n6; + Token n7; + NodeToken n8; + Token n9; + MultiplicativeExpression n10; + n0 = CastExpression(); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case 58: + case 93: + case 94: + n2 = new NodeSequence(2); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case 58: + n5 = jj_consume_token(58); + n4 = JTBToolkit.makeNodeToken(n5); + n3 = new NodeChoice(n4, 0); + break; + case 93: + n7 = jj_consume_token(93); + n6 = JTBToolkit.makeNodeToken(n7); + n3 = new NodeChoice(n6, 1); + break; + case 94: + n9 = jj_consume_token(94); + n8 = JTBToolkit.makeNodeToken(n9); + n3 = new NodeChoice(n8, 2); + break; + default: + jj_la1[82] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + n2.addNode(n3); + n10 = MultiplicativeExpression(); + n2.addNode(n10); + n1.addNode(n2); + break; + default: + jj_la1[83] = jj_gen; + ; + } + {if (true) return new MultiplicativeExpression(n0,n1);} + throw new Error("Missing return statement in function"); + } + + final public CastExpression CastExpression() throws ParseException { + NodeChoice n0; + NodeSequence n1; + NodeToken n2; + Token n3; + TypeSpecifier n4; + NodeToken n5; + Token n6; + CastExpression n7; + UnaryExpression n8; + if (jj_2_15(2147483647)) { + n1 = new NodeSequence(5); + n3 = jj_consume_token(55); + n2 = JTBToolkit.makeNodeToken(n3); + n1.addNode(n2); + n4 = TypeSpecifier(); + n1.addNode(n4); + n6 = jj_consume_token(56); + n5 = JTBToolkit.makeNodeToken(n6); + n1.addNode(n5); + n7 = CastExpression(); + n1.addNode(n7); + n0 = new NodeChoice(n1, 0); + } else { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case INTEGER_LITERAL: + case FLOATING_POINT_LITERAL: + case CHARACTER_LITERAL: + case STRING_LITERAL: + case SIZEOF: + case IDENTIFIER: + case 55: + case 58: + case 82: + case 91: + case 92: + case 95: + case 96: + case 97: + case 98: + n8 = UnaryExpression(); + n0 = new NodeChoice(n8, 1); + break; + default: + jj_la1[84] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + } + {if (true) return new CastExpression(n0);} + throw new Error("Missing return statement in function"); + } + + final public UnaryExpression UnaryExpression() throws ParseException { + NodeChoice n0; + PostfixExpression n1; + NodeSequence n2; + NodeToken n3; + Token n4; + UnaryExpression n5; + NodeSequence n6; + NodeToken n7; + Token n8; + UnaryExpression n9; + NodeSequence n10; + UnaryOperator n11; + CastExpression n12; + NodeSequence n13; + NodeToken n14; + Token n15; + NodeChoice n16; + UnaryExpression n17; + NodeSequence n18; + NodeToken n19; + Token n20; + TypeSpecifier n21; + NodeToken n22; + Token n23; + if (jj_2_17(3)) { + n1 = PostfixExpression(); + n0 = new NodeChoice(n1, 0); + } else { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case 95: + n2 = new NodeSequence(2); + n4 = jj_consume_token(95); + n3 = JTBToolkit.makeNodeToken(n4); + n2.addNode(n3); + n5 = UnaryExpression(); + n2.addNode(n5); + n0 = new NodeChoice(n2, 1); + break; + case 96: + n6 = new NodeSequence(2); + n8 = jj_consume_token(96); + n7 = JTBToolkit.makeNodeToken(n8); + n6.addNode(n7); + n9 = UnaryExpression(); + n6.addNode(n9); + n0 = new NodeChoice(n6, 2); + break; + case 58: + case 82: + case 91: + case 92: + case 97: + case 98: + n10 = new NodeSequence(2); + n11 = UnaryOperator(); + n10.addNode(n11); + n12 = CastExpression(); + n10.addNode(n12); + n0 = new NodeChoice(n10, 3); + break; + case SIZEOF: + n13 = new NodeSequence(2); + n15 = jj_consume_token(SIZEOF); + n14 = JTBToolkit.makeNodeToken(n15); + n13.addNode(n14); + if (jj_2_16(2147483647)) { + n17 = UnaryExpression(); + n16 = new NodeChoice(n17, 0); + } else { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case 55: + n18 = new NodeSequence(3); + n20 = jj_consume_token(55); + n19 = JTBToolkit.makeNodeToken(n20); + n18.addNode(n19); + n21 = TypeSpecifier(); + n18.addNode(n21); + n23 = jj_consume_token(56); + n22 = JTBToolkit.makeNodeToken(n23); + n18.addNode(n22); + n16 = new NodeChoice(n18, 1); + break; + default: + jj_la1[85] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + } + n13.addNode(n16); + n0 = new NodeChoice(n13, 4); + break; + default: + jj_la1[86] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + } + {if (true) return new UnaryExpression(n0);} + throw new Error("Missing return statement in function"); + } + + final public UnaryOperator UnaryOperator() throws ParseException { + NodeChoice n0; + NodeToken n1; + Token n2; + NodeToken n3; + Token n4; + NodeToken n5; + Token n6; + NodeToken n7; + Token n8; + NodeToken n9; + Token n10; + NodeToken n11; + Token n12; + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case 82: + n2 = jj_consume_token(82); + n1 = JTBToolkit.makeNodeToken(n2); + n0 = new NodeChoice(n1, 0); + break; + case 58: + n4 = jj_consume_token(58); + n3 = JTBToolkit.makeNodeToken(n4); + n0 = new NodeChoice(n3, 1); + break; + case 91: + n6 = jj_consume_token(91); + n5 = JTBToolkit.makeNodeToken(n6); + n0 = new NodeChoice(n5, 2); + break; + case 92: + n8 = jj_consume_token(92); + n7 = JTBToolkit.makeNodeToken(n8); + n0 = new NodeChoice(n7, 3); + break; + case 97: + n10 = jj_consume_token(97); + n9 = JTBToolkit.makeNodeToken(n10); + n0 = new NodeChoice(n9, 4); + break; + case 98: + n12 = jj_consume_token(98); + n11 = JTBToolkit.makeNodeToken(n12); + n0 = new NodeChoice(n11, 5); + break; + default: + jj_la1[87] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + {if (true) return new UnaryOperator(n0);} + throw new Error("Missing return statement in function"); + } + + final public PostfixExpression PostfixExpression() throws ParseException { + PrimaryExpression n0; + NodeListOptional n1 = new NodeListOptional(); + NodeChoice n2; + NodeSequence n3; + NodeToken n4; + Token n5; + Expression n6; + NodeToken n7; + Token n8; + NodeSequence n9; + NodeToken n10; + Token n11; + NodeOptional n12; + ArgumentExpressionList n13; + NodeToken n14; + Token n15; + NodeSequence n16; + NodeToken n17; + Token n18; + NodeToken n19; + Token n20; + NodeSequence n21; + NodeToken n22; + Token n23; + NodeToken n24; + Token n25; + NodeToken n26; + Token n27; + NodeToken n28; + Token n29; + n0 = PrimaryExpression(); + label_12: + while (true) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case 55: + case 65: + case 95: + case 96: + case 99: + case 100: + ; + break; + default: + jj_la1[88] = jj_gen; + break label_12; + } + n12 = new NodeOptional(); + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case 65: + n3 = new NodeSequence(3); + n5 = jj_consume_token(65); + n4 = JTBToolkit.makeNodeToken(n5); + n3.addNode(n4); + n6 = Expression(); + n3.addNode(n6); + n8 = jj_consume_token(66); + n7 = JTBToolkit.makeNodeToken(n8); + n3.addNode(n7); + n2 = new NodeChoice(n3, 0); + break; + case 55: + n9 = new NodeSequence(3); + n11 = jj_consume_token(55); + n10 = JTBToolkit.makeNodeToken(n11); + n9.addNode(n10); + if (jj_2_18(2147483647)) { + n13 = ArgumentExpressionList(); + n12.addNode(n13); + } else { + ; + } + n9.addNode(n12); + n15 = jj_consume_token(56); + n14 = JTBToolkit.makeNodeToken(n15); + n9.addNode(n14); + n2 = new NodeChoice(n9, 1); + break; + case 99: + n16 = new NodeSequence(2); + n18 = jj_consume_token(99); + n17 = JTBToolkit.makeNodeToken(n18); + n16.addNode(n17); + n20 = jj_consume_token(IDENTIFIER); + n19 = JTBToolkit.makeNodeToken(n20); + n16.addNode(n19); + n2 = new NodeChoice(n16, 2); + break; + case 100: + n21 = new NodeSequence(2); + n23 = jj_consume_token(100); + n22 = JTBToolkit.makeNodeToken(n23); + n21.addNode(n22); + n25 = jj_consume_token(IDENTIFIER); + n24 = JTBToolkit.makeNodeToken(n25); + n21.addNode(n24); + n2 = new NodeChoice(n21, 3); + break; + case 95: + n27 = jj_consume_token(95); + n26 = JTBToolkit.makeNodeToken(n27); + n2 = new NodeChoice(n26, 4); + break; + case 96: + n29 = jj_consume_token(96); + n28 = JTBToolkit.makeNodeToken(n29); + n2 = new NodeChoice(n28, 5); + break; + default: + jj_la1[89] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + n1.addNode(n2); + } + n1.nodes.trimToSize(); + {if (true) return new PostfixExpression(n0,n1);} + throw new Error("Missing return statement in function"); + } + + final public PrimaryExpression PrimaryExpression() throws ParseException { + NodeChoice n0; + NodeToken n1; + Token n2; + Constant n3; + NodeSequence n4; + NodeToken n5; + Token n6; + Expression n7; + NodeToken n8; + Token n9; + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case IDENTIFIER: + n2 = jj_consume_token(IDENTIFIER); + n1 = JTBToolkit.makeNodeToken(n2); + n0 = new NodeChoice(n1, 0); + break; + case INTEGER_LITERAL: + case FLOATING_POINT_LITERAL: + case CHARACTER_LITERAL: + case STRING_LITERAL: + n3 = Constant(); + n0 = new NodeChoice(n3, 1); + break; + case 55: + n4 = new NodeSequence(3); + n6 = jj_consume_token(55); + n5 = JTBToolkit.makeNodeToken(n6); + n4.addNode(n5); + n7 = Expression(); + n4.addNode(n7); + n9 = jj_consume_token(56); + n8 = JTBToolkit.makeNodeToken(n9); + n4.addNode(n8); + n0 = new NodeChoice(n4, 2); + break; + default: + jj_la1[90] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + {if (true) return new PrimaryExpression(n0);} + throw new Error("Missing return statement in function"); + } + + final public ArgumentExpressionList ArgumentExpressionList() throws ParseException { + AssignmentOrTypeExpression n0; + NodeListOptional n1 = new NodeListOptional(); + NodeSequence n2; + NodeToken n3; + Token n4; + AssignmentOrTypeExpression n5; + n0 = AssignmentOrTypeExpression(); + label_13: + while (true) { + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case 59: + ; + break; + default: + jj_la1[91] = jj_gen; + break label_13; + } + n2 = new NodeSequence(2); + n4 = jj_consume_token(59); + n3 = JTBToolkit.makeNodeToken(n4); + n2.addNode(n3); + n5 = AssignmentOrTypeExpression(); + n2.addNode(n5); + n1.addNode(n2); + } + n1.nodes.trimToSize(); + {if (true) return new ArgumentExpressionList(n0,n1);} + throw new Error("Missing return statement in function"); + } + + final public AssignmentOrTypeExpression AssignmentOrTypeExpression() throws ParseException { + NodeChoice n0; + NoIdentifierTypeSpecifier n1; + AssignmentExpression n2; + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case UNSIGNED: + case DOUBLE: + case STRUCT: + case SIGNED: + case UNION: + case CONST: + case FLOAT: + case SHORT: + case LONG: + case ENUM: + case VOID: + case CHAR: + case INT: + n1 = NoIdentifierTypeSpecifier(); + n0 = new NodeChoice(n1, 0); + break; + case INTEGER_LITERAL: + case FLOATING_POINT_LITERAL: + case CHARACTER_LITERAL: + case STRING_LITERAL: + case SIZEOF: + case IDENTIFIER: + case 55: + case 58: + case 82: + case 91: + case 92: + case 95: + case 96: + case 97: + case 98: + n2 = AssignmentExpression(); + n0 = new NodeChoice(n2, 1); + break; + default: + jj_la1[92] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + {if (true) return new AssignmentOrTypeExpression(n0);} + throw new Error("Missing return statement in function"); + } + + final public Constant Constant() throws ParseException { + NodeChoice n0; + NodeToken n1; + Token n2; + NodeToken n3; + Token n4; + NodeToken n5; + Token n6; + NodeToken n7; + Token n8; + switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { + case INTEGER_LITERAL: + n2 = jj_consume_token(INTEGER_LITERAL); + n1 = JTBToolkit.makeNodeToken(n2); + n0 = new NodeChoice(n1, 0); + break; + case FLOATING_POINT_LITERAL: + n4 = jj_consume_token(FLOATING_POINT_LITERAL); + n3 = JTBToolkit.makeNodeToken(n4); + n0 = new NodeChoice(n3, 1); + break; + case CHARACTER_LITERAL: + n6 = jj_consume_token(CHARACTER_LITERAL); + n5 = JTBToolkit.makeNodeToken(n6); + n0 = new NodeChoice(n5, 2); + break; + case STRING_LITERAL: + n8 = jj_consume_token(STRING_LITERAL); + n7 = JTBToolkit.makeNodeToken(n8); + n0 = new NodeChoice(n7, 3); + break; + default: + jj_la1[93] = jj_gen; + jj_consume_token(-1); + throw new ParseException(); + } + {if (true) return new Constant(n0);} + throw new Error("Missing return statement in function"); + } + + private boolean jj_2_1(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_1(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(0, xla); } + } + + private boolean jj_2_2(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_2(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(1, xla); } + } + + private boolean jj_2_3(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_3(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(2, xla); } + } + + private boolean jj_2_4(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_4(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(3, xla); } + } + + private boolean jj_2_5(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_5(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(4, xla); } + } + + private boolean jj_2_6(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_6(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(5, xla); } + } + + private boolean jj_2_7(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_7(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(6, xla); } + } + + private boolean jj_2_8(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_8(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(7, xla); } + } + + private boolean jj_2_9(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_9(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(8, xla); } + } + + private boolean jj_2_10(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_10(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(9, xla); } + } + + private boolean jj_2_11(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_11(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(10, xla); } + } + + private boolean jj_2_12(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_12(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(11, xla); } + } + + private boolean jj_2_13(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_13(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(12, xla); } + } + + private boolean jj_2_14(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_14(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(13, xla); } + } + + private boolean jj_2_15(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_15(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(14, xla); } + } + + private boolean jj_2_16(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_16(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(15, xla); } + } + + private boolean jj_2_17(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_17(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(16, xla); } + } + + private boolean jj_2_18(int xla) { + jj_la = xla; jj_lastpos = jj_scanpos = token; + try { return !jj_3_18(); } + catch(LookaheadSuccess ls) { return true; } + finally { jj_save(17, xla); } + } + + private boolean jj_3R_113() { + if (jj_scan_token(55)) return true; + if (jj_3R_32()) return true; + if (jj_scan_token(56)) return true; + return false; + } + + private boolean jj_3R_192() { + if (jj_scan_token(DOUBLE)) return true; + return false; + } + + private boolean jj_3R_168() { + if (jj_3R_123()) return true; + return false; + } + + private boolean jj_3_6() { + if (jj_scan_token(59)) return true; + if (jj_3R_19()) return true; + return false; + } + + private boolean jj_3R_191() { + if (jj_scan_token(FLOAT)) return true; + return false; + } + + private boolean jj_3R_112() { + if (jj_3R_29()) return true; + return false; + } + + private boolean jj_3R_203() { + if (jj_scan_token(LONG)) return true; + return false; + } + + private boolean jj_3R_167() { + if (jj_scan_token(CONST)) return true; + return false; + } + + private boolean jj_3R_97() { + if (jj_3R_19()) return true; + Token xsp; + while (true) { + xsp = jj_scanpos; + if (jj_3_6()) { jj_scanpos = xsp; break; } + } + xsp = jj_scanpos; + if (jj_3R_136()) jj_scanpos = xsp; + return false; + } + + private boolean jj_3R_123() { + if (jj_scan_token(58)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3R_167()) jj_scanpos = xsp; + xsp = jj_scanpos; + if (jj_3R_168()) jj_scanpos = xsp; + return false; + } + + private boolean jj_3R_190() { + if (jj_scan_token(LONG)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3R_203()) jj_scanpos = xsp; + return false; + } + + private boolean jj_3R_63() { + if (jj_scan_token(SIZEOF)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3R_112()) { + jj_scanpos = xsp; + if (jj_3R_113()) return true; + } + return false; + } + + private boolean jj_3R_161() { + if (jj_scan_token(79)) return true; + if (jj_3R_114()) return true; + return false; + } + + private boolean jj_3R_189() { + if (jj_scan_token(INT)) return true; + return false; + } + + private boolean jj_3R_202() { + if (jj_scan_token(INT)) return true; + return false; + } + + private boolean jj_3R_114() { + if (jj_3R_160()) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3R_161()) jj_scanpos = xsp; + return false; + } + + private boolean jj_3R_62() { + if (jj_3R_111()) return true; + if (jj_3R_33()) return true; + return false; + } + + private boolean jj_3R_188() { + if (jj_scan_token(SHORT)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3R_202()) jj_scanpos = xsp; + return false; + } + + private boolean jj_3R_61() { + if (jj_scan_token(96)) return true; + if (jj_3R_29()) return true; + return false; + } + + private boolean jj_3R_187() { + if (jj_scan_token(CHAR)) return true; + return false; + } + + private boolean jj_3R_142() { + if (jj_3R_97()) return true; + return false; + } + + private boolean jj_3R_186() { + if (jj_scan_token(VOID)) return true; + return false; + } + + private boolean jj_3R_104() { + if (jj_scan_token(63)) return true; + if (jj_3R_106()) return true; + return false; + } + + private boolean jj_3R_60() { + if (jj_scan_token(95)) return true; + if (jj_3R_29()) return true; + return false; + } + + private boolean jj_3R_47() { + if (jj_scan_token(IDENTIFIER)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3R_104()) jj_scanpos = xsp; + return false; + } + + private boolean jj_3_17() { + if (jj_3R_34()) return true; + return false; + } + + private boolean jj_3R_185() { + if (jj_scan_token(CONST)) return true; + return false; + } + + private boolean jj_3R_102() { + if (jj_3R_32()) return true; + if (jj_scan_token(55)) return true; + if (jj_scan_token(58)) return true; + if (jj_scan_token(IDENTIFIER)) return true; + if (jj_scan_token(56)) return true; + if (jj_scan_token(55)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3R_142()) jj_scanpos = xsp; + if (jj_scan_token(56)) return true; + return false; + } + + private boolean jj_3R_115() { + if (jj_scan_token(78)) return true; + if (jj_3R_75()) return true; + return false; + } + + private boolean jj_3R_172() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_185()) jj_scanpos = xsp; + xsp = jj_scanpos; + if (jj_3R_186()) { + jj_scanpos = xsp; + if (jj_3R_187()) { + jj_scanpos = xsp; + if (jj_3R_188()) { + jj_scanpos = xsp; + if (jj_3R_189()) { + jj_scanpos = xsp; + if (jj_3R_190()) { + jj_scanpos = xsp; + if (jj_3R_191()) { + jj_scanpos = xsp; + if (jj_3R_192()) { + jj_scanpos = xsp; + if (jj_3R_193()) { + jj_scanpos = xsp; + if (jj_3R_194()) { + jj_scanpos = xsp; + if (jj_3R_195()) return true; + } + } + } + } + } + } + } + } + } + xsp = jj_scanpos; + if (jj_3R_196()) jj_scanpos = xsp; + xsp = jj_scanpos; + if (jj_3R_197()) jj_scanpos = xsp; + return false; + } + + private boolean jj_3R_75() { + if (jj_3R_114()) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3R_115()) jj_scanpos = xsp; + return false; + } + + private boolean jj_3R_146() { + if (jj_scan_token(SWITCH)) return true; + if (jj_scan_token(55)) return true; + if (jj_3R_116()) return true; + if (jj_scan_token(56)) return true; + if (jj_3R_28()) return true; + return false; + } + + private boolean jj_3R_29() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_17()) { + jj_scanpos = xsp; + if (jj_3R_60()) { + jj_scanpos = xsp; + if (jj_3R_61()) { + jj_scanpos = xsp; + if (jj_3R_62()) { + jj_scanpos = xsp; + if (jj_3R_63()) return true; + } + } + } + } + return false; + } + + private boolean jj_3_12() { + if (jj_scan_token(ELSE)) return true; + if (jj_3R_28()) return true; + return false; + } + + private boolean jj_3R_48() { + if (jj_scan_token(59)) return true; + if (jj_3R_47()) return true; + return false; + } + + private boolean jj_3R_106() { + if (jj_3R_31()) return true; + return false; + } + + private boolean jj_3R_24() { + if (jj_3R_47()) return true; + Token xsp; + while (true) { + xsp = jj_scanpos; + if (jj_3R_48()) { jj_scanpos = xsp; break; } + } + return false; + } + + private boolean jj_3R_18() { + if (jj_3R_15()) return true; + if (jj_scan_token(IDENTIFIER)) return true; + return false; + } + + private boolean jj_3R_145() { + if (jj_scan_token(IF)) return true; + if (jj_scan_token(55)) return true; + if (jj_3R_116()) return true; + if (jj_scan_token(56)) return true; + if (jj_3R_28()) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3_12()) jj_scanpos = xsp; + return false; + } + + private boolean jj_3_5() { + if (jj_3R_18()) return true; + if (jj_scan_token(57)) return true; + return false; + } + + private boolean jj_3R_108() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_145()) { + jj_scanpos = xsp; + if (jj_3R_146()) return true; + } + return false; + } + + private boolean jj_3R_166() { + if (jj_scan_token(IDENTIFIER)) return true; + return false; + } + + private boolean jj_3R_43() { + if (jj_3R_102()) return true; + return false; + } + + private boolean jj_3R_92() { + if (jj_3R_29()) return true; + return false; + } + + private boolean jj_3R_76() { + if (jj_scan_token(77)) return true; + if (jj_3R_116()) return true; + if (jj_scan_token(64)) return true; + if (jj_3R_31()) return true; + return false; + } + + private boolean jj_3_15() { + if (jj_scan_token(55)) return true; + if (jj_3R_32()) return true; + if (jj_scan_token(56)) return true; + if (jj_3R_33()) return true; + return false; + } + + private boolean jj_3R_42() { + if (jj_3R_18()) return true; + return false; + } + + private boolean jj_3R_31() { + if (jj_3R_75()) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3R_76()) jj_scanpos = xsp; + return false; + } + + private boolean jj_3R_23() { + if (jj_scan_token(IDENTIFIER)) return true; + return false; + } + + private boolean jj_3R_91() { + if (jj_scan_token(55)) return true; + if (jj_3R_32()) return true; + if (jj_scan_token(56)) return true; + if (jj_3R_33()) return true; + return false; + } + + private boolean jj_3R_17() { + if (jj_scan_token(TYPEDEF)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3R_42()) { + jj_scanpos = xsp; + if (jj_3R_43()) return true; + } + if (jj_scan_token(57)) return true; + return false; + } + + private boolean jj_3_8() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_23()) jj_scanpos = xsp; + if (jj_scan_token(61)) return true; + if (jj_3R_24()) return true; + if (jj_scan_token(62)) return true; + return false; + } + + private boolean jj_3R_33() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_91()) { + jj_scanpos = xsp; + if (jj_3R_92()) return true; + } + return false; + } + + private boolean jj_3R_122() { + if (jj_scan_token(ENUM)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3_8()) { + jj_scanpos = xsp; + if (jj_3R_166()) return true; + } + return false; + } + + private boolean jj_3R_74() { + if (jj_scan_token(76)) return true; + return false; + } + + private boolean jj_3_11() { + if (jj_3R_27()) return true; + return false; + } + + private boolean jj_3R_73() { + if (jj_scan_token(75)) return true; + return false; + } + + private boolean jj_3R_90() { + if (jj_3R_124()) return true; + return false; + } + + private boolean jj_3R_72() { + if (jj_scan_token(74)) return true; + return false; + } + + private boolean jj_3R_175() { + if (jj_3R_28()) return true; + return false; + } + + private boolean jj_3R_71() { + if (jj_scan_token(73)) return true; + return false; + } + + private boolean jj_3R_89() { + if (jj_3R_123()) return true; + return false; + } + + private boolean jj_3R_70() { + if (jj_scan_token(72)) return true; + return false; + } + + private boolean jj_3R_174() { + if (jj_3R_27()) return true; + return false; + } + + private boolean jj_3R_88() { + if (jj_scan_token(IDENTIFIER)) return true; + return false; + } + + private boolean jj_3R_69() { + if (jj_scan_token(71)) return true; + return false; + } + + private boolean jj_3R_244() { + if (jj_scan_token(94)) return true; + return false; + } + + private boolean jj_3R_87() { + if (jj_3R_122()) return true; + return false; + } + + private boolean jj_3R_137() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_174()) { + jj_scanpos = xsp; + if (jj_3R_175()) return true; + } + return false; + } + + private boolean jj_3R_68() { + if (jj_scan_token(70)) return true; + return false; + } + + private boolean jj_3R_243() { + if (jj_scan_token(93)) return true; + return false; + } + + private boolean jj_3R_86() { + if (jj_3R_15()) return true; + return false; + } + + private boolean jj_3R_179() { + if (jj_scan_token(LONG)) return true; + return false; + } + + private boolean jj_3R_67() { + if (jj_scan_token(69)) return true; + return false; + } + + private boolean jj_3R_242() { + if (jj_scan_token(58)) return true; + return false; + } + + private boolean jj_3R_98() { + if (jj_scan_token(61)) return true; + Token xsp; + while (true) { + xsp = jj_scanpos; + if (jj_3R_137()) { jj_scanpos = xsp; break; } + } + if (jj_scan_token(62)) return true; + return false; + } + + private boolean jj_3R_199() { + if (jj_scan_token(IDENTIFIER)) return true; + return false; + } + + private boolean jj_3R_66() { + if (jj_scan_token(68)) return true; + return false; + } + + private boolean jj_3R_183() { + if (jj_scan_token(STRING_LITERAL)) return true; + return false; + } + + private boolean jj_3R_65() { + if (jj_scan_token(67)) return true; + return false; + } + + private boolean jj_3R_165() { + if (jj_scan_token(LONG)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3R_179()) jj_scanpos = xsp; + return false; + } + + private boolean jj_3R_182() { + if (jj_scan_token(CHARACTER_LITERAL)) return true; + return false; + } + + private boolean jj_3R_38() { + if (jj_3R_98()) return true; + return false; + } + + private boolean jj_3R_64() { + if (jj_scan_token(63)) return true; + return false; + } + + private boolean jj_3R_239() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_242()) { + jj_scanpos = xsp; + if (jj_3R_243()) { + jj_scanpos = xsp; + if (jj_3R_244()) return true; + } + } + if (jj_3R_235()) return true; + return false; + } + + private boolean jj_3R_208() { + if (jj_scan_token(64)) return true; + if (jj_3R_106()) return true; + return false; + } + + private boolean jj_3R_164() { + if (jj_scan_token(INT)) return true; + return false; + } + + private boolean jj_3R_181() { + if (jj_scan_token(FLOATING_POINT_LITERAL)) return true; + return false; + } + + private boolean jj_3R_37() { + if (jj_scan_token(57)) return true; + return false; + } + + private boolean jj_3R_207() { + if (jj_3R_124()) return true; + return false; + } + + private boolean jj_3R_178() { + if (jj_scan_token(INT)) return true; + return false; + } + + private boolean jj_3R_180() { + if (jj_scan_token(INTEGER_LITERAL)) return true; + return false; + } + + private boolean jj_3R_235() { + if (jj_3R_33()) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3R_239()) jj_scanpos = xsp; + return false; + } + + private boolean jj_3R_198() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_207()) { + jj_scanpos = xsp; + if (jj_3R_208()) return true; + } + return false; + } + + private boolean jj_3R_30() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_64()) { + jj_scanpos = xsp; + if (jj_3R_65()) { + jj_scanpos = xsp; + if (jj_3R_66()) { + jj_scanpos = xsp; + if (jj_3R_67()) { + jj_scanpos = xsp; + if (jj_3R_68()) { + jj_scanpos = xsp; + if (jj_3R_69()) { + jj_scanpos = xsp; + if (jj_3R_70()) { + jj_scanpos = xsp; + if (jj_3R_71()) { + jj_scanpos = xsp; + if (jj_3R_72()) { + jj_scanpos = xsp; + if (jj_3R_73()) { + jj_scanpos = xsp; + if (jj_3R_74()) return true; + } + } + } + } + } + } + } + } + } + } + return false; + } + + private boolean jj_3R_170() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_180()) { + jj_scanpos = xsp; + if (jj_3R_181()) { + jj_scanpos = xsp; + if (jj_3R_182()) { + jj_scanpos = xsp; + if (jj_3R_183()) return true; + } + } + } + return false; + } + + private boolean jj_3R_163() { + if (jj_scan_token(SHORT)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3R_178()) jj_scanpos = xsp; + return false; + } + + private boolean jj_3R_144() { + if (jj_3R_116()) return true; + return false; + } + + private boolean jj_3R_36() { + if (jj_3R_97()) return true; + return false; + } + + private boolean jj_3R_162() { + if (jj_scan_token(CHAR)) return true; + return false; + } + + private boolean jj_3R_103() { + if (jj_3R_32()) return true; + if (jj_scan_token(IDENTIFIER)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3R_198()) jj_scanpos = xsp; + xsp = jj_scanpos; + if (jj_3R_199()) jj_scanpos = xsp; + if (jj_scan_token(57)) return true; + return false; + } + + private boolean jj_3R_107() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_144()) jj_scanpos = xsp; + if (jj_scan_token(57)) return true; + return false; + } + + private boolean jj_3R_14() { + if (jj_3R_32()) return true; + if (jj_scan_token(IDENTIFIER)) return true; + if (jj_scan_token(55)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3R_36()) jj_scanpos = xsp; + if (jj_scan_token(56)) return true; + xsp = jj_scanpos; + if (jj_3R_37()) { + jj_scanpos = xsp; + if (jj_3R_38()) return true; + } + return false; + } + + private boolean jj_3R_121() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_162()) { + jj_scanpos = xsp; + if (jj_3R_163()) { + jj_scanpos = xsp; + if (jj_3R_164()) { + jj_scanpos = xsp; + if (jj_3R_165()) return true; + } + } + } + return false; + } + + private boolean jj_3R_120() { + if (jj_scan_token(UNSIGNED)) return true; + return false; + } + + private boolean jj_3R_119() { + if (jj_scan_token(SIGNED)) return true; + return false; + } + + private boolean jj_3R_241() { + if (jj_scan_token(92)) return true; + return false; + } + + private boolean jj_3R_135() { + if (jj_3R_105()) return true; + return false; + } + + private boolean jj_3R_240() { + if (jj_scan_token(91)) return true; + return false; + } + + private boolean jj_3R_134() { + if (jj_3R_172()) return true; + return false; + } + + private boolean jj_3_4() { + if (jj_3R_17()) return true; + return false; + } + + private boolean jj_3R_53() { + if (jj_scan_token(DFLT)) return true; + if (jj_scan_token(64)) return true; + if (jj_3R_28()) return true; + return false; + } + + private boolean jj_3R_95() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_134()) { + jj_scanpos = xsp; + if (jj_3R_135()) return true; + } + return false; + } + + private boolean jj_3_3() { + if (jj_3R_16()) return true; + return false; + } + + private boolean jj_3R_85() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_119()) { + jj_scanpos = xsp; + if (jj_3R_120()) return true; + } + xsp = jj_scanpos; + if (jj_3R_121()) jj_scanpos = xsp; + return false; + } + + private boolean jj_3R_84() { + if (jj_scan_token(DOUBLE)) return true; + return false; + } + + private boolean jj_3R_236() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_240()) { + jj_scanpos = xsp; + if (jj_3R_241()) return true; + } + if (jj_3R_229()) return true; + return false; + } + + private boolean jj_3_2() { + if (jj_3R_15()) return true; + return false; + } + + private boolean jj_3R_83() { + if (jj_scan_token(FLOAT)) return true; + return false; + } + + private boolean jj_3_14() { + if (jj_3R_31()) return true; + return false; + } + + private boolean jj_3_13() { + if (jj_3R_29()) return true; + if (jj_3R_30()) return true; + return false; + } + + private boolean jj_3R_141() { + if (jj_scan_token(63)) return true; + if (jj_3R_25()) return true; + return false; + } + + private boolean jj_3_1() { + if (jj_3R_14()) return true; + return false; + } + + private boolean jj_3R_229() { + if (jj_3R_235()) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3R_236()) jj_scanpos = xsp; + return false; + } + + private boolean jj_3R_118() { + if (jj_scan_token(LONG)) return true; + return false; + } + + private boolean jj_3R_52() { + if (jj_scan_token(CASE)) return true; + if (jj_3R_106()) return true; + if (jj_scan_token(64)) return true; + if (jj_3R_28()) return true; + return false; + } + + private boolean jj_3R_140() { + if (jj_3R_124()) return true; + return false; + } + + private boolean jj_3R_143() { + if (jj_3R_29()) return true; + if (jj_3R_30()) return true; + if (jj_3R_105()) return true; + return false; + } + + private boolean jj_3R_82() { + if (jj_scan_token(LONG)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3R_118()) jj_scanpos = xsp; + return false; + } + + private boolean jj_3R_100() { + if (jj_scan_token(IDENTIFIER)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3R_140()) jj_scanpos = xsp; + xsp = jj_scanpos; + if (jj_3R_141()) jj_scanpos = xsp; + return false; + } + + private boolean jj_3R_96() { + if (jj_scan_token(59)) return true; + if (jj_3R_95()) return true; + return false; + } + + private boolean jj_3R_51() { + if (jj_scan_token(IDENTIFIER)) return true; + if (jj_scan_token(64)) return true; + if (jj_3R_28()) return true; + return false; + } + + private boolean jj_3R_81() { + if (jj_scan_token(INT)) return true; + return false; + } + + private boolean jj_3R_105() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_143()) { + jj_scanpos = xsp; + if (jj_3_14()) return true; + } + return false; + } + + private boolean jj_3R_35() { + if (jj_3R_95()) return true; + Token xsp; + while (true) { + xsp = jj_scanpos; + if (jj_3R_96()) { jj_scanpos = xsp; break; } + } + return false; + } + + private boolean jj_3R_117() { + if (jj_scan_token(INT)) return true; + return false; + } + + private boolean jj_3R_26() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_51()) { + jj_scanpos = xsp; + if (jj_3R_52()) { + jj_scanpos = xsp; + if (jj_3R_53()) return true; + } + } + return false; + } + + private boolean jj_3R_238() { + if (jj_scan_token(90)) return true; + return false; + } + + private boolean jj_3R_80() { + if (jj_scan_token(SHORT)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3R_117()) jj_scanpos = xsp; + return false; + } + + private boolean jj_3R_237() { + if (jj_scan_token(89)) return true; + return false; + } + + private boolean jj_3R_79() { + if (jj_scan_token(CHAR)) return true; + return false; + } + + private boolean jj_3R_78() { + if (jj_scan_token(VOID)) return true; + return false; + } + + private boolean jj_3R_101() { + if (jj_scan_token(59)) return true; + if (jj_3R_100()) return true; + return false; + } + + private boolean jj_3R_230() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_237()) { + jj_scanpos = xsp; + if (jj_3R_238()) return true; + } + if (jj_3R_221()) return true; + return false; + } + + private boolean jj_3R_184() { + if (jj_scan_token(59)) return true; + if (jj_3R_105()) return true; + return false; + } + + private boolean jj_3R_77() { + if (jj_scan_token(CONST)) return true; + return false; + } + + private boolean jj_3R_127() { + if (jj_scan_token(55)) return true; + if (jj_3R_116()) return true; + if (jj_scan_token(56)) return true; + return false; + } + + private boolean jj_3R_41() { + if (jj_3R_100()) return true; + Token xsp; + while (true) { + xsp = jj_scanpos; + if (jj_3R_101()) { jj_scanpos = xsp; break; } + } + return false; + } + + private boolean jj_3R_221() { + if (jj_3R_229()) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3R_230()) jj_scanpos = xsp; + return false; + } + + private boolean jj_3R_116() { + if (jj_3R_105()) return true; + Token xsp; + while (true) { + xsp = jj_scanpos; + if (jj_3R_184()) { jj_scanpos = xsp; break; } + } + return false; + } + + private boolean jj_3R_32() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_77()) jj_scanpos = xsp; + xsp = jj_scanpos; + if (jj_3R_78()) { + jj_scanpos = xsp; + if (jj_3R_79()) { + jj_scanpos = xsp; + if (jj_3R_80()) { + jj_scanpos = xsp; + if (jj_3R_81()) { + jj_scanpos = xsp; + if (jj_3R_82()) { + jj_scanpos = xsp; + if (jj_3R_83()) { + jj_scanpos = xsp; + if (jj_3R_84()) { + jj_scanpos = xsp; + if (jj_3R_85()) { + jj_scanpos = xsp; + if (jj_3R_86()) { + jj_scanpos = xsp; + if (jj_3R_87()) { + jj_scanpos = xsp; + if (jj_3R_88()) return true; + } + } + } + } + } + } + } + } + } + } + xsp = jj_scanpos; + if (jj_3R_89()) jj_scanpos = xsp; + xsp = jj_scanpos; + if (jj_3R_90()) jj_scanpos = xsp; + return false; + } + + private boolean jj_3R_126() { + if (jj_3R_170()) return true; + return false; + } + + private boolean jj_3R_125() { + if (jj_scan_token(IDENTIFIER)) return true; + return false; + } + + private boolean jj_3R_93() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_125()) { + jj_scanpos = xsp; + if (jj_3R_126()) { + jj_scanpos = xsp; + if (jj_3R_127()) return true; + } + } + return false; + } + + private boolean jj_3R_59() { + if (jj_3R_110()) return true; + return false; + } + + private boolean jj_3R_58() { + if (jj_3R_109()) return true; + return false; + } + + private boolean jj_3R_57() { + if (jj_3R_108()) return true; + return false; + } + + private boolean jj_3R_46() { + if (jj_3R_103()) return true; + return false; + } + + private boolean jj_3R_228() { + if (jj_3R_116()) return true; + return false; + } + + private boolean jj_3R_56() { + if (jj_3R_98()) return true; + return false; + } + + private boolean jj_3R_234() { + if (jj_scan_token(88)) return true; + return false; + } + + private boolean jj_3R_22() { + Token xsp; + if (jj_3R_46()) return true; + while (true) { + xsp = jj_scanpos; + if (jj_3R_46()) { jj_scanpos = xsp; break; } + } + return false; + } + + private boolean jj_3R_55() { + if (jj_3R_107()) return true; + return false; + } + + private boolean jj_3R_233() { + if (jj_scan_token(87)) return true; + return false; + } + + private boolean jj_3R_153() { + if (jj_scan_token(RETURN)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3R_228()) jj_scanpos = xsp; + if (jj_scan_token(57)) return true; + return false; + } + + private boolean jj_3_10() { + if (jj_3R_26()) return true; + return false; + } + + private boolean jj_3R_232() { + if (jj_scan_token(86)) return true; + return false; + } + + private boolean jj_3R_133() { + if (jj_scan_token(96)) return true; + return false; + } + + private boolean jj_3R_231() { + if (jj_scan_token(85)) return true; + return false; + } + + private boolean jj_3R_152() { + if (jj_scan_token(BREAK)) return true; + if (jj_scan_token(57)) return true; + return false; + } + + private boolean jj_3R_45() { + if (jj_scan_token(UNION)) return true; + return false; + } + + private boolean jj_3R_132() { + if (jj_scan_token(95)) return true; + return false; + } + + private boolean jj_3R_28() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_10()) { + jj_scanpos = xsp; + if (jj_3R_55()) { + jj_scanpos = xsp; + if (jj_3R_56()) { + jj_scanpos = xsp; + if (jj_3R_57()) { + jj_scanpos = xsp; + if (jj_3R_58()) { + jj_scanpos = xsp; + if (jj_3R_59()) return true; + } + } + } + } + } + return false; + } + + private boolean jj_3R_44() { + if (jj_scan_token(STRUCT)) return true; + return false; + } + + private boolean jj_3R_222() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_231()) { + jj_scanpos = xsp; + if (jj_3R_232()) { + jj_scanpos = xsp; + if (jj_3R_233()) { + jj_scanpos = xsp; + if (jj_3R_234()) return true; + } + } + } + if (jj_3R_217()) return true; + return false; + } + + private boolean jj_3R_151() { + if (jj_scan_token(CONTINUE)) return true; + if (jj_scan_token(57)) return true; + return false; + } + + private boolean jj_3R_131() { + if (jj_scan_token(100)) return true; + if (jj_scan_token(IDENTIFIER)) return true; + return false; + } + + private boolean jj_3_18() { + if (jj_3R_35()) return true; + return false; + } + + private boolean jj_3R_20() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_44()) { + jj_scanpos = xsp; + if (jj_3R_45()) return true; + } + return false; + } + + private boolean jj_3R_217() { + if (jj_3R_221()) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3R_222()) jj_scanpos = xsp; + return false; + } + + private boolean jj_3R_130() { + if (jj_scan_token(99)) return true; + if (jj_scan_token(IDENTIFIER)) return true; + return false; + } + + private boolean jj_3R_150() { + if (jj_scan_token(GOTO)) return true; + if (jj_scan_token(IDENTIFIER)) return true; + if (jj_scan_token(57)) return true; + return false; + } + + private boolean jj_3R_171() { + if (jj_3R_35()) return true; + return false; + } + + private boolean jj_3R_169() { + if (jj_3R_106()) return true; + return false; + } + + private boolean jj_3R_110() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_150()) { + jj_scanpos = xsp; + if (jj_3R_151()) { + jj_scanpos = xsp; + if (jj_3R_152()) { + jj_scanpos = xsp; + if (jj_3R_153()) return true; + } + } + } + return false; + } + + private boolean jj_3R_124() { + if (jj_scan_token(65)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3R_169()) jj_scanpos = xsp; + if (jj_scan_token(66)) return true; + return false; + } + + private boolean jj_3R_129() { + if (jj_scan_token(55)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3R_171()) jj_scanpos = xsp; + if (jj_scan_token(56)) return true; + return false; + } + + private boolean jj_3R_39() { + if (jj_3R_20()) return true; + if (jj_scan_token(IDENTIFIER)) return true; + return false; + } + + private boolean jj_3R_224() { + if (jj_scan_token(84)) return true; + return false; + } + + private boolean jj_3R_128() { + if (jj_scan_token(65)) return true; + if (jj_3R_116()) return true; + if (jj_scan_token(66)) return true; + return false; + } + + private boolean jj_3R_139() { + if (jj_scan_token(REGISTER)) return true; + return false; + } + + private boolean jj_3R_223() { + if (jj_scan_token(83)) return true; + return false; + } + + private boolean jj_3R_21() { + if (jj_scan_token(IDENTIFIER)) return true; + return false; + } + + private boolean jj_3R_138() { + if (jj_scan_token(AUTO)) return true; + return false; + } + + private boolean jj_3R_94() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_128()) { + jj_scanpos = xsp; + if (jj_3R_129()) { + jj_scanpos = xsp; + if (jj_3R_130()) { + jj_scanpos = xsp; + if (jj_3R_131()) { + jj_scanpos = xsp; + if (jj_3R_132()) { + jj_scanpos = xsp; + if (jj_3R_133()) return true; + } + } + } + } + } + return false; + } + + private boolean jj_3R_99() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_138()) { + jj_scanpos = xsp; + if (jj_3R_139()) return true; + } + return false; + } + + private boolean jj_3R_34() { + if (jj_3R_93()) return true; + Token xsp; + while (true) { + xsp = jj_scanpos; + if (jj_3R_94()) { jj_scanpos = xsp; break; } + } + return false; + } + + private boolean jj_3_7() { + if (jj_3R_20()) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3R_21()) jj_scanpos = xsp; + if (jj_scan_token(61)) return true; + if (jj_3R_22()) return true; + if (jj_scan_token(62)) return true; + return false; + } + + private boolean jj_3_9() { + if (jj_scan_token(59)) return true; + if (jj_3R_25()) return true; + return false; + } + + private boolean jj_3R_218() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_223()) { + jj_scanpos = xsp; + if (jj_3R_224()) return true; + } + if (jj_3R_211()) return true; + return false; + } + + private boolean jj_3R_40() { + Token xsp; + while (true) { + xsp = jj_scanpos; + if (jj_3R_99()) { jj_scanpos = xsp; break; } + } + return false; + } + + private boolean jj_3R_15() { + Token xsp; + xsp = jj_scanpos; + if (jj_3_7()) { + jj_scanpos = xsp; + if (jj_3R_39()) return true; + } + return false; + } + + private boolean jj_3R_209() { + if (jj_3R_25()) return true; + Token xsp; + while (true) { + xsp = jj_scanpos; + if (jj_3_9()) { jj_scanpos = xsp; break; } + } + return false; + } + + private boolean jj_3R_211() { + if (jj_3R_217()) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3R_218()) jj_scanpos = xsp; + return false; + } + + private boolean jj_3R_227() { + if (jj_3R_116()) return true; + return false; + } + + private boolean jj_3R_54() { + if (jj_scan_token(STATIC)) return true; + return false; + } + + private boolean jj_3R_226() { + if (jj_3R_116()) return true; + return false; + } + + private boolean jj_3R_210() { + if (jj_scan_token(59)) return true; + return false; + } + + private boolean jj_3R_27() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_54()) jj_scanpos = xsp; + if (jj_3R_16()) return true; + return false; + } + + private boolean jj_3R_225() { + if (jj_3R_116()) return true; + return false; + } + + private boolean jj_3R_212() { + if (jj_scan_token(82)) return true; + if (jj_3R_200()) return true; + return false; + } + + private boolean jj_3R_197() { + if (jj_3R_124()) return true; + return false; + } + + private boolean jj_3R_50() { + if (jj_scan_token(61)) return true; + if (jj_3R_209()) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3R_210()) jj_scanpos = xsp; + if (jj_scan_token(62)) return true; + return false; + } + + private boolean jj_3R_196() { + if (jj_3R_123()) return true; + return false; + } + + private boolean jj_3R_200() { + if (jj_3R_211()) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3R_212()) jj_scanpos = xsp; + return false; + } + + private boolean jj_3R_49() { + if (jj_3R_105()) return true; + return false; + } + + private boolean jj_3R_195() { + if (jj_3R_122()) return true; + return false; + } + + private boolean jj_3R_159() { + if (jj_scan_token(98)) return true; + return false; + } + + private boolean jj_3R_149() { + if (jj_scan_token(FOR)) return true; + if (jj_scan_token(55)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3R_225()) jj_scanpos = xsp; + if (jj_scan_token(57)) return true; + xsp = jj_scanpos; + if (jj_3R_226()) jj_scanpos = xsp; + if (jj_scan_token(57)) return true; + xsp = jj_scanpos; + if (jj_3R_227()) jj_scanpos = xsp; + if (jj_scan_token(56)) return true; + if (jj_3R_28()) return true; + return false; + } + + private boolean jj_3R_194() { + if (jj_3R_15()) return true; + return false; + } + + private boolean jj_3R_220() { + if (jj_scan_token(LONG)) return true; + return false; + } + + private boolean jj_3R_158() { + if (jj_scan_token(97)) return true; + return false; + } + + private boolean jj_3R_16() { + if (jj_3R_40()) return true; + if (jj_3R_32()) return true; + if (jj_3R_41()) return true; + if (jj_scan_token(57)) return true; + return false; + } + + private boolean jj_3R_25() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_49()) { + jj_scanpos = xsp; + if (jj_3R_50()) return true; + } + return false; + } + + private boolean jj_3R_157() { + if (jj_scan_token(92)) return true; + return false; + } + + private boolean jj_3R_156() { + if (jj_scan_token(91)) return true; + return false; + } + + private boolean jj_3R_216() { + if (jj_scan_token(LONG)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3R_220()) jj_scanpos = xsp; + return false; + } + + private boolean jj_3R_155() { + if (jj_scan_token(58)) return true; + return false; + } + + private boolean jj_3R_215() { + if (jj_scan_token(INT)) return true; + return false; + } + + private boolean jj_3R_154() { + if (jj_scan_token(82)) return true; + return false; + } + + private boolean jj_3R_219() { + if (jj_scan_token(INT)) return true; + return false; + } + + private boolean jj_3R_201() { + if (jj_scan_token(81)) return true; + if (jj_3R_176()) return true; + return false; + } + + private boolean jj_3R_148() { + if (jj_scan_token(DO)) return true; + if (jj_3R_28()) return true; + if (jj_scan_token(WHILE)) return true; + if (jj_scan_token(55)) return true; + if (jj_3R_116()) return true; + if (jj_scan_token(56)) return true; + if (jj_scan_token(57)) return true; + return false; + } + + private boolean jj_3R_173() { + if (jj_3R_124()) return true; + return false; + } + + private boolean jj_3R_176() { + if (jj_3R_200()) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3R_201()) jj_scanpos = xsp; + return false; + } + + private boolean jj_3R_214() { + if (jj_scan_token(SHORT)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3R_219()) jj_scanpos = xsp; + return false; + } + + private boolean jj_3R_111() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_154()) { + jj_scanpos = xsp; + if (jj_3R_155()) { + jj_scanpos = xsp; + if (jj_3R_156()) { + jj_scanpos = xsp; + if (jj_3R_157()) { + jj_scanpos = xsp; + if (jj_3R_158()) { + jj_scanpos = xsp; + if (jj_3R_159()) return true; + } + } + } + } + } + return false; + } + + private boolean jj_3R_19() { + if (jj_3R_32()) return true; + if (jj_scan_token(IDENTIFIER)) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3R_173()) jj_scanpos = xsp; + return false; + } + + private boolean jj_3R_213() { + if (jj_scan_token(CHAR)) return true; + return false; + } + + private boolean jj_3R_147() { + if (jj_scan_token(WHILE)) return true; + if (jj_scan_token(55)) return true; + if (jj_3R_116()) return true; + if (jj_scan_token(56)) return true; + if (jj_3R_28()) return true; + return false; + } + + private boolean jj_3R_206() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_213()) { + jj_scanpos = xsp; + if (jj_3R_214()) { + jj_scanpos = xsp; + if (jj_3R_215()) { + jj_scanpos = xsp; + if (jj_3R_216()) return true; + } + } + } + return false; + } + + private boolean jj_3R_205() { + if (jj_scan_token(UNSIGNED)) return true; + return false; + } + + private boolean jj_3R_109() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_147()) { + jj_scanpos = xsp; + if (jj_3R_148()) { + jj_scanpos = xsp; + if (jj_3R_149()) return true; + } + } + return false; + } + + private boolean jj_3R_204() { + if (jj_scan_token(SIGNED)) return true; + return false; + } + + private boolean jj_3R_177() { + if (jj_scan_token(80)) return true; + if (jj_3R_160()) return true; + return false; + } + + private boolean jj_3R_136() { + if (jj_scan_token(59)) return true; + if (jj_scan_token(60)) return true; + return false; + } + + private boolean jj_3_16() { + if (jj_3R_29()) return true; + return false; + } + + private boolean jj_3R_160() { + if (jj_3R_176()) return true; + Token xsp; + xsp = jj_scanpos; + if (jj_3R_177()) jj_scanpos = xsp; + return false; + } + + private boolean jj_3R_193() { + Token xsp; + xsp = jj_scanpos; + if (jj_3R_204()) { + jj_scanpos = xsp; + if (jj_3R_205()) return true; + } + xsp = jj_scanpos; + if (jj_3R_206()) jj_scanpos = xsp; + return false; + } + + /** Generated Token Manager. */ + public CParserTokenManager token_source; + SimpleCharStream jj_input_stream; + /** Current token. */ + public Token token; + /** Next token. */ + public Token jj_nt; + private int jj_ntk; + private Token jj_scanpos, jj_lastpos; + private int jj_la; + private int jj_gen; + final private int[] jj_la1 = new int[94]; + static private int[] jj_la1_0; + static private int[] jj_la1_1; + static private int[] jj_la1_2; + static private int[] jj_la1_3; + static { + jj_la1_init_0(); + jj_la1_init_1(); + jj_la1_init_2(); + jj_la1_init_3(); + } + private static void jj_la1_init_0() { + 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,}; + } + private static void jj_la1_init_1() { + 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,}; + } + private static void jj_la1_init_2() { + 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,}; + } + private static void jj_la1_init_3() { + 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,}; + } + final private JJCalls[] jj_2_rtns = new JJCalls[18]; + private boolean jj_rescan = false; + private int jj_gc = 0; + + /** Constructor with InputStream. */ + public GNUnetParser(java.io.InputStream stream) { + this(stream, null); + } + /** Constructor with InputStream and supplied encoding */ + public GNUnetParser(java.io.InputStream stream, String encoding) { + try { jj_input_stream = new SimpleCharStream(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); } + token_source = new CParserTokenManager(jj_input_stream); + token = new Token(); + jj_ntk = -1; + jj_gen = 0; + for (int i = 0; i < 94; i++) jj_la1[i] = -1; + for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); + } + + /** Reinitialise. */ + public void ReInit(java.io.InputStream stream) { + ReInit(stream, null); + } + /** Reinitialise. */ + public void ReInit(java.io.InputStream stream, String encoding) { + try { jj_input_stream.ReInit(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); } + token_source.ReInit(jj_input_stream); + token = new Token(); + jj_ntk = -1; + jj_gen = 0; + for (int i = 0; i < 94; i++) jj_la1[i] = -1; + for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); + } + + /** Constructor. */ + public GNUnetParser(java.io.Reader stream) { + jj_input_stream = new SimpleCharStream(stream, 1, 1); + token_source = new CParserTokenManager(jj_input_stream); + token = new Token(); + jj_ntk = -1; + jj_gen = 0; + for (int i = 0; i < 94; i++) jj_la1[i] = -1; + for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); + } + + /** Reinitialise. */ + public void ReInit(java.io.Reader stream) { + jj_input_stream.ReInit(stream, 1, 1); + token_source.ReInit(jj_input_stream); + token = new Token(); + jj_ntk = -1; + jj_gen = 0; + for (int i = 0; i < 94; i++) jj_la1[i] = -1; + for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); + } + + /** Constructor with generated Token Manager. */ + public GNUnetParser(CParserTokenManager tm) { + token_source = tm; + token = new Token(); + jj_ntk = -1; + jj_gen = 0; + for (int i = 0; i < 94; i++) jj_la1[i] = -1; + for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); + } + + /** Reinitialise. */ + public void ReInit(CParserTokenManager tm) { + token_source = tm; + token = new Token(); + jj_ntk = -1; + jj_gen = 0; + for (int i = 0; i < 94; i++) jj_la1[i] = -1; + for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); + } + + private Token jj_consume_token(int kind) throws ParseException { + Token oldToken; + if ((oldToken = token).next != null) token = token.next; + else token = token.next = token_source.getNextToken(); + jj_ntk = -1; + if (token.kind == kind) { + jj_gen++; + if (++jj_gc > 100) { + jj_gc = 0; + for (int i = 0; i < jj_2_rtns.length; i++) { + JJCalls c = jj_2_rtns[i]; + while (c != null) { + if (c.gen < jj_gen) c.first = null; + c = c.next; + } + } + } + return token; + } + token = oldToken; + jj_kind = kind; + throw generateParseException(); + } + + static private final class LookaheadSuccess extends java.lang.Error { } + final private LookaheadSuccess jj_ls = new LookaheadSuccess(); + private boolean jj_scan_token(int kind) { + if (jj_scanpos == jj_lastpos) { + jj_la--; + if (jj_scanpos.next == null) { + jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken(); + } else { + jj_lastpos = jj_scanpos = jj_scanpos.next; + } + } else { + jj_scanpos = jj_scanpos.next; + } + if (jj_rescan) { + int i = 0; Token tok = token; + while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; } + if (tok != null) jj_add_error_token(kind, i); + } + if (jj_scanpos.kind != kind) return true; + if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls; + return false; + } + + +/** Get the next Token. */ + final public Token getNextToken() { + if (token.next != null) token = token.next; + else token = token.next = token_source.getNextToken(); + jj_ntk = -1; + jj_gen++; + return token; + } + +/** Get the specific Token. */ + final public Token getToken(int index) { + Token t = token; + for (int i = 0; i < index; i++) { + if (t.next != null) t = t.next; + else t = t.next = token_source.getNextToken(); + } + return t; + } + + private int jj_ntk() { + if ((jj_nt=token.next) == null) + return (jj_ntk = (token.next=token_source.getNextToken()).kind); + else + return (jj_ntk = jj_nt.kind); + } + + private java.util.List jj_expentries = new java.util.ArrayList(); + private int[] jj_expentry; + private int jj_kind = -1; + private int[] jj_lasttokens = new int[100]; + private int jj_endpos; + + private void jj_add_error_token(int kind, int pos) { + if (pos >= 100) return; + if (pos == jj_endpos + 1) { + jj_lasttokens[jj_endpos++] = kind; + } else if (jj_endpos != 0) { + jj_expentry = new int[jj_endpos]; + for (int i = 0; i < jj_endpos; i++) { + jj_expentry[i] = jj_lasttokens[i]; + } + jj_entries_loop: for (java.util.Iterator it = jj_expentries.iterator(); it.hasNext();) { + int[] oldentry = (int[])(it.next()); + if (oldentry.length == jj_expentry.length) { + for (int i = 0; i < jj_expentry.length; i++) { + if (oldentry[i] != jj_expentry[i]) { + continue jj_entries_loop; + } + } + jj_expentries.add(jj_expentry); + break jj_entries_loop; + } + } + if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind; + } + } + + /** Generate ParseException. */ + public ParseException generateParseException() { + jj_expentries.clear(); + boolean[] la1tokens = new boolean[101]; + if (jj_kind >= 0) { + la1tokens[jj_kind] = true; + jj_kind = -1; + } + for (int i = 0; i < 94; i++) { + if (jj_la1[i] == jj_gen) { + for (int j = 0; j < 32; j++) { + if ((jj_la1_0[i] & (1< jj_gen) { + jj_la = p.arg; jj_lastpos = jj_scanpos = p.first; + switch (i) { + case 0: jj_3_1(); break; + case 1: jj_3_2(); break; + case 2: jj_3_3(); break; + case 3: jj_3_4(); break; + case 4: jj_3_5(); break; + case 5: jj_3_6(); break; + case 6: jj_3_7(); break; + case 7: jj_3_8(); break; + case 8: jj_3_9(); break; + case 9: jj_3_10(); break; + case 10: jj_3_11(); break; + case 11: jj_3_12(); break; + case 12: jj_3_13(); break; + case 13: jj_3_14(); break; + case 14: jj_3_15(); break; + case 15: jj_3_16(); break; + case 16: jj_3_17(); break; + case 17: jj_3_18(); break; + } + } + p = p.next; + } while (p != null); + } catch(LookaheadSuccess ls) { } + } + jj_rescan = false; + } + + private void jj_save(int index, int xla) { + JJCalls p = jj_2_rtns[index]; + while (p.gen > jj_gen) { + if (p.next == null) { p = p.next = new JJCalls(); break; } + p = p.next; + } + p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla; + } + + static final class JJCalls { + int gen; + Token first; + int arg; + JJCalls next; + } + +} + +class JTBToolkit { + static NodeToken makeNodeToken(Token t) { + return new NodeToken(t.image.intern(), t.kind, t.beginLine, t.beginColumn, t.endLine, t.endColumn); + } +} diff --git a/contrib/gnunet-tree-builder/gtb b/contrib/gnunet-tree-builder/gtb new file mode 100755 index 000000000..d57dfdc3f --- /dev/null +++ b/contrib/gnunet-tree-builder/gtb @@ -0,0 +1,6 @@ +#!/bin/sh +# gtb: gnunet tree builder +# Script for automating the generation of GNUnet syntax tree +# MAINDIR: GNUnet workspace + +$MAINDIR/contrib/gnunet-tree-builder/regenerate \ No newline at end of file diff --git a/contrib/gnunet-tree-builder/regenerate b/contrib/gnunet-tree-builder/regenerate new file mode 100755 index 000000000..fd5696a2a --- /dev/null +++ b/contrib/gnunet-tree-builder/regenerate @@ -0,0 +1,20 @@ +#!/bin/sh +# MAINDIR: Environment Variable for GNUnet workspace +# Note: The script will generate the grammar file C.out.jj under src/monkey + +rm -f *.java +mkdir -p org/gnunet/monkey/parser +cd org/gnunet/monkey/parser +jtb -printer -jd -np org.gnunet.monkey.parser.nodes -vp org.gnunet.monkey.parser.visitors -o $MAINDIR/src/monkey/C.out.jj $MAINDIR/src/monkey/C.jj +javacc -STATIC=false $MAINDIR/src/monkey/C.out.jj + +echo 'package org.gnunet.monkey.parser;' > PACKAGE +for n in *.java +do + cat $n >> PACKAGE + mv PACKAGE $n + echo 'package org.gnunet.monkey.parser;' > PACKAGE +done + +rm -f PACKAGE + \ No newline at end of file -- cgit v1.2.3