From 58d9e7da240d42030d5a14a27e74af118d6bc005 Mon Sep 17 00:00:00 2001 From: "Safey A.Halim" Date: Thu, 21 Oct 2010 21:45:23 +0000 Subject: Checkin for Seaspider and Parser generator script. --- .../gnunet/seaspider/parser/CParserConstants.java | 209 + .../seaspider/parser/CParserTokenManager.java | 1413 +++++ .../parser/ExpressionDatabaseHandler.java | 75 + .../seaspider/parser/GNUnetDepthFirstVisitor.java | 36 + .../org/gnunet/seaspider/parser/GNUnetParser.java | 5633 ++++++++++++++++++++ .../gnunet/seaspider/parser/ParseException.java | 186 + .../gnunet/seaspider/parser/SimpleCharStream.java | 470 ++ .../org/gnunet/seaspider/parser/Token.java | 130 + .../org/gnunet/seaspider/parser/TokenMgrError.java | 146 + .../seaspider/parser/nodes/ANDExpression.java | 36 + .../seaspider/parser/nodes/AdditiveExpression.java | 36 + .../parser/nodes/ArgumentExpressionList.java | 36 + .../org/gnunet/seaspider/parser/nodes/Array.java | 45 + .../parser/nodes/AssignmentExpression.java | 34 + .../seaspider/parser/nodes/AssignmentOperator.java | 33 + .../parser/nodes/AssignmentOrTypeExpression.java | 34 + .../seaspider/parser/nodes/CastExpression.java | 33 + .../seaspider/parser/nodes/CompoundStatement.java | 45 + .../parser/nodes/ConditionalExpression.java | 36 + .../gnunet/seaspider/parser/nodes/Constant.java | 36 + .../seaspider/parser/nodes/ConstantExpression.java | 33 + .../gnunet/seaspider/parser/nodes/DataType.java | 36 + .../seaspider/parser/nodes/EnumSpecifier.java | 41 + .../gnunet/seaspider/parser/nodes/Enumerator.java | 36 + .../seaspider/parser/nodes/EnumeratorList.java | 36 + .../seaspider/parser/nodes/EqualityExpression.java | 36 + .../parser/nodes/ExclusiveORExpression.java | 36 + .../gnunet/seaspider/parser/nodes/Expression.java | 36 + .../parser/nodes/ExpressionStatement.java | 41 + .../parser/nodes/ExternalDeclaration.java | 36 + .../parser/nodes/FunctionDeclaration.java | 57 + .../seaspider/parser/nodes/FunctionType.java | 65 + .../seaspider/parser/nodes/IdentifierList.java | 36 + .../parser/nodes/InclusiveORExpression.java | 36 + .../seaspider/parser/nodes/InitDeclarator.java | 39 + .../seaspider/parser/nodes/InitDeclaratorList.java | 36 + .../gnunet/seaspider/parser/nodes/Initializer.java | 33 + .../seaspider/parser/nodes/InitializerList.java | 36 + .../seaspider/parser/nodes/IterationStatement.java | 33 + .../seaspider/parser/nodes/JumpStatement.java | 33 + .../seaspider/parser/nodes/LabeledStatement.java | 33 + .../parser/nodes/LocalVariableDeclaration.java | 36 + .../parser/nodes/LogicalANDExpression.java | 36 + .../parser/nodes/LogicalORExpression.java | 36 + .../parser/nodes/MultiplicativeExpression.java | 36 + .../parser/nodes/NoIdentifierTypeSpecifier.java | 42 + .../org/gnunet/seaspider/parser/nodes/Node.java | 16 + .../gnunet/seaspider/parser/nodes/NodeChoice.java | 36 + .../gnunet/seaspider/parser/nodes/NodeList.java | 44 + .../seaspider/parser/nodes/NodeListInterface.java | 22 + .../seaspider/parser/nodes/NodeListOptional.java | 45 + .../seaspider/parser/nodes/NodeOptional.java | 41 + .../seaspider/parser/nodes/NodeSequence.java | 45 + .../gnunet/seaspider/parser/nodes/NodeToken.java | 87 + .../parser/nodes/ParameterDeclaration.java | 39 + .../seaspider/parser/nodes/ParameterList.java | 39 + .../org/gnunet/seaspider/parser/nodes/Pointer.java | 45 + .../seaspider/parser/nodes/PostfixExpression.java | 36 + .../seaspider/parser/nodes/PrimaryExpression.java | 35 + .../parser/nodes/RelationalExpression.java | 36 + .../seaspider/parser/nodes/SelectionStatement.java | 33 + .../seaspider/parser/nodes/ShiftExpression.java | 36 + .../gnunet/seaspider/parser/nodes/Statement.java | 33 + .../parser/nodes/StorageClassSpecifier.java | 33 + .../seaspider/parser/nodes/StructDeclaration.java | 53 + .../parser/nodes/StructDeclarationList.java | 33 + .../seaspider/parser/nodes/StructOrUnion.java | 33 + .../parser/nodes/StructOrUnionSpecifier.java | 34 + .../seaspider/parser/nodes/TranslationUnit.java | 33 + .../seaspider/parser/nodes/TypeDeclaration.java | 45 + .../seaspider/parser/nodes/TypeSpecifier.java | 42 + .../seaspider/parser/nodes/UnaryExpression.java | 33 + .../seaspider/parser/nodes/UnaryOperator.java | 33 + .../parser/nodes/VariableClassSpecifier.java | 33 + .../parser/nodes/VariableDeclaration.java | 49 + .../parser/visitors/DepthFirstVisitor.java | 701 +++ .../seaspider/parser/visitors/GJDepthFirst.java | 837 +++ .../parser/visitors/GJNoArguDepthFirst.java | 837 +++ .../seaspider/parser/visitors/GJNoArguVisitor.java | 508 ++ .../seaspider/parser/visitors/GJVisitor.java | 507 ++ .../parser/visitors/GJVoidDepthFirst.java | 711 +++ .../seaspider/parser/visitors/GJVoidVisitor.java | 508 ++ .../seaspider/parser/visitors/TreeDumper.java | 132 + .../seaspider/parser/visitors/TreeFormatter.java | 980 ++++ .../gnunet/seaspider/parser/visitors/Visitor.java | 508 ++ 85 files changed, 17043 insertions(+) create mode 100644 src/monkey/seaspider/org/gnunet/seaspider/parser/CParserConstants.java create mode 100644 src/monkey/seaspider/org/gnunet/seaspider/parser/CParserTokenManager.java create mode 100644 src/monkey/seaspider/org/gnunet/seaspider/parser/ExpressionDatabaseHandler.java create mode 100644 src/monkey/seaspider/org/gnunet/seaspider/parser/GNUnetDepthFirstVisitor.java create mode 100644 src/monkey/seaspider/org/gnunet/seaspider/parser/GNUnetParser.java create mode 100644 src/monkey/seaspider/org/gnunet/seaspider/parser/ParseException.java create mode 100644 src/monkey/seaspider/org/gnunet/seaspider/parser/SimpleCharStream.java create mode 100644 src/monkey/seaspider/org/gnunet/seaspider/parser/Token.java create mode 100644 src/monkey/seaspider/org/gnunet/seaspider/parser/TokenMgrError.java create mode 100644 src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/ANDExpression.java create mode 100644 src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/AdditiveExpression.java create mode 100644 src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/ArgumentExpressionList.java create mode 100644 src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/Array.java create mode 100644 src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/AssignmentExpression.java create mode 100644 src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/AssignmentOperator.java create mode 100644 src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/AssignmentOrTypeExpression.java create mode 100644 src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/CastExpression.java create mode 100644 src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/CompoundStatement.java create mode 100644 src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/ConditionalExpression.java create mode 100644 src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/Constant.java create mode 100644 src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/ConstantExpression.java create mode 100644 src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/DataType.java create mode 100644 src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/EnumSpecifier.java create mode 100644 src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/Enumerator.java create mode 100644 src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/EnumeratorList.java create mode 100644 src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/EqualityExpression.java create mode 100644 src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/ExclusiveORExpression.java create mode 100644 src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/Expression.java create mode 100644 src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/ExpressionStatement.java create mode 100644 src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/ExternalDeclaration.java create mode 100644 src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/FunctionDeclaration.java create mode 100644 src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/FunctionType.java create mode 100644 src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/IdentifierList.java create mode 100644 src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/InclusiveORExpression.java create mode 100644 src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/InitDeclarator.java create mode 100644 src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/InitDeclaratorList.java create mode 100644 src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/Initializer.java create mode 100644 src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/InitializerList.java create mode 100644 src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/IterationStatement.java create mode 100644 src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/JumpStatement.java create mode 100644 src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/LabeledStatement.java create mode 100644 src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/LocalVariableDeclaration.java create mode 100644 src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/LogicalANDExpression.java create mode 100644 src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/LogicalORExpression.java create mode 100644 src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/MultiplicativeExpression.java create mode 100644 src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/NoIdentifierTypeSpecifier.java create mode 100644 src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/Node.java create mode 100644 src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/NodeChoice.java create mode 100644 src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/NodeList.java create mode 100644 src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/NodeListInterface.java create mode 100644 src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/NodeListOptional.java create mode 100644 src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/NodeOptional.java create mode 100644 src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/NodeSequence.java create mode 100644 src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/NodeToken.java create mode 100644 src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/ParameterDeclaration.java create mode 100644 src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/ParameterList.java create mode 100644 src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/Pointer.java create mode 100644 src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/PostfixExpression.java create mode 100644 src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/PrimaryExpression.java create mode 100644 src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/RelationalExpression.java create mode 100644 src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/SelectionStatement.java create mode 100644 src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/ShiftExpression.java create mode 100644 src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/Statement.java create mode 100644 src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/StorageClassSpecifier.java create mode 100644 src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/StructDeclaration.java create mode 100644 src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/StructDeclarationList.java create mode 100644 src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/StructOrUnion.java create mode 100644 src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/StructOrUnionSpecifier.java create mode 100644 src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/TranslationUnit.java create mode 100644 src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/TypeDeclaration.java create mode 100644 src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/TypeSpecifier.java create mode 100644 src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/UnaryExpression.java create mode 100644 src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/UnaryOperator.java create mode 100644 src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/VariableClassSpecifier.java create mode 100644 src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/VariableDeclaration.java create mode 100644 src/monkey/seaspider/org/gnunet/seaspider/parser/visitors/DepthFirstVisitor.java create mode 100644 src/monkey/seaspider/org/gnunet/seaspider/parser/visitors/GJDepthFirst.java create mode 100644 src/monkey/seaspider/org/gnunet/seaspider/parser/visitors/GJNoArguDepthFirst.java create mode 100644 src/monkey/seaspider/org/gnunet/seaspider/parser/visitors/GJNoArguVisitor.java create mode 100644 src/monkey/seaspider/org/gnunet/seaspider/parser/visitors/GJVisitor.java create mode 100644 src/monkey/seaspider/org/gnunet/seaspider/parser/visitors/GJVoidDepthFirst.java create mode 100644 src/monkey/seaspider/org/gnunet/seaspider/parser/visitors/GJVoidVisitor.java create mode 100644 src/monkey/seaspider/org/gnunet/seaspider/parser/visitors/TreeDumper.java create mode 100644 src/monkey/seaspider/org/gnunet/seaspider/parser/visitors/TreeFormatter.java create mode 100644 src/monkey/seaspider/org/gnunet/seaspider/parser/visitors/Visitor.java (limited to 'src') diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/CParserConstants.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/CParserConstants.java new file mode 100644 index 000000000..44bd0d411 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/CParserConstants.java @@ -0,0 +1,209 @@ +package org.gnunet.seaspider.parser; +/* Generated By:JavaCC: Do not edit this line. CParserConstants.java */ + +/** + * Token literal values and constants. + * Generated by org.javacc.parser.OtherFilesGen#start() + */ +public interface CParserConstants { + + /** End of File. */ + int EOF = 0; + /** RegularExpression Id. */ + int INTEGER_LITERAL = 12; + /** RegularExpression Id. */ + int DECIMAL_LITERAL = 13; + /** RegularExpression Id. */ + int HEX_LITERAL = 14; + /** RegularExpression Id. */ + int OCTAL_LITERAL = 15; + /** RegularExpression Id. */ + int FLOATING_POINT_LITERAL = 16; + /** RegularExpression Id. */ + int EXPONENT = 17; + /** RegularExpression Id. */ + int CHARACTER_LITERAL = 18; + /** RegularExpression Id. */ + int STRING_LITERAL = 19; + /** RegularExpression Id. */ + int CONTINUE = 20; + /** RegularExpression Id. */ + int VOLATILE = 21; + /** RegularExpression Id. */ + int REGISTER = 22; + /** RegularExpression Id. */ + int UNSIGNED = 23; + /** RegularExpression Id. */ + int TYPEDEF = 24; + /** RegularExpression Id. */ + int DFLT = 25; + /** RegularExpression Id. */ + int DOUBLE = 26; + /** RegularExpression Id. */ + int SIZEOF = 27; + /** RegularExpression Id. */ + int SWITCH = 28; + /** RegularExpression Id. */ + int RETURN = 29; + /** RegularExpression Id. */ + int EXTERN = 30; + /** RegularExpression Id. */ + int STRUCT = 31; + /** RegularExpression Id. */ + int STATIC = 32; + /** RegularExpression Id. */ + int SIGNED = 33; + /** RegularExpression Id. */ + int WHILE = 34; + /** RegularExpression Id. */ + int BREAK = 35; + /** RegularExpression Id. */ + int UNION = 36; + /** RegularExpression Id. */ + int CONST = 37; + /** RegularExpression Id. */ + int FLOAT = 38; + /** RegularExpression Id. */ + int SHORT = 39; + /** RegularExpression Id. */ + int ELSE = 40; + /** RegularExpression Id. */ + int CASE = 41; + /** RegularExpression Id. */ + int LONG = 42; + /** RegularExpression Id. */ + int ENUM = 43; + /** RegularExpression Id. */ + int AUTO = 44; + /** RegularExpression Id. */ + int VOID = 45; + /** RegularExpression Id. */ + int CHAR = 46; + /** RegularExpression Id. */ + int GOTO = 47; + /** RegularExpression Id. */ + int FOR = 48; + /** RegularExpression Id. */ + int INT = 49; + /** RegularExpression Id. */ + int IF = 50; + /** RegularExpression Id. */ + int DO = 51; + /** RegularExpression Id. */ + int IDENTIFIER = 52; + /** RegularExpression Id. */ + int LETTER = 53; + /** RegularExpression Id. */ + int DIGIT = 54; + + /** Lexical state. */ + int DEFAULT = 0; + /** Lexical state. */ + int PREPROCESSOR_OUTPUT = 1; + + /** Literal token values. */ + String[] tokenImage = { + "", + "\" \"", + "\"\\t\"", + "\"\\n\"", + "\"\\r\"", + "", + "", + "\"#\"", + "\"\\n\"", + "\"\\\\\\n\"", + "\"\\\\\\r\\n\"", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "\"continue\"", + "\"volatile\"", + "\"register\"", + "\"unsigned\"", + "\"typedef\"", + "\"default\"", + "\"double\"", + "\"sizeof\"", + "\"switch\"", + "\"return\"", + "\"extern\"", + "\"struct\"", + "\"static\"", + "\"signed\"", + "\"while\"", + "\"break\"", + "\"union\"", + "\"const\"", + "\"float\"", + "\"short\"", + "\"else\"", + "\"case\"", + "\"long\"", + "\"enum\"", + "\"auto\"", + "\"void\"", + "\"char\"", + "\"goto\"", + "\"for\"", + "\"int\"", + "\"if\"", + "\"do\"", + "", + "", + "", + "\"(\"", + "\")\"", + "\";\"", + "\"*\"", + "\",\"", + "\"...\"", + "\"{\"", + "\"}\"", + "\"=\"", + "\":\"", + "\"[\"", + "\"]\"", + "\"*=\"", + "\"/=\"", + "\"%=\"", + "\"+=\"", + "\"-=\"", + "\"<<=\"", + "\">>=\"", + "\"&=\"", + "\"^=\"", + "\"|=\"", + "\"?\"", + "\"||\"", + "\"&&\"", + "\"|\"", + "\"^\"", + "\"&\"", + "\"==\"", + "\"!=\"", + "\"<\"", + "\">\"", + "\"<=\"", + "\">=\"", + "\"<<\"", + "\">>\"", + "\"+\"", + "\"-\"", + "\"/\"", + "\"%\"", + "\"++\"", + "\"--\"", + "\"~\"", + "\"!\"", + "\".\"", + "\"->\"", + }; + +} diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/CParserTokenManager.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/CParserTokenManager.java new file mode 100644 index 000000000..41930bf36 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/CParserTokenManager.java @@ -0,0 +1,1413 @@ +package org.gnunet.seaspider.parser; +/* Generated By:JavaCC: Do not edit this line. CParserTokenManager.java */ +import java.util.*; + +import org.gnunet.seaspider.parser.nodes.*; + +import java.util.Vector; + +/** Token Manager. */ +public class CParserTokenManager implements CParserConstants +{ + + /** Debug output. */ + public java.io.PrintStream debugStream = System.out; + /** Set debug output. */ + public void setDebugStream(java.io.PrintStream ds) { debugStream = ds; } +private final int jjStopStringLiteralDfa_0(int pos, long active0, long active1) +{ + switch (pos) + { + case 0: + if ((active1 & 0x20000010L) != 0L) + return 65; + if ((active0 & 0xffffffff00000L) != 0L) + { + jjmatchedKind = 52; + return 42; + } + if ((active0 & 0x1000000000000000L) != 0L || (active1 & 0x800000000L) != 0L) + return 5; + return -1; + case 1: + if ((active0 & 0xc000004000000L) != 0L) + return 42; + if ((active0 & 0x3fffffbf00000L) != 0L) + { + if (jjmatchedPos != 1) + { + jjmatchedKind = 52; + jjmatchedPos = 1; + } + return 42; + } + return -1; + case 2: + if ((active0 & 0xfffffff00000L) != 0L) + { + jjmatchedKind = 52; + jjmatchedPos = 2; + return 42; + } + if ((active0 & 0x3000000000000L) != 0L) + return 42; + return -1; + case 3: + if ((active0 & 0xfffff00000L) != 0L) + { + jjmatchedKind = 52; + jjmatchedPos = 3; + return 42; + } + if ((active0 & 0xff0000000000L) != 0L) + return 42; + return -1; + case 4: + if ((active0 & 0x3fff00000L) != 0L) + { + jjmatchedKind = 52; + jjmatchedPos = 4; + return 42; + } + if ((active0 & 0xfc00000000L) != 0L) + return 42; + return -1; + case 5: + if ((active0 & 0x3fc000000L) != 0L) + return 42; + if ((active0 & 0x3f00000L) != 0L) + { + jjmatchedKind = 52; + jjmatchedPos = 5; + return 42; + } + return -1; + case 6: + if ((active0 & 0xf00000L) != 0L) + { + jjmatchedKind = 52; + jjmatchedPos = 6; + return 42; + } + if ((active0 & 0x3000000L) != 0L) + return 42; + return -1; + default : + return -1; + } +} +private final int jjStartNfa_0(int pos, long active0, long active1) +{ + return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0, active1), pos + 1); +} +private int jjStopAtPos(int pos, int kind) +{ + jjmatchedKind = kind; + jjmatchedPos = pos; + return pos + 1; +} +private int jjMoveStringLiteralDfa0_0() +{ + switch(curChar) + { + case 33: + jjmatchedKind = 98; + return jjMoveStringLiteralDfa1_0(0x0L, 0x100000L); + case 35: + return jjStopAtPos(0, 7); + case 37: + jjmatchedKind = 94; + return jjMoveStringLiteralDfa1_0(0x0L, 0x20L); + case 38: + jjmatchedKind = 82; + return jjMoveStringLiteralDfa1_0(0x0L, 0x8400L); + case 40: + return jjStopAtPos(0, 55); + case 41: + return jjStopAtPos(0, 56); + case 42: + jjmatchedKind = 58; + return jjMoveStringLiteralDfa1_0(0x0L, 0x8L); + case 43: + jjmatchedKind = 91; + return jjMoveStringLiteralDfa1_0(0x0L, 0x80000040L); + case 44: + return jjStopAtPos(0, 59); + case 45: + jjmatchedKind = 92; + return jjMoveStringLiteralDfa1_0(0x0L, 0x1100000080L); + case 46: + jjmatchedKind = 99; + return jjMoveStringLiteralDfa1_0(0x1000000000000000L, 0x0L); + case 47: + jjmatchedKind = 93; + return jjMoveStringLiteralDfa1_0(0x0L, 0x10L); + case 58: + return jjStopAtPos(0, 64); + case 59: + return jjStopAtPos(0, 57); + case 60: + jjmatchedKind = 85; + return jjMoveStringLiteralDfa1_0(0x0L, 0x2800100L); + case 61: + jjmatchedKind = 63; + return jjMoveStringLiteralDfa1_0(0x0L, 0x80000L); + case 62: + jjmatchedKind = 86; + return jjMoveStringLiteralDfa1_0(0x0L, 0x5000200L); + case 63: + return jjStopAtPos(0, 77); + case 91: + return jjStopAtPos(0, 65); + case 93: + return jjStopAtPos(0, 66); + case 94: + jjmatchedKind = 81; + return jjMoveStringLiteralDfa1_0(0x0L, 0x800L); + case 97: + return jjMoveStringLiteralDfa1_0(0x100000000000L, 0x0L); + case 98: + return jjMoveStringLiteralDfa1_0(0x800000000L, 0x0L); + case 99: + return jjMoveStringLiteralDfa1_0(0x422000100000L, 0x0L); + case 100: + return jjMoveStringLiteralDfa1_0(0x8000006000000L, 0x0L); + case 101: + return jjMoveStringLiteralDfa1_0(0x90040000000L, 0x0L); + case 102: + return jjMoveStringLiteralDfa1_0(0x1004000000000L, 0x0L); + case 103: + return jjMoveStringLiteralDfa1_0(0x800000000000L, 0x0L); + case 105: + return jjMoveStringLiteralDfa1_0(0x6000000000000L, 0x0L); + case 108: + return jjMoveStringLiteralDfa1_0(0x40000000000L, 0x0L); + case 114: + return jjMoveStringLiteralDfa1_0(0x20400000L, 0x0L); + case 115: + return jjMoveStringLiteralDfa1_0(0x8398000000L, 0x0L); + case 116: + return jjMoveStringLiteralDfa1_0(0x1000000L, 0x0L); + case 117: + return jjMoveStringLiteralDfa1_0(0x1000800000L, 0x0L); + case 118: + return jjMoveStringLiteralDfa1_0(0x200000200000L, 0x0L); + case 119: + return jjMoveStringLiteralDfa1_0(0x400000000L, 0x0L); + case 123: + return jjStopAtPos(0, 61); + case 124: + jjmatchedKind = 80; + return jjMoveStringLiteralDfa1_0(0x0L, 0x5000L); + case 125: + return jjStopAtPos(0, 62); + case 126: + return jjStopAtPos(0, 97); + default : + return jjMoveNfa_0(0, 0); + } +} +private int jjMoveStringLiteralDfa1_0(long active0, long active1) +{ + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(0, active0, active1); + return 1; + } + switch(curChar) + { + case 38: + if ((active1 & 0x8000L) != 0L) + return jjStopAtPos(1, 79); + break; + case 43: + if ((active1 & 0x80000000L) != 0L) + return jjStopAtPos(1, 95); + break; + case 45: + if ((active1 & 0x100000000L) != 0L) + return jjStopAtPos(1, 96); + break; + case 46: + return jjMoveStringLiteralDfa2_0(active0, 0x1000000000000000L, active1, 0L); + case 60: + if ((active1 & 0x2000000L) != 0L) + { + jjmatchedKind = 89; + jjmatchedPos = 1; + } + return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x100L); + case 61: + if ((active1 & 0x8L) != 0L) + return jjStopAtPos(1, 67); + else if ((active1 & 0x10L) != 0L) + return jjStopAtPos(1, 68); + else if ((active1 & 0x20L) != 0L) + return jjStopAtPos(1, 69); + else if ((active1 & 0x40L) != 0L) + return jjStopAtPos(1, 70); + else if ((active1 & 0x80L) != 0L) + return jjStopAtPos(1, 71); + else if ((active1 & 0x400L) != 0L) + return jjStopAtPos(1, 74); + else if ((active1 & 0x800L) != 0L) + return jjStopAtPos(1, 75); + else if ((active1 & 0x1000L) != 0L) + return jjStopAtPos(1, 76); + else if ((active1 & 0x80000L) != 0L) + return jjStopAtPos(1, 83); + else if ((active1 & 0x100000L) != 0L) + return jjStopAtPos(1, 84); + else if ((active1 & 0x800000L) != 0L) + return jjStopAtPos(1, 87); + else if ((active1 & 0x1000000L) != 0L) + return jjStopAtPos(1, 88); + break; + case 62: + if ((active1 & 0x4000000L) != 0L) + { + jjmatchedKind = 90; + jjmatchedPos = 1; + } + else if ((active1 & 0x1000000000L) != 0L) + return jjStopAtPos(1, 100); + return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x200L); + case 97: + return jjMoveStringLiteralDfa2_0(active0, 0x20000000000L, active1, 0L); + case 101: + return jjMoveStringLiteralDfa2_0(active0, 0x22400000L, active1, 0L); + case 102: + if ((active0 & 0x4000000000000L) != 0L) + return jjStartNfaWithStates_0(1, 50, 42); + break; + case 104: + return jjMoveStringLiteralDfa2_0(active0, 0x408400000000L, active1, 0L); + case 105: + return jjMoveStringLiteralDfa2_0(active0, 0x208000000L, active1, 0L); + case 108: + return jjMoveStringLiteralDfa2_0(active0, 0x14000000000L, active1, 0L); + case 110: + return jjMoveStringLiteralDfa2_0(active0, 0x2081000800000L, active1, 0L); + case 111: + if ((active0 & 0x8000000000000L) != 0L) + { + jjmatchedKind = 51; + jjmatchedPos = 1; + } + return jjMoveStringLiteralDfa2_0(active0, 0x1a42004300000L, active1, 0L); + case 114: + return jjMoveStringLiteralDfa2_0(active0, 0x800000000L, active1, 0L); + case 116: + return jjMoveStringLiteralDfa2_0(active0, 0x180000000L, active1, 0L); + case 117: + return jjMoveStringLiteralDfa2_0(active0, 0x100000000000L, active1, 0L); + case 119: + return jjMoveStringLiteralDfa2_0(active0, 0x10000000L, active1, 0L); + case 120: + return jjMoveStringLiteralDfa2_0(active0, 0x40000000L, active1, 0L); + case 121: + return jjMoveStringLiteralDfa2_0(active0, 0x1000000L, active1, 0L); + case 124: + if ((active1 & 0x4000L) != 0L) + return jjStopAtPos(1, 78); + break; + default : + break; + } + return jjStartNfa_0(0, active0, active1); +} +private int jjMoveStringLiteralDfa2_0(long old0, long active0, long old1, long active1) +{ + if (((active0 &= old0) | (active1 &= old1)) == 0L) + return jjStartNfa_0(0, old0, old1); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(1, active0, active1); + return 2; + } + switch(curChar) + { + case 46: + if ((active0 & 0x1000000000000000L) != 0L) + return jjStopAtPos(2, 60); + break; + case 61: + if ((active1 & 0x100L) != 0L) + return jjStopAtPos(2, 72); + else if ((active1 & 0x200L) != 0L) + return jjStopAtPos(2, 73); + break; + case 97: + return jjMoveStringLiteralDfa3_0(active0, 0x400100000000L, active1, 0L); + case 101: + return jjMoveStringLiteralDfa3_0(active0, 0x800000000L, active1, 0L); + case 102: + return jjMoveStringLiteralDfa3_0(active0, 0x2000000L, active1, 0L); + case 103: + return jjMoveStringLiteralDfa3_0(active0, 0x200400000L, active1, 0L); + case 105: + return jjMoveStringLiteralDfa3_0(active0, 0x201410000000L, active1, 0L); + case 108: + return jjMoveStringLiteralDfa3_0(active0, 0x200000L, active1, 0L); + case 110: + return jjMoveStringLiteralDfa3_0(active0, 0x42000100000L, active1, 0L); + case 111: + return jjMoveStringLiteralDfa3_0(active0, 0xc000000000L, active1, 0L); + case 112: + return jjMoveStringLiteralDfa3_0(active0, 0x1000000L, active1, 0L); + case 114: + if ((active0 & 0x1000000000000L) != 0L) + return jjStartNfaWithStates_0(2, 48, 42); + return jjMoveStringLiteralDfa3_0(active0, 0x80000000L, active1, 0L); + case 115: + return jjMoveStringLiteralDfa3_0(active0, 0x30000800000L, active1, 0L); + case 116: + if ((active0 & 0x2000000000000L) != 0L) + return jjStartNfaWithStates_0(2, 49, 42); + return jjMoveStringLiteralDfa3_0(active0, 0x900060000000L, active1, 0L); + case 117: + return jjMoveStringLiteralDfa3_0(active0, 0x80004000000L, active1, 0L); + case 122: + return jjMoveStringLiteralDfa3_0(active0, 0x8000000L, active1, 0L); + default : + break; + } + return jjStartNfa_0(1, active0, active1); +} +private int jjMoveStringLiteralDfa3_0(long old0, long active0, long old1, long active1) +{ + if (((active0 &= old0) | (active1 &= old1)) == 0L) + return jjStartNfa_0(1, old0, old1); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(2, active0, 0L); + return 3; + } + switch(curChar) + { + case 97: + return jjMoveStringLiteralDfa4_0(active0, 0x4802200000L); + case 98: + return jjMoveStringLiteralDfa4_0(active0, 0x4000000L); + case 100: + if ((active0 & 0x200000000000L) != 0L) + return jjStartNfaWithStates_0(3, 45, 42); + break; + case 101: + if ((active0 & 0x10000000000L) != 0L) + return jjStartNfaWithStates_0(3, 40, 42); + else if ((active0 & 0x20000000000L) != 0L) + return jjStartNfaWithStates_0(3, 41, 42); + return jjMoveStringLiteralDfa4_0(active0, 0x49000000L); + case 103: + if ((active0 & 0x40000000000L) != 0L) + return jjStartNfaWithStates_0(3, 42, 42); + break; + case 105: + return jjMoveStringLiteralDfa4_0(active0, 0xc00000L); + case 108: + return jjMoveStringLiteralDfa4_0(active0, 0x400000000L); + case 109: + if ((active0 & 0x80000000000L) != 0L) + return jjStartNfaWithStates_0(3, 43, 42); + break; + case 110: + return jjMoveStringLiteralDfa4_0(active0, 0x200000000L); + case 111: + if ((active0 & 0x100000000000L) != 0L) + return jjStartNfaWithStates_0(3, 44, 42); + else if ((active0 & 0x800000000000L) != 0L) + return jjStartNfaWithStates_0(3, 47, 42); + return jjMoveStringLiteralDfa4_0(active0, 0x1000000000L); + case 114: + if ((active0 & 0x400000000000L) != 0L) + return jjStartNfaWithStates_0(3, 46, 42); + return jjMoveStringLiteralDfa4_0(active0, 0x8000000000L); + case 115: + return jjMoveStringLiteralDfa4_0(active0, 0x2000000000L); + case 116: + return jjMoveStringLiteralDfa4_0(active0, 0x110100000L); + case 117: + return jjMoveStringLiteralDfa4_0(active0, 0xa0000000L); + default : + break; + } + return jjStartNfa_0(2, active0, 0L); +} +private int jjMoveStringLiteralDfa4_0(long old0, long active0) +{ + if (((active0 &= old0)) == 0L) + return jjStartNfa_0(2, old0, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(3, active0, 0L); + return 4; + } + switch(curChar) + { + case 99: + return jjMoveStringLiteralDfa5_0(active0, 0x90000000L); + case 100: + return jjMoveStringLiteralDfa5_0(active0, 0x1000000L); + case 101: + if ((active0 & 0x400000000L) != 0L) + return jjStartNfaWithStates_0(4, 34, 42); + return jjMoveStringLiteralDfa5_0(active0, 0x200000000L); + case 103: + return jjMoveStringLiteralDfa5_0(active0, 0x800000L); + case 105: + return jjMoveStringLiteralDfa5_0(active0, 0x100100000L); + case 107: + if ((active0 & 0x800000000L) != 0L) + return jjStartNfaWithStates_0(4, 35, 42); + break; + case 108: + return jjMoveStringLiteralDfa5_0(active0, 0x4000000L); + case 110: + if ((active0 & 0x1000000000L) != 0L) + return jjStartNfaWithStates_0(4, 36, 42); + break; + case 111: + return jjMoveStringLiteralDfa5_0(active0, 0x8000000L); + case 114: + return jjMoveStringLiteralDfa5_0(active0, 0x60000000L); + case 115: + return jjMoveStringLiteralDfa5_0(active0, 0x400000L); + case 116: + if ((active0 & 0x2000000000L) != 0L) + return jjStartNfaWithStates_0(4, 37, 42); + else if ((active0 & 0x4000000000L) != 0L) + return jjStartNfaWithStates_0(4, 38, 42); + else if ((active0 & 0x8000000000L) != 0L) + return jjStartNfaWithStates_0(4, 39, 42); + return jjMoveStringLiteralDfa5_0(active0, 0x200000L); + case 117: + return jjMoveStringLiteralDfa5_0(active0, 0x2000000L); + default : + break; + } + return jjStartNfa_0(3, active0, 0L); +} +private int jjMoveStringLiteralDfa5_0(long old0, long active0) +{ + if (((active0 &= old0)) == 0L) + return jjStartNfa_0(3, old0, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(4, active0, 0L); + return 5; + } + switch(curChar) + { + case 99: + if ((active0 & 0x100000000L) != 0L) + return jjStartNfaWithStates_0(5, 32, 42); + break; + case 100: + if ((active0 & 0x200000000L) != 0L) + return jjStartNfaWithStates_0(5, 33, 42); + break; + case 101: + if ((active0 & 0x4000000L) != 0L) + return jjStartNfaWithStates_0(5, 26, 42); + return jjMoveStringLiteralDfa6_0(active0, 0x1000000L); + case 102: + if ((active0 & 0x8000000L) != 0L) + return jjStartNfaWithStates_0(5, 27, 42); + break; + case 104: + if ((active0 & 0x10000000L) != 0L) + return jjStartNfaWithStates_0(5, 28, 42); + break; + case 105: + return jjMoveStringLiteralDfa6_0(active0, 0x200000L); + case 108: + return jjMoveStringLiteralDfa6_0(active0, 0x2000000L); + case 110: + if ((active0 & 0x20000000L) != 0L) + return jjStartNfaWithStates_0(5, 29, 42); + else if ((active0 & 0x40000000L) != 0L) + return jjStartNfaWithStates_0(5, 30, 42); + return jjMoveStringLiteralDfa6_0(active0, 0x900000L); + case 116: + if ((active0 & 0x80000000L) != 0L) + return jjStartNfaWithStates_0(5, 31, 42); + return jjMoveStringLiteralDfa6_0(active0, 0x400000L); + default : + break; + } + return jjStartNfa_0(4, active0, 0L); +} +private int jjMoveStringLiteralDfa6_0(long old0, long active0) +{ + if (((active0 &= old0)) == 0L) + return jjStartNfa_0(4, old0, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(5, active0, 0L); + return 6; + } + switch(curChar) + { + case 101: + return jjMoveStringLiteralDfa7_0(active0, 0xc00000L); + case 102: + if ((active0 & 0x1000000L) != 0L) + return jjStartNfaWithStates_0(6, 24, 42); + break; + case 108: + return jjMoveStringLiteralDfa7_0(active0, 0x200000L); + case 116: + if ((active0 & 0x2000000L) != 0L) + return jjStartNfaWithStates_0(6, 25, 42); + break; + case 117: + return jjMoveStringLiteralDfa7_0(active0, 0x100000L); + default : + break; + } + return jjStartNfa_0(5, active0, 0L); +} +private int jjMoveStringLiteralDfa7_0(long old0, long active0) +{ + if (((active0 &= old0)) == 0L) + return jjStartNfa_0(5, old0, 0L); + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + jjStopStringLiteralDfa_0(6, active0, 0L); + return 7; + } + switch(curChar) + { + case 100: + if ((active0 & 0x800000L) != 0L) + return jjStartNfaWithStates_0(7, 23, 42); + break; + case 101: + if ((active0 & 0x100000L) != 0L) + return jjStartNfaWithStates_0(7, 20, 42); + else if ((active0 & 0x200000L) != 0L) + return jjStartNfaWithStates_0(7, 21, 42); + break; + case 114: + if ((active0 & 0x400000L) != 0L) + return jjStartNfaWithStates_0(7, 22, 42); + break; + default : + break; + } + return jjStartNfa_0(6, active0, 0L); +} +private int jjStartNfaWithStates_0(int pos, int kind, int state) +{ + jjmatchedKind = kind; + jjmatchedPos = pos; + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { return pos + 1; } + return jjMoveNfa_0(state, pos + 1); +} +static final long[] jjbitVec0 = { + 0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL +}; +private int jjMoveNfa_0(int startState, int curPos) +{ + int startsAt = 0; + jjnewStateCnt = 76; + int i = 1; + jjstateSet[0] = startState; + int kind = 0x7fffffff; + for (;;) + { + if (++jjround == 0x7fffffff) + ReInitRounds(); + if (curChar < 64) + { + long l = 1L << curChar; + do + { + switch(jjstateSet[--i]) + { + case 65: + if (curChar == 42) + jjCheckNAddTwoStates(71, 72); + else if (curChar == 47) + jjCheckNAddStates(0, 2); + break; + case 0: + if ((0x3ff000000000000L & l) != 0L) + jjCheckNAddStates(3, 9); + else if (curChar == 47) + jjAddStates(10, 11); + else if (curChar == 36) + { + if (kind > 52) + kind = 52; + jjCheckNAdd(42); + } + else if (curChar == 34) + jjCheckNAddStates(12, 14); + else if (curChar == 39) + jjAddStates(15, 16); + else if (curChar == 46) + jjCheckNAdd(5); + if ((0x3fe000000000000L & l) != 0L) + { + if (kind > 12) + kind = 12; + jjCheckNAddTwoStates(1, 2); + } + else if (curChar == 48) + { + if (kind > 12) + kind = 12; + jjCheckNAddStates(17, 19); + } + break; + case 1: + if ((0x3ff000000000000L & l) == 0L) + break; + if (kind > 12) + kind = 12; + jjCheckNAddTwoStates(1, 2); + break; + case 4: + if (curChar == 46) + jjCheckNAdd(5); + break; + case 5: + if ((0x3ff000000000000L & l) == 0L) + break; + if (kind > 16) + kind = 16; + jjCheckNAddStates(20, 22); + break; + case 7: + if ((0x280000000000L & l) != 0L) + jjCheckNAdd(8); + break; + case 8: + if ((0x3ff000000000000L & l) == 0L) + break; + if (kind > 16) + kind = 16; + jjCheckNAddTwoStates(8, 9); + break; + case 10: + if (curChar == 39) + jjAddStates(15, 16); + break; + case 11: + if ((0xffffff7fffffdbffL & l) != 0L) + jjCheckNAdd(12); + break; + case 12: + if (curChar == 39 && kind > 18) + kind = 18; + break; + case 14: + if ((0x8400000000L & l) != 0L) + jjCheckNAdd(12); + break; + case 15: + if ((0xff000000000000L & l) != 0L) + jjCheckNAddTwoStates(16, 12); + break; + case 16: + if ((0xff000000000000L & l) != 0L) + jjCheckNAdd(12); + break; + case 17: + if ((0xf000000000000L & l) != 0L) + jjstateSet[jjnewStateCnt++] = 18; + break; + case 18: + if ((0xff000000000000L & l) != 0L) + jjCheckNAdd(16); + break; + case 19: + if (curChar == 34) + jjCheckNAddStates(12, 14); + break; + case 20: + if ((0xfffffffbffffdbffL & l) != 0L) + jjCheckNAddStates(12, 14); + break; + case 22: + if ((0x8400002400L & l) != 0L) + jjCheckNAddStates(12, 14); + break; + case 23: + if (curChar != 34) + break; + if (kind > 19) + kind = 19; + jjCheckNAddTwoStates(24, 25); + break; + case 24: + if ((0x100002400L & l) != 0L) + jjCheckNAddTwoStates(24, 25); + break; + case 25: + if (curChar == 34) + jjCheckNAddStates(23, 25); + break; + case 26: + if ((0xfffffffbffffdbffL & l) != 0L) + jjCheckNAddStates(23, 25); + break; + case 28: + if ((0x8400002400L & l) != 0L) + jjCheckNAddStates(23, 25); + break; + case 29: + if ((0xff000000000000L & l) != 0L) + jjCheckNAddStates(26, 29); + break; + case 30: + if ((0xff000000000000L & l) != 0L) + jjCheckNAddStates(23, 25); + break; + case 31: + if ((0xf000000000000L & l) != 0L) + jjstateSet[jjnewStateCnt++] = 32; + break; + case 32: + if ((0xff000000000000L & l) != 0L) + jjCheckNAdd(30); + break; + case 33: + if (curChar == 10) + jjCheckNAddStates(23, 25); + break; + case 34: + if (curChar == 13) + jjstateSet[jjnewStateCnt++] = 33; + break; + case 35: + if ((0xff000000000000L & l) != 0L) + jjCheckNAddStates(30, 33); + break; + case 36: + if ((0xff000000000000L & l) != 0L) + jjCheckNAddStates(12, 14); + break; + case 37: + if ((0xf000000000000L & l) != 0L) + jjstateSet[jjnewStateCnt++] = 38; + break; + case 38: + if ((0xff000000000000L & l) != 0L) + jjCheckNAdd(36); + break; + case 39: + if (curChar == 10) + jjCheckNAddStates(12, 14); + break; + case 40: + if (curChar == 13) + jjstateSet[jjnewStateCnt++] = 39; + break; + case 41: + if (curChar != 36) + break; + if (kind > 52) + kind = 52; + jjCheckNAdd(42); + break; + case 42: + if ((0x3ff001000000000L & l) == 0L) + break; + if (kind > 52) + kind = 52; + jjCheckNAdd(42); + break; + case 43: + if ((0x3ff000000000000L & l) != 0L) + jjCheckNAddStates(3, 9); + break; + case 44: + if ((0x3ff000000000000L & l) != 0L) + jjCheckNAddTwoStates(44, 45); + break; + case 45: + if (curChar != 46) + break; + if (kind > 16) + kind = 16; + jjCheckNAddStates(34, 36); + break; + case 46: + if ((0x3ff000000000000L & l) == 0L) + break; + if (kind > 16) + kind = 16; + jjCheckNAddStates(34, 36); + break; + case 48: + if ((0x280000000000L & l) != 0L) + jjCheckNAdd(49); + break; + case 49: + if ((0x3ff000000000000L & l) == 0L) + break; + if (kind > 16) + kind = 16; + jjCheckNAddTwoStates(49, 9); + break; + case 50: + if ((0x3ff000000000000L & l) != 0L) + jjCheckNAddTwoStates(50, 51); + break; + case 52: + if ((0x280000000000L & l) != 0L) + jjCheckNAdd(53); + break; + case 53: + if ((0x3ff000000000000L & l) == 0L) + break; + if (kind > 16) + kind = 16; + jjCheckNAddTwoStates(53, 9); + break; + case 54: + if ((0x3ff000000000000L & l) != 0L) + jjCheckNAddStates(37, 39); + break; + case 56: + if ((0x280000000000L & l) != 0L) + jjCheckNAdd(57); + break; + case 57: + if ((0x3ff000000000000L & l) != 0L) + jjCheckNAddTwoStates(57, 9); + break; + case 58: + if (curChar != 48) + break; + if (kind > 12) + kind = 12; + jjCheckNAddStates(17, 19); + break; + case 60: + if ((0x3ff000000000000L & l) == 0L) + break; + if (kind > 12) + kind = 12; + jjAddStates(40, 41); + break; + case 62: + if ((0xff000000000000L & l) == 0L) + break; + if (kind > 12) + kind = 12; + jjCheckNAddTwoStates(62, 63); + break; + case 64: + if (curChar == 47) + jjAddStates(10, 11); + break; + case 66: + if ((0xffffffffffffdbffL & l) != 0L) + jjCheckNAddStates(0, 2); + break; + case 67: + if ((0x2400L & l) != 0L && kind > 5) + kind = 5; + break; + case 68: + if (curChar == 10 && kind > 5) + kind = 5; + break; + case 69: + if (curChar == 13) + jjstateSet[jjnewStateCnt++] = 68; + break; + case 70: + if (curChar == 42) + jjCheckNAddTwoStates(71, 72); + break; + case 71: + if ((0xfffffbffffffffffL & l) != 0L) + jjCheckNAddTwoStates(71, 72); + break; + case 72: + if (curChar == 42) + jjCheckNAddStates(42, 44); + break; + case 73: + if ((0xffff7bffffffffffL & l) != 0L) + jjCheckNAddTwoStates(74, 72); + break; + case 74: + if ((0xfffffbffffffffffL & l) != 0L) + jjCheckNAddTwoStates(74, 72); + break; + case 75: + if (curChar == 47 && kind > 6) + kind = 6; + break; + default : break; + } + } while(i != startsAt); + } + else if (curChar < 128) + { + long l = 1L << (curChar & 077); + do + { + switch(jjstateSet[--i]) + { + case 0: + case 42: + if ((0x7fffffe87fffffeL & l) == 0L) + break; + if (kind > 52) + kind = 52; + jjCheckNAdd(42); + break; + case 2: + case 61: + case 63: + if ((0x100000001000L & l) == 0L) + break; + if (kind > 12) + kind = 12; + jjCheckNAdd(3); + break; + case 3: + if ((0x100000001000L & l) != 0L && kind > 12) + kind = 12; + break; + case 6: + if ((0x2000000020L & l) != 0L) + jjAddStates(45, 46); + break; + case 9: + if ((0x5000000050L & l) != 0L && kind > 16) + kind = 16; + break; + case 11: + if ((0xffffffffefffffffL & l) != 0L) + jjCheckNAdd(12); + break; + case 13: + if (curChar == 92) + jjAddStates(47, 49); + break; + case 14: + if ((0x14404410000000L & l) != 0L) + jjCheckNAdd(12); + break; + case 20: + if ((0xffffffffefffffffL & l) != 0L) + jjCheckNAddStates(12, 14); + break; + case 21: + if (curChar == 92) + jjAddStates(50, 53); + break; + case 22: + if ((0x14404410000000L & l) != 0L) + jjCheckNAddStates(12, 14); + break; + case 26: + if ((0xffffffffefffffffL & l) != 0L) + jjCheckNAddStates(23, 25); + break; + case 27: + if (curChar == 92) + jjAddStates(54, 57); + break; + case 28: + if ((0x14404410000000L & l) != 0L) + jjCheckNAddStates(23, 25); + break; + case 47: + if ((0x2000000020L & l) != 0L) + jjAddStates(58, 59); + break; + case 51: + if ((0x2000000020L & l) != 0L) + jjAddStates(60, 61); + break; + case 55: + if ((0x2000000020L & l) != 0L) + jjAddStates(62, 63); + break; + case 59: + if ((0x100000001000000L & l) != 0L) + jjCheckNAdd(60); + break; + case 60: + if ((0x7e0000007eL & l) == 0L) + break; + if (kind > 12) + kind = 12; + jjCheckNAddTwoStates(60, 61); + break; + case 66: + jjAddStates(0, 2); + break; + case 71: + jjCheckNAddTwoStates(71, 72); + break; + case 73: + case 74: + jjCheckNAddTwoStates(74, 72); + break; + default : break; + } + } while(i != startsAt); + } + else + { + int i2 = (curChar & 0xff) >> 6; + long l2 = 1L << (curChar & 077); + do + { + switch(jjstateSet[--i]) + { + case 11: + if ((jjbitVec0[i2] & l2) != 0L) + jjstateSet[jjnewStateCnt++] = 12; + break; + case 20: + if ((jjbitVec0[i2] & l2) != 0L) + jjCheckNAddStates(12, 14); + break; + case 26: + if ((jjbitVec0[i2] & l2) != 0L) + jjCheckNAddStates(23, 25); + break; + case 66: + if ((jjbitVec0[i2] & l2) != 0L) + jjAddStates(0, 2); + break; + case 71: + if ((jjbitVec0[i2] & l2) != 0L) + jjCheckNAddTwoStates(71, 72); + break; + case 73: + case 74: + if ((jjbitVec0[i2] & l2) != 0L) + jjCheckNAddTwoStates(74, 72); + break; + default : break; + } + } while(i != startsAt); + } + if (kind != 0x7fffffff) + { + jjmatchedKind = kind; + jjmatchedPos = curPos; + kind = 0x7fffffff; + } + ++curPos; + if ((i = jjnewStateCnt) == (startsAt = 76 - (jjnewStateCnt = startsAt))) + return curPos; + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { return curPos; } + } +} +private int jjMoveStringLiteralDfa0_1() +{ + switch(curChar) + { + case 10: + return jjStopAtPos(0, 8); + case 92: + return jjMoveStringLiteralDfa1_1(0x600L); + default : + return 1; + } +} +private int jjMoveStringLiteralDfa1_1(long active0) +{ + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + return 1; + } + switch(curChar) + { + case 10: + if ((active0 & 0x200L) != 0L) + return jjStopAtPos(1, 9); + break; + case 13: + return jjMoveStringLiteralDfa2_1(active0, 0x400L); + default : + return 2; + } + return 2; +} +private int jjMoveStringLiteralDfa2_1(long old0, long active0) +{ + if (((active0 &= old0)) == 0L) + return 2; + try { curChar = input_stream.readChar(); } + catch(java.io.IOException e) { + return 2; + } + switch(curChar) + { + case 10: + if ((active0 & 0x400L) != 0L) + return jjStopAtPos(2, 10); + break; + default : + return 3; + } + return 3; +} +static final int[] jjnextStates = { + 66, 67, 69, 44, 45, 50, 51, 54, 55, 9, 65, 70, 20, 21, 23, 11, + 13, 59, 62, 63, 5, 6, 9, 26, 27, 23, 26, 27, 30, 23, 20, 21, + 36, 23, 46, 47, 9, 54, 55, 9, 60, 61, 72, 73, 75, 7, 8, 14, + 15, 17, 22, 35, 37, 40, 28, 29, 31, 34, 48, 49, 52, 53, 56, 57, +}; + +/** Token literal values. */ +public static final String[] jjstrLiteralImages = { +"", null, null, null, null, null, null, null, null, null, null, null, null, +null, null, null, null, null, null, null, "\143\157\156\164\151\156\165\145", +"\166\157\154\141\164\151\154\145", "\162\145\147\151\163\164\145\162", "\165\156\163\151\147\156\145\144", +"\164\171\160\145\144\145\146", "\144\145\146\141\165\154\164", "\144\157\165\142\154\145", +"\163\151\172\145\157\146", "\163\167\151\164\143\150", "\162\145\164\165\162\156", +"\145\170\164\145\162\156", "\163\164\162\165\143\164", "\163\164\141\164\151\143", +"\163\151\147\156\145\144", "\167\150\151\154\145", "\142\162\145\141\153", "\165\156\151\157\156", +"\143\157\156\163\164", "\146\154\157\141\164", "\163\150\157\162\164", "\145\154\163\145", +"\143\141\163\145", "\154\157\156\147", "\145\156\165\155", "\141\165\164\157", +"\166\157\151\144", "\143\150\141\162", "\147\157\164\157", "\146\157\162", "\151\156\164", +"\151\146", "\144\157", null, null, null, "\50", "\51", "\73", "\52", "\54", "\56\56\56", +"\173", "\175", "\75", "\72", "\133", "\135", "\52\75", "\57\75", "\45\75", "\53\75", +"\55\75", "\74\74\75", "\76\76\75", "\46\75", "\136\75", "\174\75", "\77", "\174\174", +"\46\46", "\174", "\136", "\46", "\75\75", "\41\75", "\74", "\76", "\74\75", "\76\75", +"\74\74", "\76\76", "\53", "\55", "\57", "\45", "\53\53", "\55\55", "\176", "\41", +"\56", "\55\76", }; + +/** Lexer state names. */ +public static final String[] lexStateNames = { + "DEFAULT", + "PREPROCESSOR_OUTPUT", +}; + +/** Lex State array. */ +public static final int[] jjnewLexState = { + -1, -1, -1, -1, -1, -1, -1, 1, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, +}; +static final long[] jjtoToken = { + 0xff9ffffffffd1001L, 0x1fffffffffL, +}; +static final long[] jjtoSkip = { + 0x1feL, 0x0L, +}; +static final long[] jjtoMore = { + 0xe00L, 0x0L, +}; +protected SimpleCharStream input_stream; +private final int[] jjrounds = new int[76]; +private final int[] jjstateSet = new int[152]; +protected char curChar; +/** Constructor. */ +public CParserTokenManager(SimpleCharStream stream){ + if (SimpleCharStream.staticFlag) + throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer."); + input_stream = stream; +} + +/** Constructor. */ +public CParserTokenManager(SimpleCharStream stream, int lexState){ + this(stream); + SwitchTo(lexState); +} + +/** Reinitialise parser. */ +public void ReInit(SimpleCharStream stream) +{ + jjmatchedPos = jjnewStateCnt = 0; + curLexState = defaultLexState; + input_stream = stream; + ReInitRounds(); +} +private void ReInitRounds() +{ + int i; + jjround = 0x80000001; + for (i = 76; i-- > 0;) + jjrounds[i] = 0x80000000; +} + +/** Reinitialise parser. */ +public void ReInit(SimpleCharStream stream, int lexState) +{ + ReInit(stream); + SwitchTo(lexState); +} + +/** Switch to specified lex state. */ +public void SwitchTo(int lexState) +{ + if (lexState >= 2 || lexState < 0) + throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE); + else + curLexState = lexState; +} + +protected Token jjFillToken() +{ + final Token t; + final String curTokenImage; + final int beginLine; + final int endLine; + final int beginColumn; + final int endColumn; + String im = jjstrLiteralImages[jjmatchedKind]; + curTokenImage = (im == null) ? input_stream.GetImage() : im; + beginLine = input_stream.getBeginLine(); + beginColumn = input_stream.getBeginColumn(); + endLine = input_stream.getEndLine(); + endColumn = input_stream.getEndColumn(); + t = Token.newToken(jjmatchedKind, curTokenImage); + + t.beginLine = beginLine; + t.endLine = endLine; + t.beginColumn = beginColumn; + t.endColumn = endColumn; + + return t; +} + +int curLexState = 0; +int defaultLexState = 0; +int jjnewStateCnt; +int jjround; +int jjmatchedPos; +int jjmatchedKind; + +/** Get the next Token. */ +public Token getNextToken() +{ + Token matchedToken; + int curPos = 0; + + EOFLoop : + for (;;) + { + try + { + curChar = input_stream.BeginToken(); + } + catch(java.io.IOException e) + { + jjmatchedKind = 0; + matchedToken = jjFillToken(); + return matchedToken; + } + + for (;;) + { + switch(curLexState) + { + case 0: + try { input_stream.backup(0); + while (curChar <= 32 && (0x100002600L & (1L << curChar)) != 0L) + curChar = input_stream.BeginToken(); + } + catch (java.io.IOException e1) { continue EOFLoop; } + jjmatchedKind = 0x7fffffff; + jjmatchedPos = 0; + curPos = jjMoveStringLiteralDfa0_0(); + break; + case 1: + jjmatchedKind = 0x7fffffff; + jjmatchedPos = 0; + curPos = jjMoveStringLiteralDfa0_1(); + if (jjmatchedPos == 0 && jjmatchedKind > 11) + { + jjmatchedKind = 11; + } + break; + } + if (jjmatchedKind != 0x7fffffff) + { + if (jjmatchedPos + 1 < curPos) + input_stream.backup(curPos - jjmatchedPos - 1); + if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) + { + matchedToken = jjFillToken(); + if (jjnewLexState[jjmatchedKind] != -1) + curLexState = jjnewLexState[jjmatchedKind]; + return matchedToken; + } + else if ((jjtoSkip[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) + { + if (jjnewLexState[jjmatchedKind] != -1) + curLexState = jjnewLexState[jjmatchedKind]; + continue EOFLoop; + } + if (jjnewLexState[jjmatchedKind] != -1) + curLexState = jjnewLexState[jjmatchedKind]; + curPos = 0; + jjmatchedKind = 0x7fffffff; + try { + curChar = input_stream.readChar(); + continue; + } + catch (java.io.IOException e1) { } + } + int error_line = input_stream.getEndLine(); + int error_column = input_stream.getEndColumn(); + String error_after = null; + boolean EOFSeen = false; + try { input_stream.readChar(); input_stream.backup(1); } + catch (java.io.IOException e1) { + EOFSeen = true; + error_after = curPos <= 1 ? "" : input_stream.GetImage(); + if (curChar == '\n' || curChar == '\r') { + error_line++; + error_column = 0; + } + else + error_column++; + } + if (!EOFSeen) { + input_stream.backup(1); + error_after = curPos <= 1 ? "" : input_stream.GetImage(); + } + throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR); + } + } +} + +private void jjCheckNAdd(int state) +{ + if (jjrounds[state] != jjround) + { + jjstateSet[jjnewStateCnt++] = state; + jjrounds[state] = jjround; + } +} +private void jjAddStates(int start, int end) +{ + do { + jjstateSet[jjnewStateCnt++] = jjnextStates[start]; + } while (start++ != end); +} +private void jjCheckNAddTwoStates(int state1, int state2) +{ + jjCheckNAdd(state1); + jjCheckNAdd(state2); +} + +private void jjCheckNAddStates(int start, int end) +{ + do { + jjCheckNAdd(jjnextStates[start]); + } while (start++ != end); +} + +} diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/ExpressionDatabaseHandler.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/ExpressionDatabaseHandler.java new file mode 100644 index 000000000..36c34d1de --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/ExpressionDatabaseHandler.java @@ -0,0 +1,75 @@ +package org.gnunet.seaspider.parser; + +import java.io.File; + +import org.tmatesoft.sqljet.core.SqlJetException; +import org.tmatesoft.sqljet.core.SqlJetTransactionMode; +import org.tmatesoft.sqljet.core.table.ISqlJetTable; +import org.tmatesoft.sqljet.core.table.SqlJetDb; + +public class ExpressionDatabaseHandler { + + private static SqlJetDb db = null; + + public static void createExpressionDatabase(String databasePath) { + String createTableQuery = "CREATE TABLE Expression ( expr_ID INT NOT NULL PRIMARY KEY , " + + "file_name TEXT NOT NULL , expr_syntax TEXT NOT NULL ," + + " start_lineno INT NOT NULL , end_lineno INT NOT NULL , " + + "scope_start_lineno INT NOT NULL , scope_end_lineno INT NOT NULL)"; + + File dbFile = new File(databasePath + "/GNUnetExpressions.db"); + dbFile.delete();/* Delete it if already existent */ + + /* Create Expressions database */ + try { + db = SqlJetDb.open(dbFile, true); + db.getOptions().setAutovacuum(true); + db.beginTransaction(SqlJetTransactionMode.WRITE); + try { + db.getOptions().setUserVersion(1);/* Sets the user's cookie */ + } finally { + db.commit(); + } + /* Create table Expression */ + db.createTable(createTableQuery); + } + catch (SqlJetException e) { + e.printStackTrace(); + } + } + + + public static void closeDatabase() + { + try { + db.close(); + } catch (SqlJetException e) { + e.printStackTrace(); + } + } + + + public static void insertIntoExpressionTable(String fileName, String expressionSyntax, + int startLineNo, int endLineNo, int scopeStartLineNo, + int scopeEndLineNo) + { + if (db == null) { + System.out.println("Error:Database handle is not initialized. Program will exit now!"); + System.exit(1); + } + + ISqlJetTable table; + try { + table = db.getTable("Expression"); + db.beginTransaction(SqlJetTransactionMode.WRITE); + try { + table.insert(fileName, expressionSyntax, startLineNo, endLineNo, scopeStartLineNo, scopeEndLineNo); + } finally { + db.commit(); + } + } + catch (SqlJetException e) { + e.printStackTrace(); + } + } +} diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/GNUnetDepthFirstVisitor.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/GNUnetDepthFirstVisitor.java new file mode 100644 index 000000000..17592b8a8 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/GNUnetDepthFirstVisitor.java @@ -0,0 +1,36 @@ +package org.gnunet.seaspider.parser; +import org.gnunet.seaspider.parser.nodes.AssignmentOperator; +import org.gnunet.seaspider.parser.nodes.CompoundStatement; +import org.gnunet.seaspider.parser.nodes.Expression; +import org.gnunet.seaspider.parser.nodes.NodeToken; +import org.gnunet.seaspider.parser.visitors.DepthFirstVisitor; + +public class GNUnetDepthFirstVisitor extends DepthFirstVisitor { + private int current_endline; + private int blockStart; + private int blockEnd; + + public void visit(Expression n) { + n.f0.accept(this); + } + public void visit(AssignmentOperator n) { + n.f0.accept(this); + } + + /** + * 
+    * f0 -> "{"
+    * f1 -> ( LocalVariableDeclaration() | Statement() )*
+    * f2 -> "}"
+    *
+ */ + public void visit(CompoundStatement n) { + int old_ll = current_endline; + current_endline = n.f2.endLine; + System.out.println("Scope starts at line:" + n.f0.endLine + " and ends at line:" + n.f2.endLine); + n.f0.accept(this); + n.f1.accept(this); + n.f2.accept(this); + current_endline = old_ll; + } +} diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/GNUnetParser.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/GNUnetParser.java new file mode 100644 index 000000000..d0a6a94f0 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/GNUnetParser.java @@ -0,0 +1,5633 @@ +package org.gnunet.seaspider.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.seaspider.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; + String databasePath; + + if (null == (databasePath = args[0])) { + System.out.println("Error: Missing Database Path argument. Program will exit now!"); + System.exit(1); + } + + 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")); + } + }; + + /* Create the Expressions Database */ + ExpressionDatabaseHandler.createExpressionDatabase(databasePath); + + 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 { + System.out.println("Parsing file: " + dir + "/" + fileArr[j].getName()); + Node root = parser.TranslationUnit(); + root.accept(new GNUnetDepthFirstVisitor()); + System.out.println("File " + dir + "/" + 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(); + } + } + } + + /* We're done with the Expression Database, close it */ + ExpressionDatabaseHandler.closeDatabase(); + + 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/src/monkey/seaspider/org/gnunet/seaspider/parser/ParseException.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/ParseException.java new file mode 100644 index 000000000..44162fe6e --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/ParseException.java @@ -0,0 +1,186 @@ +package org.gnunet.seaspider.parser; +/* Generated By:JavaCC: Do not edit this line. ParseException.java Version 5.0 */ +/* JavaCCOptions:KEEP_LINE_COL=null */ +/** + * This exception is thrown when parse errors are encountered. + * You can explicitly create objects of this exception type by + * calling the method generateParseException in the generated + * parser. + * + * You can modify this class to customize your error reporting + * mechanisms so long as you retain the public fields. + */ +public class ParseException extends Exception { + + /** + * The version identifier for this Serializable class. + * Increment only if the serialized form of the + * class changes. + */ + private static final long serialVersionUID = 1L; + + /** + * This constructor is used by the method "generateParseException" + * in the generated parser. Calling this constructor generates + * a new object of this type with the fields "currentToken", + * "expectedTokenSequences", and "tokenImage" set. + */ + public ParseException(Token currentTokenVal, + int[][] expectedTokenSequencesVal, + String[] tokenImageVal + ) + { + super(initialise(currentTokenVal, expectedTokenSequencesVal, tokenImageVal)); + currentToken = currentTokenVal; + expectedTokenSequences = expectedTokenSequencesVal; + tokenImage = tokenImageVal; + } + + /** + * The following constructors are for use by you for whatever + * purpose you can think of. Constructing the exception in this + * manner makes the exception behave in the normal way - i.e., as + * documented in the class "Throwable". The fields "errorToken", + * "expectedTokenSequences", and "tokenImage" do not contain + * relevant information. The JavaCC generated code does not use + * these constructors. + */ + + public ParseException() { + super(); + } + + /** Constructor with message. */ + public ParseException(String message) { + super(message); + } + + + /** + * This is the last token that has been consumed successfully. If + * this object has been created due to a parse error, the token + * followng this token will (therefore) be the first error token. + */ + public Token currentToken; + + /** + * Each entry in this array is an array of integers. Each array + * of integers represents a sequence of tokens (by their ordinal + * values) that is expected at this point of the parse. + */ + public int[][] expectedTokenSequences; + + /** + * This is a reference to the "tokenImage" array of the generated + * parser within which the parse error occurred. This array is + * defined in the generated ...Constants interface. + */ + public String[] tokenImage; + + /** + * It uses "currentToken" and "expectedTokenSequences" to generate a parse + * error message and returns it. If this object has been created + * due to a parse error, and you do not catch it (it gets thrown + * from the parser) the correct error message + * gets displayed. + */ + private static String initialise(Token currentToken, + int[][] expectedTokenSequences, + String[] tokenImage) { + String eol = System.getProperty("line.separator", "\n"); + StringBuffer expected = new StringBuffer(); + int maxSize = 0; + for (int i = 0; i < expectedTokenSequences.length; i++) { + if (maxSize < expectedTokenSequences[i].length) { + maxSize = expectedTokenSequences[i].length; + } + for (int j = 0; j < expectedTokenSequences[i].length; j++) { + expected.append(tokenImage[expectedTokenSequences[i][j]]).append(' '); + } + if (expectedTokenSequences[i][expectedTokenSequences[i].length - 1] != 0) { + expected.append("..."); + } + expected.append(eol).append(" "); + } + String retval = "Encountered \""; + Token tok = currentToken.next; + for (int i = 0; i < maxSize; i++) { + if (i != 0) retval += " "; + if (tok.kind == 0) { + retval += tokenImage[0]; + break; + } + retval += " " + tokenImage[tok.kind]; + retval += " \""; + retval += add_escapes(tok.image); + retval += " \""; + tok = tok.next; + } + retval += "\" at line " + currentToken.next.beginLine + ", column " + currentToken.next.beginColumn; + retval += "." + eol; + if (expectedTokenSequences.length == 1) { + retval += "Was expecting:" + eol + " "; + } else { + retval += "Was expecting one of:" + eol + " "; + } + retval += expected.toString(); + return retval; + } + + /** + * The end of line string for this machine. + */ + protected String eol = System.getProperty("line.separator", "\n"); + + /** + * Used to convert raw characters to their escaped version + * when these raw version cannot be used as part of an ASCII + * string literal. + */ + static String add_escapes(String str) { + StringBuffer retval = new StringBuffer(); + char ch; + for (int i = 0; i < str.length(); i++) { + switch (str.charAt(i)) + { + case 0 : + continue; + case '\b': + retval.append("\\b"); + continue; + case '\t': + retval.append("\\t"); + continue; + case '\n': + retval.append("\\n"); + continue; + case '\f': + retval.append("\\f"); + continue; + case '\r': + retval.append("\\r"); + continue; + case '\"': + retval.append("\\\""); + continue; + case '\'': + retval.append("\\\'"); + continue; + case '\\': + retval.append("\\\\"); + continue; + default: + if ((ch = str.charAt(i)) < 0x20 || ch > 0x7e) { + String s = "0000" + Integer.toString(ch, 16); + retval.append("\\u" + s.substring(s.length() - 4, s.length())); + } else { + retval.append(ch); + } + continue; + } + } + return retval.toString(); + } + +} +/* JavaCC - OriginalChecksum=c5a983a229aa877dc2b3b3b9933cdd6b (do not edit this line) */ diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/SimpleCharStream.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/SimpleCharStream.java new file mode 100644 index 000000000..8f115d519 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/SimpleCharStream.java @@ -0,0 +1,470 @@ +package org.gnunet.seaspider.parser; +/* Generated By:JavaCC: Do not edit this line. SimpleCharStream.java Version 5.0 */ +/* JavaCCOptions:STATIC=false,SUPPORT_CLASS_VISIBILITY_PUBLIC=true */ +/** + * An implementation of interface CharStream, where the stream is assumed to + * contain only ASCII characters (without unicode processing). + */ + +public class SimpleCharStream +{ +/** Whether parser is static. */ + public static final boolean staticFlag = false; + int bufsize; + int available; + int tokenBegin; +/** Position in buffer. */ + public int bufpos = -1; + protected int bufline[]; + protected int bufcolumn[]; + + protected int column = 0; + protected int line = 1; + + protected boolean prevCharIsCR = false; + protected boolean prevCharIsLF = false; + + protected java.io.Reader inputStream; + + protected char[] buffer; + protected int maxNextCharInd = 0; + protected int inBuf = 0; + protected int tabSize = 8; + + protected void setTabSize(int i) { tabSize = i; } + protected int getTabSize(int i) { return tabSize; } + + + protected void ExpandBuff(boolean wrapAround) + { + char[] newbuffer = new char[bufsize + 2048]; + int newbufline[] = new int[bufsize + 2048]; + int newbufcolumn[] = new int[bufsize + 2048]; + + try + { + if (wrapAround) + { + System.arraycopy(buffer, tokenBegin, newbuffer, 0, bufsize - tokenBegin); + System.arraycopy(buffer, 0, newbuffer, bufsize - tokenBegin, bufpos); + buffer = newbuffer; + + System.arraycopy(bufline, tokenBegin, newbufline, 0, bufsize - tokenBegin); + System.arraycopy(bufline, 0, newbufline, bufsize - tokenBegin, bufpos); + bufline = newbufline; + + System.arraycopy(bufcolumn, tokenBegin, newbufcolumn, 0, bufsize - tokenBegin); + System.arraycopy(bufcolumn, 0, newbufcolumn, bufsize - tokenBegin, bufpos); + bufcolumn = newbufcolumn; + + maxNextCharInd = (bufpos += (bufsize - tokenBegin)); + } + else + { + System.arraycopy(buffer, tokenBegin, newbuffer, 0, bufsize - tokenBegin); + buffer = newbuffer; + + System.arraycopy(bufline, tokenBegin, newbufline, 0, bufsize - tokenBegin); + bufline = newbufline; + + System.arraycopy(bufcolumn, tokenBegin, newbufcolumn, 0, bufsize - tokenBegin); + bufcolumn = newbufcolumn; + + maxNextCharInd = (bufpos -= tokenBegin); + } + } + catch (Throwable t) + { + throw new Error(t.getMessage()); + } + + + bufsize += 2048; + available = bufsize; + tokenBegin = 0; + } + + protected void FillBuff() throws java.io.IOException + { + if (maxNextCharInd == available) + { + if (available == bufsize) + { + if (tokenBegin > 2048) + { + bufpos = maxNextCharInd = 0; + available = tokenBegin; + } + else if (tokenBegin < 0) + bufpos = maxNextCharInd = 0; + else + ExpandBuff(false); + } + else if (available > tokenBegin) + available = bufsize; + else if ((tokenBegin - available) < 2048) + ExpandBuff(true); + else + available = tokenBegin; + } + + int i; + try { + if ((i = inputStream.read(buffer, maxNextCharInd, available - maxNextCharInd)) == -1) + { + inputStream.close(); + throw new java.io.IOException(); + } + else + maxNextCharInd += i; + return; + } + catch(java.io.IOException e) { + --bufpos; + backup(0); + if (tokenBegin == -1) + tokenBegin = bufpos; + throw e; + } + } + +/** Start. */ + public char BeginToken() throws java.io.IOException + { + tokenBegin = -1; + char c = readChar(); + tokenBegin = bufpos; + + return c; + } + + protected void UpdateLineColumn(char c) + { + column++; + + if (prevCharIsLF) + { + prevCharIsLF = false; + line += (column = 1); + } + else if (prevCharIsCR) + { + prevCharIsCR = false; + if (c == '\n') + { + prevCharIsLF = true; + } + else + line += (column = 1); + } + + switch (c) + { + case '\r' : + prevCharIsCR = true; + break; + case '\n' : + prevCharIsLF = true; + break; + case '\t' : + column--; + column += (tabSize - (column % tabSize)); + break; + default : + break; + } + + bufline[bufpos] = line; + bufcolumn[bufpos] = column; + } + +/** Read a character. */ + public char readChar() throws java.io.IOException + { + if (inBuf > 0) + { + --inBuf; + + if (++bufpos == bufsize) + bufpos = 0; + + return buffer[bufpos]; + } + + if (++bufpos >= maxNextCharInd) + FillBuff(); + + char c = buffer[bufpos]; + + UpdateLineColumn(c); + return c; + } + + @Deprecated + /** + * @deprecated + * @see #getEndColumn + */ + + public int getColumn() { + return bufcolumn[bufpos]; + } + + @Deprecated + /** + * @deprecated + * @see #getEndLine + */ + + public int getLine() { + return bufline[bufpos]; + } + + /** Get token end column number. */ + public int getEndColumn() { + return bufcolumn[bufpos]; + } + + /** Get token end line number. */ + public int getEndLine() { + return bufline[bufpos]; + } + + /** Get token beginning column number. */ + public int getBeginColumn() { + return bufcolumn[tokenBegin]; + } + + /** Get token beginning line number. */ + public int getBeginLine() { + return bufline[tokenBegin]; + } + +/** Backup a number of characters. */ + public void backup(int amount) { + + inBuf += amount; + if ((bufpos -= amount) < 0) + bufpos += bufsize; + } + + /** Constructor. */ + public SimpleCharStream(java.io.Reader dstream, int startline, + int startcolumn, int buffersize) + { + inputStream = dstream; + line = startline; + column = startcolumn - 1; + + available = bufsize = buffersize; + buffer = new char[buffersize]; + bufline = new int[buffersize]; + bufcolumn = new int[buffersize]; + } + + /** Constructor. */ + public SimpleCharStream(java.io.Reader dstream, int startline, + int startcolumn) + { + this(dstream, startline, startcolumn, 4096); + } + + /** Constructor. */ + public SimpleCharStream(java.io.Reader dstream) + { + this(dstream, 1, 1, 4096); + } + + /** Reinitialise. */ + public void ReInit(java.io.Reader dstream, int startline, + int startcolumn, int buffersize) + { + inputStream = dstream; + line = startline; + column = startcolumn - 1; + + if (buffer == null || buffersize != buffer.length) + { + available = bufsize = buffersize; + buffer = new char[buffersize]; + bufline = new int[buffersize]; + bufcolumn = new int[buffersize]; + } + prevCharIsLF = prevCharIsCR = false; + tokenBegin = inBuf = maxNextCharInd = 0; + bufpos = -1; + } + + /** Reinitialise. */ + public void ReInit(java.io.Reader dstream, int startline, + int startcolumn) + { + ReInit(dstream, startline, startcolumn, 4096); + } + + /** Reinitialise. */ + public void ReInit(java.io.Reader dstream) + { + ReInit(dstream, 1, 1, 4096); + } + /** Constructor. */ + public SimpleCharStream(java.io.InputStream dstream, String encoding, int startline, + int startcolumn, int buffersize) throws java.io.UnsupportedEncodingException + { + this(encoding == null ? new java.io.InputStreamReader(dstream) : new java.io.InputStreamReader(dstream, encoding), startline, startcolumn, buffersize); + } + + /** Constructor. */ + public SimpleCharStream(java.io.InputStream dstream, int startline, + int startcolumn, int buffersize) + { + this(new java.io.InputStreamReader(dstream), startline, startcolumn, buffersize); + } + + /** Constructor. */ + public SimpleCharStream(java.io.InputStream dstream, String encoding, int startline, + int startcolumn) throws java.io.UnsupportedEncodingException + { + this(dstream, encoding, startline, startcolumn, 4096); + } + + /** Constructor. */ + public SimpleCharStream(java.io.InputStream dstream, int startline, + int startcolumn) + { + this(dstream, startline, startcolumn, 4096); + } + + /** Constructor. */ + public SimpleCharStream(java.io.InputStream dstream, String encoding) throws java.io.UnsupportedEncodingException + { + this(dstream, encoding, 1, 1, 4096); + } + + /** Constructor. */ + public SimpleCharStream(java.io.InputStream dstream) + { + this(dstream, 1, 1, 4096); + } + + /** Reinitialise. */ + public void ReInit(java.io.InputStream dstream, String encoding, int startline, + int startcolumn, int buffersize) throws java.io.UnsupportedEncodingException + { + ReInit(encoding == null ? new java.io.InputStreamReader(dstream) : new java.io.InputStreamReader(dstream, encoding), startline, startcolumn, buffersize); + } + + /** Reinitialise. */ + public void ReInit(java.io.InputStream dstream, int startline, + int startcolumn, int buffersize) + { + ReInit(new java.io.InputStreamReader(dstream), startline, startcolumn, buffersize); + } + + /** Reinitialise. */ + public void ReInit(java.io.InputStream dstream, String encoding) throws java.io.UnsupportedEncodingException + { + ReInit(dstream, encoding, 1, 1, 4096); + } + + /** Reinitialise. */ + public void ReInit(java.io.InputStream dstream) + { + ReInit(dstream, 1, 1, 4096); + } + /** Reinitialise. */ + public void ReInit(java.io.InputStream dstream, String encoding, int startline, + int startcolumn) throws java.io.UnsupportedEncodingException + { + ReInit(dstream, encoding, startline, startcolumn, 4096); + } + /** Reinitialise. */ + public void ReInit(java.io.InputStream dstream, int startline, + int startcolumn) + { + ReInit(dstream, startline, startcolumn, 4096); + } + /** Get token literal value. */ + public String GetImage() + { + if (bufpos >= tokenBegin) + return new String(buffer, tokenBegin, bufpos - tokenBegin + 1); + else + return new String(buffer, tokenBegin, bufsize - tokenBegin) + + new String(buffer, 0, bufpos + 1); + } + + /** Get the suffix. */ + public char[] GetSuffix(int len) + { + char[] ret = new char[len]; + + if ((bufpos + 1) >= len) + System.arraycopy(buffer, bufpos - len + 1, ret, 0, len); + else + { + System.arraycopy(buffer, bufsize - (len - bufpos - 1), ret, 0, + len - bufpos - 1); + System.arraycopy(buffer, 0, ret, len - bufpos - 1, bufpos + 1); + } + + return ret; + } + + /** Reset buffer when finished. */ + public void Done() + { + buffer = null; + bufline = null; + bufcolumn = null; + } + + /** + * Method to adjust line and column numbers for the start of a token. + */ + public void adjustBeginLineColumn(int newLine, int newCol) + { + int start = tokenBegin; + int len; + + if (bufpos >= tokenBegin) + { + len = bufpos - tokenBegin + inBuf + 1; + } + else + { + len = bufsize - tokenBegin + bufpos + 1 + inBuf; + } + + int i = 0, j = 0, k = 0; + int nextColDiff = 0, columnDiff = 0; + + while (i < len && bufline[j = start % bufsize] == bufline[k = ++start % bufsize]) + { + bufline[j] = newLine; + nextColDiff = columnDiff + bufcolumn[k] - bufcolumn[j]; + bufcolumn[j] = newCol + columnDiff; + columnDiff = nextColDiff; + i++; + } + + if (i < len) + { + bufline[j] = newLine++; + bufcolumn[j] = newCol + columnDiff; + + while (i++ < len) + { + if (bufline[j = start % bufsize] != bufline[++start % bufsize]) + bufline[j] = newLine++; + else + bufline[j] = newLine; + } + } + + line = bufline[j]; + column = bufcolumn[j]; + } + +} +/* JavaCC - OriginalChecksum=b0bce35239226f00f9dd0fa14ab3ad17 (do not edit this line) */ diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/Token.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/Token.java new file mode 100644 index 000000000..468572c5b --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/Token.java @@ -0,0 +1,130 @@ +package org.gnunet.seaspider.parser; +/* Generated By:JavaCC: Do not edit this line. Token.java Version 5.0 */ +/* JavaCCOptions:TOKEN_EXTENDS=,KEEP_LINE_COL=null,SUPPORT_CLASS_VISIBILITY_PUBLIC=true */ +/** + * Describes the input token stream. + */ + +public class Token implements java.io.Serializable { + + /** + * The version identifier for this Serializable class. + * Increment only if the serialized form of the + * class changes. + */ + private static final long serialVersionUID = 1L; + + /** + * An integer that describes the kind of this token. This numbering + * system is determined by JavaCCParser, and a table of these numbers is + * stored in the file ...Constants.java. + */ + public int kind; + + /** The line number of the first character of this Token. */ + public int beginLine; + /** The column number of the first character of this Token. */ + public int beginColumn; + /** The line number of the last character of this Token. */ + public int endLine; + /** The column number of the last character of this Token. */ + public int endColumn; + + /** + * The string image of the token. + */ + public String image; + + /** + * A reference to the next regular (non-special) token from the input + * stream. If this is the last token from the input stream, or if the + * token manager has not read tokens beyond this one, this field is + * set to null. This is true only if this token is also a regular + * token. Otherwise, see below for a description of the contents of + * this field. + */ + public Token next; + + /** + * This field is used to access special tokens that occur prior to this + * token, but after the immediately preceding regular (non-special) token. + * If there are no such special tokens, this field is set to null. + * When there are more than one such special token, this field refers + * to the last of these special tokens, which in turn refers to the next + * previous special token through its specialToken field, and so on + * until the first special token (whose specialToken field is null). + * The next fields of special tokens refer to other special tokens that + * immediately follow it (without an intervening regular token). If there + * is no such token, this field is null. + */ + public Token specialToken; + + /** + * An optional attribute value of the Token. + * Tokens which are not used as syntactic sugar will often contain + * meaningful values that will be used later on by the compiler or + * interpreter. This attribute value is often different from the image. + * Any subclass of Token that actually wants to return a non-null value can + * override this method as appropriate. + */ + public Object getValue() { + return null; + } + + /** + * No-argument constructor + */ + public Token() {} + + /** + * Constructs a new token for the specified Image. + */ + public Token(int kind) + { + this(kind, null); + } + + /** + * Constructs a new token for the specified Image and Kind. + */ + public Token(int kind, String image) + { + this.kind = kind; + this.image = image; + } + + /** + * Returns the image. + */ + public String toString() + { + return image; + } + + /** + * Returns a new Token object, by default. However, if you want, you + * can create and return subclass objects based on the value of ofKind. + * Simply add the cases to the switch for all those special cases. + * For example, if you have a subclass of Token called IDToken that + * you want to create if ofKind is ID, simply add something like : + * + * case MyParserConstants.ID : return new IDToken(ofKind, image); + * + * to the following switch statement. Then you can cast matchedToken + * variable to the appropriate type and use sit in your lexical actions. + */ + public static Token newToken(int ofKind, String image) + { + switch(ofKind) + { + default : return new Token(ofKind, image); + } + } + + public static Token newToken(int ofKind) + { + return newToken(ofKind, null); + } + +} +/* JavaCC - OriginalChecksum=6145f5d5b504ccb4f95e09f2ce3e748a (do not edit this line) */ diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/TokenMgrError.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/TokenMgrError.java new file mode 100644 index 000000000..3e46dcfc5 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/TokenMgrError.java @@ -0,0 +1,146 @@ +package org.gnunet.seaspider.parser; +/* Generated By:JavaCC: Do not edit this line. TokenMgrError.java Version 5.0 */ +/* JavaCCOptions: */ +/** Token Manager Error. */ +public class TokenMgrError extends Error +{ + + /** + * The version identifier for this Serializable class. + * Increment only if the serialized form of the + * class changes. + */ + private static final long serialVersionUID = 1L; + + /* + * Ordinals for various reasons why an Error of this type can be thrown. + */ + + /** + * Lexical error occurred. + */ + static final int LEXICAL_ERROR = 0; + + /** + * An attempt was made to create a second instance of a static token manager. + */ + static final int STATIC_LEXER_ERROR = 1; + + /** + * Tried to change to an invalid lexical state. + */ + static final int INVALID_LEXICAL_STATE = 2; + + /** + * Detected (and bailed out of) an infinite loop in the token manager. + */ + static final int LOOP_DETECTED = 3; + + /** + * Indicates the reason why the exception is thrown. It will have + * one of the above 4 values. + */ + int errorCode; + + /** + * Replaces unprintable characters by their escaped (or unicode escaped) + * equivalents in the given string + */ + protected static final String addEscapes(String str) { + StringBuffer retval = new StringBuffer(); + char ch; + for (int i = 0; i < str.length(); i++) { + switch (str.charAt(i)) + { + case 0 : + continue; + case '\b': + retval.append("\\b"); + continue; + case '\t': + retval.append("\\t"); + continue; + case '\n': + retval.append("\\n"); + continue; + case '\f': + retval.append("\\f"); + continue; + case '\r': + retval.append("\\r"); + continue; + case '\"': + retval.append("\\\""); + continue; + case '\'': + retval.append("\\\'"); + continue; + case '\\': + retval.append("\\\\"); + continue; + default: + if ((ch = str.charAt(i)) < 0x20 || ch > 0x7e) { + String s = "0000" + Integer.toString(ch, 16); + retval.append("\\u" + s.substring(s.length() - 4, s.length())); + } else { + retval.append(ch); + } + continue; + } + } + return retval.toString(); + } + + /** + * Returns a detailed message for the Error when it is thrown by the + * token manager to indicate a lexical error. + * Parameters : + * EOFSeen : indicates if EOF caused the lexical error + * curLexState : lexical state in which this error occurred + * errorLine : line number when the error occurred + * errorColumn : column number when the error occurred + * errorAfter : prefix that was seen before this error occurred + * curchar : the offending character + * Note: You can customize the lexical error message by modifying this method. + */ + protected static String LexicalError(boolean EOFSeen, int lexState, int errorLine, int errorColumn, String errorAfter, char curChar) { + return("Lexical error at line " + + errorLine + ", column " + + errorColumn + ". Encountered: " + + (EOFSeen ? " " : ("\"" + addEscapes(String.valueOf(curChar)) + "\"") + " (" + (int)curChar + "), ") + + "after : \"" + addEscapes(errorAfter) + "\""); + } + + /** + * You can also modify the body of this method to customize your error messages. + * For example, cases like LOOP_DETECTED and INVALID_LEXICAL_STATE are not + * of end-users concern, so you can return something like : + * + * "Internal Error : Please file a bug report .... " + * + * from this method for such cases in the release version of your parser. + */ + public String getMessage() { + return super.getMessage(); + } + + /* + * Constructors of various flavors follow. + */ + + /** No arg constructor. */ + public TokenMgrError() { + } + + /** Constructor with message and reason. */ + public TokenMgrError(String message, int reason) { + super(message); + errorCode = reason; + } + + /** Full Constructor. */ + public TokenMgrError(boolean EOFSeen, int lexState, int errorLine, int errorColumn, String errorAfter, char curChar, int reason) { + this(LexicalError(EOFSeen, lexState, errorLine, errorColumn, errorAfter, curChar), reason); + } +} +/* JavaCC - OriginalChecksum=3f827858bf5c87e5502cccca67d9b325 (do not edit this line) */ diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/ANDExpression.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/ANDExpression.java new file mode 100644 index 000000000..8ced2c188 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/ANDExpression.java @@ -0,0 +1,36 @@ +// +// Generated by JTB 1.3.2 +// + +package org.gnunet.seaspider.parser.nodes; + +/** + * Grammar production: + * 
+ * f0 -> EqualityExpression()
+ * f1 -> [ "&" ANDExpression() ]
+ *
+ */ +public class ANDExpression implements Node { + public EqualityExpression f0; + public NodeOptional f1; + + public ANDExpression(EqualityExpression n0, NodeOptional n1) { + f0 = n0; + f1 = n1; + } + + public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { + v.visit(this); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJVisitor v, A argu) { + return v.visit(this,argu); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor v) { + return v.visit(this); + } + public void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor v, A argu) { + v.visit(this,argu); + } +} + diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/AdditiveExpression.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/AdditiveExpression.java new file mode 100644 index 000000000..f0c2f33ab --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/AdditiveExpression.java @@ -0,0 +1,36 @@ +// +// Generated by JTB 1.3.2 +// + +package org.gnunet.seaspider.parser.nodes; + +/** + * Grammar production: + * 
+ * f0 -> MultiplicativeExpression()
+ * f1 -> [ ( "+" | "-" ) AdditiveExpression() ]
+ *
+ */ +public class AdditiveExpression implements Node { + public MultiplicativeExpression f0; + public NodeOptional f1; + + public AdditiveExpression(MultiplicativeExpression n0, NodeOptional n1) { + f0 = n0; + f1 = n1; + } + + public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { + v.visit(this); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJVisitor v, A argu) { + return v.visit(this,argu); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor v) { + return v.visit(this); + } + public void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor v, A argu) { + v.visit(this,argu); + } +} + diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/ArgumentExpressionList.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/ArgumentExpressionList.java new file mode 100644 index 000000000..0d93ab689 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/ArgumentExpressionList.java @@ -0,0 +1,36 @@ +// +// Generated by JTB 1.3.2 +// + +package org.gnunet.seaspider.parser.nodes; + +/** + * Grammar production: + * 
+ * f0 -> AssignmentOrTypeExpression()
+ * f1 -> ( "," AssignmentOrTypeExpression() )*
+ *
+ */ +public class ArgumentExpressionList implements Node { + public AssignmentOrTypeExpression f0; + public NodeListOptional f1; + + public ArgumentExpressionList(AssignmentOrTypeExpression n0, NodeListOptional n1) { + f0 = n0; + f1 = n1; + } + + public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { + v.visit(this); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJVisitor v, A argu) { + return v.visit(this,argu); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor v) { + return v.visit(this); + } + public void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor v, A argu) { + v.visit(this,argu); + } +} + diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/Array.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/Array.java new file mode 100644 index 000000000..2d2798d7b --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/Array.java @@ -0,0 +1,45 @@ +// +// Generated by JTB 1.3.2 +// + +package org.gnunet.seaspider.parser.nodes; + +/** + * Grammar production: + * 
+ * f0 -> "["
+ * f1 -> [ ConstantExpression() ]
+ * f2 -> "]"
+ *
+ */ +public class Array implements Node { + public NodeToken f0; + public NodeOptional f1; + public NodeToken f2; + + public Array(NodeToken n0, NodeOptional n1, NodeToken n2) { + f0 = n0; + f1 = n1; + f2 = n2; + } + + public Array(NodeOptional n0) { + f0 = new NodeToken("["); + f1 = n0; + f2 = new NodeToken("]"); + } + + public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { + v.visit(this); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJVisitor v, A argu) { + return v.visit(this,argu); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor v) { + return v.visit(this); + } + public void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor v, A argu) { + v.visit(this,argu); + } +} + diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/AssignmentExpression.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/AssignmentExpression.java new file mode 100644 index 000000000..1dc2606df --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/AssignmentExpression.java @@ -0,0 +1,34 @@ +// +// Generated by JTB 1.3.2 +// + +package org.gnunet.seaspider.parser.nodes; + +/** + * Grammar production: + * 
+ * f0 -> UnaryExpression() AssignmentOperator() AssignmentExpression()
+ *       | ConditionalExpression()
+ *
+ */ +public class AssignmentExpression implements Node { + public NodeChoice f0; + + public AssignmentExpression(NodeChoice n0) { + f0 = n0; + } + + public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { + v.visit(this); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJVisitor v, A argu) { + return v.visit(this,argu); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor v) { + return v.visit(this); + } + public void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor v, A argu) { + v.visit(this,argu); + } +} + diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/AssignmentOperator.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/AssignmentOperator.java new file mode 100644 index 000000000..76b5bfb12 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/AssignmentOperator.java @@ -0,0 +1,33 @@ +// +// Generated by JTB 1.3.2 +// + +package org.gnunet.seaspider.parser.nodes; + +/** + * Grammar production: + * 
+ * f0 -> ( "=" | "*=" | "/=" | "%=" | "+=" | "-=" | "<<=" | ">>=" | "&=" | "^=" | "|=" )
+ *
+ */ +public class AssignmentOperator implements Node { + public NodeChoice f0; + + public AssignmentOperator(NodeChoice n0) { + f0 = n0; + } + + public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { + v.visit(this); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJVisitor v, A argu) { + return v.visit(this,argu); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor v) { + return v.visit(this); + } + public void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor v, A argu) { + v.visit(this,argu); + } +} + diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/AssignmentOrTypeExpression.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/AssignmentOrTypeExpression.java new file mode 100644 index 000000000..2d118d221 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/AssignmentOrTypeExpression.java @@ -0,0 +1,34 @@ +// +// Generated by JTB 1.3.2 +// + +package org.gnunet.seaspider.parser.nodes; + +/** + * Grammar production: + * 
+ * f0 -> NoIdentifierTypeSpecifier()
+ *       | AssignmentExpression()
+ *
+ */ +public class AssignmentOrTypeExpression implements Node { + public NodeChoice f0; + + public AssignmentOrTypeExpression(NodeChoice n0) { + f0 = n0; + } + + public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { + v.visit(this); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJVisitor v, A argu) { + return v.visit(this,argu); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor v) { + return v.visit(this); + } + public void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor v, A argu) { + v.visit(this,argu); + } +} + diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/CastExpression.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/CastExpression.java new file mode 100644 index 000000000..8a420c55f --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/CastExpression.java @@ -0,0 +1,33 @@ +// +// Generated by JTB 1.3.2 +// + +package org.gnunet.seaspider.parser.nodes; + +/** + * Grammar production: + * 
+ * f0 -> ( "(" TypeSpecifier() ")" CastExpression() | UnaryExpression() )
+ *
+ */ +public class CastExpression implements Node { + public NodeChoice f0; + + public CastExpression(NodeChoice n0) { + f0 = n0; + } + + public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { + v.visit(this); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJVisitor v, A argu) { + return v.visit(this,argu); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor v) { + return v.visit(this); + } + public void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor v, A argu) { + v.visit(this,argu); + } +} + diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/CompoundStatement.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/CompoundStatement.java new file mode 100644 index 000000000..18e7e6d8a --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/CompoundStatement.java @@ -0,0 +1,45 @@ +// +// Generated by JTB 1.3.2 +// + +package org.gnunet.seaspider.parser.nodes; + +/** + * Grammar production: + * 
+ * f0 -> "{"
+ * f1 -> ( LocalVariableDeclaration() | Statement() )*
+ * f2 -> "}"
+ *
+ */ +public class CompoundStatement implements Node { + public NodeToken f0; + public NodeListOptional f1; + public NodeToken f2; + + public CompoundStatement(NodeToken n0, NodeListOptional n1, NodeToken n2) { + f0 = n0; + f1 = n1; + f2 = n2; + } + + public CompoundStatement(NodeListOptional n0) { + f0 = new NodeToken("{"); + f1 = n0; + f2 = new NodeToken("}"); + } + + public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { + v.visit(this); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJVisitor v, A argu) { + return v.visit(this,argu); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor v) { + return v.visit(this); + } + public void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor v, A argu) { + v.visit(this,argu); + } +} + diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/ConditionalExpression.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/ConditionalExpression.java new file mode 100644 index 000000000..404ec903a --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/ConditionalExpression.java @@ -0,0 +1,36 @@ +// +// Generated by JTB 1.3.2 +// + +package org.gnunet.seaspider.parser.nodes; + +/** + * Grammar production: + * 
+ * f0 -> LogicalORExpression()
+ * f1 -> [ "?" Expression() ":" ConditionalExpression() ]
+ *
+ */ +public class ConditionalExpression implements Node { + public LogicalORExpression f0; + public NodeOptional f1; + + public ConditionalExpression(LogicalORExpression n0, NodeOptional n1) { + f0 = n0; + f1 = n1; + } + + public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { + v.visit(this); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJVisitor v, A argu) { + return v.visit(this,argu); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor v) { + return v.visit(this); + } + public void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor v, A argu) { + v.visit(this,argu); + } +} + diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/Constant.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/Constant.java new file mode 100644 index 000000000..6ccd64ae4 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/Constant.java @@ -0,0 +1,36 @@ +// +// Generated by JTB 1.3.2 +// + +package org.gnunet.seaspider.parser.nodes; + +/** + * Grammar production: + * 
+ * f0 -> <INTEGER_LITERAL>
+ *       | <FLOATING_POINT_LITERAL>
+ *       | <CHARACTER_LITERAL>
+ *       | <STRING_LITERAL>
+ *
+ */ +public class Constant implements Node { + public NodeChoice f0; + + public Constant(NodeChoice n0) { + f0 = n0; + } + + public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { + v.visit(this); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJVisitor v, A argu) { + return v.visit(this,argu); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor v) { + return v.visit(this); + } + public void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor v, A argu) { + v.visit(this,argu); + } +} + diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/ConstantExpression.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/ConstantExpression.java new file mode 100644 index 000000000..e1024c4ad --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/ConstantExpression.java @@ -0,0 +1,33 @@ +// +// Generated by JTB 1.3.2 +// + +package org.gnunet.seaspider.parser.nodes; + +/** + * Grammar production: + * 
+ * f0 -> ConditionalExpression()
+ *
+ */ +public class ConstantExpression implements Node { + public ConditionalExpression f0; + + public ConstantExpression(ConditionalExpression n0) { + f0 = n0; + } + + public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { + v.visit(this); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJVisitor v, A argu) { + return v.visit(this,argu); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor v) { + return v.visit(this); + } + public void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor v, A argu) { + v.visit(this,argu); + } +} + diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/DataType.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/DataType.java new file mode 100644 index 000000000..e99a46a9c --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/DataType.java @@ -0,0 +1,36 @@ +// +// Generated by JTB 1.3.2 +// + +package org.gnunet.seaspider.parser.nodes; + +/** + * Grammar production: + * 
+ * f0 -> StructOrUnionSpecifier()
+ * f1 -> <IDENTIFIER>
+ *
+ */ +public class DataType implements Node { + public StructOrUnionSpecifier f0; + public NodeToken f1; + + public DataType(StructOrUnionSpecifier n0, NodeToken n1) { + f0 = n0; + f1 = n1; + } + + public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { + v.visit(this); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJVisitor v, A argu) { + return v.visit(this,argu); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor v) { + return v.visit(this); + } + public void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor v, A argu) { + v.visit(this,argu); + } +} + diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/EnumSpecifier.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/EnumSpecifier.java new file mode 100644 index 000000000..5bb08faca --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/EnumSpecifier.java @@ -0,0 +1,41 @@ +// +// Generated by JTB 1.3.2 +// + +package org.gnunet.seaspider.parser.nodes; + +/** + * Grammar production: + * 
+ * f0 -> <ENUM>
+ * f1 -> ( [ <IDENTIFIER> ] "{" EnumeratorList() "}" | <IDENTIFIER> )
+ *
+ */ +public class EnumSpecifier implements Node { + public NodeToken f0; + public NodeChoice f1; + + public EnumSpecifier(NodeToken n0, NodeChoice n1) { + f0 = n0; + f1 = n1; + } + + public EnumSpecifier(NodeChoice n0) { + f0 = new NodeToken("enum"); + f1 = n0; + } + + public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { + v.visit(this); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJVisitor v, A argu) { + return v.visit(this,argu); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor v) { + return v.visit(this); + } + public void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor v, A argu) { + v.visit(this,argu); + } +} + diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/Enumerator.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/Enumerator.java new file mode 100644 index 000000000..305cf697a --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/Enumerator.java @@ -0,0 +1,36 @@ +// +// Generated by JTB 1.3.2 +// + +package org.gnunet.seaspider.parser.nodes; + +/** + * Grammar production: + * 
+ * f0 -> <IDENTIFIER>
+ * f1 -> [ "=" ConstantExpression() ]
+ *
+ */ +public class Enumerator implements Node { + public NodeToken f0; + public NodeOptional f1; + + public Enumerator(NodeToken n0, NodeOptional n1) { + f0 = n0; + f1 = n1; + } + + public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { + v.visit(this); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJVisitor v, A argu) { + return v.visit(this,argu); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor v) { + return v.visit(this); + } + public void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor v, A argu) { + v.visit(this,argu); + } +} + diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/EnumeratorList.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/EnumeratorList.java new file mode 100644 index 000000000..ba72c0668 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/EnumeratorList.java @@ -0,0 +1,36 @@ +// +// Generated by JTB 1.3.2 +// + +package org.gnunet.seaspider.parser.nodes; + +/** + * Grammar production: + * 
+ * f0 -> Enumerator()
+ * f1 -> ( "," Enumerator() )*
+ *
+ */ +public class EnumeratorList implements Node { + public Enumerator f0; + public NodeListOptional f1; + + public EnumeratorList(Enumerator n0, NodeListOptional n1) { + f0 = n0; + f1 = n1; + } + + public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { + v.visit(this); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJVisitor v, A argu) { + return v.visit(this,argu); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor v) { + return v.visit(this); + } + public void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor v, A argu) { + v.visit(this,argu); + } +} + diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/EqualityExpression.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/EqualityExpression.java new file mode 100644 index 000000000..44157bb00 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/EqualityExpression.java @@ -0,0 +1,36 @@ +// +// Generated by JTB 1.3.2 +// + +package org.gnunet.seaspider.parser.nodes; + +/** + * Grammar production: + * 
+ * f0 -> RelationalExpression()
+ * f1 -> [ ( "==" | "!=" ) EqualityExpression() ]
+ *
+ */ +public class EqualityExpression implements Node { + public RelationalExpression f0; + public NodeOptional f1; + + public EqualityExpression(RelationalExpression n0, NodeOptional n1) { + f0 = n0; + f1 = n1; + } + + public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { + v.visit(this); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJVisitor v, A argu) { + return v.visit(this,argu); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor v) { + return v.visit(this); + } + public void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor v, A argu) { + v.visit(this,argu); + } +} + diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/ExclusiveORExpression.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/ExclusiveORExpression.java new file mode 100644 index 000000000..d80f4099a --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/ExclusiveORExpression.java @@ -0,0 +1,36 @@ +// +// Generated by JTB 1.3.2 +// + +package org.gnunet.seaspider.parser.nodes; + +/** + * Grammar production: + * 
+ * f0 -> ANDExpression()
+ * f1 -> [ "^" ExclusiveORExpression() ]
+ *
+ */ +public class ExclusiveORExpression implements Node { + public ANDExpression f0; + public NodeOptional f1; + + public ExclusiveORExpression(ANDExpression n0, NodeOptional n1) { + f0 = n0; + f1 = n1; + } + + public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { + v.visit(this); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJVisitor v, A argu) { + return v.visit(this,argu); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor v) { + return v.visit(this); + } + public void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor v, A argu) { + v.visit(this,argu); + } +} + diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/Expression.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/Expression.java new file mode 100644 index 000000000..e8f021a7d --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/Expression.java @@ -0,0 +1,36 @@ +// +// Generated by JTB 1.3.2 +// + +package org.gnunet.seaspider.parser.nodes; + +/** + * Grammar production: + * 
+ * f0 -> AssignmentExpression()
+ * f1 -> ( "," AssignmentExpression() )*
+ *
+ */ +public class Expression implements Node { + public AssignmentExpression f0; + public NodeListOptional f1; + + public Expression(AssignmentExpression n0, NodeListOptional n1) { + f0 = n0; + f1 = n1; + } + + public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { + v.visit(this); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJVisitor v, A argu) { + return v.visit(this,argu); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor v) { + return v.visit(this); + } + public void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor v, A argu) { + v.visit(this,argu); + } +} + diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/ExpressionStatement.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/ExpressionStatement.java new file mode 100644 index 000000000..d6f23828d --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/ExpressionStatement.java @@ -0,0 +1,41 @@ +// +// Generated by JTB 1.3.2 +// + +package org.gnunet.seaspider.parser.nodes; + +/** + * Grammar production: + * 
+ * f0 -> [ Expression() ]
+ * f1 -> ";"
+ *
+ */ +public class ExpressionStatement implements Node { + public NodeOptional f0; + public NodeToken f1; + + public ExpressionStatement(NodeOptional n0, NodeToken n1) { + f0 = n0; + f1 = n1; + } + + public ExpressionStatement(NodeOptional n0) { + f0 = n0; + f1 = new NodeToken(";"); + } + + public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { + v.visit(this); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJVisitor v, A argu) { + return v.visit(this,argu); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor v) { + return v.visit(this); + } + public void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor v, A argu) { + v.visit(this,argu); + } +} + diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/ExternalDeclaration.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/ExternalDeclaration.java new file mode 100644 index 000000000..9d359285d --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/ExternalDeclaration.java @@ -0,0 +1,36 @@ +// +// Generated by JTB 1.3.2 +// + +package org.gnunet.seaspider.parser.nodes; + +/** + * Grammar production: + * 
+ * f0 -> ( StorageClassSpecifier() )*
+ * f1 -> ( FunctionDeclaration() | StructOrUnionSpecifier() | VariableDeclaration() | TypeDeclaration() )
+ *
+ */ +public class ExternalDeclaration implements Node { + public NodeListOptional f0; + public NodeChoice f1; + + public ExternalDeclaration(NodeListOptional n0, NodeChoice n1) { + f0 = n0; + f1 = n1; + } + + public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { + v.visit(this); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJVisitor v, A argu) { + return v.visit(this,argu); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor v) { + return v.visit(this); + } + public void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor v, A argu) { + v.visit(this,argu); + } +} + diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/FunctionDeclaration.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/FunctionDeclaration.java new file mode 100644 index 000000000..54da9f7ed --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/FunctionDeclaration.java @@ -0,0 +1,57 @@ +// +// Generated by JTB 1.3.2 +// + +package org.gnunet.seaspider.parser.nodes; + +/** + * Grammar production: + * 
+ * f0 -> TypeSpecifier()
+ * f1 -> <IDENTIFIER>
+ * f2 -> "("
+ * f3 -> [ ParameterList() ]
+ * f4 -> ")"
+ * f5 -> ( ";" | CompoundStatement() )
+ *
+ */ +public class FunctionDeclaration implements Node { + public TypeSpecifier f0; + public NodeToken f1; + public NodeToken f2; + public NodeOptional f3; + public NodeToken f4; + public NodeChoice f5; + + public FunctionDeclaration(TypeSpecifier n0, NodeToken n1, NodeToken n2, NodeOptional n3, NodeToken n4, NodeChoice n5) { + f0 = n0; + f1 = n1; + f2 = n2; + f3 = n3; + f4 = n4; + f5 = n5; + } + + public FunctionDeclaration(TypeSpecifier n0, NodeToken n1, NodeOptional n2, NodeChoice n3) { + f0 = n0; + f1 = n1; + f2 = new NodeToken("("); + f3 = n2; + f4 = new NodeToken(")"); + f5 = n3; + } + + public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { + v.visit(this); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJVisitor v, A argu) { + return v.visit(this,argu); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor v) { + return v.visit(this); + } + public void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor v, A argu) { + v.visit(this,argu); + } +} + diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/FunctionType.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/FunctionType.java new file mode 100644 index 000000000..263e73e2f --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/FunctionType.java @@ -0,0 +1,65 @@ +// +// Generated by JTB 1.3.2 +// + +package org.gnunet.seaspider.parser.nodes; + +/** + * Grammar production: + * 
+ * f0 -> TypeSpecifier()
+ * f1 -> "("
+ * f2 -> "*"
+ * f3 -> <IDENTIFIER>
+ * f4 -> ")"
+ * f5 -> "("
+ * f6 -> [ ParameterList() ]
+ * f7 -> ")"
+ *
+ */ +public class FunctionType implements Node { + public TypeSpecifier f0; + public NodeToken f1; + public NodeToken f2; + public NodeToken f3; + public NodeToken f4; + public NodeToken f5; + public NodeOptional f6; + public NodeToken f7; + + public FunctionType(TypeSpecifier n0, NodeToken n1, NodeToken n2, NodeToken n3, NodeToken n4, NodeToken n5, NodeOptional n6, NodeToken n7) { + f0 = n0; + f1 = n1; + f2 = n2; + f3 = n3; + f4 = n4; + f5 = n5; + f6 = n6; + f7 = n7; + } + + public FunctionType(TypeSpecifier n0, NodeToken n1, NodeOptional n2) { + f0 = n0; + f1 = new NodeToken("("); + f2 = new NodeToken("*"); + f3 = n1; + f4 = new NodeToken(")"); + f5 = new NodeToken("("); + f6 = n2; + f7 = new NodeToken(")"); + } + + public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { + v.visit(this); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJVisitor v, A argu) { + return v.visit(this,argu); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor v) { + return v.visit(this); + } + public void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor v, A argu) { + v.visit(this,argu); + } +} + diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/IdentifierList.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/IdentifierList.java new file mode 100644 index 000000000..7df6de807 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/IdentifierList.java @@ -0,0 +1,36 @@ +// +// Generated by JTB 1.3.2 +// + +package org.gnunet.seaspider.parser.nodes; + +/** + * Grammar production: + * 
+ * f0 -> <IDENTIFIER>
+ * f1 -> ( "," <IDENTIFIER> )*
+ *
+ */ +public class IdentifierList implements Node { + public NodeToken f0; + public NodeListOptional f1; + + public IdentifierList(NodeToken n0, NodeListOptional n1) { + f0 = n0; + f1 = n1; + } + + public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { + v.visit(this); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJVisitor v, A argu) { + return v.visit(this,argu); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor v) { + return v.visit(this); + } + public void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor v, A argu) { + v.visit(this,argu); + } +} + diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/InclusiveORExpression.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/InclusiveORExpression.java new file mode 100644 index 000000000..9d972377d --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/InclusiveORExpression.java @@ -0,0 +1,36 @@ +// +// Generated by JTB 1.3.2 +// + +package org.gnunet.seaspider.parser.nodes; + +/** + * Grammar production: + * 
+ * f0 -> ExclusiveORExpression()
+ * f1 -> [ "|" InclusiveORExpression() ]
+ *
+ */ +public class InclusiveORExpression implements Node { + public ExclusiveORExpression f0; + public NodeOptional f1; + + public InclusiveORExpression(ExclusiveORExpression n0, NodeOptional n1) { + f0 = n0; + f1 = n1; + } + + public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { + v.visit(this); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJVisitor v, A argu) { + return v.visit(this,argu); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor v) { + return v.visit(this); + } + public void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor v, A argu) { + v.visit(this,argu); + } +} + diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/InitDeclarator.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/InitDeclarator.java new file mode 100644 index 000000000..27cd735fa --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/InitDeclarator.java @@ -0,0 +1,39 @@ +// +// Generated by JTB 1.3.2 +// + +package org.gnunet.seaspider.parser.nodes; + +/** + * Grammar production: + * 
+ * f0 -> <IDENTIFIER>
+ * f1 -> [ Array() ]
+ * f2 -> [ "=" Initializer() ]
+ *
+ */ +public class InitDeclarator implements Node { + public NodeToken f0; + public NodeOptional f1; + public NodeOptional f2; + + public InitDeclarator(NodeToken n0, NodeOptional n1, NodeOptional n2) { + f0 = n0; + f1 = n1; + f2 = n2; + } + + public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { + v.visit(this); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJVisitor v, A argu) { + return v.visit(this,argu); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor v) { + return v.visit(this); + } + public void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor v, A argu) { + v.visit(this,argu); + } +} + diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/InitDeclaratorList.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/InitDeclaratorList.java new file mode 100644 index 000000000..0323a1826 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/InitDeclaratorList.java @@ -0,0 +1,36 @@ +// +// Generated by JTB 1.3.2 +// + +package org.gnunet.seaspider.parser.nodes; + +/** + * Grammar production: + * 
+ * f0 -> InitDeclarator()
+ * f1 -> ( "," InitDeclarator() )*
+ *
+ */ +public class InitDeclaratorList implements Node { + public InitDeclarator f0; + public NodeListOptional f1; + + public InitDeclaratorList(InitDeclarator n0, NodeListOptional n1) { + f0 = n0; + f1 = n1; + } + + public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { + v.visit(this); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJVisitor v, A argu) { + return v.visit(this,argu); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor v) { + return v.visit(this); + } + public void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor v, A argu) { + v.visit(this,argu); + } +} + diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/Initializer.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/Initializer.java new file mode 100644 index 000000000..e7e03b967 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/Initializer.java @@ -0,0 +1,33 @@ +// +// Generated by JTB 1.3.2 +// + +package org.gnunet.seaspider.parser.nodes; + +/** + * Grammar production: + * 
+ * f0 -> ( AssignmentExpression() | "{" InitializerList() [ "," ] "}" )
+ *
+ */ +public class Initializer implements Node { + public NodeChoice f0; + + public Initializer(NodeChoice n0) { + f0 = n0; + } + + public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { + v.visit(this); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJVisitor v, A argu) { + return v.visit(this,argu); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor v) { + return v.visit(this); + } + public void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor v, A argu) { + v.visit(this,argu); + } +} + diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/InitializerList.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/InitializerList.java new file mode 100644 index 000000000..921602582 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/InitializerList.java @@ -0,0 +1,36 @@ +// +// Generated by JTB 1.3.2 +// + +package org.gnunet.seaspider.parser.nodes; + +/** + * Grammar production: + * 
+ * f0 -> Initializer()
+ * f1 -> ( "," Initializer() )*
+ *
+ */ +public class InitializerList implements Node { + public Initializer f0; + public NodeListOptional f1; + + public InitializerList(Initializer n0, NodeListOptional n1) { + f0 = n0; + f1 = n1; + } + + public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { + v.visit(this); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJVisitor v, A argu) { + return v.visit(this,argu); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor v) { + return v.visit(this); + } + public void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor v, A argu) { + v.visit(this,argu); + } +} + diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/IterationStatement.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/IterationStatement.java new file mode 100644 index 000000000..c9ba91916 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/IterationStatement.java @@ -0,0 +1,33 @@ +// +// Generated by JTB 1.3.2 +// + +package org.gnunet.seaspider.parser.nodes; + +/** + * Grammar production: + * 
+ * f0 -> ( <WHILE> "(" Expression() ")" Statement() | <DO> Statement() <WHILE> "(" Expression() ")" ";" | <FOR> "(" [ Expression() ] ";" [ Expression() ] ";" [ Expression() ] ")" Statement() )
+ *
+ */ +public class IterationStatement implements Node { + public NodeChoice f0; + + public IterationStatement(NodeChoice n0) { + f0 = n0; + } + + public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { + v.visit(this); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJVisitor v, A argu) { + return v.visit(this,argu); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor v) { + return v.visit(this); + } + public void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor v, A argu) { + v.visit(this,argu); + } +} + diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/JumpStatement.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/JumpStatement.java new file mode 100644 index 000000000..7341aadf2 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/JumpStatement.java @@ -0,0 +1,33 @@ +// +// Generated by JTB 1.3.2 +// + +package org.gnunet.seaspider.parser.nodes; + +/** + * Grammar production: + * 
+ * f0 -> ( <GOTO> <IDENTIFIER> ";" | <CONTINUE> ";" | <BREAK> ";" | <RETURN> [ Expression() ] ";" )
+ *
+ */ +public class JumpStatement implements Node { + public NodeChoice f0; + + public JumpStatement(NodeChoice n0) { + f0 = n0; + } + + public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { + v.visit(this); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJVisitor v, A argu) { + return v.visit(this,argu); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor v) { + return v.visit(this); + } + public void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor v, A argu) { + v.visit(this,argu); + } +} + diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/LabeledStatement.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/LabeledStatement.java new file mode 100644 index 000000000..5f4ef4f98 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/LabeledStatement.java @@ -0,0 +1,33 @@ +// +// Generated by JTB 1.3.2 +// + +package org.gnunet.seaspider.parser.nodes; + +/** + * Grammar production: + * 
+ * f0 -> ( <IDENTIFIER> ":" Statement() | <CASE> ConstantExpression() ":" Statement() | <DFLT> ":" Statement() )
+ *
+ */ +public class LabeledStatement implements Node { + public NodeChoice f0; + + public LabeledStatement(NodeChoice n0) { + f0 = n0; + } + + public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { + v.visit(this); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJVisitor v, A argu) { + return v.visit(this,argu); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor v) { + return v.visit(this); + } + public void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor v, A argu) { + v.visit(this,argu); + } +} + diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/LocalVariableDeclaration.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/LocalVariableDeclaration.java new file mode 100644 index 000000000..8337772a4 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/LocalVariableDeclaration.java @@ -0,0 +1,36 @@ +// +// Generated by JTB 1.3.2 +// + +package org.gnunet.seaspider.parser.nodes; + +/** + * Grammar production: + * 
+ * f0 -> [ <STATIC> ]
+ * f1 -> VariableDeclaration()
+ *
+ */ +public class LocalVariableDeclaration implements Node { + public NodeOptional f0; + public VariableDeclaration f1; + + public LocalVariableDeclaration(NodeOptional n0, VariableDeclaration n1) { + f0 = n0; + f1 = n1; + } + + public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { + v.visit(this); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJVisitor v, A argu) { + return v.visit(this,argu); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor v) { + return v.visit(this); + } + public void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor v, A argu) { + v.visit(this,argu); + } +} + diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/LogicalANDExpression.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/LogicalANDExpression.java new file mode 100644 index 000000000..b353bb7f6 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/LogicalANDExpression.java @@ -0,0 +1,36 @@ +// +// Generated by JTB 1.3.2 +// + +package org.gnunet.seaspider.parser.nodes; + +/** + * Grammar production: + * 
+ * f0 -> InclusiveORExpression()
+ * f1 -> [ "&&" LogicalANDExpression() ]
+ *
+ */ +public class LogicalANDExpression implements Node { + public InclusiveORExpression f0; + public NodeOptional f1; + + public LogicalANDExpression(InclusiveORExpression n0, NodeOptional n1) { + f0 = n0; + f1 = n1; + } + + public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { + v.visit(this); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJVisitor v, A argu) { + return v.visit(this,argu); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor v) { + return v.visit(this); + } + public void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor v, A argu) { + v.visit(this,argu); + } +} + diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/LogicalORExpression.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/LogicalORExpression.java new file mode 100644 index 000000000..87f8d0d11 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/LogicalORExpression.java @@ -0,0 +1,36 @@ +// +// Generated by JTB 1.3.2 +// + +package org.gnunet.seaspider.parser.nodes; + +/** + * Grammar production: + * 
+ * f0 -> LogicalANDExpression()
+ * f1 -> [ "||" LogicalORExpression() ]
+ *
+ */ +public class LogicalORExpression implements Node { + public LogicalANDExpression f0; + public NodeOptional f1; + + public LogicalORExpression(LogicalANDExpression n0, NodeOptional n1) { + f0 = n0; + f1 = n1; + } + + public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { + v.visit(this); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJVisitor v, A argu) { + return v.visit(this,argu); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor v) { + return v.visit(this); + } + public void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor v, A argu) { + v.visit(this,argu); + } +} + diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/MultiplicativeExpression.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/MultiplicativeExpression.java new file mode 100644 index 000000000..9b801d12f --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/MultiplicativeExpression.java @@ -0,0 +1,36 @@ +// +// Generated by JTB 1.3.2 +// + +package org.gnunet.seaspider.parser.nodes; + +/** + * Grammar production: + * 
+ * f0 -> CastExpression()
+ * f1 -> [ ( "*" | "/" | "%" ) MultiplicativeExpression() ]
+ *
+ */ +public class MultiplicativeExpression implements Node { + public CastExpression f0; + public NodeOptional f1; + + public MultiplicativeExpression(CastExpression n0, NodeOptional n1) { + f0 = n0; + f1 = n1; + } + + public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { + v.visit(this); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJVisitor v, A argu) { + return v.visit(this,argu); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor v) { + return v.visit(this); + } + public void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor v, A argu) { + v.visit(this,argu); + } +} + diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/NoIdentifierTypeSpecifier.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/NoIdentifierTypeSpecifier.java new file mode 100644 index 000000000..ff4fc4108 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/NoIdentifierTypeSpecifier.java @@ -0,0 +1,42 @@ +// +// Generated by JTB 1.3.2 +// + +package org.gnunet.seaspider.parser.nodes; + +/** + * Grammar production: + * 
+ * f0 -> [ <CONST> ]
+ * f1 -> ( <VOID> | <CHAR> | <SHORT> [ <INT> ] | <INT> | <LONG> [ <LONG> ] | <FLOAT> | <DOUBLE> | ( <SIGNED> | <UNSIGNED> ) [ <CHAR> | <SHORT> [ <INT> ] | <INT> | <LONG> [ <LONG> ] ] | StructOrUnionSpecifier() | EnumSpecifier() )
+ * f2 -> [ Pointer() ]
+ * f3 -> [ Array() ]
+ *
+ */ +public class NoIdentifierTypeSpecifier implements Node { + public NodeOptional f0; + public NodeChoice f1; + public NodeOptional f2; + public NodeOptional f3; + + public NoIdentifierTypeSpecifier(NodeOptional n0, NodeChoice n1, NodeOptional n2, NodeOptional n3) { + f0 = n0; + f1 = n1; + f2 = n2; + f3 = n3; + } + + public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { + v.visit(this); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJVisitor v, A argu) { + return v.visit(this,argu); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor v) { + return v.visit(this); + } + public void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor v, A argu) { + v.visit(this,argu); + } +} + diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/Node.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/Node.java new file mode 100644 index 000000000..4ea3904db --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/Node.java @@ -0,0 +1,16 @@ +// +// Generated by JTB 1.3.2 +// + +package org.gnunet.seaspider.parser.nodes; + +/** + * The interface which all syntax tree classes must implement. + */ +public interface Node extends java.io.Serializable { + public void accept(org.gnunet.seaspider.parser.visitors.Visitor v); + public R accept(org.gnunet.seaspider.parser.visitors.GJVisitor v, A argu); + public R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor v); + public void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor v, A argu); +} + diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/NodeChoice.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/NodeChoice.java new file mode 100644 index 000000000..ff9a66d1b --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/NodeChoice.java @@ -0,0 +1,36 @@ +// +// Generated by JTB 1.3.2 +// + +package org.gnunet.seaspider.parser.nodes; + +/** + * Represents a grammar choice, e.g. ( A | B ) + */ +public class NodeChoice implements Node { + public NodeChoice(Node node) { + this(node, -1); + } + + public NodeChoice(Node node, int whichChoice) { + choice = node; + which = whichChoice; + } + + public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { + choice.accept(v); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJVisitor v, A argu) { + return choice.accept(v,argu); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor v) { + return choice.accept(v); + } + public void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor v, A argu) { + choice.accept(v,argu); + } + + public Node choice; + public int which; +} + diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/NodeList.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/NodeList.java new file mode 100644 index 000000000..36352b0f5 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/NodeList.java @@ -0,0 +1,44 @@ +// +// Generated by JTB 1.3.2 +// + +package org.gnunet.seaspider.parser.nodes; + +import java.util.*; + +/** + * Represents a grammar list, e.g. ( A )+ + */ +public class NodeList implements NodeListInterface { + public NodeList() { + nodes = new Vector(); + } + + public NodeList(Node firstNode) { + nodes = new Vector(); + addNode(firstNode); + } + + public void addNode(Node n) { + nodes.addElement(n); + } + + public Enumeration elements() { return nodes.elements(); } + public Node elementAt(int i) { return nodes.elementAt(i); } + public int size() { return nodes.size(); } + public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { + v.visit(this); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJVisitor v, A argu) { + return v.visit(this,argu); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor v) { + return v.visit(this); + } + public void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor v, A argu) { + v.visit(this,argu); + } + + public Vector nodes; +} + diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/NodeListInterface.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/NodeListInterface.java new file mode 100644 index 000000000..5b37ab566 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/NodeListInterface.java @@ -0,0 +1,22 @@ +// +// Generated by JTB 1.3.2 +// + +package org.gnunet.seaspider.parser.nodes; + +/** + * The interface which NodeList, NodeListOptional, and NodeSequence + * implement. + */ +public interface NodeListInterface extends Node { + public void addNode(Node n); + public Node elementAt(int i); + public java.util.Enumeration elements(); + public int size(); + + public void accept(org.gnunet.seaspider.parser.visitors.Visitor v); + public R accept(org.gnunet.seaspider.parser.visitors.GJVisitor v, A argu); + public R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor v); + public void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor v, A argu); +} + diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/NodeListOptional.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/NodeListOptional.java new file mode 100644 index 000000000..73ca45fd4 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/NodeListOptional.java @@ -0,0 +1,45 @@ +// +// Generated by JTB 1.3.2 +// + +package org.gnunet.seaspider.parser.nodes; + +import java.util.*; + +/** + * Represents an optional grammar list, e.g. ( A )* + */ +public class NodeListOptional implements NodeListInterface { + public NodeListOptional() { + nodes = new Vector(); + } + + public NodeListOptional(Node firstNode) { + nodes = new Vector(); + addNode(firstNode); + } + + public void addNode(Node n) { + nodes.addElement(n); + } + + public Enumeration elements() { return nodes.elements(); } + public Node elementAt(int i) { return nodes.elementAt(i); } + public int size() { return nodes.size(); } + public boolean present() { return nodes.size() != 0; } + public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { + v.visit(this); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJVisitor v, A argu) { + return v.visit(this,argu); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor v) { + return v.visit(this); + } + public void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor v, A argu) { + v.visit(this,argu); + } + + public Vector nodes; +} + diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/NodeOptional.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/NodeOptional.java new file mode 100644 index 000000000..364c7c6c2 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/NodeOptional.java @@ -0,0 +1,41 @@ +// +// Generated by JTB 1.3.2 +// + +package org.gnunet.seaspider.parser.nodes; + +/** + * Represents an grammar optional node, e.g. ( A )? or [ A ] + */ +public class NodeOptional implements Node { + public NodeOptional() { + node = null; + } + + public NodeOptional(Node n) { + addNode(n); + } + + public void addNode(Node n) { + if ( node != null) // Oh oh! + throw new Error("Attempt to set optional node twice"); + + node = n; + } + public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { + v.visit(this); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJVisitor v, A argu) { + return v.visit(this,argu); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor v) { + return v.visit(this); + } + public void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor v, A argu) { + v.visit(this,argu); + } + public boolean present() { return node != null; } + + public Node node; +} + diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/NodeSequence.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/NodeSequence.java new file mode 100644 index 000000000..63c09786a --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/NodeSequence.java @@ -0,0 +1,45 @@ +// +// Generated by JTB 1.3.2 +// + +package org.gnunet.seaspider.parser.nodes; + +import java.util.*; + +/** + * Represents a sequence of nodes nested within a choice, list, + * optional list, or optional, e.g. ( A B )+ or [ C D E ] + */ +public class NodeSequence implements NodeListInterface { + public NodeSequence(int n) { + nodes = new Vector(n); + } + + public NodeSequence(Node firstNode) { + nodes = new Vector(); + addNode(firstNode); + } + + public void addNode(Node n) { + nodes.addElement(n); + } + + public Node elementAt(int i) { return nodes.elementAt(i); } + public Enumeration elements() { return nodes.elements(); } + public int size() { return nodes.size(); } + public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { + v.visit(this); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJVisitor v, A argu) { + return v.visit(this,argu); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor v) { + return v.visit(this); + } + public void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor v, A argu) { + v.visit(this,argu); + } + + public Vector nodes; +} + diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/NodeToken.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/NodeToken.java new file mode 100644 index 000000000..90db44d7a --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/NodeToken.java @@ -0,0 +1,87 @@ +// +// Generated by JTB 1.3.2 +// + +package org.gnunet.seaspider.parser.nodes; + +import java.util.*; +/** + * Represents a single token in the grammar. If the "-tk" option + * is used, also contains a Vector of preceding special tokens. + */ +public class NodeToken implements Node { + public NodeToken(String s) { + this(s, -1, -1, -1, -1, -1); } + + public NodeToken(String s, int kind, int beginLine, int beginColumn, int endLine, int endColumn) { + tokenImage = s; + specialTokens = null; + this.kind = kind; + this.beginLine = beginLine; + this.beginColumn = beginColumn; + this.endLine = endLine; + this.endColumn = endColumn; + } + + public NodeToken getSpecialAt(int i) { + if ( specialTokens == null ) + throw new java.util.NoSuchElementException("No specials in token"); + return specialTokens.elementAt(i); + } + + public int numSpecials() { + if ( specialTokens == null ) return 0; + return specialTokens.size(); + } + + public void addSpecial(NodeToken s) { + if ( specialTokens == null ) specialTokens = new Vector(); + specialTokens.addElement(s); + } + + public void trimSpecials() { + if ( specialTokens == null ) return; + specialTokens.trimToSize(); + } + + public String toString() { return tokenImage; } + + public String withSpecials() { + if ( specialTokens == null ) + return tokenImage; + + StringBuffer buf = new StringBuffer(); + + for ( Enumeration e = specialTokens.elements(); e.hasMoreElements(); ) + buf.append(e.nextElement().toString()); + + buf.append(tokenImage); + return buf.toString(); + } + + public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { + v.visit(this); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJVisitor v, A argu) { + return v.visit(this,argu); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor v) { + return v.visit(this); + } + public void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor v, A argu) { + v.visit(this,argu); + } + + public String tokenImage; + + // Stores a list of NodeTokens + public Vector specialTokens; + + // -1 for these ints means no position info is available. + public int beginLine, beginColumn, endLine, endColumn; + + // Equal to the JavaCC token "kind" integer. + // -1 if not available. + public int kind; +} + diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/ParameterDeclaration.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/ParameterDeclaration.java new file mode 100644 index 000000000..da7a71d44 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/ParameterDeclaration.java @@ -0,0 +1,39 @@ +// +// Generated by JTB 1.3.2 +// + +package org.gnunet.seaspider.parser.nodes; + +/** + * Grammar production: + * 
+ * f0 -> TypeSpecifier()
+ * f1 -> <IDENTIFIER>
+ * f2 -> [ Array() ]
+ *
+ */ +public class ParameterDeclaration implements Node { + public TypeSpecifier f0; + public NodeToken f1; + public NodeOptional f2; + + public ParameterDeclaration(TypeSpecifier n0, NodeToken n1, NodeOptional n2) { + f0 = n0; + f1 = n1; + f2 = n2; + } + + public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { + v.visit(this); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJVisitor v, A argu) { + return v.visit(this,argu); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor v) { + return v.visit(this); + } + public void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor v, A argu) { + v.visit(this,argu); + } +} + diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/ParameterList.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/ParameterList.java new file mode 100644 index 000000000..d92fd41ff --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/ParameterList.java @@ -0,0 +1,39 @@ +// +// Generated by JTB 1.3.2 +// + +package org.gnunet.seaspider.parser.nodes; + +/** + * Grammar production: + * 
+ * f0 -> ParameterDeclaration()
+ * f1 -> ( "," ParameterDeclaration() )*
+ * f2 -> [ "," "..." ]
+ *
+ */ +public class ParameterList implements Node { + public ParameterDeclaration f0; + public NodeListOptional f1; + public NodeOptional f2; + + public ParameterList(ParameterDeclaration n0, NodeListOptional n1, NodeOptional n2) { + f0 = n0; + f1 = n1; + f2 = n2; + } + + public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { + v.visit(this); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJVisitor v, A argu) { + return v.visit(this,argu); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor v) { + return v.visit(this); + } + public void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor v, A argu) { + v.visit(this,argu); + } +} + diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/Pointer.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/Pointer.java new file mode 100644 index 000000000..56f175eb1 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/Pointer.java @@ -0,0 +1,45 @@ +// +// Generated by JTB 1.3.2 +// + +package org.gnunet.seaspider.parser.nodes; + +/** + * Grammar production: + * 
+ * f0 -> "*"
+ * f1 -> [ <CONST> ]
+ * f2 -> [ Pointer() ]
+ *
+ */ +public class Pointer implements Node { + public NodeToken f0; + public NodeOptional f1; + public NodeOptional f2; + + public Pointer(NodeToken n0, NodeOptional n1, NodeOptional n2) { + f0 = n0; + f1 = n1; + f2 = n2; + } + + public Pointer(NodeOptional n0, NodeOptional n1) { + f0 = new NodeToken("*"); + f1 = n0; + f2 = n1; + } + + public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { + v.visit(this); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJVisitor v, A argu) { + return v.visit(this,argu); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor v) { + return v.visit(this); + } + public void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor v, A argu) { + v.visit(this,argu); + } +} + diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/PostfixExpression.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/PostfixExpression.java new file mode 100644 index 000000000..52e141504 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/PostfixExpression.java @@ -0,0 +1,36 @@ +// +// Generated by JTB 1.3.2 +// + +package org.gnunet.seaspider.parser.nodes; + +/** + * Grammar production: + * 
+ * f0 -> PrimaryExpression()
+ * f1 -> ( "[" Expression() "]" | "(" [ ArgumentExpressionList() ] ")" | "." <IDENTIFIER> | "->" <IDENTIFIER> | "++" | "--" )*
+ *
+ */ +public class PostfixExpression implements Node { + public PrimaryExpression f0; + public NodeListOptional f1; + + public PostfixExpression(PrimaryExpression n0, NodeListOptional n1) { + f0 = n0; + f1 = n1; + } + + public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { + v.visit(this); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJVisitor v, A argu) { + return v.visit(this,argu); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor v) { + return v.visit(this); + } + public void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor v, A argu) { + v.visit(this,argu); + } +} + diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/PrimaryExpression.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/PrimaryExpression.java new file mode 100644 index 000000000..fb953dccd --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/PrimaryExpression.java @@ -0,0 +1,35 @@ +// +// Generated by JTB 1.3.2 +// + +package org.gnunet.seaspider.parser.nodes; + +/** + * Grammar production: + * 
+ * f0 -> <IDENTIFIER>
+ *       | Constant()
+ *       | "(" Expression() ")"
+ *
+ */ +public class PrimaryExpression implements Node { + public NodeChoice f0; + + public PrimaryExpression(NodeChoice n0) { + f0 = n0; + } + + public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { + v.visit(this); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJVisitor v, A argu) { + return v.visit(this,argu); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor v) { + return v.visit(this); + } + public void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor v, A argu) { + v.visit(this,argu); + } +} + diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/RelationalExpression.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/RelationalExpression.java new file mode 100644 index 000000000..5b823077b --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/RelationalExpression.java @@ -0,0 +1,36 @@ +// +// Generated by JTB 1.3.2 +// + +package org.gnunet.seaspider.parser.nodes; + +/** + * Grammar production: + * 
+ * f0 -> ShiftExpression()
+ * f1 -> [ ( "<" | ">" | "<=" | ">=" ) RelationalExpression() ]
+ *
+ */ +public class RelationalExpression implements Node { + public ShiftExpression f0; + public NodeOptional f1; + + public RelationalExpression(ShiftExpression n0, NodeOptional n1) { + f0 = n0; + f1 = n1; + } + + public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { + v.visit(this); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJVisitor v, A argu) { + return v.visit(this,argu); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor v) { + return v.visit(this); + } + public void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor v, A argu) { + v.visit(this,argu); + } +} + diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/SelectionStatement.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/SelectionStatement.java new file mode 100644 index 000000000..e3da4cf34 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/SelectionStatement.java @@ -0,0 +1,33 @@ +// +// Generated by JTB 1.3.2 +// + +package org.gnunet.seaspider.parser.nodes; + +/** + * Grammar production: + * 
+ * f0 -> ( <IF> "(" Expression() ")" Statement() [ <ELSE> Statement() ] | <SWITCH> "(" Expression() ")" Statement() )
+ *
+ */ +public class SelectionStatement implements Node { + public NodeChoice f0; + + public SelectionStatement(NodeChoice n0) { + f0 = n0; + } + + public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { + v.visit(this); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJVisitor v, A argu) { + return v.visit(this,argu); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor v) { + return v.visit(this); + } + public void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor v, A argu) { + v.visit(this,argu); + } +} + diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/ShiftExpression.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/ShiftExpression.java new file mode 100644 index 000000000..b3c9e5b0f --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/ShiftExpression.java @@ -0,0 +1,36 @@ +// +// Generated by JTB 1.3.2 +// + +package org.gnunet.seaspider.parser.nodes; + +/** + * Grammar production: + * 
+ * f0 -> AdditiveExpression()
+ * f1 -> [ ( "<<" | ">>" ) ShiftExpression() ]
+ *
+ */ +public class ShiftExpression implements Node { + public AdditiveExpression f0; + public NodeOptional f1; + + public ShiftExpression(AdditiveExpression n0, NodeOptional n1) { + f0 = n0; + f1 = n1; + } + + public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { + v.visit(this); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJVisitor v, A argu) { + return v.visit(this,argu); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor v) { + return v.visit(this); + } + public void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor v, A argu) { + v.visit(this,argu); + } +} + diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/Statement.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/Statement.java new file mode 100644 index 000000000..27148dfe7 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/Statement.java @@ -0,0 +1,33 @@ +// +// Generated by JTB 1.3.2 +// + +package org.gnunet.seaspider.parser.nodes; + +/** + * Grammar production: + * 
+ * f0 -> ( LabeledStatement() | ExpressionStatement() | CompoundStatement() | SelectionStatement() | IterationStatement() | JumpStatement() )
+ *
+ */ +public class Statement implements Node { + public NodeChoice f0; + + public Statement(NodeChoice n0) { + f0 = n0; + } + + public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { + v.visit(this); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJVisitor v, A argu) { + return v.visit(this,argu); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor v) { + return v.visit(this); + } + public void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor v, A argu) { + v.visit(this,argu); + } +} + diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/StorageClassSpecifier.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/StorageClassSpecifier.java new file mode 100644 index 000000000..223839f96 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/StorageClassSpecifier.java @@ -0,0 +1,33 @@ +// +// Generated by JTB 1.3.2 +// + +package org.gnunet.seaspider.parser.nodes; + +/** + * Grammar production: + * 
+ * f0 -> ( <STATIC> | <EXTERN> )
+ *
+ */ +public class StorageClassSpecifier implements Node { + public NodeChoice f0; + + public StorageClassSpecifier(NodeChoice n0) { + f0 = n0; + } + + public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { + v.visit(this); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJVisitor v, A argu) { + return v.visit(this,argu); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor v) { + return v.visit(this); + } + public void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor v, A argu) { + v.visit(this,argu); + } +} + diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/StructDeclaration.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/StructDeclaration.java new file mode 100644 index 000000000..074ec4266 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/StructDeclaration.java @@ -0,0 +1,53 @@ +// +// Generated by JTB 1.3.2 +// + +package org.gnunet.seaspider.parser.nodes; + +/** + * Grammar production: + * 
+ * f0 -> TypeSpecifier()
+ * f1 -> <IDENTIFIER>
+ * f2 -> [ Array() | ":" ConstantExpression() ]
+ * f3 -> [ <IDENTIFIER> ]
+ * f4 -> ";"
+ *
+ */ +public class StructDeclaration implements Node { + public TypeSpecifier f0; + public NodeToken f1; + public NodeOptional f2; + public NodeOptional f3; + public NodeToken f4; + + public StructDeclaration(TypeSpecifier n0, NodeToken n1, NodeOptional n2, NodeOptional n3, NodeToken n4) { + f0 = n0; + f1 = n1; + f2 = n2; + f3 = n3; + f4 = n4; + } + + public StructDeclaration(TypeSpecifier n0, NodeToken n1, NodeOptional n2, NodeOptional n3) { + f0 = n0; + f1 = n1; + f2 = n2; + f3 = n3; + f4 = new NodeToken(";"); + } + + public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { + v.visit(this); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJVisitor v, A argu) { + return v.visit(this,argu); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor v) { + return v.visit(this); + } + public void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor v, A argu) { + v.visit(this,argu); + } +} + diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/StructDeclarationList.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/StructDeclarationList.java new file mode 100644 index 000000000..32d081495 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/StructDeclarationList.java @@ -0,0 +1,33 @@ +// +// Generated by JTB 1.3.2 +// + +package org.gnunet.seaspider.parser.nodes; + +/** + * Grammar production: + * 
+ * f0 -> ( StructDeclaration() )+
+ *
+ */ +public class StructDeclarationList implements Node { + public NodeList f0; + + public StructDeclarationList(NodeList n0) { + f0 = n0; + } + + public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { + v.visit(this); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJVisitor v, A argu) { + return v.visit(this,argu); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor v) { + return v.visit(this); + } + public void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor v, A argu) { + v.visit(this,argu); + } +} + diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/StructOrUnion.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/StructOrUnion.java new file mode 100644 index 000000000..2131d7a6b --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/StructOrUnion.java @@ -0,0 +1,33 @@ +// +// Generated by JTB 1.3.2 +// + +package org.gnunet.seaspider.parser.nodes; + +/** + * Grammar production: + * 
+ * f0 -> ( <STRUCT> | <UNION> )
+ *
+ */ +public class StructOrUnion implements Node { + public NodeChoice f0; + + public StructOrUnion(NodeChoice n0) { + f0 = n0; + } + + public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { + v.visit(this); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJVisitor v, A argu) { + return v.visit(this,argu); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor v) { + return v.visit(this); + } + public void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor v, A argu) { + v.visit(this,argu); + } +} + diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/StructOrUnionSpecifier.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/StructOrUnionSpecifier.java new file mode 100644 index 000000000..aa64929be --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/StructOrUnionSpecifier.java @@ -0,0 +1,34 @@ +// +// Generated by JTB 1.3.2 +// + +package org.gnunet.seaspider.parser.nodes; + +/** + * Grammar production: + * 
+ * f0 -> StructOrUnion() [ <IDENTIFIER> ] "{" StructDeclarationList() "}"
+ *       | StructOrUnion() <IDENTIFIER>
+ *
+ */ +public class StructOrUnionSpecifier implements Node { + public NodeChoice f0; + + public StructOrUnionSpecifier(NodeChoice n0) { + f0 = n0; + } + + public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { + v.visit(this); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJVisitor v, A argu) { + return v.visit(this,argu); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor v) { + return v.visit(this); + } + public void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor v, A argu) { + v.visit(this,argu); + } +} + diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/TranslationUnit.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/TranslationUnit.java new file mode 100644 index 000000000..feb48f646 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/TranslationUnit.java @@ -0,0 +1,33 @@ +// +// Generated by JTB 1.3.2 +// + +package org.gnunet.seaspider.parser.nodes; + +/** + * Grammar production: + * 
+ * f0 -> ( ExternalDeclaration() )+
+ *
+ */ +public class TranslationUnit implements Node { + public NodeList f0; + + public TranslationUnit(NodeList n0) { + f0 = n0; + } + + public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { + v.visit(this); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJVisitor v, A argu) { + return v.visit(this,argu); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor v) { + return v.visit(this); + } + public void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor v, A argu) { + v.visit(this,argu); + } +} + diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/TypeDeclaration.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/TypeDeclaration.java new file mode 100644 index 000000000..500aecaf3 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/TypeDeclaration.java @@ -0,0 +1,45 @@ +// +// Generated by JTB 1.3.2 +// + +package org.gnunet.seaspider.parser.nodes; + +/** + * Grammar production: + * 
+ * f0 -> <TYPEDEF>
+ * f1 -> ( DataType() | FunctionType() )
+ * f2 -> ";"
+ *
+ */ +public class TypeDeclaration implements Node { + public NodeToken f0; + public NodeChoice f1; + public NodeToken f2; + + public TypeDeclaration(NodeToken n0, NodeChoice n1, NodeToken n2) { + f0 = n0; + f1 = n1; + f2 = n2; + } + + public TypeDeclaration(NodeChoice n0) { + f0 = new NodeToken("typedef"); + f1 = n0; + f2 = new NodeToken(";"); + } + + public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { + v.visit(this); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJVisitor v, A argu) { + return v.visit(this,argu); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor v) { + return v.visit(this); + } + public void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor v, A argu) { + v.visit(this,argu); + } +} + diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/TypeSpecifier.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/TypeSpecifier.java new file mode 100644 index 000000000..6d1607d1a --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/TypeSpecifier.java @@ -0,0 +1,42 @@ +// +// Generated by JTB 1.3.2 +// + +package org.gnunet.seaspider.parser.nodes; + +/** + * Grammar production: + * 
+ * f0 -> [ <CONST> ]
+ * f1 -> ( <VOID> | <CHAR> | <SHORT> [ <INT> ] | <INT> | <LONG> [ <LONG> ] | <FLOAT> | <DOUBLE> | ( <SIGNED> | <UNSIGNED> ) [ <CHAR> | <SHORT> [ <INT> ] | <INT> | <LONG> [ <LONG> ] ] | StructOrUnionSpecifier() | EnumSpecifier() | <IDENTIFIER> )
+ * f2 -> [ Pointer() ]
+ * f3 -> [ Array() ]
+ *
+ */ +public class TypeSpecifier implements Node { + public NodeOptional f0; + public NodeChoice f1; + public NodeOptional f2; + public NodeOptional f3; + + public TypeSpecifier(NodeOptional n0, NodeChoice n1, NodeOptional n2, NodeOptional n3) { + f0 = n0; + f1 = n1; + f2 = n2; + f3 = n3; + } + + public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { + v.visit(this); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJVisitor v, A argu) { + return v.visit(this,argu); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor v) { + return v.visit(this); + } + public void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor v, A argu) { + v.visit(this,argu); + } +} + diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/UnaryExpression.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/UnaryExpression.java new file mode 100644 index 000000000..1e7894e23 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/UnaryExpression.java @@ -0,0 +1,33 @@ +// +// Generated by JTB 1.3.2 +// + +package org.gnunet.seaspider.parser.nodes; + +/** + * Grammar production: + * 
+ * f0 -> ( PostfixExpression() | "++" UnaryExpression() | "--" UnaryExpression() | UnaryOperator() CastExpression() | <SIZEOF> ( UnaryExpression() | "(" TypeSpecifier() ")" ) )
+ *
+ */ +public class UnaryExpression implements Node { + public NodeChoice f0; + + public UnaryExpression(NodeChoice n0) { + f0 = n0; + } + + public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { + v.visit(this); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJVisitor v, A argu) { + return v.visit(this,argu); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor v) { + return v.visit(this); + } + public void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor v, A argu) { + v.visit(this,argu); + } +} + diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/UnaryOperator.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/UnaryOperator.java new file mode 100644 index 000000000..630af9d21 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/UnaryOperator.java @@ -0,0 +1,33 @@ +// +// Generated by JTB 1.3.2 +// + +package org.gnunet.seaspider.parser.nodes; + +/** + * Grammar production: + * 
+ * f0 -> ( "&" | "*" | "+" | "-" | "~" | "!" )
+ *
+ */ +public class UnaryOperator implements Node { + public NodeChoice f0; + + public UnaryOperator(NodeChoice n0) { + f0 = n0; + } + + public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { + v.visit(this); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJVisitor v, A argu) { + return v.visit(this,argu); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor v) { + return v.visit(this); + } + public void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor v, A argu) { + v.visit(this,argu); + } +} + diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/VariableClassSpecifier.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/VariableClassSpecifier.java new file mode 100644 index 000000000..5a9101937 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/VariableClassSpecifier.java @@ -0,0 +1,33 @@ +// +// Generated by JTB 1.3.2 +// + +package org.gnunet.seaspider.parser.nodes; + +/** + * Grammar production: + * 
+ * f0 -> ( <AUTO> | <REGISTER> )*
+ *
+ */ +public class VariableClassSpecifier implements Node { + public NodeListOptional f0; + + public VariableClassSpecifier(NodeListOptional n0) { + f0 = n0; + } + + public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { + v.visit(this); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJVisitor v, A argu) { + return v.visit(this,argu); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor v) { + return v.visit(this); + } + public void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor v, A argu) { + v.visit(this,argu); + } +} + diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/VariableDeclaration.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/VariableDeclaration.java new file mode 100644 index 000000000..aa7cf6e32 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/nodes/VariableDeclaration.java @@ -0,0 +1,49 @@ +// +// Generated by JTB 1.3.2 +// + +package org.gnunet.seaspider.parser.nodes; + +/** + * Grammar production: + * 
+ * f0 -> VariableClassSpecifier()
+ * f1 -> TypeSpecifier()
+ * f2 -> InitDeclaratorList()
+ * f3 -> ";"
+ *
+ */ +public class VariableDeclaration implements Node { + public VariableClassSpecifier f0; + public TypeSpecifier f1; + public InitDeclaratorList f2; + public NodeToken f3; + + public VariableDeclaration(VariableClassSpecifier n0, TypeSpecifier n1, InitDeclaratorList n2, NodeToken n3) { + f0 = n0; + f1 = n1; + f2 = n2; + f3 = n3; + } + + public VariableDeclaration(VariableClassSpecifier n0, TypeSpecifier n1, InitDeclaratorList n2) { + f0 = n0; + f1 = n1; + f2 = n2; + f3 = new NodeToken(";"); + } + + public void accept(org.gnunet.seaspider.parser.visitors.Visitor v) { + v.visit(this); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJVisitor v, A argu) { + return v.visit(this,argu); + } + public R accept(org.gnunet.seaspider.parser.visitors.GJNoArguVisitor v) { + return v.visit(this); + } + public void accept(org.gnunet.seaspider.parser.visitors.GJVoidVisitor v, A argu) { + v.visit(this,argu); + } +} + diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/visitors/DepthFirstVisitor.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/visitors/DepthFirstVisitor.java new file mode 100644 index 000000000..57c92b752 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/visitors/DepthFirstVisitor.java @@ -0,0 +1,701 @@ +// +// Generated by JTB 1.3.2 +// + +package org.gnunet.seaspider.parser.visitors; +import org.gnunet.seaspider.parser.nodes.*; + +import java.util.*; + +/** + * Provides default methods which visit each node in the tree in depth-first + * order. Your visitors may extend this class. + */ +public class DepthFirstVisitor implements Visitor { + // + // Auto class visitors--probably don't need to be overridden. + // + public void visit(NodeList n) { + for ( Enumeration e = n.elements(); e.hasMoreElements(); ) + e.nextElement().accept(this); + } + + public void visit(NodeListOptional n) { + if ( n.present() ) + for ( Enumeration e = n.elements(); e.hasMoreElements(); ) + e.nextElement().accept(this); + } + + public void visit(NodeOptional n) { + if ( n.present() ) + n.node.accept(this); + } + + public void visit(NodeSequence n) { + for ( Enumeration e = n.elements(); e.hasMoreElements(); ) + e.nextElement().accept(this); + } + + public void visit(NodeToken n) { } + + // + // User-generated visitor methods below + // + + /** + * 
+    * f0 -> ( ExternalDeclaration() )+
+    *
+ */ + public void visit(TranslationUnit n) { + n.f0.accept(this); + } + + /** + * 
+    * f0 -> ( StorageClassSpecifier() )*
+    * f1 -> ( FunctionDeclaration() | StructOrUnionSpecifier() | VariableDeclaration() | TypeDeclaration() )
+    *
+ */ + public void visit(ExternalDeclaration n) { + n.f0.accept(this); + n.f1.accept(this); + } + + /** + * 
+    * f0 -> TypeSpecifier()
+    * f1 -> <IDENTIFIER>
+    * f2 -> "("
+    * f3 -> [ ParameterList() ]
+    * f4 -> ")"
+    * f5 -> ( ";" | CompoundStatement() )
+    *
+ */ + public void visit(FunctionDeclaration n) { + n.f0.accept(this); + n.f1.accept(this); + n.f2.accept(this); + n.f3.accept(this); + n.f4.accept(this); + n.f5.accept(this); + } + + /** + * 
+    * f0 -> ( <STATIC> | <EXTERN> )
+    *
+ */ + public void visit(StorageClassSpecifier n) { + n.f0.accept(this); + } + + /** + * 
+    * f0 -> <TYPEDEF>
+    * f1 -> ( DataType() | FunctionType() )
+    * f2 -> ";"
+    *
+ */ + public void visit(TypeDeclaration n) { + n.f0.accept(this); + n.f1.accept(this); + n.f2.accept(this); + } + + /** + * 
+    * f0 -> StructOrUnionSpecifier()
+    * f1 -> <IDENTIFIER>
+    *
+ */ + public void visit(DataType n) { + n.f0.accept(this); + n.f1.accept(this); + } + + /** + * 
+    * f0 -> TypeSpecifier()
+    * f1 -> "("
+    * f2 -> "*"
+    * f3 -> <IDENTIFIER>
+    * f4 -> ")"
+    * f5 -> "("
+    * f6 -> [ ParameterList() ]
+    * f7 -> ")"
+    *
+ */ + public void visit(FunctionType n) { + n.f0.accept(this); + n.f1.accept(this); + n.f2.accept(this); + n.f3.accept(this); + n.f4.accept(this); + n.f5.accept(this); + n.f6.accept(this); + n.f7.accept(this); + } + + /** + * 
+    * f0 -> ParameterDeclaration()
+    * f1 -> ( "," ParameterDeclaration() )*
+    * f2 -> [ "," "..." ]
+    *
+ */ + public void visit(ParameterList n) { + n.f0.accept(this); + n.f1.accept(this); + n.f2.accept(this); + } + + /** + * 
+    * f0 -> TypeSpecifier()
+    * f1 -> <IDENTIFIER>
+    * f2 -> [ Array() ]
+    *
+ */ + public void visit(ParameterDeclaration n) { + n.f0.accept(this); + n.f1.accept(this); + n.f2.accept(this); + } + + /** + * 
+    * f0 -> VariableClassSpecifier()
+    * f1 -> TypeSpecifier()
+    * f2 -> InitDeclaratorList()
+    * f3 -> ";"
+    *
+ */ + public void visit(VariableDeclaration n) { + n.f0.accept(this); + n.f1.accept(this); + n.f2.accept(this); + n.f3.accept(this); + } + + /** + * 
+    * f0 -> [ <STATIC> ]
+    * f1 -> VariableDeclaration()
+    *
+ */ + public void visit(LocalVariableDeclaration n) { + n.f0.accept(this); + n.f1.accept(this); + } + + /** + * 
+    * f0 -> ( <AUTO> | <REGISTER> )*
+    *
+ */ + public void visit(VariableClassSpecifier n) { + n.f0.accept(this); + } + + /** + * 
+    * f0 -> [ <CONST> ]
+    * f1 -> ( <VOID> | <CHAR> | <SHORT> [ <INT> ] | <INT> | <LONG> [ <LONG> ] | <FLOAT> | <DOUBLE> | ( <SIGNED> | <UNSIGNED> ) [ <CHAR> | <SHORT> [ <INT> ] | <INT> | <LONG> [ <LONG> ] ] | StructOrUnionSpecifier() | EnumSpecifier() | <IDENTIFIER> )
+    * f2 -> [ Pointer() ]
+    * f3 -> [ Array() ]
+    *
+ */ + public void visit(TypeSpecifier n) { + n.f0.accept(this); + n.f1.accept(this); + n.f2.accept(this); + n.f3.accept(this); + } + + /** + * 
+    * f0 -> [ <CONST> ]
+    * f1 -> ( <VOID> | <CHAR> | <SHORT> [ <INT> ] | <INT> | <LONG> [ <LONG> ] | <FLOAT> | <DOUBLE> | ( <SIGNED> | <UNSIGNED> ) [ <CHAR> | <SHORT> [ <INT> ] | <INT> | <LONG> [ <LONG> ] ] | StructOrUnionSpecifier() | EnumSpecifier() )
+    * f2 -> [ Pointer() ]
+    * f3 -> [ Array() ]
+    *
+ */ + public void visit(NoIdentifierTypeSpecifier n) { + n.f0.accept(this); + n.f1.accept(this); + n.f2.accept(this); + n.f3.accept(this); + } + + /** + * 
+    * f0 -> StructOrUnion() [ <IDENTIFIER> ] "{" StructDeclarationList() "}"
+    *       | StructOrUnion() <IDENTIFIER>
+    *
+ */ + public void visit(StructOrUnionSpecifier n) { + n.f0.accept(this); + } + + /** + * 
+    * f0 -> ( <STRUCT> | <UNION> )
+    *
+ */ + public void visit(StructOrUnion n) { + n.f0.accept(this); + } + + /** + * 
+    * f0 -> ( StructDeclaration() )+
+    *
+ */ + public void visit(StructDeclarationList n) { + n.f0.accept(this); + } + + /** + * 
+    * f0 -> InitDeclarator()
+    * f1 -> ( "," InitDeclarator() )*
+    *
+ */ + public void visit(InitDeclaratorList n) { + n.f0.accept(this); + n.f1.accept(this); + } + + /** + * 
+    * f0 -> <IDENTIFIER>
+    * f1 -> [ Array() ]
+    * f2 -> [ "=" Initializer() ]
+    *
+ */ + public void visit(InitDeclarator n) { + n.f0.accept(this); + n.f1.accept(this); + n.f2.accept(this); + } + + /** + * 
+    * f0 -> TypeSpecifier()
+    * f1 -> <IDENTIFIER>
+    * f2 -> [ Array() | ":" ConstantExpression() ]
+    * f3 -> [ <IDENTIFIER> ]
+    * f4 -> ";"
+    *
+ */ + public void visit(StructDeclaration n) { + n.f0.accept(this); + n.f1.accept(this); + n.f2.accept(this); + n.f3.accept(this); + n.f4.accept(this); + } + + /** + * 
+    * f0 -> <ENUM>
+    * f1 -> ( [ <IDENTIFIER> ] "{" EnumeratorList() "}" | <IDENTIFIER> )
+    *
+ */ + public void visit(EnumSpecifier n) { + n.f0.accept(this); + n.f1.accept(this); + } + + /** + * 
+    * f0 -> Enumerator()
+    * f1 -> ( "," Enumerator() )*
+    *
+ */ + public void visit(EnumeratorList n) { + n.f0.accept(this); + n.f1.accept(this); + } + + /** + * 
+    * f0 -> <IDENTIFIER>
+    * f1 -> [ "=" ConstantExpression() ]
+    *
+ */ + public void visit(Enumerator n) { + n.f0.accept(this); + n.f1.accept(this); + } + + /** + * 
+    * f0 -> "*"
+    * f1 -> [ <CONST> ]
+    * f2 -> [ Pointer() ]
+    *
+ */ + public void visit(Pointer n) { + n.f0.accept(this); + n.f1.accept(this); + n.f2.accept(this); + } + + /** + * 
+    * f0 -> <IDENTIFIER>
+    * f1 -> ( "," <IDENTIFIER> )*
+    *
+ */ + public void visit(IdentifierList n) { + n.f0.accept(this); + n.f1.accept(this); + } + + /** + * 
+    * f0 -> ( AssignmentExpression() | "{" InitializerList() [ "," ] "}" )
+    *
+ */ + public void visit(Initializer n) { + n.f0.accept(this); + } + + /** + * 
+    * f0 -> Initializer()
+    * f1 -> ( "," Initializer() )*
+    *
+ */ + public void visit(InitializerList n) { + n.f0.accept(this); + n.f1.accept(this); + } + + /** + * 
+    * f0 -> "["
+    * f1 -> [ ConstantExpression() ]
+    * f2 -> "]"
+    *
+ */ + public void visit(Array n) { + n.f0.accept(this); + n.f1.accept(this); + n.f2.accept(this); + } + + /** + * 
+    * f0 -> ( LabeledStatement() | ExpressionStatement() | CompoundStatement() | SelectionStatement() | IterationStatement() | JumpStatement() )
+    *
+ */ + public void visit(Statement n) { + n.f0.accept(this); + } + + /** + * 
+    * f0 -> ( <IDENTIFIER> ":" Statement() | <CASE> ConstantExpression() ":" Statement() | <DFLT> ":" Statement() )
+    *
+ */ + public void visit(LabeledStatement n) { + n.f0.accept(this); + } + + /** + * 
+    * f0 -> [ Expression() ]
+    * f1 -> ";"
+    *
+ */ + public void visit(ExpressionStatement n) { + n.f0.accept(this); + n.f1.accept(this); + } + + /** + * 
+    * f0 -> "{"
+    * f1 -> ( LocalVariableDeclaration() | Statement() )*
+    * f2 -> "}"
+    *
+ */ + public void visit(CompoundStatement n) { + n.f0.accept(this); + n.f1.accept(this); + n.f2.accept(this); + } + + /** + * 
+    * f0 -> ( <IF> "(" Expression() ")" Statement() [ <ELSE> Statement() ] | <SWITCH> "(" Expression() ")" Statement() )
+    *
+ */ + public void visit(SelectionStatement n) { + n.f0.accept(this); + } + + /** + * 
+    * f0 -> ( <WHILE> "(" Expression() ")" Statement() | <DO> Statement() <WHILE> "(" Expression() ")" ";" | <FOR> "(" [ Expression() ] ";" [ Expression() ] ";" [ Expression() ] ")" Statement() )
+    *
+ */ + public void visit(IterationStatement n) { + n.f0.accept(this); + } + + /** + * 
+    * f0 -> ( <GOTO> <IDENTIFIER> ";" | <CONTINUE> ";" | <BREAK> ";" | <RETURN> [ Expression() ] ";" )
+    *
+ */ + public void visit(JumpStatement n) { + n.f0.accept(this); + } + + /** + * 
+    * f0 -> AssignmentExpression()
+    * f1 -> ( "," AssignmentExpression() )*
+    *
+ */ + public void visit(Expression n) { + n.f0.accept(this); + n.f1.accept(this); + } + + /** + * 
+    * f0 -> UnaryExpression() AssignmentOperator() AssignmentExpression()
+    *       | ConditionalExpression()
+    *
+ */ + public void visit(AssignmentExpression n) { + n.f0.accept(this); + } + + /** + * 
+    * f0 -> ( "=" | "*=" | "/=" | "%=" | "+=" | "-=" | "<<=" | ">>=" | "&=" | "^=" | "|=" )
+    *
+ */ + public void visit(AssignmentOperator n) { + n.f0.accept(this); + } + + /** + * 
+    * f0 -> LogicalORExpression()
+    * f1 -> [ "?" Expression() ":" ConditionalExpression() ]
+    *
+ */ + public void visit(ConditionalExpression n) { + n.f0.accept(this); + n.f1.accept(this); + } + + /** + * 
+    * f0 -> ConditionalExpression()
+    *
+ */ + public void visit(ConstantExpression n) { + n.f0.accept(this); + } + + /** + * 
+    * f0 -> LogicalANDExpression()
+    * f1 -> [ "||" LogicalORExpression() ]
+    *
+ */ + public void visit(LogicalORExpression n) { + n.f0.accept(this); + n.f1.accept(this); + } + + /** + * 
+    * f0 -> InclusiveORExpression()
+    * f1 -> [ "&&" LogicalANDExpression() ]
+    *
+ */ + public void visit(LogicalANDExpression n) { + n.f0.accept(this); + n.f1.accept(this); + } + + /** + * 
+    * f0 -> ExclusiveORExpression()
+    * f1 -> [ "|" InclusiveORExpression() ]
+    *
+ */ + public void visit(InclusiveORExpression n) { + n.f0.accept(this); + n.f1.accept(this); + } + + /** + * 
+    * f0 -> ANDExpression()
+    * f1 -> [ "^" ExclusiveORExpression() ]
+    *
+ */ + public void visit(ExclusiveORExpression n) { + n.f0.accept(this); + n.f1.accept(this); + } + + /** + * 
+    * f0 -> EqualityExpression()
+    * f1 -> [ "&" ANDExpression() ]
+    *
+ */ + public void visit(ANDExpression n) { + n.f0.accept(this); + n.f1.accept(this); + } + + /** + * 
+    * f0 -> RelationalExpression()
+    * f1 -> [ ( "==" | "!=" ) EqualityExpression() ]
+    *
+ */ + public void visit(EqualityExpression n) { + n.f0.accept(this); + n.f1.accept(this); + } + + /** + * 
+    * f0 -> ShiftExpression()
+    * f1 -> [ ( "<" | ">" | "<=" | ">=" ) RelationalExpression() ]
+    *
+ */ + public void visit(RelationalExpression n) { + n.f0.accept(this); + n.f1.accept(this); + } + + /** + * 
+    * f0 -> AdditiveExpression()
+    * f1 -> [ ( "<<" | ">>" ) ShiftExpression() ]
+    *
+ */ + public void visit(ShiftExpression n) { + n.f0.accept(this); + n.f1.accept(this); + } + + /** + * 
+    * f0 -> MultiplicativeExpression()
+    * f1 -> [ ( "+" | "-" ) AdditiveExpression() ]
+    *
+ */ + public void visit(AdditiveExpression n) { + n.f0.accept(this); + n.f1.accept(this); + } + + /** + * 
+    * f0 -> CastExpression()
+    * f1 -> [ ( "*" | "/" | "%" ) MultiplicativeExpression() ]
+    *
+ */ + public void visit(MultiplicativeExpression n) { + n.f0.accept(this); + n.f1.accept(this); + } + + /** + * 
+    * f0 -> ( "(" TypeSpecifier() ")" CastExpression() | UnaryExpression() )
+    *
+ */ + public void visit(CastExpression n) { + n.f0.accept(this); + } + + /** + * 
+    * f0 -> ( PostfixExpression() | "++" UnaryExpression() | "--" UnaryExpression() | UnaryOperator() CastExpression() | <SIZEOF> ( UnaryExpression() | "(" TypeSpecifier() ")" ) )
+    *
+ */ + public void visit(UnaryExpression n) { + n.f0.accept(this); + } + + /** + * 
+    * f0 -> ( "&" | "*" | "+" | "-" | "~" | "!" )
+    *
+ */ + public void visit(UnaryOperator n) { + n.f0.accept(this); + } + + /** + * 
+    * f0 -> PrimaryExpression()
+    * f1 -> ( "[" Expression() "]" | "(" [ ArgumentExpressionList() ] ")" | "." <IDENTIFIER> | "->" <IDENTIFIER> | "++" | "--" )*
+    *
+ */ + public void visit(PostfixExpression n) { + n.f0.accept(this); + n.f1.accept(this); + } + + /** + * 
+    * f0 -> <IDENTIFIER>
+    *       | Constant()
+    *       | "(" Expression() ")"
+    *
+ */ + public void visit(PrimaryExpression n) { + n.f0.accept(this); + } + + /** + * 
+    * f0 -> AssignmentOrTypeExpression()
+    * f1 -> ( "," AssignmentOrTypeExpression() )*
+    *
+ */ + public void visit(ArgumentExpressionList n) { + n.f0.accept(this); + n.f1.accept(this); + } + + /** + * 
+    * f0 -> NoIdentifierTypeSpecifier()
+    *       | AssignmentExpression()
+    *
+ */ + public void visit(AssignmentOrTypeExpression n) { + n.f0.accept(this); + } + + /** + * 
+    * f0 -> <INTEGER_LITERAL>
+    *       | <FLOATING_POINT_LITERAL>
+    *       | <CHARACTER_LITERAL>
+    *       | <STRING_LITERAL>
+    *
+ */ + public void visit(Constant n) { + n.f0.accept(this); + } + +} diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/visitors/GJDepthFirst.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/visitors/GJDepthFirst.java new file mode 100644 index 000000000..2ac3fd812 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/visitors/GJDepthFirst.java @@ -0,0 +1,837 @@ +// +// Generated by JTB 1.3.2 +// + +package org.gnunet.seaspider.parser.visitors; +import org.gnunet.seaspider.parser.nodes.*; + +import java.util.*; + +/** + * Provides default methods which visit each node in the tree in depth-first + * order. Your visitors may extend this class. + */ +public class GJDepthFirst implements GJVisitor { + // + // Auto class visitors--probably don't need to be overridden. + // + public R visit(NodeList n, A argu) { + R _ret=null; + int _count=0; + for ( Enumeration e = n.elements(); e.hasMoreElements(); ) { + e.nextElement().accept(this,argu); + _count++; + } + return _ret; + } + + public R visit(NodeListOptional n, A argu) { + if ( n.present() ) { + R _ret=null; + int _count=0; + for ( Enumeration e = n.elements(); e.hasMoreElements(); ) { + e.nextElement().accept(this,argu); + _count++; + } + return _ret; + } + else + return null; + } + + public R visit(NodeOptional n, A argu) { + if ( n.present() ) + return n.node.accept(this,argu); + else + return null; + } + + public R visit(NodeSequence n, A argu) { + R _ret=null; + int _count=0; + for ( Enumeration e = n.elements(); e.hasMoreElements(); ) { + e.nextElement().accept(this,argu); + _count++; + } + return _ret; + } + + public R visit(NodeToken n, A argu) { return null; } + + // + // User-generated visitor methods below + // + + /** + * 
+    * f0 -> ( ExternalDeclaration() )+
+    *
+ */ + public R visit(TranslationUnit n, A argu) { + R _ret=null; + n.f0.accept(this, argu); + return _ret; + } + + /** + * 
+    * f0 -> ( StorageClassSpecifier() )*
+    * f1 -> ( FunctionDeclaration() | StructOrUnionSpecifier() | VariableDeclaration() | TypeDeclaration() )
+    *
+ */ + public R visit(ExternalDeclaration n, A argu) { + R _ret=null; + n.f0.accept(this, argu); + n.f1.accept(this, argu); + return _ret; + } + + /** + * 
+    * f0 -> TypeSpecifier()
+    * f1 -> <IDENTIFIER>
+    * f2 -> "("
+    * f3 -> [ ParameterList() ]
+    * f4 -> ")"
+    * f5 -> ( ";" | CompoundStatement() )
+    *
+ */ + public R visit(FunctionDeclaration n, A argu) { + R _ret=null; + n.f0.accept(this, argu); + n.f1.accept(this, argu); + n.f2.accept(this, argu); + n.f3.accept(this, argu); + n.f4.accept(this, argu); + n.f5.accept(this, argu); + return _ret; + } + + /** + * 
+    * f0 -> ( <STATIC> | <EXTERN> )
+    *
+ */ + public R visit(StorageClassSpecifier n, A argu) { + R _ret=null; + n.f0.accept(this, argu); + return _ret; + } + + /** + * 
+    * f0 -> <TYPEDEF>
+    * f1 -> ( DataType() | FunctionType() )
+    * f2 -> ";"
+    *
+ */ + public R visit(TypeDeclaration n, A argu) { + R _ret=null; + n.f0.accept(this, argu); + n.f1.accept(this, argu); + n.f2.accept(this, argu); + return _ret; + } + + /** + * 
+    * f0 -> StructOrUnionSpecifier()
+    * f1 -> <IDENTIFIER>
+    *
+ */ + public R visit(DataType n, A argu) { + R _ret=null; + n.f0.accept(this, argu); + n.f1.accept(this, argu); + return _ret; + } + + /** + * 
+    * f0 -> TypeSpecifier()
+    * f1 -> "("
+    * f2 -> "*"
+    * f3 -> <IDENTIFIER>
+    * f4 -> ")"
+    * f5 -> "("
+    * f6 -> [ ParameterList() ]
+    * f7 -> ")"
+    *
+ */ + public R visit(FunctionType n, A argu) { + R _ret=null; + n.f0.accept(this, argu); + n.f1.accept(this, argu); + n.f2.accept(this, argu); + n.f3.accept(this, argu); + n.f4.accept(this, argu); + n.f5.accept(this, argu); + n.f6.accept(this, argu); + n.f7.accept(this, argu); + return _ret; + } + + /** + * 
+    * f0 -> ParameterDeclaration()
+    * f1 -> ( "," ParameterDeclaration() )*
+    * f2 -> [ "," "..." ]
+    *
+ */ + public R visit(ParameterList n, A argu) { + R _ret=null; + n.f0.accept(this, argu); + n.f1.accept(this, argu); + n.f2.accept(this, argu); + return _ret; + } + + /** + * 
+    * f0 -> TypeSpecifier()
+    * f1 -> <IDENTIFIER>
+    * f2 -> [ Array() ]
+    *
+ */ + public R visit(ParameterDeclaration n, A argu) { + R _ret=null; + n.f0.accept(this, argu); + n.f1.accept(this, argu); + n.f2.accept(this, argu); + return _ret; + } + + /** + * 
+    * f0 -> VariableClassSpecifier()
+    * f1 -> TypeSpecifier()
+    * f2 -> InitDeclaratorList()
+    * f3 -> ";"
+    *
+ */ + public R visit(VariableDeclaration n, A argu) { + R _ret=null; + n.f0.accept(this, argu); + n.f1.accept(this, argu); + n.f2.accept(this, argu); + n.f3.accept(this, argu); + return _ret; + } + + /** + * 
+    * f0 -> [ <STATIC> ]
+    * f1 -> VariableDeclaration()
+    *
+ */ + public R visit(LocalVariableDeclaration n, A argu) { + R _ret=null; + n.f0.accept(this, argu); + n.f1.accept(this, argu); + return _ret; + } + + /** + * 
+    * f0 -> ( <AUTO> | <REGISTER> )*
+    *
+ */ + public R visit(VariableClassSpecifier n, A argu) { + R _ret=null; + n.f0.accept(this, argu); + return _ret; + } + + /** + * 
+    * f0 -> [ <CONST> ]
+    * f1 -> ( <VOID> | <CHAR> | <SHORT> [ <INT> ] | <INT> | <LONG> [ <LONG> ] | <FLOAT> | <DOUBLE> | ( <SIGNED> | <UNSIGNED> ) [ <CHAR> | <SHORT> [ <INT> ] | <INT> | <LONG> [ <LONG> ] ] | StructOrUnionSpecifier() | EnumSpecifier() | <IDENTIFIER> )
+    * f2 -> [ Pointer() ]
+    * f3 -> [ Array() ]
+    *
+ */ + public R visit(TypeSpecifier n, A argu) { + R _ret=null; + n.f0.accept(this, argu); + n.f1.accept(this, argu); + n.f2.accept(this, argu); + n.f3.accept(this, argu); + return _ret; + } + + /** + * 
+    * f0 -> [ <CONST> ]
+    * f1 -> ( <VOID> | <CHAR> | <SHORT> [ <INT> ] | <INT> | <LONG> [ <LONG> ] | <FLOAT> | <DOUBLE> | ( <SIGNED> | <UNSIGNED> ) [ <CHAR> | <SHORT> [ <INT> ] | <INT> | <LONG> [ <LONG> ] ] | StructOrUnionSpecifier() | EnumSpecifier() )
+    * f2 -> [ Pointer() ]
+    * f3 -> [ Array() ]
+    *
+ */ + public R visit(NoIdentifierTypeSpecifier n, A argu) { + R _ret=null; + n.f0.accept(this, argu); + n.f1.accept(this, argu); + n.f2.accept(this, argu); + n.f3.accept(this, argu); + return _ret; + } + + /** + * 
+    * f0 -> StructOrUnion() [ <IDENTIFIER> ] "{" StructDeclarationList() "}"
+    *       | StructOrUnion() <IDENTIFIER>
+    *
+ */ + public R visit(StructOrUnionSpecifier n, A argu) { + R _ret=null; + n.f0.accept(this, argu); + return _ret; + } + + /** + * 
+    * f0 -> ( <STRUCT> | <UNION> )
+    *
+ */ + public R visit(StructOrUnion n, A argu) { + R _ret=null; + n.f0.accept(this, argu); + return _ret; + } + + /** + * 
+    * f0 -> ( StructDeclaration() )+
+    *
+ */ + public R visit(StructDeclarationList n, A argu) { + R _ret=null; + n.f0.accept(this, argu); + return _ret; + } + + /** + * 
+    * f0 -> InitDeclarator()
+    * f1 -> ( "," InitDeclarator() )*
+    *
+ */ + public R visit(InitDeclaratorList n, A argu) { + R _ret=null; + n.f0.accept(this, argu); + n.f1.accept(this, argu); + return _ret; + } + + /** + * 
+    * f0 -> <IDENTIFIER>
+    * f1 -> [ Array() ]
+    * f2 -> [ "=" Initializer() ]
+    *
+ */ + public R visit(InitDeclarator n, A argu) { + R _ret=null; + n.f0.accept(this, argu); + n.f1.accept(this, argu); + n.f2.accept(this, argu); + return _ret; + } + + /** + * 
+    * f0 -> TypeSpecifier()
+    * f1 -> <IDENTIFIER>
+    * f2 -> [ Array() | ":" ConstantExpression() ]
+    * f3 -> [ <IDENTIFIER> ]
+    * f4 -> ";"
+    *
+ */ + public R visit(StructDeclaration n, A argu) { + R _ret=null; + n.f0.accept(this, argu); + n.f1.accept(this, argu); + n.f2.accept(this, argu); + n.f3.accept(this, argu); + n.f4.accept(this, argu); + return _ret; + } + + /** + * 
+    * f0 -> <ENUM>
+    * f1 -> ( [ <IDENTIFIER> ] "{" EnumeratorList() "}" | <IDENTIFIER> )
+    *
+ */ + public R visit(EnumSpecifier n, A argu) { + R _ret=null; + n.f0.accept(this, argu); + n.f1.accept(this, argu); + return _ret; + } + + /** + * 
+    * f0 -> Enumerator()
+    * f1 -> ( "," Enumerator() )*
+    *
+ */ + public R visit(EnumeratorList n, A argu) { + R _ret=null; + n.f0.accept(this, argu); + n.f1.accept(this, argu); + return _ret; + } + + /** + * 
+    * f0 -> <IDENTIFIER>
+    * f1 -> [ "=" ConstantExpression() ]
+    *
+ */ + public R visit(Enumerator n, A argu) { + R _ret=null; + n.f0.accept(this, argu); + n.f1.accept(this, argu); + return _ret; + } + + /** + * 
+    * f0 -> "*"
+    * f1 -> [ <CONST> ]
+    * f2 -> [ Pointer() ]
+    *
+ */ + public R visit(Pointer n, A argu) { + R _ret=null; + n.f0.accept(this, argu); + n.f1.accept(this, argu); + n.f2.accept(this, argu); + return _ret; + } + + /** + * 
+    * f0 -> <IDENTIFIER>
+    * f1 -> ( "," <IDENTIFIER> )*
+    *
+ */ + public R visit(IdentifierList n, A argu) { + R _ret=null; + n.f0.accept(this, argu); + n.f1.accept(this, argu); + return _ret; + } + + /** + * 
+    * f0 -> ( AssignmentExpression() | "{" InitializerList() [ "," ] "}" )
+    *
+ */ + public R visit(Initializer n, A argu) { + R _ret=null; + n.f0.accept(this, argu); + return _ret; + } + + /** + * 
+    * f0 -> Initializer()
+    * f1 -> ( "," Initializer() )*
+    *
+ */ + public R visit(InitializerList n, A argu) { + R _ret=null; + n.f0.accept(this, argu); + n.f1.accept(this, argu); + return _ret; + } + + /** + * 
+    * f0 -> "["
+    * f1 -> [ ConstantExpression() ]
+    * f2 -> "]"
+    *
+ */ + public R visit(Array n, A argu) { + R _ret=null; + n.f0.accept(this, argu); + n.f1.accept(this, argu); + n.f2.accept(this, argu); + return _ret; + } + + /** + * 
+    * f0 -> ( LabeledStatement() | ExpressionStatement() | CompoundStatement() | SelectionStatement() | IterationStatement() | JumpStatement() )
+    *
+ */ + public R visit(Statement n, A argu) { + R _ret=null; + n.f0.accept(this, argu); + return _ret; + } + + /** + * 
+    * f0 -> ( <IDENTIFIER> ":" Statement() | <CASE> ConstantExpression() ":" Statement() | <DFLT> ":" Statement() )
+    *
+ */ + public R visit(LabeledStatement n, A argu) { + R _ret=null; + n.f0.accept(this, argu); + return _ret; + } + + /** + * 
+    * f0 -> [ Expression() ]
+    * f1 -> ";"
+    *
+ */ + public R visit(ExpressionStatement n, A argu) { + R _ret=null; + n.f0.accept(this, argu); + n.f1.accept(this, argu); + return _ret; + } + + /** + * 
+    * f0 -> "{"
+    * f1 -> ( LocalVariableDeclaration() | Statement() )*
+    * f2 -> "}"
+    *
+ */ + public R visit(CompoundStatement n, A argu) { + R _ret=null; + n.f0.accept(this, argu); + n.f1.accept(this, argu); + n.f2.accept(this, argu); + return _ret; + } + + /** + * 
+    * f0 -> ( <IF> "(" Expression() ")" Statement() [ <ELSE> Statement() ] | <SWITCH> "(" Expression() ")" Statement() )
+    *
+ */ + public R visit(SelectionStatement n, A argu) { + R _ret=null; + n.f0.accept(this, argu); + return _ret; + } + + /** + * 
+    * f0 -> ( <WHILE> "(" Expression() ")" Statement() | <DO> Statement() <WHILE> "(" Expression() ")" ";" | <FOR> "(" [ Expression() ] ";" [ Expression() ] ";" [ Expression() ] ")" Statement() )
+    *
+ */ + public R visit(IterationStatement n, A argu) { + R _ret=null; + n.f0.accept(this, argu); + return _ret; + } + + /** + * 
+    * f0 -> ( <GOTO> <IDENTIFIER> ";" | <CONTINUE> ";" | <BREAK> ";" | <RETURN> [ Expression() ] ";" )
+    *
+ */ + public R visit(JumpStatement n, A argu) { + R _ret=null; + n.f0.accept(this, argu); + return _ret; + } + + /** + * 
+    * f0 -> AssignmentExpression()
+    * f1 -> ( "," AssignmentExpression() )*
+    *
+ */ + public R visit(Expression n, A argu) { + R _ret=null; + n.f0.accept(this, argu); + n.f1.accept(this, argu); + return _ret; + } + + /** + * 
+    * f0 -> UnaryExpression() AssignmentOperator() AssignmentExpression()
+    *       | ConditionalExpression()
+    *
+ */ + public R visit(AssignmentExpression n, A argu) { + R _ret=null; + n.f0.accept(this, argu); + return _ret; + } + + /** + * 
+    * f0 -> ( "=" | "*=" | "/=" | "%=" | "+=" | "-=" | "<<=" | ">>=" | "&=" | "^=" | "|=" )
+    *
+ */ + public R visit(AssignmentOperator n, A argu) { + R _ret=null; + n.f0.accept(this, argu); + return _ret; + } + + /** + * 
+    * f0 -> LogicalORExpression()
+    * f1 -> [ "?" Expression() ":" ConditionalExpression() ]
+    *
+ */ + public R visit(ConditionalExpression n, A argu) { + R _ret=null; + n.f0.accept(this, argu); + n.f1.accept(this, argu); + return _ret; + } + + /** + * 
+    * f0 -> ConditionalExpression()
+    *
+ */ + public R visit(ConstantExpression n, A argu) { + R _ret=null; + n.f0.accept(this, argu); + return _ret; + } + + /** + * 
+    * f0 -> LogicalANDExpression()
+    * f1 -> [ "||" LogicalORExpression() ]
+    *
+ */ + public R visit(LogicalORExpression n, A argu) { + R _ret=null; + n.f0.accept(this, argu); + n.f1.accept(this, argu); + return _ret; + } + + /** + * 
+    * f0 -> InclusiveORExpression()
+    * f1 -> [ "&&" LogicalANDExpression() ]
+    *
+ */ + public R visit(LogicalANDExpression n, A argu) { + R _ret=null; + n.f0.accept(this, argu); + n.f1.accept(this, argu); + return _ret; + } + + /** + * 
+    * f0 -> ExclusiveORExpression()
+    * f1 -> [ "|" InclusiveORExpression() ]
+    *
+ */ + public R visit(InclusiveORExpression n, A argu) { + R _ret=null; + n.f0.accept(this, argu); + n.f1.accept(this, argu); + return _ret; + } + + /** + * 
+    * f0 -> ANDExpression()
+    * f1 -> [ "^" ExclusiveORExpression() ]
+    *
+ */ + public R visit(ExclusiveORExpression n, A argu) { + R _ret=null; + n.f0.accept(this, argu); + n.f1.accept(this, argu); + return _ret; + } + + /** + * 
+    * f0 -> EqualityExpression()
+    * f1 -> [ "&" ANDExpression() ]
+    *
+ */ + public R visit(ANDExpression n, A argu) { + R _ret=null; + n.f0.accept(this, argu); + n.f1.accept(this, argu); + return _ret; + } + + /** + * 
+    * f0 -> RelationalExpression()
+    * f1 -> [ ( "==" | "!=" ) EqualityExpression() ]
+    *
+ */ + public R visit(EqualityExpression n, A argu) { + R _ret=null; + n.f0.accept(this, argu); + n.f1.accept(this, argu); + return _ret; + } + + /** + * 
+    * f0 -> ShiftExpression()
+    * f1 -> [ ( "<" | ">" | "<=" | ">=" ) RelationalExpression() ]
+    *
+ */ + public R visit(RelationalExpression n, A argu) { + R _ret=null; + n.f0.accept(this, argu); + n.f1.accept(this, argu); + return _ret; + } + + /** + * 
+    * f0 -> AdditiveExpression()
+    * f1 -> [ ( "<<" | ">>" ) ShiftExpression() ]
+    *
+ */ + public R visit(ShiftExpression n, A argu) { + R _ret=null; + n.f0.accept(this, argu); + n.f1.accept(this, argu); + return _ret; + } + + /** + * 
+    * f0 -> MultiplicativeExpression()
+    * f1 -> [ ( "+" | "-" ) AdditiveExpression() ]
+    *
+ */ + public R visit(AdditiveExpression n, A argu) { + R _ret=null; + n.f0.accept(this, argu); + n.f1.accept(this, argu); + return _ret; + } + + /** + * 
+    * f0 -> CastExpression()
+    * f1 -> [ ( "*" | "/" | "%" ) MultiplicativeExpression() ]
+    *
+ */ + public R visit(MultiplicativeExpression n, A argu) { + R _ret=null; + n.f0.accept(this, argu); + n.f1.accept(this, argu); + return _ret; + } + + /** + * 
+    * f0 -> ( "(" TypeSpecifier() ")" CastExpression() | UnaryExpression() )
+    *
+ */ + public R visit(CastExpression n, A argu) { + R _ret=null; + n.f0.accept(this, argu); + return _ret; + } + + /** + * 
+    * f0 -> ( PostfixExpression() | "++" UnaryExpression() | "--" UnaryExpression() | UnaryOperator() CastExpression() | <SIZEOF> ( UnaryExpression() | "(" TypeSpecifier() ")" ) )
+    *
+ */ + public R visit(UnaryExpression n, A argu) { + R _ret=null; + n.f0.accept(this, argu); + return _ret; + } + + /** + * 
+    * f0 -> ( "&" | "*" | "+" | "-" | "~" | "!" )
+    *
+ */ + public R visit(UnaryOperator n, A argu) { + R _ret=null; + n.f0.accept(this, argu); + return _ret; + } + + /** + * 
+    * f0 -> PrimaryExpression()
+    * f1 -> ( "[" Expression() "]" | "(" [ ArgumentExpressionList() ] ")" | "." <IDENTIFIER> | "->" <IDENTIFIER> | "++" | "--" )*
+    *
+ */ + public R visit(PostfixExpression n, A argu) { + R _ret=null; + n.f0.accept(this, argu); + n.f1.accept(this, argu); + return _ret; + } + + /** + * 
+    * f0 -> <IDENTIFIER>
+    *       | Constant()
+    *       | "(" Expression() ")"
+    *
+ */ + public R visit(PrimaryExpression n, A argu) { + R _ret=null; + n.f0.accept(this, argu); + return _ret; + } + + /** + * 
+    * f0 -> AssignmentOrTypeExpression()
+    * f1 -> ( "," AssignmentOrTypeExpression() )*
+    *
+ */ + public R visit(ArgumentExpressionList n, A argu) { + R _ret=null; + n.f0.accept(this, argu); + n.f1.accept(this, argu); + return _ret; + } + + /** + * 
+    * f0 -> NoIdentifierTypeSpecifier()
+    *       | AssignmentExpression()
+    *
+ */ + public R visit(AssignmentOrTypeExpression n, A argu) { + R _ret=null; + n.f0.accept(this, argu); + return _ret; + } + + /** + * 
+    * f0 -> <INTEGER_LITERAL>
+    *       | <FLOATING_POINT_LITERAL>
+    *       | <CHARACTER_LITERAL>
+    *       | <STRING_LITERAL>
+    *
+ */ + public R visit(Constant n, A argu) { + R _ret=null; + n.f0.accept(this, argu); + return _ret; + } + +} diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/visitors/GJNoArguDepthFirst.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/visitors/GJNoArguDepthFirst.java new file mode 100644 index 000000000..fb13e7a2c --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/visitors/GJNoArguDepthFirst.java @@ -0,0 +1,837 @@ +// +// Generated by JTB 1.3.2 +// + +package org.gnunet.seaspider.parser.visitors; +import org.gnunet.seaspider.parser.nodes.*; + +import java.util.*; + +/** + * Provides default methods which visit each node in the tree in depth-first + * order. Your visitors may extend this class. + */ +public class GJNoArguDepthFirst implements GJNoArguVisitor { + // + // Auto class visitors--probably don't need to be overridden. + // + public R visit(NodeList n) { + R _ret=null; + int _count=0; + for ( Enumeration e = n.elements(); e.hasMoreElements(); ) { + e.nextElement().accept(this); + _count++; + } + return _ret; + } + + public R visit(NodeListOptional n) { + if ( n.present() ) { + R _ret=null; + int _count=0; + for ( Enumeration e = n.elements(); e.hasMoreElements(); ) { + e.nextElement().accept(this); + _count++; + } + return _ret; + } + else + return null; + } + + public R visit(NodeOptional n) { + if ( n.present() ) + return n.node.accept(this); + else + return null; + } + + public R visit(NodeSequence n) { + R _ret=null; + int _count=0; + for ( Enumeration e = n.elements(); e.hasMoreElements(); ) { + e.nextElement().accept(this); + _count++; + } + return _ret; + } + + public R visit(NodeToken n) { return null; } + + // + // User-generated visitor methods below + // + + /** + * 
+    * f0 -> ( ExternalDeclaration() )+
+    *
+ */ + public R visit(TranslationUnit n) { + R _ret=null; + n.f0.accept(this); + return _ret; + } + + /** + * 
+    * f0 -> ( StorageClassSpecifier() )*
+    * f1 -> ( FunctionDeclaration() | StructOrUnionSpecifier() | VariableDeclaration() | TypeDeclaration() )
+    *
+ */ + public R visit(ExternalDeclaration n) { + R _ret=null; + n.f0.accept(this); + n.f1.accept(this); + return _ret; + } + + /** + * 
+    * f0 -> TypeSpecifier()
+    * f1 -> <IDENTIFIER>
+    * f2 -> "("
+    * f3 -> [ ParameterList() ]
+    * f4 -> ")"
+    * f5 -> ( ";" | CompoundStatement() )
+    *
+ */ + public R visit(FunctionDeclaration n) { + R _ret=null; + n.f0.accept(this); + n.f1.accept(this); + n.f2.accept(this); + n.f3.accept(this); + n.f4.accept(this); + n.f5.accept(this); + return _ret; + } + + /** + * 
+    * f0 -> ( <STATIC> | <EXTERN> )
+    *
+ */ + public R visit(StorageClassSpecifier n) { + R _ret=null; + n.f0.accept(this); + return _ret; + } + + /** + * 
+    * f0 -> <TYPEDEF>
+    * f1 -> ( DataType() | FunctionType() )
+    * f2 -> ";"
+    *
+ */ + public R visit(TypeDeclaration n) { + R _ret=null; + n.f0.accept(this); + n.f1.accept(this); + n.f2.accept(this); + return _ret; + } + + /** + * 
+    * f0 -> StructOrUnionSpecifier()
+    * f1 -> <IDENTIFIER>
+    *
+ */ + public R visit(DataType n) { + R _ret=null; + n.f0.accept(this); + n.f1.accept(this); + return _ret; + } + + /** + * 
+    * f0 -> TypeSpecifier()
+    * f1 -> "("
+    * f2 -> "*"
+    * f3 -> <IDENTIFIER>
+    * f4 -> ")"
+    * f5 -> "("
+    * f6 -> [ ParameterList() ]
+    * f7 -> ")"
+    *
+ */ + public R visit(FunctionType n) { + R _ret=null; + n.f0.accept(this); + n.f1.accept(this); + n.f2.accept(this); + n.f3.accept(this); + n.f4.accept(this); + n.f5.accept(this); + n.f6.accept(this); + n.f7.accept(this); + return _ret; + } + + /** + * 
+    * f0 -> ParameterDeclaration()
+    * f1 -> ( "," ParameterDeclaration() )*
+    * f2 -> [ "," "..." ]
+    *
+ */ + public R visit(ParameterList n) { + R _ret=null; + n.f0.accept(this); + n.f1.accept(this); + n.f2.accept(this); + return _ret; + } + + /** + * 
+    * f0 -> TypeSpecifier()
+    * f1 -> <IDENTIFIER>
+    * f2 -> [ Array() ]
+    *
+ */ + public R visit(ParameterDeclaration n) { + R _ret=null; + n.f0.accept(this); + n.f1.accept(this); + n.f2.accept(this); + return _ret; + } + + /** + * 
+    * f0 -> VariableClassSpecifier()
+    * f1 -> TypeSpecifier()
+    * f2 -> InitDeclaratorList()
+    * f3 -> ";"
+    *
+ */ + public R visit(VariableDeclaration n) { + R _ret=null; + n.f0.accept(this); + n.f1.accept(this); + n.f2.accept(this); + n.f3.accept(this); + return _ret; + } + + /** + * 
+    * f0 -> [ <STATIC> ]
+    * f1 -> VariableDeclaration()
+    *
+ */ + public R visit(LocalVariableDeclaration n) { + R _ret=null; + n.f0.accept(this); + n.f1.accept(this); + return _ret; + } + + /** + * 
+    * f0 -> ( <AUTO> | <REGISTER> )*
+    *
+ */ + public R visit(VariableClassSpecifier n) { + R _ret=null; + n.f0.accept(this); + return _ret; + } + + /** + * 
+    * f0 -> [ <CONST> ]
+    * f1 -> ( <VOID> | <CHAR> | <SHORT> [ <INT> ] | <INT> | <LONG> [ <LONG> ] | <FLOAT> | <DOUBLE> | ( <SIGNED> | <UNSIGNED> ) [ <CHAR> | <SHORT> [ <INT> ] | <INT> | <LONG> [ <LONG> ] ] | StructOrUnionSpecifier() | EnumSpecifier() | <IDENTIFIER> )
+    * f2 -> [ Pointer() ]
+    * f3 -> [ Array() ]
+    *
+ */ + public R visit(TypeSpecifier n) { + R _ret=null; + n.f0.accept(this); + n.f1.accept(this); + n.f2.accept(this); + n.f3.accept(this); + return _ret; + } + + /** + * 
+    * f0 -> [ <CONST> ]
+    * f1 -> ( <VOID> | <CHAR> | <SHORT> [ <INT> ] | <INT> | <LONG> [ <LONG> ] | <FLOAT> | <DOUBLE> | ( <SIGNED> | <UNSIGNED> ) [ <CHAR> | <SHORT> [ <INT> ] | <INT> | <LONG> [ <LONG> ] ] | StructOrUnionSpecifier() | EnumSpecifier() )
+    * f2 -> [ Pointer() ]
+    * f3 -> [ Array() ]
+    *
+ */ + public R visit(NoIdentifierTypeSpecifier n) { + R _ret=null; + n.f0.accept(this); + n.f1.accept(this); + n.f2.accept(this); + n.f3.accept(this); + return _ret; + } + + /** + * 
+    * f0 -> StructOrUnion() [ <IDENTIFIER> ] "{" StructDeclarationList() "}"
+    *       | StructOrUnion() <IDENTIFIER>
+    *
+ */ + public R visit(StructOrUnionSpecifier n) { + R _ret=null; + n.f0.accept(this); + return _ret; + } + + /** + * 
+    * f0 -> ( <STRUCT> | <UNION> )
+    *
+ */ + public R visit(StructOrUnion n) { + R _ret=null; + n.f0.accept(this); + return _ret; + } + + /** + * 
+    * f0 -> ( StructDeclaration() )+
+    *
+ */ + public R visit(StructDeclarationList n) { + R _ret=null; + n.f0.accept(this); + return _ret; + } + + /** + * 
+    * f0 -> InitDeclarator()
+    * f1 -> ( "," InitDeclarator() )*
+    *
+ */ + public R visit(InitDeclaratorList n) { + R _ret=null; + n.f0.accept(this); + n.f1.accept(this); + return _ret; + } + + /** + * 
+    * f0 -> <IDENTIFIER>
+    * f1 -> [ Array() ]
+    * f2 -> [ "=" Initializer() ]
+    *
+ */ + public R visit(InitDeclarator n) { + R _ret=null; + n.f0.accept(this); + n.f1.accept(this); + n.f2.accept(this); + return _ret; + } + + /** + * 
+    * f0 -> TypeSpecifier()
+    * f1 -> <IDENTIFIER>
+    * f2 -> [ Array() | ":" ConstantExpression() ]
+    * f3 -> [ <IDENTIFIER> ]
+    * f4 -> ";"
+    *
+ */ + public R visit(StructDeclaration n) { + R _ret=null; + n.f0.accept(this); + n.f1.accept(this); + n.f2.accept(this); + n.f3.accept(this); + n.f4.accept(this); + return _ret; + } + + /** + * 
+    * f0 -> <ENUM>
+    * f1 -> ( [ <IDENTIFIER> ] "{" EnumeratorList() "}" | <IDENTIFIER> )
+    *
+ */ + public R visit(EnumSpecifier n) { + R _ret=null; + n.f0.accept(this); + n.f1.accept(this); + return _ret; + } + + /** + * 
+    * f0 -> Enumerator()
+    * f1 -> ( "," Enumerator() )*
+    *
+ */ + public R visit(EnumeratorList n) { + R _ret=null; + n.f0.accept(this); + n.f1.accept(this); + return _ret; + } + + /** + * 
+    * f0 -> <IDENTIFIER>
+    * f1 -> [ "=" ConstantExpression() ]
+    *
+ */ + public R visit(Enumerator n) { + R _ret=null; + n.f0.accept(this); + n.f1.accept(this); + return _ret; + } + + /** + * 
+    * f0 -> "*"
+    * f1 -> [ <CONST> ]
+    * f2 -> [ Pointer() ]
+    *
+ */ + public R visit(Pointer n) { + R _ret=null; + n.f0.accept(this); + n.f1.accept(this); + n.f2.accept(this); + return _ret; + } + + /** + * 
+    * f0 -> <IDENTIFIER>
+    * f1 -> ( "," <IDENTIFIER> )*
+    *
+ */ + public R visit(IdentifierList n) { + R _ret=null; + n.f0.accept(this); + n.f1.accept(this); + return _ret; + } + + /** + * 
+    * f0 -> ( AssignmentExpression() | "{" InitializerList() [ "," ] "}" )
+    *
+ */ + public R visit(Initializer n) { + R _ret=null; + n.f0.accept(this); + return _ret; + } + + /** + * 
+    * f0 -> Initializer()
+    * f1 -> ( "," Initializer() )*
+    *
+ */ + public R visit(InitializerList n) { + R _ret=null; + n.f0.accept(this); + n.f1.accept(this); + return _ret; + } + + /** + * 
+    * f0 -> "["
+    * f1 -> [ ConstantExpression() ]
+    * f2 -> "]"
+    *
+ */ + public R visit(Array n) { + R _ret=null; + n.f0.accept(this); + n.f1.accept(this); + n.f2.accept(this); + return _ret; + } + + /** + * 
+    * f0 -> ( LabeledStatement() | ExpressionStatement() | CompoundStatement() | SelectionStatement() | IterationStatement() | JumpStatement() )
+    *
+ */ + public R visit(Statement n) { + R _ret=null; + n.f0.accept(this); + return _ret; + } + + /** + * 
+    * f0 -> ( <IDENTIFIER> ":" Statement() | <CASE> ConstantExpression() ":" Statement() | <DFLT> ":" Statement() )
+    *
+ */ + public R visit(LabeledStatement n) { + R _ret=null; + n.f0.accept(this); + return _ret; + } + + /** + * 
+    * f0 -> [ Expression() ]
+    * f1 -> ";"
+    *
+ */ + public R visit(ExpressionStatement n) { + R _ret=null; + n.f0.accept(this); + n.f1.accept(this); + return _ret; + } + + /** + * 
+    * f0 -> "{"
+    * f1 -> ( LocalVariableDeclaration() | Statement() )*
+    * f2 -> "}"
+    *
+ */ + public R visit(CompoundStatement n) { + R _ret=null; + n.f0.accept(this); + n.f1.accept(this); + n.f2.accept(this); + return _ret; + } + + /** + * 
+    * f0 -> ( <IF> "(" Expression() ")" Statement() [ <ELSE> Statement() ] | <SWITCH> "(" Expression() ")" Statement() )
+    *
+ */ + public R visit(SelectionStatement n) { + R _ret=null; + n.f0.accept(this); + return _ret; + } + + /** + * 
+    * f0 -> ( <WHILE> "(" Expression() ")" Statement() | <DO> Statement() <WHILE> "(" Expression() ")" ";" | <FOR> "(" [ Expression() ] ";" [ Expression() ] ";" [ Expression() ] ")" Statement() )
+    *
+ */ + public R visit(IterationStatement n) { + R _ret=null; + n.f0.accept(this); + return _ret; + } + + /** + * 
+    * f0 -> ( <GOTO> <IDENTIFIER> ";" | <CONTINUE> ";" | <BREAK> ";" | <RETURN> [ Expression() ] ";" )
+    *
+ */ + public R visit(JumpStatement n) { + R _ret=null; + n.f0.accept(this); + return _ret; + } + + /** + * 
+    * f0 -> AssignmentExpression()
+    * f1 -> ( "," AssignmentExpression() )*
+    *
+ */ + public R visit(Expression n) { + R _ret=null; + n.f0.accept(this); + n.f1.accept(this); + return _ret; + } + + /** + * 
+    * f0 -> UnaryExpression() AssignmentOperator() AssignmentExpression()
+    *       | ConditionalExpression()
+    *
+ */ + public R visit(AssignmentExpression n) { + R _ret=null; + n.f0.accept(this); + return _ret; + } + + /** + * 
+    * f0 -> ( "=" | "*=" | "/=" | "%=" | "+=" | "-=" | "<<=" | ">>=" | "&=" | "^=" | "|=" )
+    *
+ */ + public R visit(AssignmentOperator n) { + R _ret=null; + n.f0.accept(this); + return _ret; + } + + /** + * 
+    * f0 -> LogicalORExpression()
+    * f1 -> [ "?" Expression() ":" ConditionalExpression() ]
+    *
+ */ + public R visit(ConditionalExpression n) { + R _ret=null; + n.f0.accept(this); + n.f1.accept(this); + return _ret; + } + + /** + * 
+    * f0 -> ConditionalExpression()
+    *
+ */ + public R visit(ConstantExpression n) { + R _ret=null; + n.f0.accept(this); + return _ret; + } + + /** + * 
+    * f0 -> LogicalANDExpression()
+    * f1 -> [ "||" LogicalORExpression() ]
+    *
+ */ + public R visit(LogicalORExpression n) { + R _ret=null; + n.f0.accept(this); + n.f1.accept(this); + return _ret; + } + + /** + * 
+    * f0 -> InclusiveORExpression()
+    * f1 -> [ "&&" LogicalANDExpression() ]
+    *
+ */ + public R visit(LogicalANDExpression n) { + R _ret=null; + n.f0.accept(this); + n.f1.accept(this); + return _ret; + } + + /** + * 
+    * f0 -> ExclusiveORExpression()
+    * f1 -> [ "|" InclusiveORExpression() ]
+    *
+ */ + public R visit(InclusiveORExpression n) { + R _ret=null; + n.f0.accept(this); + n.f1.accept(this); + return _ret; + } + + /** + * 
+    * f0 -> ANDExpression()
+    * f1 -> [ "^" ExclusiveORExpression() ]
+    *
+ */ + public R visit(ExclusiveORExpression n) { + R _ret=null; + n.f0.accept(this); + n.f1.accept(this); + return _ret; + } + + /** + * 
+    * f0 -> EqualityExpression()
+    * f1 -> [ "&" ANDExpression() ]
+    *
+ */ + public R visit(ANDExpression n) { + R _ret=null; + n.f0.accept(this); + n.f1.accept(this); + return _ret; + } + + /** + * 
+    * f0 -> RelationalExpression()
+    * f1 -> [ ( "==" | "!=" ) EqualityExpression() ]
+    *
+ */ + public R visit(EqualityExpression n) { + R _ret=null; + n.f0.accept(this); + n.f1.accept(this); + return _ret; + } + + /** + * 
+    * f0 -> ShiftExpression()
+    * f1 -> [ ( "<" | ">" | "<=" | ">=" ) RelationalExpression() ]
+    *
+ */ + public R visit(RelationalExpression n) { + R _ret=null; + n.f0.accept(this); + n.f1.accept(this); + return _ret; + } + + /** + * 
+    * f0 -> AdditiveExpression()
+    * f1 -> [ ( "<<" | ">>" ) ShiftExpression() ]
+    *
+ */ + public R visit(ShiftExpression n) { + R _ret=null; + n.f0.accept(this); + n.f1.accept(this); + return _ret; + } + + /** + * 
+    * f0 -> MultiplicativeExpression()
+    * f1 -> [ ( "+" | "-" ) AdditiveExpression() ]
+    *
+ */ + public R visit(AdditiveExpression n) { + R _ret=null; + n.f0.accept(this); + n.f1.accept(this); + return _ret; + } + + /** + * 
+    * f0 -> CastExpression()
+    * f1 -> [ ( "*" | "/" | "%" ) MultiplicativeExpression() ]
+    *
+ */ + public R visit(MultiplicativeExpression n) { + R _ret=null; + n.f0.accept(this); + n.f1.accept(this); + return _ret; + } + + /** + * 
+    * f0 -> ( "(" TypeSpecifier() ")" CastExpression() | UnaryExpression() )
+    *
+ */ + public R visit(CastExpression n) { + R _ret=null; + n.f0.accept(this); + return _ret; + } + + /** + * 
+    * f0 -> ( PostfixExpression() | "++" UnaryExpression() | "--" UnaryExpression() | UnaryOperator() CastExpression() | <SIZEOF> ( UnaryExpression() | "(" TypeSpecifier() ")" ) )
+    *
+ */ + public R visit(UnaryExpression n) { + R _ret=null; + n.f0.accept(this); + return _ret; + } + + /** + * 
+    * f0 -> ( "&" | "*" | "+" | "-" | "~" | "!" )
+    *
+ */ + public R visit(UnaryOperator n) { + R _ret=null; + n.f0.accept(this); + return _ret; + } + + /** + * 
+    * f0 -> PrimaryExpression()
+    * f1 -> ( "[" Expression() "]" | "(" [ ArgumentExpressionList() ] ")" | "." <IDENTIFIER> | "->" <IDENTIFIER> | "++" | "--" )*
+    *
+ */ + public R visit(PostfixExpression n) { + R _ret=null; + n.f0.accept(this); + n.f1.accept(this); + return _ret; + } + + /** + * 
+    * f0 -> <IDENTIFIER>
+    *       | Constant()
+    *       | "(" Expression() ")"
+    *
+ */ + public R visit(PrimaryExpression n) { + R _ret=null; + n.f0.accept(this); + return _ret; + } + + /** + * 
+    * f0 -> AssignmentOrTypeExpression()
+    * f1 -> ( "," AssignmentOrTypeExpression() )*
+    *
+ */ + public R visit(ArgumentExpressionList n) { + R _ret=null; + n.f0.accept(this); + n.f1.accept(this); + return _ret; + } + + /** + * 
+    * f0 -> NoIdentifierTypeSpecifier()
+    *       | AssignmentExpression()
+    *
+ */ + public R visit(AssignmentOrTypeExpression n) { + R _ret=null; + n.f0.accept(this); + return _ret; + } + + /** + * 
+    * f0 -> <INTEGER_LITERAL>
+    *       | <FLOATING_POINT_LITERAL>
+    *       | <CHARACTER_LITERAL>
+    *       | <STRING_LITERAL>
+    *
+ */ + public R visit(Constant n) { + R _ret=null; + n.f0.accept(this); + return _ret; + } + +} diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/visitors/GJNoArguVisitor.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/visitors/GJNoArguVisitor.java new file mode 100644 index 000000000..0e32ab25d --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/visitors/GJNoArguVisitor.java @@ -0,0 +1,508 @@ +// +// Generated by JTB 1.3.2 +// + +package org.gnunet.seaspider.parser.visitors; +import org.gnunet.seaspider.parser.nodes.*; + +import java.util.*; + +/** + * All GJ visitors with no argument must implement this interface. + */ + +public interface GJNoArguVisitor { + + // + // GJ Auto class visitors with no argument + // + + public R visit(NodeList n); + public R visit(NodeListOptional n); + public R visit(NodeOptional n); + public R visit(NodeSequence n); + public R visit(NodeToken n); + + // + // User-generated visitor methods below + // + + /** + * 
+    * f0 -> ( ExternalDeclaration() )+
+    *
+ */ + public R visit(TranslationUnit n); + + /** + * 
+    * f0 -> ( StorageClassSpecifier() )*
+    * f1 -> ( FunctionDeclaration() | StructOrUnionSpecifier() | VariableDeclaration() | TypeDeclaration() )
+    *
+ */ + public R visit(ExternalDeclaration n); + + /** + * 
+    * f0 -> TypeSpecifier()
+    * f1 -> <IDENTIFIER>
+    * f2 -> "("
+    * f3 -> [ ParameterList() ]
+    * f4 -> ")"
+    * f5 -> ( ";" | CompoundStatement() )
+    *
+ */ + public R visit(FunctionDeclaration n); + + /** + * 
+    * f0 -> ( <STATIC> | <EXTERN> )
+    *
+ */ + public R visit(StorageClassSpecifier n); + + /** + * 
+    * f0 -> <TYPEDEF>
+    * f1 -> ( DataType() | FunctionType() )
+    * f2 -> ";"
+    *
+ */ + public R visit(TypeDeclaration n); + + /** + * 
+    * f0 -> StructOrUnionSpecifier()
+    * f1 -> <IDENTIFIER>
+    *
+ */ + public R visit(DataType n); + + /** + * 
+    * f0 -> TypeSpecifier()
+    * f1 -> "("
+    * f2 -> "*"
+    * f3 -> <IDENTIFIER>
+    * f4 -> ")"
+    * f5 -> "("
+    * f6 -> [ ParameterList() ]
+    * f7 -> ")"
+    *
+ */ + public R visit(FunctionType n); + + /** + * 
+    * f0 -> ParameterDeclaration()
+    * f1 -> ( "," ParameterDeclaration() )*
+    * f2 -> [ "," "..." ]
+    *
+ */ + public R visit(ParameterList n); + + /** + * 
+    * f0 -> TypeSpecifier()
+    * f1 -> <IDENTIFIER>
+    * f2 -> [ Array() ]
+    *
+ */ + public R visit(ParameterDeclaration n); + + /** + * 
+    * f0 -> VariableClassSpecifier()
+    * f1 -> TypeSpecifier()
+    * f2 -> InitDeclaratorList()
+    * f3 -> ";"
+    *
+ */ + public R visit(VariableDeclaration n); + + /** + * 
+    * f0 -> [ <STATIC> ]
+    * f1 -> VariableDeclaration()
+    *
+ */ + public R visit(LocalVariableDeclaration n); + + /** + * 
+    * f0 -> ( <AUTO> | <REGISTER> )*
+    *
+ */ + public R visit(VariableClassSpecifier n); + + /** + * 
+    * f0 -> [ <CONST> ]
+    * f1 -> ( <VOID> | <CHAR> | <SHORT> [ <INT> ] | <INT> | <LONG> [ <LONG> ] | <FLOAT> | <DOUBLE> | ( <SIGNED> | <UNSIGNED> ) [ <CHAR> | <SHORT> [ <INT> ] | <INT> | <LONG> [ <LONG> ] ] | StructOrUnionSpecifier() | EnumSpecifier() | <IDENTIFIER> )
+    * f2 -> [ Pointer() ]
+    * f3 -> [ Array() ]
+    *
+ */ + public R visit(TypeSpecifier n); + + /** + * 
+    * f0 -> [ <CONST> ]
+    * f1 -> ( <VOID> | <CHAR> | <SHORT> [ <INT> ] | <INT> | <LONG> [ <LONG> ] | <FLOAT> | <DOUBLE> | ( <SIGNED> | <UNSIGNED> ) [ <CHAR> | <SHORT> [ <INT> ] | <INT> | <LONG> [ <LONG> ] ] | StructOrUnionSpecifier() | EnumSpecifier() )
+    * f2 -> [ Pointer() ]
+    * f3 -> [ Array() ]
+    *
+ */ + public R visit(NoIdentifierTypeSpecifier n); + + /** + * 
+    * f0 -> StructOrUnion() [ <IDENTIFIER> ] "{" StructDeclarationList() "}"
+    *       | StructOrUnion() <IDENTIFIER>
+    *
+ */ + public R visit(StructOrUnionSpecifier n); + + /** + * 
+    * f0 -> ( <STRUCT> | <UNION> )
+    *
+ */ + public R visit(StructOrUnion n); + + /** + * 
+    * f0 -> ( StructDeclaration() )+
+    *
+ */ + public R visit(StructDeclarationList n); + + /** + * 
+    * f0 -> InitDeclarator()
+    * f1 -> ( "," InitDeclarator() )*
+    *
+ */ + public R visit(InitDeclaratorList n); + + /** + * 
+    * f0 -> <IDENTIFIER>
+    * f1 -> [ Array() ]
+    * f2 -> [ "=" Initializer() ]
+    *
+ */ + public R visit(InitDeclarator n); + + /** + * 
+    * f0 -> TypeSpecifier()
+    * f1 -> <IDENTIFIER>
+    * f2 -> [ Array() | ":" ConstantExpression() ]
+    * f3 -> [ <IDENTIFIER> ]
+    * f4 -> ";"
+    *
+ */ + public R visit(StructDeclaration n); + + /** + * 
+    * f0 -> <ENUM>
+    * f1 -> ( [ <IDENTIFIER> ] "{" EnumeratorList() "}" | <IDENTIFIER> )
+    *
+ */ + public R visit(EnumSpecifier n); + + /** + * 
+    * f0 -> Enumerator()
+    * f1 -> ( "," Enumerator() )*
+    *
+ */ + public R visit(EnumeratorList n); + + /** + * 
+    * f0 -> <IDENTIFIER>
+    * f1 -> [ "=" ConstantExpression() ]
+    *
+ */ + public R visit(Enumerator n); + + /** + * 
+    * f0 -> "*"
+    * f1 -> [ <CONST> ]
+    * f2 -> [ Pointer() ]
+    *
+ */ + public R visit(Pointer n); + + /** + * 
+    * f0 -> <IDENTIFIER>
+    * f1 -> ( "," <IDENTIFIER> )*
+    *
+ */ + public R visit(IdentifierList n); + + /** + * 
+    * f0 -> ( AssignmentExpression() | "{" InitializerList() [ "," ] "}" )
+    *
+ */ + public R visit(Initializer n); + + /** + * 
+    * f0 -> Initializer()
+    * f1 -> ( "," Initializer() )*
+    *
+ */ + public R visit(InitializerList n); + + /** + * 
+    * f0 -> "["
+    * f1 -> [ ConstantExpression() ]
+    * f2 -> "]"
+    *
+ */ + public R visit(Array n); + + /** + * 
+    * f0 -> ( LabeledStatement() | ExpressionStatement() | CompoundStatement() | SelectionStatement() | IterationStatement() | JumpStatement() )
+    *
+ */ + public R visit(Statement n); + + /** + * 
+    * f0 -> ( <IDENTIFIER> ":" Statement() | <CASE> ConstantExpression() ":" Statement() | <DFLT> ":" Statement() )
+    *
+ */ + public R visit(LabeledStatement n); + + /** + * 
+    * f0 -> [ Expression() ]
+    * f1 -> ";"
+    *
+ */ + public R visit(ExpressionStatement n); + + /** + * 
+    * f0 -> "{"
+    * f1 -> ( LocalVariableDeclaration() | Statement() )*
+    * f2 -> "}"
+    *
+ */ + public R visit(CompoundStatement n); + + /** + * 
+    * f0 -> ( <IF> "(" Expression() ")" Statement() [ <ELSE> Statement() ] | <SWITCH> "(" Expression() ")" Statement() )
+    *
+ */ + public R visit(SelectionStatement n); + + /** + * 
+    * f0 -> ( <WHILE> "(" Expression() ")" Statement() | <DO> Statement() <WHILE> "(" Expression() ")" ";" | <FOR> "(" [ Expression() ] ";" [ Expression() ] ";" [ Expression() ] ")" Statement() )
+    *
+ */ + public R visit(IterationStatement n); + + /** + * 
+    * f0 -> ( <GOTO> <IDENTIFIER> ";" | <CONTINUE> ";" | <BREAK> ";" | <RETURN> [ Expression() ] ";" )
+    *
+ */ + public R visit(JumpStatement n); + + /** + * 
+    * f0 -> AssignmentExpression()
+    * f1 -> ( "," AssignmentExpression() )*
+    *
+ */ + public R visit(Expression n); + + /** + * 
+    * f0 -> UnaryExpression() AssignmentOperator() AssignmentExpression()
+    *       | ConditionalExpression()
+    *
+ */ + public R visit(AssignmentExpression n); + + /** + * 
+    * f0 -> ( "=" | "*=" | "/=" | "%=" | "+=" | "-=" | "<<=" | ">>=" | "&=" | "^=" | "|=" )
+    *
+ */ + public R visit(AssignmentOperator n); + + /** + * 
+    * f0 -> LogicalORExpression()
+    * f1 -> [ "?" Expression() ":" ConditionalExpression() ]
+    *
+ */ + public R visit(ConditionalExpression n); + + /** + * 
+    * f0 -> ConditionalExpression()
+    *
+ */ + public R visit(ConstantExpression n); + + /** + * 
+    * f0 -> LogicalANDExpression()
+    * f1 -> [ "||" LogicalORExpression() ]
+    *
+ */ + public R visit(LogicalORExpression n); + + /** + * 
+    * f0 -> InclusiveORExpression()
+    * f1 -> [ "&&" LogicalANDExpression() ]
+    *
+ */ + public R visit(LogicalANDExpression n); + + /** + * 
+    * f0 -> ExclusiveORExpression()
+    * f1 -> [ "|" InclusiveORExpression() ]
+    *
+ */ + public R visit(InclusiveORExpression n); + + /** + * 
+    * f0 -> ANDExpression()
+    * f1 -> [ "^" ExclusiveORExpression() ]
+    *
+ */ + public R visit(ExclusiveORExpression n); + + /** + * 
+    * f0 -> EqualityExpression()
+    * f1 -> [ "&" ANDExpression() ]
+    *
+ */ + public R visit(ANDExpression n); + + /** + * 
+    * f0 -> RelationalExpression()
+    * f1 -> [ ( "==" | "!=" ) EqualityExpression() ]
+    *
+ */ + public R visit(EqualityExpression n); + + /** + * 
+    * f0 -> ShiftExpression()
+    * f1 -> [ ( "<" | ">" | "<=" | ">=" ) RelationalExpression() ]
+    *
+ */ + public R visit(RelationalExpression n); + + /** + * 
+    * f0 -> AdditiveExpression()
+    * f1 -> [ ( "<<" | ">>" ) ShiftExpression() ]
+    *
+ */ + public R visit(ShiftExpression n); + + /** + * 
+    * f0 -> MultiplicativeExpression()
+    * f1 -> [ ( "+" | "-" ) AdditiveExpression() ]
+    *
+ */ + public R visit(AdditiveExpression n); + + /** + * 
+    * f0 -> CastExpression()
+    * f1 -> [ ( "*" | "/" | "%" ) MultiplicativeExpression() ]
+    *
+ */ + public R visit(MultiplicativeExpression n); + + /** + * 
+    * f0 -> ( "(" TypeSpecifier() ")" CastExpression() | UnaryExpression() )
+    *
+ */ + public R visit(CastExpression n); + + /** + * 
+    * f0 -> ( PostfixExpression() | "++" UnaryExpression() | "--" UnaryExpression() | UnaryOperator() CastExpression() | <SIZEOF> ( UnaryExpression() | "(" TypeSpecifier() ")" ) )
+    *
+ */ + public R visit(UnaryExpression n); + + /** + * 
+    * f0 -> ( "&" | "*" | "+" | "-" | "~" | "!" )
+    *
+ */ + public R visit(UnaryOperator n); + + /** + * 
+    * f0 -> PrimaryExpression()
+    * f1 -> ( "[" Expression() "]" | "(" [ ArgumentExpressionList() ] ")" | "." <IDENTIFIER> | "->" <IDENTIFIER> | "++" | "--" )*
+    *
+ */ + public R visit(PostfixExpression n); + + /** + * 
+    * f0 -> <IDENTIFIER>
+    *       | Constant()
+    *       | "(" Expression() ")"
+    *
+ */ + public R visit(PrimaryExpression n); + + /** + * 
+    * f0 -> AssignmentOrTypeExpression()
+    * f1 -> ( "," AssignmentOrTypeExpression() )*
+    *
+ */ + public R visit(ArgumentExpressionList n); + + /** + * 
+    * f0 -> NoIdentifierTypeSpecifier()
+    *       | AssignmentExpression()
+    *
+ */ + public R visit(AssignmentOrTypeExpression n); + + /** + * 
+    * f0 -> <INTEGER_LITERAL>
+    *       | <FLOATING_POINT_LITERAL>
+    *       | <CHARACTER_LITERAL>
+    *       | <STRING_LITERAL>
+    *
+ */ + public R visit(Constant n); + +} + diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/visitors/GJVisitor.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/visitors/GJVisitor.java new file mode 100644 index 000000000..431c1953a --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/visitors/GJVisitor.java @@ -0,0 +1,507 @@ +// +// Generated by JTB 1.3.2 +// + +package org.gnunet.seaspider.parser.visitors; +import org.gnunet.seaspider.parser.nodes.*; + +import java.util.*; + +/** + * All GJ visitors must implement this interface. + */ + +public interface GJVisitor { + + // + // GJ Auto class visitors + // + + public R visit(NodeList n, A argu); + public R visit(NodeListOptional n, A argu); + public R visit(NodeOptional n, A argu); + public R visit(NodeSequence n, A argu); + public R visit(NodeToken n, A argu); + + // + // User-generated visitor methods below + // + + /** + * 
+    * f0 -> ( ExternalDeclaration() )+
+    *
+ */ + public R visit(TranslationUnit n, A argu); + + /** + * 
+    * f0 -> ( StorageClassSpecifier() )*
+    * f1 -> ( FunctionDeclaration() | StructOrUnionSpecifier() | VariableDeclaration() | TypeDeclaration() )
+    *
+ */ + public R visit(ExternalDeclaration n, A argu); + + /** + * 
+    * f0 -> TypeSpecifier()
+    * f1 -> <IDENTIFIER>
+    * f2 -> "("
+    * f3 -> [ ParameterList() ]
+    * f4 -> ")"
+    * f5 -> ( ";" | CompoundStatement() )
+    *
+ */ + public R visit(FunctionDeclaration n, A argu); + + /** + * 
+    * f0 -> ( <STATIC> | <EXTERN> )
+    *
+ */ + public R visit(StorageClassSpecifier n, A argu); + + /** + * 
+    * f0 -> <TYPEDEF>
+    * f1 -> ( DataType() | FunctionType() )
+    * f2 -> ";"
+    *
+ */ + public R visit(TypeDeclaration n, A argu); + + /** + * 
+    * f0 -> StructOrUnionSpecifier()
+    * f1 -> <IDENTIFIER>
+    *
+ */ + public R visit(DataType n, A argu); + + /** + * 
+    * f0 -> TypeSpecifier()
+    * f1 -> "("
+    * f2 -> "*"
+    * f3 -> <IDENTIFIER>
+    * f4 -> ")"
+    * f5 -> "("
+    * f6 -> [ ParameterList() ]
+    * f7 -> ")"
+    *
+ */ + public R visit(FunctionType n, A argu); + + /** + * 
+    * f0 -> ParameterDeclaration()
+    * f1 -> ( "," ParameterDeclaration() )*
+    * f2 -> [ "," "..." ]
+    *
+ */ + public R visit(ParameterList n, A argu); + + /** + * 
+    * f0 -> TypeSpecifier()
+    * f1 -> <IDENTIFIER>
+    * f2 -> [ Array() ]
+    *
+ */ + public R visit(ParameterDeclaration n, A argu); + + /** + * 
+    * f0 -> VariableClassSpecifier()
+    * f1 -> TypeSpecifier()
+    * f2 -> InitDeclaratorList()
+    * f3 -> ";"
+    *
+ */ + public R visit(VariableDeclaration n, A argu); + + /** + * 
+    * f0 -> [ <STATIC> ]
+    * f1 -> VariableDeclaration()
+    *
+ */ + public R visit(LocalVariableDeclaration n, A argu); + + /** + * 
+    * f0 -> ( <AUTO> | <REGISTER> )*
+    *
+ */ + public R visit(VariableClassSpecifier n, A argu); + + /** + * 
+    * f0 -> [ <CONST> ]
+    * f1 -> ( <VOID> | <CHAR> | <SHORT> [ <INT> ] | <INT> | <LONG> [ <LONG> ] | <FLOAT> | <DOUBLE> | ( <SIGNED> | <UNSIGNED> ) [ <CHAR> | <SHORT> [ <INT> ] | <INT> | <LONG> [ <LONG> ] ] | StructOrUnionSpecifier() | EnumSpecifier() | <IDENTIFIER> )
+    * f2 -> [ Pointer() ]
+    * f3 -> [ Array() ]
+    *
+ */ + public R visit(TypeSpecifier n, A argu); + + /** + * 
+    * f0 -> [ <CONST> ]
+    * f1 -> ( <VOID> | <CHAR> | <SHORT> [ <INT> ] | <INT> | <LONG> [ <LONG> ] | <FLOAT> | <DOUBLE> | ( <SIGNED> | <UNSIGNED> ) [ <CHAR> | <SHORT> [ <INT> ] | <INT> | <LONG> [ <LONG> ] ] | StructOrUnionSpecifier() | EnumSpecifier() )
+    * f2 -> [ Pointer() ]
+    * f3 -> [ Array() ]
+    *
+ */ + public R visit(NoIdentifierTypeSpecifier n, A argu); + + /** + * 
+    * f0 -> StructOrUnion() [ <IDENTIFIER> ] "{" StructDeclarationList() "}"
+    *       | StructOrUnion() <IDENTIFIER>
+    *
+ */ + public R visit(StructOrUnionSpecifier n, A argu); + + /** + * 
+    * f0 -> ( <STRUCT> | <UNION> )
+    *
+ */ + public R visit(StructOrUnion n, A argu); + + /** + * 
+    * f0 -> ( StructDeclaration() )+
+    *
+ */ + public R visit(StructDeclarationList n, A argu); + + /** + * 
+    * f0 -> InitDeclarator()
+    * f1 -> ( "," InitDeclarator() )*
+    *
+ */ + public R visit(InitDeclaratorList n, A argu); + + /** + * 
+    * f0 -> <IDENTIFIER>
+    * f1 -> [ Array() ]
+    * f2 -> [ "=" Initializer() ]
+    *
+ */ + public R visit(InitDeclarator n, A argu); + + /** + * 
+    * f0 -> TypeSpecifier()
+    * f1 -> <IDENTIFIER>
+    * f2 -> [ Array() | ":" ConstantExpression() ]
+    * f3 -> [ <IDENTIFIER> ]
+    * f4 -> ";"
+    *
+ */ + public R visit(StructDeclaration n, A argu); + + /** + * 
+    * f0 -> <ENUM>
+    * f1 -> ( [ <IDENTIFIER> ] "{" EnumeratorList() "}" | <IDENTIFIER> )
+    *
+ */ + public R visit(EnumSpecifier n, A argu); + + /** + * 
+    * f0 -> Enumerator()
+    * f1 -> ( "," Enumerator() )*
+    *
+ */ + public R visit(EnumeratorList n, A argu); + + /** + * 
+    * f0 -> <IDENTIFIER>
+    * f1 -> [ "=" ConstantExpression() ]
+    *
+ */ + public R visit(Enumerator n, A argu); + + /** + * 
+    * f0 -> "*"
+    * f1 -> [ <CONST> ]
+    * f2 -> [ Pointer() ]
+    *
+ */ + public R visit(Pointer n, A argu); + + /** + * 
+    * f0 -> <IDENTIFIER>
+    * f1 -> ( "," <IDENTIFIER> )*
+    *
+ */ + public R visit(IdentifierList n, A argu); + + /** + * 
+    * f0 -> ( AssignmentExpression() | "{" InitializerList() [ "," ] "}" )
+    *
+ */ + public R visit(Initializer n, A argu); + + /** + * 
+    * f0 -> Initializer()
+    * f1 -> ( "," Initializer() )*
+    *
+ */ + public R visit(InitializerList n, A argu); + + /** + * 
+    * f0 -> "["
+    * f1 -> [ ConstantExpression() ]
+    * f2 -> "]"
+    *
+ */ + public R visit(Array n, A argu); + + /** + * 
+    * f0 -> ( LabeledStatement() | ExpressionStatement() | CompoundStatement() | SelectionStatement() | IterationStatement() | JumpStatement() )
+    *
+ */ + public R visit(Statement n, A argu); + + /** + * 
+    * f0 -> ( <IDENTIFIER> ":" Statement() | <CASE> ConstantExpression() ":" Statement() | <DFLT> ":" Statement() )
+    *
+ */ + public R visit(LabeledStatement n, A argu); + + /** + * 
+    * f0 -> [ Expression() ]
+    * f1 -> ";"
+    *
+ */ + public R visit(ExpressionStatement n, A argu); + + /** + * 
+    * f0 -> "{"
+    * f1 -> ( LocalVariableDeclaration() | Statement() )*
+    * f2 -> "}"
+    *
+ */ + public R visit(CompoundStatement n, A argu); + + /** + * 
+    * f0 -> ( <IF> "(" Expression() ")" Statement() [ <ELSE> Statement() ] | <SWITCH> "(" Expression() ")" Statement() )
+    *
+ */ + public R visit(SelectionStatement n, A argu); + + /** + * 
+    * f0 -> ( <WHILE> "(" Expression() ")" Statement() | <DO> Statement() <WHILE> "(" Expression() ")" ";" | <FOR> "(" [ Expression() ] ";" [ Expression() ] ";" [ Expression() ] ")" Statement() )
+    *
+ */ + public R visit(IterationStatement n, A argu); + + /** + * 
+    * f0 -> ( <GOTO> <IDENTIFIER> ";" | <CONTINUE> ";" | <BREAK> ";" | <RETURN> [ Expression() ] ";" )
+    *
+ */ + public R visit(JumpStatement n, A argu); + + /** + * 
+    * f0 -> AssignmentExpression()
+    * f1 -> ( "," AssignmentExpression() )*
+    *
+ */ + public R visit(Expression n, A argu); + + /** + * 
+    * f0 -> UnaryExpression() AssignmentOperator() AssignmentExpression()
+    *       | ConditionalExpression()
+    *
+ */ + public R visit(AssignmentExpression n, A argu); + + /** + * 
+    * f0 -> ( "=" | "*=" | "/=" | "%=" | "+=" | "-=" | "<<=" | ">>=" | "&=" | "^=" | "|=" )
+    *
+ */ + public R visit(AssignmentOperator n, A argu); + + /** + * 
+    * f0 -> LogicalORExpression()
+    * f1 -> [ "?" Expression() ":" ConditionalExpression() ]
+    *
+ */ + public R visit(ConditionalExpression n, A argu); + + /** + * 
+    * f0 -> ConditionalExpression()
+    *
+ */ + public R visit(ConstantExpression n, A argu); + + /** + * 
+    * f0 -> LogicalANDExpression()
+    * f1 -> [ "||" LogicalORExpression() ]
+    *
+ */ + public R visit(LogicalORExpression n, A argu); + + /** + * 
+    * f0 -> InclusiveORExpression()
+    * f1 -> [ "&&" LogicalANDExpression() ]
+    *
+ */ + public R visit(LogicalANDExpression n, A argu); + + /** + * 
+    * f0 -> ExclusiveORExpression()
+    * f1 -> [ "|" InclusiveORExpression() ]
+    *
+ */ + public R visit(InclusiveORExpression n, A argu); + + /** + * 
+    * f0 -> ANDExpression()
+    * f1 -> [ "^" ExclusiveORExpression() ]
+    *
+ */ + public R visit(ExclusiveORExpression n, A argu); + + /** + * 
+    * f0 -> EqualityExpression()
+    * f1 -> [ "&" ANDExpression() ]
+    *
+ */ + public R visit(ANDExpression n, A argu); + + /** + * 
+    * f0 -> RelationalExpression()
+    * f1 -> [ ( "==" | "!=" ) EqualityExpression() ]
+    *
+ */ + public R visit(EqualityExpression n, A argu); + + /** + * 
+    * f0 -> ShiftExpression()
+    * f1 -> [ ( "<" | ">" | "<=" | ">=" ) RelationalExpression() ]
+    *
+ */ + public R visit(RelationalExpression n, A argu); + + /** + * 
+    * f0 -> AdditiveExpression()
+    * f1 -> [ ( "<<" | ">>" ) ShiftExpression() ]
+    *
+ */ + public R visit(ShiftExpression n, A argu); + + /** + * 
+    * f0 -> MultiplicativeExpression()
+    * f1 -> [ ( "+" | "-" ) AdditiveExpression() ]
+    *
+ */ + public R visit(AdditiveExpression n, A argu); + + /** + * 
+    * f0 -> CastExpression()
+    * f1 -> [ ( "*" | "/" | "%" ) MultiplicativeExpression() ]
+    *
+ */ + public R visit(MultiplicativeExpression n, A argu); + + /** + * 
+    * f0 -> ( "(" TypeSpecifier() ")" CastExpression() | UnaryExpression() )
+    *
+ */ + public R visit(CastExpression n, A argu); + + /** + * 
+    * f0 -> ( PostfixExpression() | "++" UnaryExpression() | "--" UnaryExpression() | UnaryOperator() CastExpression() | <SIZEOF> ( UnaryExpression() | "(" TypeSpecifier() ")" ) )
+    *
+ */ + public R visit(UnaryExpression n, A argu); + + /** + * 
+    * f0 -> ( "&" | "*" | "+" | "-" | "~" | "!" )
+    *
+ */ + public R visit(UnaryOperator n, A argu); + + /** + * 
+    * f0 -> PrimaryExpression()
+    * f1 -> ( "[" Expression() "]" | "(" [ ArgumentExpressionList() ] ")" | "." <IDENTIFIER> | "->" <IDENTIFIER> | "++" | "--" )*
+    *
+ */ + public R visit(PostfixExpression n, A argu); + + /** + * 
+    * f0 -> <IDENTIFIER>
+    *       | Constant()
+    *       | "(" Expression() ")"
+    *
+ */ + public R visit(PrimaryExpression n, A argu); + + /** + * 
+    * f0 -> AssignmentOrTypeExpression()
+    * f1 -> ( "," AssignmentOrTypeExpression() )*
+    *
+ */ + public R visit(ArgumentExpressionList n, A argu); + + /** + * 
+    * f0 -> NoIdentifierTypeSpecifier()
+    *       | AssignmentExpression()
+    *
+ */ + public R visit(AssignmentOrTypeExpression n, A argu); + + /** + * 
+    * f0 -> <INTEGER_LITERAL>
+    *       | <FLOATING_POINT_LITERAL>
+    *       | <CHARACTER_LITERAL>
+    *       | <STRING_LITERAL>
+    *
+ */ + public R visit(Constant n, A argu); + +} diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/visitors/GJVoidDepthFirst.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/visitors/GJVoidDepthFirst.java new file mode 100644 index 000000000..eb49d3698 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/visitors/GJVoidDepthFirst.java @@ -0,0 +1,711 @@ +// +// Generated by JTB 1.3.2 +// + +package org.gnunet.seaspider.parser.visitors; +import org.gnunet.seaspider.parser.nodes.*; + +import java.util.*; + +/** + * Provides default methods which visit each node in the tree in depth-first + * order. Your visitors may extend this class. + */ +public class GJVoidDepthFirst implements GJVoidVisitor { + // + // Auto class visitors--probably don't need to be overridden. + // + public void visit(NodeList n, A argu) { + int _count=0; + for ( Enumeration e = n.elements(); e.hasMoreElements(); ) { + e.nextElement().accept(this,argu); + _count++; + } + } + + public void visit(NodeListOptional n, A argu) { + if ( n.present() ) { + int _count=0; + for ( Enumeration e = n.elements(); e.hasMoreElements(); ) { + e.nextElement().accept(this,argu); + _count++; + } + } + } + + public void visit(NodeOptional n, A argu) { + if ( n.present() ) + n.node.accept(this,argu); + } + + public void visit(NodeSequence n, A argu) { + int _count=0; + for ( Enumeration e = n.elements(); e.hasMoreElements(); ) { + e.nextElement().accept(this,argu); + _count++; + } + } + + public void visit(NodeToken n, A argu) {} + + // + // User-generated visitor methods below + // + + /** + * 
+    * f0 -> ( ExternalDeclaration() )+
+    *
+ */ + public void visit(TranslationUnit n, A argu) { + n.f0.accept(this, argu); + } + + /** + * 
+    * f0 -> ( StorageClassSpecifier() )*
+    * f1 -> ( FunctionDeclaration() | StructOrUnionSpecifier() | VariableDeclaration() | TypeDeclaration() )
+    *
+ */ + public void visit(ExternalDeclaration n, A argu) { + n.f0.accept(this, argu); + n.f1.accept(this, argu); + } + + /** + * 
+    * f0 -> TypeSpecifier()
+    * f1 -> <IDENTIFIER>
+    * f2 -> "("
+    * f3 -> [ ParameterList() ]
+    * f4 -> ")"
+    * f5 -> ( ";" | CompoundStatement() )
+    *
+ */ + public void visit(FunctionDeclaration n, A argu) { + n.f0.accept(this, argu); + n.f1.accept(this, argu); + n.f2.accept(this, argu); + n.f3.accept(this, argu); + n.f4.accept(this, argu); + n.f5.accept(this, argu); + } + + /** + * 
+    * f0 -> ( <STATIC> | <EXTERN> )
+    *
+ */ + public void visit(StorageClassSpecifier n, A argu) { + n.f0.accept(this, argu); + } + + /** + * 
+    * f0 -> <TYPEDEF>
+    * f1 -> ( DataType() | FunctionType() )
+    * f2 -> ";"
+    *
+ */ + public void visit(TypeDeclaration n, A argu) { + n.f0.accept(this, argu); + n.f1.accept(this, argu); + n.f2.accept(this, argu); + } + + /** + * 
+    * f0 -> StructOrUnionSpecifier()
+    * f1 -> <IDENTIFIER>
+    *
+ */ + public void visit(DataType n, A argu) { + n.f0.accept(this, argu); + n.f1.accept(this, argu); + } + + /** + * 
+    * f0 -> TypeSpecifier()
+    * f1 -> "("
+    * f2 -> "*"
+    * f3 -> <IDENTIFIER>
+    * f4 -> ")"
+    * f5 -> "("
+    * f6 -> [ ParameterList() ]
+    * f7 -> ")"
+    *
+ */ + public void visit(FunctionType n, A argu) { + n.f0.accept(this, argu); + n.f1.accept(this, argu); + n.f2.accept(this, argu); + n.f3.accept(this, argu); + n.f4.accept(this, argu); + n.f5.accept(this, argu); + n.f6.accept(this, argu); + n.f7.accept(this, argu); + } + + /** + * 
+    * f0 -> ParameterDeclaration()
+    * f1 -> ( "," ParameterDeclaration() )*
+    * f2 -> [ "," "..." ]
+    *
+ */ + public void visit(ParameterList n, A argu) { + n.f0.accept(this, argu); + n.f1.accept(this, argu); + n.f2.accept(this, argu); + } + + /** + * 
+    * f0 -> TypeSpecifier()
+    * f1 -> <IDENTIFIER>
+    * f2 -> [ Array() ]
+    *
+ */ + public void visit(ParameterDeclaration n, A argu) { + n.f0.accept(this, argu); + n.f1.accept(this, argu); + n.f2.accept(this, argu); + } + + /** + * 
+    * f0 -> VariableClassSpecifier()
+    * f1 -> TypeSpecifier()
+    * f2 -> InitDeclaratorList()
+    * f3 -> ";"
+    *
+ */ + public void visit(VariableDeclaration n, A argu) { + n.f0.accept(this, argu); + n.f1.accept(this, argu); + n.f2.accept(this, argu); + n.f3.accept(this, argu); + } + + /** + * 
+    * f0 -> [ <STATIC> ]
+    * f1 -> VariableDeclaration()
+    *
+ */ + public void visit(LocalVariableDeclaration n, A argu) { + n.f0.accept(this, argu); + n.f1.accept(this, argu); + } + + /** + * 
+    * f0 -> ( <AUTO> | <REGISTER> )*
+    *
+ */ + public void visit(VariableClassSpecifier n, A argu) { + n.f0.accept(this, argu); + } + + /** + * 
+    * f0 -> [ <CONST> ]
+    * f1 -> ( <VOID> | <CHAR> | <SHORT> [ <INT> ] | <INT> | <LONG> [ <LONG> ] | <FLOAT> | <DOUBLE> | ( <SIGNED> | <UNSIGNED> ) [ <CHAR> | <SHORT> [ <INT> ] | <INT> | <LONG> [ <LONG> ] ] | StructOrUnionSpecifier() | EnumSpecifier() | <IDENTIFIER> )
+    * f2 -> [ Pointer() ]
+    * f3 -> [ Array() ]
+    *
+ */ + public void visit(TypeSpecifier n, A argu) { + n.f0.accept(this, argu); + n.f1.accept(this, argu); + n.f2.accept(this, argu); + n.f3.accept(this, argu); + } + + /** + * 
+    * f0 -> [ <CONST> ]
+    * f1 -> ( <VOID> | <CHAR> | <SHORT> [ <INT> ] | <INT> | <LONG> [ <LONG> ] | <FLOAT> | <DOUBLE> | ( <SIGNED> | <UNSIGNED> ) [ <CHAR> | <SHORT> [ <INT> ] | <INT> | <LONG> [ <LONG> ] ] | StructOrUnionSpecifier() | EnumSpecifier() )
+    * f2 -> [ Pointer() ]
+    * f3 -> [ Array() ]
+    *
+ */ + public void visit(NoIdentifierTypeSpecifier n, A argu) { + n.f0.accept(this, argu); + n.f1.accept(this, argu); + n.f2.accept(this, argu); + n.f3.accept(this, argu); + } + + /** + * 
+    * f0 -> StructOrUnion() [ <IDENTIFIER> ] "{" StructDeclarationList() "}"
+    *       | StructOrUnion() <IDENTIFIER>
+    *
+ */ + public void visit(StructOrUnionSpecifier n, A argu) { + n.f0.accept(this, argu); + } + + /** + * 
+    * f0 -> ( <STRUCT> | <UNION> )
+    *
+ */ + public void visit(StructOrUnion n, A argu) { + n.f0.accept(this, argu); + } + + /** + * 
+    * f0 -> ( StructDeclaration() )+
+    *
+ */ + public void visit(StructDeclarationList n, A argu) { + n.f0.accept(this, argu); + } + + /** + * 
+    * f0 -> InitDeclarator()
+    * f1 -> ( "," InitDeclarator() )*
+    *
+ */ + public void visit(InitDeclaratorList n, A argu) { + n.f0.accept(this, argu); + n.f1.accept(this, argu); + } + + /** + * 
+    * f0 -> <IDENTIFIER>
+    * f1 -> [ Array() ]
+    * f2 -> [ "=" Initializer() ]
+    *
+ */ + public void visit(InitDeclarator n, A argu) { + n.f0.accept(this, argu); + n.f1.accept(this, argu); + n.f2.accept(this, argu); + } + + /** + * 
+    * f0 -> TypeSpecifier()
+    * f1 -> <IDENTIFIER>
+    * f2 -> [ Array() | ":" ConstantExpression() ]
+    * f3 -> [ <IDENTIFIER> ]
+    * f4 -> ";"
+    *
+ */ + public void visit(StructDeclaration n, A argu) { + n.f0.accept(this, argu); + n.f1.accept(this, argu); + n.f2.accept(this, argu); + n.f3.accept(this, argu); + n.f4.accept(this, argu); + } + + /** + * 
+    * f0 -> <ENUM>
+    * f1 -> ( [ <IDENTIFIER> ] "{" EnumeratorList() "}" | <IDENTIFIER> )
+    *
+ */ + public void visit(EnumSpecifier n, A argu) { + n.f0.accept(this, argu); + n.f1.accept(this, argu); + } + + /** + * 
+    * f0 -> Enumerator()
+    * f1 -> ( "," Enumerator() )*
+    *
+ */ + public void visit(EnumeratorList n, A argu) { + n.f0.accept(this, argu); + n.f1.accept(this, argu); + } + + /** + * 
+    * f0 -> <IDENTIFIER>
+    * f1 -> [ "=" ConstantExpression() ]
+    *
+ */ + public void visit(Enumerator n, A argu) { + n.f0.accept(this, argu); + n.f1.accept(this, argu); + } + + /** + * 
+    * f0 -> "*"
+    * f1 -> [ <CONST> ]
+    * f2 -> [ Pointer() ]
+    *
+ */ + public void visit(Pointer n, A argu) { + n.f0.accept(this, argu); + n.f1.accept(this, argu); + n.f2.accept(this, argu); + } + + /** + * 
+    * f0 -> <IDENTIFIER>
+    * f1 -> ( "," <IDENTIFIER> )*
+    *
+ */ + public void visit(IdentifierList n, A argu) { + n.f0.accept(this, argu); + n.f1.accept(this, argu); + } + + /** + * 
+    * f0 -> ( AssignmentExpression() | "{" InitializerList() [ "," ] "}" )
+    *
+ */ + public void visit(Initializer n, A argu) { + n.f0.accept(this, argu); + } + + /** + * 
+    * f0 -> Initializer()
+    * f1 -> ( "," Initializer() )*
+    *
+ */ + public void visit(InitializerList n, A argu) { + n.f0.accept(this, argu); + n.f1.accept(this, argu); + } + + /** + * 
+    * f0 -> "["
+    * f1 -> [ ConstantExpression() ]
+    * f2 -> "]"
+    *
+ */ + public void visit(Array n, A argu) { + n.f0.accept(this, argu); + n.f1.accept(this, argu); + n.f2.accept(this, argu); + } + + /** + * 
+    * f0 -> ( LabeledStatement() | ExpressionStatement() | CompoundStatement() | SelectionStatement() | IterationStatement() | JumpStatement() )
+    *
+ */ + public void visit(Statement n, A argu) { + n.f0.accept(this, argu); + } + + /** + * 
+    * f0 -> ( <IDENTIFIER> ":" Statement() | <CASE> ConstantExpression() ":" Statement() | <DFLT> ":" Statement() )
+    *
+ */ + public void visit(LabeledStatement n, A argu) { + n.f0.accept(this, argu); + } + + /** + * 
+    * f0 -> [ Expression() ]
+    * f1 -> ";"
+    *
+ */ + public void visit(ExpressionStatement n, A argu) { + n.f0.accept(this, argu); + n.f1.accept(this, argu); + } + + /** + * 
+    * f0 -> "{"
+    * f1 -> ( LocalVariableDeclaration() | Statement() )*
+    * f2 -> "}"
+    *
+ */ + public void visit(CompoundStatement n, A argu) { + n.f0.accept(this, argu); + n.f1.accept(this, argu); + n.f2.accept(this, argu); + } + + /** + * 
+    * f0 -> ( <IF> "(" Expression() ")" Statement() [ <ELSE> Statement() ] | <SWITCH> "(" Expression() ")" Statement() )
+    *
+ */ + public void visit(SelectionStatement n, A argu) { + n.f0.accept(this, argu); + } + + /** + * 
+    * f0 -> ( <WHILE> "(" Expression() ")" Statement() | <DO> Statement() <WHILE> "(" Expression() ")" ";" | <FOR> "(" [ Expression() ] ";" [ Expression() ] ";" [ Expression() ] ")" Statement() )
+    *
+ */ + public void visit(IterationStatement n, A argu) { + n.f0.accept(this, argu); + } + + /** + * 
+    * f0 -> ( <GOTO> <IDENTIFIER> ";" | <CONTINUE> ";" | <BREAK> ";" | <RETURN> [ Expression() ] ";" )
+    *
+ */ + public void visit(JumpStatement n, A argu) { + n.f0.accept(this, argu); + } + + /** + * 
+    * f0 -> AssignmentExpression()
+    * f1 -> ( "," AssignmentExpression() )*
+    *
+ */ + public void visit(Expression n, A argu) { + n.f0.accept(this, argu); + n.f1.accept(this, argu); + } + + /** + * 
+    * f0 -> UnaryExpression() AssignmentOperator() AssignmentExpression()
+    *       | ConditionalExpression()
+    *
+ */ + public void visit(AssignmentExpression n, A argu) { + n.f0.accept(this, argu); + } + + /** + * 
+    * f0 -> ( "=" | "*=" | "/=" | "%=" | "+=" | "-=" | "<<=" | ">>=" | "&=" | "^=" | "|=" )
+    *
+ */ + public void visit(AssignmentOperator n, A argu) { + n.f0.accept(this, argu); + } + + /** + * 
+    * f0 -> LogicalORExpression()
+    * f1 -> [ "?" Expression() ":" ConditionalExpression() ]
+    *
+ */ + public void visit(ConditionalExpression n, A argu) { + n.f0.accept(this, argu); + n.f1.accept(this, argu); + } + + /** + * 
+    * f0 -> ConditionalExpression()
+    *
+ */ + public void visit(ConstantExpression n, A argu) { + n.f0.accept(this, argu); + } + + /** + * 
+    * f0 -> LogicalANDExpression()
+    * f1 -> [ "||" LogicalORExpression() ]
+    *
+ */ + public void visit(LogicalORExpression n, A argu) { + n.f0.accept(this, argu); + n.f1.accept(this, argu); + } + + /** + * 
+    * f0 -> InclusiveORExpression()
+    * f1 -> [ "&&" LogicalANDExpression() ]
+    *
+ */ + public void visit(LogicalANDExpression n, A argu) { + n.f0.accept(this, argu); + n.f1.accept(this, argu); + } + + /** + * 
+    * f0 -> ExclusiveORExpression()
+    * f1 -> [ "|" InclusiveORExpression() ]
+    *
+ */ + public void visit(InclusiveORExpression n, A argu) { + n.f0.accept(this, argu); + n.f1.accept(this, argu); + } + + /** + * 
+    * f0 -> ANDExpression()
+    * f1 -> [ "^" ExclusiveORExpression() ]
+    *
+ */ + public void visit(ExclusiveORExpression n, A argu) { + n.f0.accept(this, argu); + n.f1.accept(this, argu); + } + + /** + * 
+    * f0 -> EqualityExpression()
+    * f1 -> [ "&" ANDExpression() ]
+    *
+ */ + public void visit(ANDExpression n, A argu) { + n.f0.accept(this, argu); + n.f1.accept(this, argu); + } + + /** + * 
+    * f0 -> RelationalExpression()
+    * f1 -> [ ( "==" | "!=" ) EqualityExpression() ]
+    *
+ */ + public void visit(EqualityExpression n, A argu) { + n.f0.accept(this, argu); + n.f1.accept(this, argu); + } + + /** + * 
+    * f0 -> ShiftExpression()
+    * f1 -> [ ( "<" | ">" | "<=" | ">=" ) RelationalExpression() ]
+    *
+ */ + public void visit(RelationalExpression n, A argu) { + n.f0.accept(this, argu); + n.f1.accept(this, argu); + } + + /** + * 
+    * f0 -> AdditiveExpression()
+    * f1 -> [ ( "<<" | ">>" ) ShiftExpression() ]
+    *
+ */ + public void visit(ShiftExpression n, A argu) { + n.f0.accept(this, argu); + n.f1.accept(this, argu); + } + + /** + * 
+    * f0 -> MultiplicativeExpression()
+    * f1 -> [ ( "+" | "-" ) AdditiveExpression() ]
+    *
+ */ + public void visit(AdditiveExpression n, A argu) { + n.f0.accept(this, argu); + n.f1.accept(this, argu); + } + + /** + * 
+    * f0 -> CastExpression()
+    * f1 -> [ ( "*" | "/" | "%" ) MultiplicativeExpression() ]
+    *
+ */ + public void visit(MultiplicativeExpression n, A argu) { + n.f0.accept(this, argu); + n.f1.accept(this, argu); + } + + /** + * 
+    * f0 -> ( "(" TypeSpecifier() ")" CastExpression() | UnaryExpression() )
+    *
+ */ + public void visit(CastExpression n, A argu) { + n.f0.accept(this, argu); + } + + /** + * 
+    * f0 -> ( PostfixExpression() | "++" UnaryExpression() | "--" UnaryExpression() | UnaryOperator() CastExpression() | <SIZEOF> ( UnaryExpression() | "(" TypeSpecifier() ")" ) )
+    *
+ */ + public void visit(UnaryExpression n, A argu) { + n.f0.accept(this, argu); + } + + /** + * 
+    * f0 -> ( "&" | "*" | "+" | "-" | "~" | "!" )
+    *
+ */ + public void visit(UnaryOperator n, A argu) { + n.f0.accept(this, argu); + } + + /** + * 
+    * f0 -> PrimaryExpression()
+    * f1 -> ( "[" Expression() "]" | "(" [ ArgumentExpressionList() ] ")" | "." <IDENTIFIER> | "->" <IDENTIFIER> | "++" | "--" )*
+    *
+ */ + public void visit(PostfixExpression n, A argu) { + n.f0.accept(this, argu); + n.f1.accept(this, argu); + } + + /** + * 
+    * f0 -> <IDENTIFIER>
+    *       | Constant()
+    *       | "(" Expression() ")"
+    *
+ */ + public void visit(PrimaryExpression n, A argu) { + n.f0.accept(this, argu); + } + + /** + * 
+    * f0 -> AssignmentOrTypeExpression()
+    * f1 -> ( "," AssignmentOrTypeExpression() )*
+    *
+ */ + public void visit(ArgumentExpressionList n, A argu) { + n.f0.accept(this, argu); + n.f1.accept(this, argu); + } + + /** + * 
+    * f0 -> NoIdentifierTypeSpecifier()
+    *       | AssignmentExpression()
+    *
+ */ + public void visit(AssignmentOrTypeExpression n, A argu) { + n.f0.accept(this, argu); + } + + /** + * 
+    * f0 -> <INTEGER_LITERAL>
+    *       | <FLOATING_POINT_LITERAL>
+    *       | <CHARACTER_LITERAL>
+    *       | <STRING_LITERAL>
+    *
+ */ + public void visit(Constant n, A argu) { + n.f0.accept(this, argu); + } + +} diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/visitors/GJVoidVisitor.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/visitors/GJVoidVisitor.java new file mode 100644 index 000000000..13176c4e8 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/visitors/GJVoidVisitor.java @@ -0,0 +1,508 @@ +// +// Generated by JTB 1.3.2 +// + +package org.gnunet.seaspider.parser.visitors; +import org.gnunet.seaspider.parser.nodes.*; + +import java.util.*; + +/** + * All GJ void visitors must implement this interface. + */ + +public interface GJVoidVisitor { + + // + // GJ void Auto class visitors + // + + public void visit(NodeList n, A argu); + public void visit(NodeListOptional n, A argu); + public void visit(NodeOptional n, A argu); + public void visit(NodeSequence n, A argu); + public void visit(NodeToken n, A argu); + + // + // User-generated visitor methods below + // + + /** + * 
+    * f0 -> ( ExternalDeclaration() )+
+    *
+ */ + public void visit(TranslationUnit n, A argu); + + /** + * 
+    * f0 -> ( StorageClassSpecifier() )*
+    * f1 -> ( FunctionDeclaration() | StructOrUnionSpecifier() | VariableDeclaration() | TypeDeclaration() )
+    *
+ */ + public void visit(ExternalDeclaration n, A argu); + + /** + * 
+    * f0 -> TypeSpecifier()
+    * f1 -> <IDENTIFIER>
+    * f2 -> "("
+    * f3 -> [ ParameterList() ]
+    * f4 -> ")"
+    * f5 -> ( ";" | CompoundStatement() )
+    *
+ */ + public void visit(FunctionDeclaration n, A argu); + + /** + * 
+    * f0 -> ( <STATIC> | <EXTERN> )
+    *
+ */ + public void visit(StorageClassSpecifier n, A argu); + + /** + * 
+    * f0 -> <TYPEDEF>
+    * f1 -> ( DataType() | FunctionType() )
+    * f2 -> ";"
+    *
+ */ + public void visit(TypeDeclaration n, A argu); + + /** + * 
+    * f0 -> StructOrUnionSpecifier()
+    * f1 -> <IDENTIFIER>
+    *
+ */ + public void visit(DataType n, A argu); + + /** + * 
+    * f0 -> TypeSpecifier()
+    * f1 -> "("
+    * f2 -> "*"
+    * f3 -> <IDENTIFIER>
+    * f4 -> ")"
+    * f5 -> "("
+    * f6 -> [ ParameterList() ]
+    * f7 -> ")"
+    *
+ */ + public void visit(FunctionType n, A argu); + + /** + * 
+    * f0 -> ParameterDeclaration()
+    * f1 -> ( "," ParameterDeclaration() )*
+    * f2 -> [ "," "..." ]
+    *
+ */ + public void visit(ParameterList n, A argu); + + /** + * 
+    * f0 -> TypeSpecifier()
+    * f1 -> <IDENTIFIER>
+    * f2 -> [ Array() ]
+    *
+ */ + public void visit(ParameterDeclaration n, A argu); + + /** + * 
+    * f0 -> VariableClassSpecifier()
+    * f1 -> TypeSpecifier()
+    * f2 -> InitDeclaratorList()
+    * f3 -> ";"
+    *
+ */ + public void visit(VariableDeclaration n, A argu); + + /** + * 
+    * f0 -> [ <STATIC> ]
+    * f1 -> VariableDeclaration()
+    *
+ */ + public void visit(LocalVariableDeclaration n, A argu); + + /** + * 
+    * f0 -> ( <AUTO> | <REGISTER> )*
+    *
+ */ + public void visit(VariableClassSpecifier n, A argu); + + /** + * 
+    * f0 -> [ <CONST> ]
+    * f1 -> ( <VOID> | <CHAR> | <SHORT> [ <INT> ] | <INT> | <LONG> [ <LONG> ] | <FLOAT> | <DOUBLE> | ( <SIGNED> | <UNSIGNED> ) [ <CHAR> | <SHORT> [ <INT> ] | <INT> | <LONG> [ <LONG> ] ] | StructOrUnionSpecifier() | EnumSpecifier() | <IDENTIFIER> )
+    * f2 -> [ Pointer() ]
+    * f3 -> [ Array() ]
+    *
+ */ + public void visit(TypeSpecifier n, A argu); + + /** + * 
+    * f0 -> [ <CONST> ]
+    * f1 -> ( <VOID> | <CHAR> | <SHORT> [ <INT> ] | <INT> | <LONG> [ <LONG> ] | <FLOAT> | <DOUBLE> | ( <SIGNED> | <UNSIGNED> ) [ <CHAR> | <SHORT> [ <INT> ] | <INT> | <LONG> [ <LONG> ] ] | StructOrUnionSpecifier() | EnumSpecifier() )
+    * f2 -> [ Pointer() ]
+    * f3 -> [ Array() ]
+    *
+ */ + public void visit(NoIdentifierTypeSpecifier n, A argu); + + /** + * 
+    * f0 -> StructOrUnion() [ <IDENTIFIER> ] "{" StructDeclarationList() "}"
+    *       | StructOrUnion() <IDENTIFIER>
+    *
+ */ + public void visit(StructOrUnionSpecifier n, A argu); + + /** + * 
+    * f0 -> ( <STRUCT> | <UNION> )
+    *
+ */ + public void visit(StructOrUnion n, A argu); + + /** + * 
+    * f0 -> ( StructDeclaration() )+
+    *
+ */ + public void visit(StructDeclarationList n, A argu); + + /** + * 
+    * f0 -> InitDeclarator()
+    * f1 -> ( "," InitDeclarator() )*
+    *
+ */ + public void visit(InitDeclaratorList n, A argu); + + /** + * 
+    * f0 -> <IDENTIFIER>
+    * f1 -> [ Array() ]
+    * f2 -> [ "=" Initializer() ]
+    *
+ */ + public void visit(InitDeclarator n, A argu); + + /** + * 
+    * f0 -> TypeSpecifier()
+    * f1 -> <IDENTIFIER>
+    * f2 -> [ Array() | ":" ConstantExpression() ]
+    * f3 -> [ <IDENTIFIER> ]
+    * f4 -> ";"
+    *
+ */ + public void visit(StructDeclaration n, A argu); + + /** + * 
+    * f0 -> <ENUM>
+    * f1 -> ( [ <IDENTIFIER> ] "{" EnumeratorList() "}" | <IDENTIFIER> )
+    *
+ */ + public void visit(EnumSpecifier n, A argu); + + /** + * 
+    * f0 -> Enumerator()
+    * f1 -> ( "," Enumerator() )*
+    *
+ */ + public void visit(EnumeratorList n, A argu); + + /** + * 
+    * f0 -> <IDENTIFIER>
+    * f1 -> [ "=" ConstantExpression() ]
+    *
+ */ + public void visit(Enumerator n, A argu); + + /** + * 
+    * f0 -> "*"
+    * f1 -> [ <CONST> ]
+    * f2 -> [ Pointer() ]
+    *
+ */ + public void visit(Pointer n, A argu); + + /** + * 
+    * f0 -> <IDENTIFIER>
+    * f1 -> ( "," <IDENTIFIER> )*
+    *
+ */ + public void visit(IdentifierList n, A argu); + + /** + * 
+    * f0 -> ( AssignmentExpression() | "{" InitializerList() [ "," ] "}" )
+    *
+ */ + public void visit(Initializer n, A argu); + + /** + * 
+    * f0 -> Initializer()
+    * f1 -> ( "," Initializer() )*
+    *
+ */ + public void visit(InitializerList n, A argu); + + /** + * 
+    * f0 -> "["
+    * f1 -> [ ConstantExpression() ]
+    * f2 -> "]"
+    *
+ */ + public void visit(Array n, A argu); + + /** + * 
+    * f0 -> ( LabeledStatement() | ExpressionStatement() | CompoundStatement() | SelectionStatement() | IterationStatement() | JumpStatement() )
+    *
+ */ + public void visit(Statement n, A argu); + + /** + * 
+    * f0 -> ( <IDENTIFIER> ":" Statement() | <CASE> ConstantExpression() ":" Statement() | <DFLT> ":" Statement() )
+    *
+ */ + public void visit(LabeledStatement n, A argu); + + /** + * 
+    * f0 -> [ Expression() ]
+    * f1 -> ";"
+    *
+ */ + public void visit(ExpressionStatement n, A argu); + + /** + * 
+    * f0 -> "{"
+    * f1 -> ( LocalVariableDeclaration() | Statement() )*
+    * f2 -> "}"
+    *
+ */ + public void visit(CompoundStatement n, A argu); + + /** + * 
+    * f0 -> ( <IF> "(" Expression() ")" Statement() [ <ELSE> Statement() ] | <SWITCH> "(" Expression() ")" Statement() )
+    *
+ */ + public void visit(SelectionStatement n, A argu); + + /** + * 
+    * f0 -> ( <WHILE> "(" Expression() ")" Statement() | <DO> Statement() <WHILE> "(" Expression() ")" ";" | <FOR> "(" [ Expression() ] ";" [ Expression() ] ";" [ Expression() ] ")" Statement() )
+    *
+ */ + public void visit(IterationStatement n, A argu); + + /** + * 
+    * f0 -> ( <GOTO> <IDENTIFIER> ";" | <CONTINUE> ";" | <BREAK> ";" | <RETURN> [ Expression() ] ";" )
+    *
+ */ + public void visit(JumpStatement n, A argu); + + /** + * 
+    * f0 -> AssignmentExpression()
+    * f1 -> ( "," AssignmentExpression() )*
+    *
+ */ + public void visit(Expression n, A argu); + + /** + * 
+    * f0 -> UnaryExpression() AssignmentOperator() AssignmentExpression()
+    *       | ConditionalExpression()
+    *
+ */ + public void visit(AssignmentExpression n, A argu); + + /** + * 
+    * f0 -> ( "=" | "*=" | "/=" | "%=" | "+=" | "-=" | "<<=" | ">>=" | "&=" | "^=" | "|=" )
+    *
+ */ + public void visit(AssignmentOperator n, A argu); + + /** + * 
+    * f0 -> LogicalORExpression()
+    * f1 -> [ "?" Expression() ":" ConditionalExpression() ]
+    *
+ */ + public void visit(ConditionalExpression n, A argu); + + /** + * 
+    * f0 -> ConditionalExpression()
+    *
+ */ + public void visit(ConstantExpression n, A argu); + + /** + * 
+    * f0 -> LogicalANDExpression()
+    * f1 -> [ "||" LogicalORExpression() ]
+    *
+ */ + public void visit(LogicalORExpression n, A argu); + + /** + * 
+    * f0 -> InclusiveORExpression()
+    * f1 -> [ "&&" LogicalANDExpression() ]
+    *
+ */ + public void visit(LogicalANDExpression n, A argu); + + /** + * 
+    * f0 -> ExclusiveORExpression()
+    * f1 -> [ "|" InclusiveORExpression() ]
+    *
+ */ + public void visit(InclusiveORExpression n, A argu); + + /** + * 
+    * f0 -> ANDExpression()
+    * f1 -> [ "^" ExclusiveORExpression() ]
+    *
+ */ + public void visit(ExclusiveORExpression n, A argu); + + /** + * 
+    * f0 -> EqualityExpression()
+    * f1 -> [ "&" ANDExpression() ]
+    *
+ */ + public void visit(ANDExpression n, A argu); + + /** + * 
+    * f0 -> RelationalExpression()
+    * f1 -> [ ( "==" | "!=" ) EqualityExpression() ]
+    *
+ */ + public void visit(EqualityExpression n, A argu); + + /** + * 
+    * f0 -> ShiftExpression()
+    * f1 -> [ ( "<" | ">" | "<=" | ">=" ) RelationalExpression() ]
+    *
+ */ + public void visit(RelationalExpression n, A argu); + + /** + * 
+    * f0 -> AdditiveExpression()
+    * f1 -> [ ( "<<" | ">>" ) ShiftExpression() ]
+    *
+ */ + public void visit(ShiftExpression n, A argu); + + /** + * 
+    * f0 -> MultiplicativeExpression()
+    * f1 -> [ ( "+" | "-" ) AdditiveExpression() ]
+    *
+ */ + public void visit(AdditiveExpression n, A argu); + + /** + * 
+    * f0 -> CastExpression()
+    * f1 -> [ ( "*" | "/" | "%" ) MultiplicativeExpression() ]
+    *
+ */ + public void visit(MultiplicativeExpression n, A argu); + + /** + * 
+    * f0 -> ( "(" TypeSpecifier() ")" CastExpression() | UnaryExpression() )
+    *
+ */ + public void visit(CastExpression n, A argu); + + /** + * 
+    * f0 -> ( PostfixExpression() | "++" UnaryExpression() | "--" UnaryExpression() | UnaryOperator() CastExpression() | <SIZEOF> ( UnaryExpression() | "(" TypeSpecifier() ")" ) )
+    *
+ */ + public void visit(UnaryExpression n, A argu); + + /** + * 
+    * f0 -> ( "&" | "*" | "+" | "-" | "~" | "!" )
+    *
+ */ + public void visit(UnaryOperator n, A argu); + + /** + * 
+    * f0 -> PrimaryExpression()
+    * f1 -> ( "[" Expression() "]" | "(" [ ArgumentExpressionList() ] ")" | "." <IDENTIFIER> | "->" <IDENTIFIER> | "++" | "--" )*
+    *
+ */ + public void visit(PostfixExpression n, A argu); + + /** + * 
+    * f0 -> <IDENTIFIER>
+    *       | Constant()
+    *       | "(" Expression() ")"
+    *
+ */ + public void visit(PrimaryExpression n, A argu); + + /** + * 
+    * f0 -> AssignmentOrTypeExpression()
+    * f1 -> ( "," AssignmentOrTypeExpression() )*
+    *
+ */ + public void visit(ArgumentExpressionList n, A argu); + + /** + * 
+    * f0 -> NoIdentifierTypeSpecifier()
+    *       | AssignmentExpression()
+    *
+ */ + public void visit(AssignmentOrTypeExpression n, A argu); + + /** + * 
+    * f0 -> <INTEGER_LITERAL>
+    *       | <FLOATING_POINT_LITERAL>
+    *       | <CHARACTER_LITERAL>
+    *       | <STRING_LITERAL>
+    *
+ */ + public void visit(Constant n, A argu); + +} + diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/visitors/TreeDumper.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/visitors/TreeDumper.java new file mode 100644 index 000000000..c2e7c1558 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/visitors/TreeDumper.java @@ -0,0 +1,132 @@ +// +// Generated by JTB 1.3.2 +// +package org.gnunet.seaspider.parser.visitors; + +import org.gnunet.seaspider.parser.nodes.*; + +import java.util.*; +import java.io.*; + +/** + * Dumps the syntax tree to a Writer using the location information in + * each NodeToken. + */ +public class TreeDumper extends DepthFirstVisitor { + protected PrintWriter out; + private int curLine = 1; + private int curColumn = 1; + private boolean startAtNextToken = false; + private boolean printSpecials = true; + + /** + * The default constructor uses System.out as its output location. + * You may specify your own Writer or OutputStream using one of the + * other constructors. + */ + public TreeDumper() { out = new PrintWriter(System.out, true); } + public TreeDumper(Writer o) { out = new PrintWriter(o, true); } + public TreeDumper(OutputStream o) { out = new PrintWriter(o, true); } + + /** + * Flushes the OutputStream or Writer that this TreeDumper is using. + */ + public void flushWriter() { out.flush(); } + + /** + * Allows you to specify whether or not to print special tokens. + */ + public void printSpecials(boolean b) { printSpecials = b; } + + /** + * Starts the tree dumper on the line containing the next token + * visited. For example, if the next token begins on line 50 and the + * dumper is currently on line 1 of the file, it will set its current + * line to 50 and continue printing from there, as opposed to + * printing 49 blank lines and then printing the token. + */ + public void startAtNextToken() { startAtNextToken = true; } + + /** + * Resets the position of the output "cursor" to the first line and + * column. When using a dumper on a syntax tree more than once, you + * either need to call this method or startAtNextToken() between each + * dump. + */ + public void resetPosition() { curLine = curColumn = 1; } + + /** + * Dumps the current NodeToken to the output stream being used. + * + * @throws IllegalStateException if the token position is invalid + * relative to the current position, i.e. its location places it + * before the previous token. + */ + public void visit(NodeToken n) { + if ( n.beginLine == -1 || n.beginColumn == -1 ) { + printToken(n.tokenImage); + return; + } + + // + // Handle special tokens + // + if ( printSpecials && n.numSpecials() > 0 ) + for ( Enumeration e = n.specialTokens.elements(); e.hasMoreElements(); ) + visit(e.nextElement()); + + // + // Handle startAtNextToken option + // + if ( startAtNextToken ) { + curLine = n.beginLine; + curColumn = 1; + startAtNextToken = false; + + if ( n.beginColumn < curColumn ) + out.println(); + } + + // + // Check for invalid token position relative to current position. + // + if ( n.beginLine < curLine ) + throw new IllegalStateException("at token \"" + n.tokenImage + + "\", n.beginLine = " + Integer.toString(n.beginLine) + + ", curLine = " + Integer.toString(curLine)); + else if ( n.beginLine == curLine && n.beginColumn < curColumn ) + throw new IllegalStateException("at token \"" + n.tokenImage + + "\", n.beginColumn = " + + Integer.toString(n.beginColumn) + ", curColumn = " + + Integer.toString(curColumn)); + + // + // Move output "cursor" to proper location, then print the token + // + if ( curLine < n.beginLine ) { + curColumn = 1; + for ( ; curLine < n.beginLine; ++curLine ) + out.println(); + } + + for ( ; curColumn < n.beginColumn; ++curColumn ) + out.print(" "); + + printToken(n.tokenImage); + } + + private void printToken(String s) { + for ( int i = 0; i < s.length(); ++i ) { + if ( s.charAt(i) == '\n' ) { + ++curLine; + curColumn = 1; + } + else + curColumn++; + + out.print(s.charAt(i)); + } + + out.flush(); + } +} diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/visitors/TreeFormatter.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/visitors/TreeFormatter.java new file mode 100644 index 000000000..7cb5ae051 --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/visitors/TreeFormatter.java @@ -0,0 +1,980 @@ +// +// Generated by JTB 1.3.2 +// +package org.gnunet.seaspider.parser.visitors; + +import org.gnunet.seaspider.parser.nodes.*; + +import java.util.*; + +/** + * A skeleton output formatter for your language grammar. Using the + * add() method along with force(), indent(), and outdent(), you can + * easily specify how this visitor will format the given syntax tree. + * See the JTB documentation for more details. + * + * Pass your syntax tree to this visitor, and then to the TreeDumper + * visitor in order to "pretty print" your tree. + */ +public class TreeFormatter extends DepthFirstVisitor { + private Vector cmdQueue = new Vector(); + private boolean lineWrap; + private int wrapWidth; + private int indentAmt; + private int curLine = 1; + private int curColumn = 1; + private int curIndent = 0; + + /** + * The default constructor assumes an indentation amount of 3 spaces + * and no line-wrap. You may alternately use the other constructor to + * specify your own indentation amount and line width. + */ + public TreeFormatter() { this(3, 0); } + + /** + * This constructor accepts an indent amount and a line width which is + * used to wrap long lines. If a token's beginColumn value is greater + * than the specified wrapWidth, it will be moved to the next line and + * indented one extra level. To turn off line-wrapping, specify a + * wrapWidth of 0. + * + * @param indentAmt Amount of spaces per indentation level. + * @param wrapWidth Wrap lines longer than wrapWidth. 0 for no wrap. + */ + public TreeFormatter(int indentAmt, int wrapWidth) { + this.indentAmt = indentAmt; + this.wrapWidth = wrapWidth; + + if ( wrapWidth > 0 ) + lineWrap = true; + else + lineWrap = false; + } + + /** + * Accepts a NodeListInterface object and performs an optional format + * command between each node in the list (but not after the last node). + */ + protected void processList(NodeListInterface n) { + processList(n, null); + } + + protected void processList(NodeListInterface n, FormatCommand cmd) { + for ( Enumeration e = n.elements(); e.hasMoreElements(); ) { + e.nextElement().accept(this); + if ( cmd != null && e.hasMoreElements() ) + cmdQueue.addElement(cmd); + } + } + + /** + * A Force command inserts a line break and indents the next line to + * the current indentation level. Use "add(force());". + */ + protected FormatCommand force() { return force(1); } + protected FormatCommand force(int i) { + return new FormatCommand(FormatCommand.FORCE, i); + } + + /** + * An Indent command increases the indentation level by one (or a + * user-specified amount). Use "add(indent());". + */ + protected FormatCommand indent() { return indent(1); } + protected FormatCommand indent(int i) { + return new FormatCommand(FormatCommand.INDENT, i); + } + + /** + * An Outdent command is the reverse of the Indent command: it reduces + * the indentation level. Use "add(outdent());". + */ + protected FormatCommand outdent() { return outdent(1); } + protected FormatCommand outdent(int i) { + return new FormatCommand(FormatCommand.OUTDENT, i); + } + + /** + * A Space command simply adds one or a user-specified number of + * spaces between tokens. Use "add(space());". + */ + protected FormatCommand space() { return space(1); } + protected FormatCommand space(int i) { + return new FormatCommand(FormatCommand.SPACE, i); + } + + /** + * Use this method to add FormatCommands to the command queue to be + * executed when the next token in the tree is visited. + */ + protected void add(FormatCommand cmd) { + cmdQueue.addElement(cmd); + } + + /** + * Executes the commands waiting in the command queue, then inserts the + * proper location information into the current NodeToken. + * + * If there are any special tokens preceding this token, they will be + * given the current location information. The token will follow on + * the next line, at the proper indentation level. If this is not the + * behavior you want from special tokens, feel free to modify this + * method. + */ + public void visit(NodeToken n) { + for ( Enumeration e = cmdQueue.elements(); e.hasMoreElements(); ) { + FormatCommand cmd = e.nextElement(); + switch ( cmd.getCommand() ) { + case FormatCommand.FORCE : + curLine += cmd.getNumCommands(); + curColumn = curIndent + 1; + break; + case FormatCommand.INDENT : + curIndent += indentAmt * cmd.getNumCommands(); + break; + case FormatCommand.OUTDENT : + if ( curIndent >= indentAmt ) + curIndent -= indentAmt * cmd.getNumCommands(); + break; + case FormatCommand.SPACE : + curColumn += cmd.getNumCommands(); + break; + default : + throw new TreeFormatterException( + "Invalid value in command queue."); + } + } + + cmdQueue.removeAllElements(); + + // + // Handle all special tokens preceding this NodeToken + // + if ( n.numSpecials() > 0 ) + for ( Enumeration e = n.specialTokens.elements(); + e.hasMoreElements(); ) { + NodeToken special = e.nextElement(); + + // + // -Place the token. + // -Move cursor to next line after the special token. + // -Don't update curColumn--want to keep current indent level. + // + placeToken(special, curLine, curColumn); + curLine = special.endLine + 1; + } + + placeToken(n, curLine, curColumn); + curLine = n.endLine; + curColumn = n.endColumn; + } + + /** + * Inserts token location (beginLine, beginColumn, endLine, endColumn) + * information into the NodeToken. Takes into account line-wrap. + * Does not update curLine and curColumn. + */ + private void placeToken(NodeToken n, int line, int column) { + int length = n.tokenImage.length(); + + // + // Find beginning of token. Only line-wrap for single-line tokens + // + if ( !lineWrap || n.tokenImage.indexOf('\n') != -1 || + column + length <= wrapWidth ) + n.beginColumn = column; + else { + ++line; + column = curIndent + indentAmt + 1; + n.beginColumn = column; + } + + n.beginLine = line; + + // + // Find end of token; don't count \n if it's the last character + // + for ( int i = 0; i < length; ++i ) { + if ( n.tokenImage.charAt(i) == '\n' && i < length - 1 ) { + ++line; + column = 1; + } + else + ++column; + } + + n.endLine = line; + n.endColumn = column; + } + + // + // User-generated visitor methods below + // + + /** + * 
+    * f0 -> ( ExternalDeclaration() )+
+    *
+ */ + public void visit(TranslationUnit n) { + processList(n.f0); + } + + /** + * 
+    * f0 -> ( StorageClassSpecifier() )*
+    * f1 -> ( FunctionDeclaration() | StructOrUnionSpecifier() | VariableDeclaration() | TypeDeclaration() )
+    *
+ */ + public void visit(ExternalDeclaration n) { + if ( n.f0.present() ) { + processList(n.f0); + } + n.f1.accept(this); + } + + /** + * 
+    * f0 -> TypeSpecifier()
+    * f1 -> <IDENTIFIER>
+    * f2 -> "("
+    * f3 -> [ ParameterList() ]
+    * f4 -> ")"
+    * f5 -> ( ";" | CompoundStatement() )
+    *
+ */ + public void visit(FunctionDeclaration n) { + n.f0.accept(this); + n.f1.accept(this); + n.f2.accept(this); + if ( n.f3.present() ) { + n.f3.accept(this); + } + n.f4.accept(this); + n.f5.accept(this); + } + + /** + * 
+    * f0 -> ( <STATIC> | <EXTERN> )
+    *
+ */ + public void visit(StorageClassSpecifier n) { + n.f0.accept(this); + } + + /** + * 
+    * f0 -> <TYPEDEF>
+    * f1 -> ( DataType() | FunctionType() )
+    * f2 -> ";"
+    *
+ */ + public void visit(TypeDeclaration n) { + n.f0.accept(this); + n.f1.accept(this); + n.f2.accept(this); + } + + /** + * 
+    * f0 -> StructOrUnionSpecifier()
+    * f1 -> <IDENTIFIER>
+    *
+ */ + public void visit(DataType n) { + n.f0.accept(this); + n.f1.accept(this); + } + + /** + * 
+    * f0 -> TypeSpecifier()
+    * f1 -> "("
+    * f2 -> "*"
+    * f3 -> <IDENTIFIER>
+    * f4 -> ")"
+    * f5 -> "("
+    * f6 -> [ ParameterList() ]
+    * f7 -> ")"
+    *
+ */ + public void visit(FunctionType n) { + n.f0.accept(this); + n.f1.accept(this); + n.f2.accept(this); + n.f3.accept(this); + n.f4.accept(this); + n.f5.accept(this); + if ( n.f6.present() ) { + n.f6.accept(this); + } + n.f7.accept(this); + } + + /** + * 
+    * f0 -> ParameterDeclaration()
+    * f1 -> ( "," ParameterDeclaration() )*
+    * f2 -> [ "," "..." ]
+    *
+ */ + public void visit(ParameterList n) { + n.f0.accept(this); + if ( n.f1.present() ) { + processList(n.f1); + } + if ( n.f2.present() ) { + n.f2.accept(this); + } + } + + /** + * 
+    * f0 -> TypeSpecifier()
+    * f1 -> <IDENTIFIER>
+    * f2 -> [ Array() ]
+    *
+ */ + public void visit(ParameterDeclaration n) { + n.f0.accept(this); + n.f1.accept(this); + if ( n.f2.present() ) { + n.f2.accept(this); + } + } + + /** + * 
+    * f0 -> VariableClassSpecifier()
+    * f1 -> TypeSpecifier()
+    * f2 -> InitDeclaratorList()
+    * f3 -> ";"
+    *
+ */ + public void visit(VariableDeclaration n) { + n.f0.accept(this); + n.f1.accept(this); + n.f2.accept(this); + n.f3.accept(this); + } + + /** + * 
+    * f0 -> [ <STATIC> ]
+    * f1 -> VariableDeclaration()
+    *
+ */ + public void visit(LocalVariableDeclaration n) { + if ( n.f0.present() ) { + n.f0.accept(this); + } + n.f1.accept(this); + } + + /** + * 
+    * f0 -> ( <AUTO> | <REGISTER> )*
+    *
+ */ + public void visit(VariableClassSpecifier n) { + if ( n.f0.present() ) { + processList(n.f0); + } + } + + /** + * 
+    * f0 -> [ <CONST> ]
+    * f1 -> ( <VOID> | <CHAR> | <SHORT> [ <INT> ] | <INT> | <LONG> [ <LONG> ] | <FLOAT> | <DOUBLE> | ( <SIGNED> | <UNSIGNED> ) [ <CHAR> | <SHORT> [ <INT> ] | <INT> | <LONG> [ <LONG> ] ] | StructOrUnionSpecifier() | EnumSpecifier() | <IDENTIFIER> )
+    * f2 -> [ Pointer() ]
+    * f3 -> [ Array() ]
+    *
+ */ + public void visit(TypeSpecifier n) { + if ( n.f0.present() ) { + n.f0.accept(this); + } + n.f1.accept(this); + if ( n.f2.present() ) { + n.f2.accept(this); + } + if ( n.f3.present() ) { + n.f3.accept(this); + } + } + + /** + * 
+    * f0 -> [ <CONST> ]
+    * f1 -> ( <VOID> | <CHAR> | <SHORT> [ <INT> ] | <INT> | <LONG> [ <LONG> ] | <FLOAT> | <DOUBLE> | ( <SIGNED> | <UNSIGNED> ) [ <CHAR> | <SHORT> [ <INT> ] | <INT> | <LONG> [ <LONG> ] ] | StructOrUnionSpecifier() | EnumSpecifier() )
+    * f2 -> [ Pointer() ]
+    * f3 -> [ Array() ]
+    *
+ */ + public void visit(NoIdentifierTypeSpecifier n) { + if ( n.f0.present() ) { + n.f0.accept(this); + } + n.f1.accept(this); + if ( n.f2.present() ) { + n.f2.accept(this); + } + if ( n.f3.present() ) { + n.f3.accept(this); + } + } + + /** + * 
+    * f0 -> StructOrUnion() [ <IDENTIFIER> ] "{" StructDeclarationList() "}"
+    *       | StructOrUnion() <IDENTIFIER>
+    *
+ */ + public void visit(StructOrUnionSpecifier n) { + n.f0.accept(this); + } + + /** + * 
+    * f0 -> ( <STRUCT> | <UNION> )
+    *
+ */ + public void visit(StructOrUnion n) { + n.f0.accept(this); + } + + /** + * 
+    * f0 -> ( StructDeclaration() )+
+    *
+ */ + public void visit(StructDeclarationList n) { + processList(n.f0); + } + + /** + * 
+    * f0 -> InitDeclarator()
+    * f1 -> ( "," InitDeclarator() )*
+    *
+ */ + public void visit(InitDeclaratorList n) { + n.f0.accept(this); + if ( n.f1.present() ) { + processList(n.f1); + } + } + + /** + * 
+    * f0 -> <IDENTIFIER>
+    * f1 -> [ Array() ]
+    * f2 -> [ "=" Initializer() ]
+    *
+ */ + public void visit(InitDeclarator n) { + n.f0.accept(this); + if ( n.f1.present() ) { + n.f1.accept(this); + } + if ( n.f2.present() ) { + n.f2.accept(this); + } + } + + /** + * 
+    * f0 -> TypeSpecifier()
+    * f1 -> <IDENTIFIER>
+    * f2 -> [ Array() | ":" ConstantExpression() ]
+    * f3 -> [ <IDENTIFIER> ]
+    * f4 -> ";"
+    *
+ */ + public void visit(StructDeclaration n) { + n.f0.accept(this); + n.f1.accept(this); + if ( n.f2.present() ) { + n.f2.accept(this); + } + if ( n.f3.present() ) { + n.f3.accept(this); + } + n.f4.accept(this); + } + + /** + * 
+    * f0 -> <ENUM>
+    * f1 -> ( [ <IDENTIFIER> ] "{" EnumeratorList() "}" | <IDENTIFIER> )
+    *
+ */ + public void visit(EnumSpecifier n) { + n.f0.accept(this); + n.f1.accept(this); + } + + /** + * 
+    * f0 -> Enumerator()
+    * f1 -> ( "," Enumerator() )*
+    *
+ */ + public void visit(EnumeratorList n) { + n.f0.accept(this); + if ( n.f1.present() ) { + processList(n.f1); + } + } + + /** + * 
+    * f0 -> <IDENTIFIER>
+    * f1 -> [ "=" ConstantExpression() ]
+    *
+ */ + public void visit(Enumerator n) { + n.f0.accept(this); + if ( n.f1.present() ) { + n.f1.accept(this); + } + } + + /** + * 
+    * f0 -> "*"
+    * f1 -> [ <CONST> ]
+    * f2 -> [ Pointer() ]
+    *
+ */ + public void visit(Pointer n) { + n.f0.accept(this); + if ( n.f1.present() ) { + n.f1.accept(this); + } + if ( n.f2.present() ) { + n.f2.accept(this); + } + } + + /** + * 
+    * f0 -> <IDENTIFIER>
+    * f1 -> ( "," <IDENTIFIER> )*
+    *
+ */ + public void visit(IdentifierList n) { + n.f0.accept(this); + if ( n.f1.present() ) { + processList(n.f1); + } + } + + /** + * 
+    * f0 -> ( AssignmentExpression() | "{" InitializerList() [ "," ] "}" )
+    *
+ */ + public void visit(Initializer n) { + n.f0.accept(this); + } + + /** + * 
+    * f0 -> Initializer()
+    * f1 -> ( "," Initializer() )*
+    *
+ */ + public void visit(InitializerList n) { + n.f0.accept(this); + if ( n.f1.present() ) { + processList(n.f1); + } + } + + /** + * 
+    * f0 -> "["
+    * f1 -> [ ConstantExpression() ]
+    * f2 -> "]"
+    *
+ */ + public void visit(Array n) { + n.f0.accept(this); + if ( n.f1.present() ) { + n.f1.accept(this); + } + n.f2.accept(this); + } + + /** + * 
+    * f0 -> ( LabeledStatement() | ExpressionStatement() | CompoundStatement() | SelectionStatement() | IterationStatement() | JumpStatement() )
+    *
+ */ + public void visit(Statement n) { + n.f0.accept(this); + } + + /** + * 
+    * f0 -> ( <IDENTIFIER> ":" Statement() | <CASE> ConstantExpression() ":" Statement() | <DFLT> ":" Statement() )
+    *
+ */ + public void visit(LabeledStatement n) { + n.f0.accept(this); + } + + /** + * 
+    * f0 -> [ Expression() ]
+    * f1 -> ";"
+    *
+ */ + public void visit(ExpressionStatement n) { + if ( n.f0.present() ) { + n.f0.accept(this); + } + n.f1.accept(this); + } + + /** + * 
+    * f0 -> "{"
+    * f1 -> ( LocalVariableDeclaration() | Statement() )*
+    * f2 -> "}"
+    *
+ */ + public void visit(CompoundStatement n) { + n.f0.accept(this); + if ( n.f1.present() ) { + processList(n.f1); + } + n.f2.accept(this); + } + + /** + * 
+    * f0 -> ( <IF> "(" Expression() ")" Statement() [ <ELSE> Statement() ] | <SWITCH> "(" Expression() ")" Statement() )
+    *
+ */ + public void visit(SelectionStatement n) { + n.f0.accept(this); + } + + /** + * 
+    * f0 -> ( <WHILE> "(" Expression() ")" Statement() | <DO> Statement() <WHILE> "(" Expression() ")" ";" | <FOR> "(" [ Expression() ] ";" [ Expression() ] ";" [ Expression() ] ")" Statement() )
+    *
+ */ + public void visit(IterationStatement n) { + n.f0.accept(this); + } + + /** + * 
+    * f0 -> ( <GOTO> <IDENTIFIER> ";" | <CONTINUE> ";" | <BREAK> ";" | <RETURN> [ Expression() ] ";" )
+    *
+ */ + public void visit(JumpStatement n) { + n.f0.accept(this); + } + + /** + * 
+    * f0 -> AssignmentExpression()
+    * f1 -> ( "," AssignmentExpression() )*
+    *
+ */ + public void visit(Expression n) { + n.f0.accept(this); + if ( n.f1.present() ) { + processList(n.f1); + } + } + + /** + * 
+    * f0 -> UnaryExpression() AssignmentOperator() AssignmentExpression()
+    *       | ConditionalExpression()
+    *
+ */ + public void visit(AssignmentExpression n) { + n.f0.accept(this); + } + + /** + * 
+    * f0 -> ( "=" | "*=" | "/=" | "%=" | "+=" | "-=" | "<<=" | ">>=" | "&=" | "^=" | "|=" )
+    *
+ */ + public void visit(AssignmentOperator n) { + n.f0.accept(this); + } + + /** + * 
+    * f0 -> LogicalORExpression()
+    * f1 -> [ "?" Expression() ":" ConditionalExpression() ]
+    *
+ */ + public void visit(ConditionalExpression n) { + n.f0.accept(this); + if ( n.f1.present() ) { + n.f1.accept(this); + } + } + + /** + * 
+    * f0 -> ConditionalExpression()
+    *
+ */ + public void visit(ConstantExpression n) { + n.f0.accept(this); + } + + /** + * 
+    * f0 -> LogicalANDExpression()
+    * f1 -> [ "||" LogicalORExpression() ]
+    *
+ */ + public void visit(LogicalORExpression n) { + n.f0.accept(this); + if ( n.f1.present() ) { + n.f1.accept(this); + } + } + + /** + * 
+    * f0 -> InclusiveORExpression()
+    * f1 -> [ "&&" LogicalANDExpression() ]
+    *
+ */ + public void visit(LogicalANDExpression n) { + n.f0.accept(this); + if ( n.f1.present() ) { + n.f1.accept(this); + } + } + + /** + * 
+    * f0 -> ExclusiveORExpression()
+    * f1 -> [ "|" InclusiveORExpression() ]
+    *
+ */ + public void visit(InclusiveORExpression n) { + n.f0.accept(this); + if ( n.f1.present() ) { + n.f1.accept(this); + } + } + + /** + * 
+    * f0 -> ANDExpression()
+    * f1 -> [ "^" ExclusiveORExpression() ]
+    *
+ */ + public void visit(ExclusiveORExpression n) { + n.f0.accept(this); + if ( n.f1.present() ) { + n.f1.accept(this); + } + } + + /** + * 
+    * f0 -> EqualityExpression()
+    * f1 -> [ "&" ANDExpression() ]
+    *
+ */ + public void visit(ANDExpression n) { + n.f0.accept(this); + if ( n.f1.present() ) { + n.f1.accept(this); + } + } + + /** + * 
+    * f0 -> RelationalExpression()
+    * f1 -> [ ( "==" | "!=" ) EqualityExpression() ]
+    *
+ */ + public void visit(EqualityExpression n) { + n.f0.accept(this); + if ( n.f1.present() ) { + n.f1.accept(this); + } + } + + /** + * 
+    * f0 -> ShiftExpression()
+    * f1 -> [ ( "<" | ">" | "<=" | ">=" ) RelationalExpression() ]
+    *
+ */ + public void visit(RelationalExpression n) { + n.f0.accept(this); + if ( n.f1.present() ) { + n.f1.accept(this); + } + } + + /** + * 
+    * f0 -> AdditiveExpression()
+    * f1 -> [ ( "<<" | ">>" ) ShiftExpression() ]
+    *
+ */ + public void visit(ShiftExpression n) { + n.f0.accept(this); + if ( n.f1.present() ) { + n.f1.accept(this); + } + } + + /** + * 
+    * f0 -> MultiplicativeExpression()
+    * f1 -> [ ( "+" | "-" ) AdditiveExpression() ]
+    *
+ */ + public void visit(AdditiveExpression n) { + n.f0.accept(this); + if ( n.f1.present() ) { + n.f1.accept(this); + } + } + + /** + * 
+    * f0 -> CastExpression()
+    * f1 -> [ ( "*" | "/" | "%" ) MultiplicativeExpression() ]
+    *
+ */ + public void visit(MultiplicativeExpression n) { + n.f0.accept(this); + if ( n.f1.present() ) { + n.f1.accept(this); + } + } + + /** + * 
+    * f0 -> ( "(" TypeSpecifier() ")" CastExpression() | UnaryExpression() )
+    *
+ */ + public void visit(CastExpression n) { + n.f0.accept(this); + } + + /** + * 
+    * f0 -> ( PostfixExpression() | "++" UnaryExpression() | "--" UnaryExpression() | UnaryOperator() CastExpression() | <SIZEOF> ( UnaryExpression() | "(" TypeSpecifier() ")" ) )
+    *
+ */ + public void visit(UnaryExpression n) { + n.f0.accept(this); + } + + /** + * 
+    * f0 -> ( "&" | "*" | "+" | "-" | "~" | "!" )
+    *
+ */ + public void visit(UnaryOperator n) { + n.f0.accept(this); + } + + /** + * 
+    * f0 -> PrimaryExpression()
+    * f1 -> ( "[" Expression() "]" | "(" [ ArgumentExpressionList() ] ")" | "." <IDENTIFIER> | "->" <IDENTIFIER> | "++" | "--" )*
+    *
+ */ + public void visit(PostfixExpression n) { + n.f0.accept(this); + if ( n.f1.present() ) { + processList(n.f1); + } + } + + /** + * 
+    * f0 -> <IDENTIFIER>
+    *       | Constant()
+    *       | "(" Expression() ")"
+    *
+ */ + public void visit(PrimaryExpression n) { + n.f0.accept(this); + } + + /** + * 
+    * f0 -> AssignmentOrTypeExpression()
+    * f1 -> ( "," AssignmentOrTypeExpression() )*
+    *
+ */ + public void visit(ArgumentExpressionList n) { + n.f0.accept(this); + if ( n.f1.present() ) { + processList(n.f1); + } + } + + /** + * 
+    * f0 -> NoIdentifierTypeSpecifier()
+    *       | AssignmentExpression()
+    *
+ */ + public void visit(AssignmentOrTypeExpression n) { + n.f0.accept(this); + } + + /** + * 
+    * f0 -> <INTEGER_LITERAL>
+    *       | <FLOATING_POINT_LITERAL>
+    *       | <CHARACTER_LITERAL>
+    *       | <STRING_LITERAL>
+    *
+ */ + public void visit(Constant n) { + n.f0.accept(this); + } + +} + +class FormatCommand { + public static final int FORCE = 0; + public static final int INDENT = 1; + public static final int OUTDENT = 2; + public static final int SPACE = 3; + + private int command; + private int numCommands; + + FormatCommand(int command, int numCommands) { + this.command = command; + this.numCommands = numCommands; + } + + public int getCommand() { return command; } + public int getNumCommands() { return numCommands; } + public void setCommand(int i) { command = i; } + public void setNumCommands(int i) { numCommands = i; } +} + +class TreeFormatterException extends RuntimeException { + TreeFormatterException() { super(); } + TreeFormatterException(String s) { super(s); } +} diff --git a/src/monkey/seaspider/org/gnunet/seaspider/parser/visitors/Visitor.java b/src/monkey/seaspider/org/gnunet/seaspider/parser/visitors/Visitor.java new file mode 100644 index 000000000..456698aec --- /dev/null +++ b/src/monkey/seaspider/org/gnunet/seaspider/parser/visitors/Visitor.java @@ -0,0 +1,508 @@ +// +// Generated by JTB 1.3.2 +// + +package org.gnunet.seaspider.parser.visitors; +import org.gnunet.seaspider.parser.nodes.*; + +import java.util.*; + +/** + * All void visitors must implement this interface. + */ + +public interface Visitor { + + // + // void Auto class visitors + // + + public void visit(NodeList n); + public void visit(NodeListOptional n); + public void visit(NodeOptional n); + public void visit(NodeSequence n); + public void visit(NodeToken n); + + // + // User-generated visitor methods below + // + + /** + * 
+    * f0 -> ( ExternalDeclaration() )+
+    *
+ */ + public void visit(TranslationUnit n); + + /** + * 
+    * f0 -> ( StorageClassSpecifier() )*
+    * f1 -> ( FunctionDeclaration() | StructOrUnionSpecifier() | VariableDeclaration() | TypeDeclaration() )
+    *
+ */ + public void visit(ExternalDeclaration n); + + /** + * 
+    * f0 -> TypeSpecifier()
+    * f1 -> <IDENTIFIER>
+    * f2 -> "("
+    * f3 -> [ ParameterList() ]
+    * f4 -> ")"
+    * f5 -> ( ";" | CompoundStatement() )
+    *
+ */ + public void visit(FunctionDeclaration n); + + /** + * 
+    * f0 -> ( <STATIC> | <EXTERN> )
+    *
+ */ + public void visit(StorageClassSpecifier n); + + /** + * 
+    * f0 -> <TYPEDEF>
+    * f1 -> ( DataType() | FunctionType() )
+    * f2 -> ";"
+    *
+ */ + public void visit(TypeDeclaration n); + + /** + * 
+    * f0 -> StructOrUnionSpecifier()
+    * f1 -> <IDENTIFIER>
+    *
+ */ + public void visit(DataType n); + + /** + * 
+    * f0 -> TypeSpecifier()
+    * f1 -> "("
+    * f2 -> "*"
+    * f3 -> <IDENTIFIER>
+    * f4 -> ")"
+    * f5 -> "("
+    * f6 -> [ ParameterList() ]
+    * f7 -> ")"
+    *
+ */ + public void visit(FunctionType n); + + /** + * 
+    * f0 -> ParameterDeclaration()
+    * f1 -> ( "," ParameterDeclaration() )*
+    * f2 -> [ "," "..." ]
+    *
+ */ + public void visit(ParameterList n); + + /** + * 
+    * f0 -> TypeSpecifier()
+    * f1 -> <IDENTIFIER>
+    * f2 -> [ Array() ]
+    *
+ */ + public void visit(ParameterDeclaration n); + + /** + * 
+    * f0 -> VariableClassSpecifier()
+    * f1 -> TypeSpecifier()
+    * f2 -> InitDeclaratorList()
+    * f3 -> ";"
+    *
+ */ + public void visit(VariableDeclaration n); + + /** + * 
+    * f0 -> [ <STATIC> ]
+    * f1 -> VariableDeclaration()
+    *
+ */ + public void visit(LocalVariableDeclaration n); + + /** + * 
+    * f0 -> ( <AUTO> | <REGISTER> )*
+    *
+ */ + public void visit(VariableClassSpecifier n); + + /** + * 
+    * f0 -> [ <CONST> ]
+    * f1 -> ( <VOID> | <CHAR> | <SHORT> [ <INT> ] | <INT> | <LONG> [ <LONG> ] | <FLOAT> | <DOUBLE> | ( <SIGNED> | <UNSIGNED> ) [ <CHAR> | <SHORT> [ <INT> ] | <INT> | <LONG> [ <LONG> ] ] | StructOrUnionSpecifier() | EnumSpecifier() | <IDENTIFIER> )
+    * f2 -> [ Pointer() ]
+    * f3 -> [ Array() ]
+    *
+ */ + public void visit(TypeSpecifier n); + + /** + * 
+    * f0 -> [ <CONST> ]
+    * f1 -> ( <VOID> | <CHAR> | <SHORT> [ <INT> ] | <INT> | <LONG> [ <LONG> ] | <FLOAT> | <DOUBLE> | ( <SIGNED> | <UNSIGNED> ) [ <CHAR> | <SHORT> [ <INT> ] | <INT> | <LONG> [ <LONG> ] ] | StructOrUnionSpecifier() | EnumSpecifier() )
+    * f2 -> [ Pointer() ]
+    * f3 -> [ Array() ]
+    *
+ */ + public void visit(NoIdentifierTypeSpecifier n); + + /** + * 
+    * f0 -> StructOrUnion() [ <IDENTIFIER> ] "{" StructDeclarationList() "}"
+    *       | StructOrUnion() <IDENTIFIER>
+    *
+ */ + public void visit(StructOrUnionSpecifier n); + + /** + * 
+    * f0 -> ( <STRUCT> | <UNION> )
+    *
+ */ + public void visit(StructOrUnion n); + + /** + * 
+    * f0 -> ( StructDeclaration() )+
+    *
+ */ + public void visit(StructDeclarationList n); + + /** + * 
+    * f0 -> InitDeclarator()
+    * f1 -> ( "," InitDeclarator() )*
+    *
+ */ + public void visit(InitDeclaratorList n); + + /** + * 
+    * f0 -> <IDENTIFIER>
+    * f1 -> [ Array() ]
+    * f2 -> [ "=" Initializer() ]
+    *
+ */ + public void visit(InitDeclarator n); + + /** + * 
+    * f0 -> TypeSpecifier()
+    * f1 -> <IDENTIFIER>
+    * f2 -> [ Array() | ":" ConstantExpression() ]
+    * f3 -> [ <IDENTIFIER> ]
+    * f4 -> ";"
+    *
+ */ + public void visit(StructDeclaration n); + + /** + * 
+    * f0 -> <ENUM>
+    * f1 -> ( [ <IDENTIFIER> ] "{" EnumeratorList() "}" | <IDENTIFIER> )
+    *
+ */ + public void visit(EnumSpecifier n); + + /** + * 
+    * f0 -> Enumerator()
+    * f1 -> ( "," Enumerator() )*
+    *
+ */ + public void visit(EnumeratorList n); + + /** + * 
+    * f0 -> <IDENTIFIER>
+    * f1 -> [ "=" ConstantExpression() ]
+    *
+ */ + public void visit(Enumerator n); + + /** + * 
+    * f0 -> "*"
+    * f1 -> [ <CONST> ]
+    * f2 -> [ Pointer() ]
+    *
+ */ + public void visit(Pointer n); + + /** + * 
+    * f0 -> <IDENTIFIER>
+    * f1 -> ( "," <IDENTIFIER> )*
+    *
+ */ + public void visit(IdentifierList n); + + /** + * 
+    * f0 -> ( AssignmentExpression() | "{" InitializerList() [ "," ] "}" )
+    *
+ */ + public void visit(Initializer n); + + /** + * 
+    * f0 -> Initializer()
+    * f1 -> ( "," Initializer() )*
+    *
+ */ + public void visit(InitializerList n); + + /** + * 
+    * f0 -> "["
+    * f1 -> [ ConstantExpression() ]
+    * f2 -> "]"
+    *
+ */ + public void visit(Array n); + + /** + * 
+    * f0 -> ( LabeledStatement() | ExpressionStatement() | CompoundStatement() | SelectionStatement() | IterationStatement() | JumpStatement() )
+    *
+ */ + public void visit(Statement n); + + /** + * 
+    * f0 -> ( <IDENTIFIER> ":" Statement() | <CASE> ConstantExpression() ":" Statement() | <DFLT> ":" Statement() )
+    *
+ */ + public void visit(LabeledStatement n); + + /** + * 
+    * f0 -> [ Expression() ]
+    * f1 -> ";"
+    *
+ */ + public void visit(ExpressionStatement n); + + /** + * 
+    * f0 -> "{"
+    * f1 -> ( LocalVariableDeclaration() | Statement() )*
+    * f2 -> "}"
+    *
+ */ + public void visit(CompoundStatement n); + + /** + * 
+    * f0 -> ( <IF> "(" Expression() ")" Statement() [ <ELSE> Statement() ] | <SWITCH> "(" Expression() ")" Statement() )
+    *
+ */ + public void visit(SelectionStatement n); + + /** + * 
+    * f0 -> ( <WHILE> "(" Expression() ")" Statement() | <DO> Statement() <WHILE> "(" Expression() ")" ";" | <FOR> "(" [ Expression() ] ";" [ Expression() ] ";" [ Expression() ] ")" Statement() )
+    *
+ */ + public void visit(IterationStatement n); + + /** + * 
+    * f0 -> ( <GOTO> <IDENTIFIER> ";" | <CONTINUE> ";" | <BREAK> ";" | <RETURN> [ Expression() ] ";" )
+    *
+ */ + public void visit(JumpStatement n); + + /** + * 
+    * f0 -> AssignmentExpression()
+    * f1 -> ( "," AssignmentExpression() )*
+    *
+ */ + public void visit(Expression n); + + /** + * 
+    * f0 -> UnaryExpression() AssignmentOperator() AssignmentExpression()
+    *       | ConditionalExpression()
+    *
+ */ + public void visit(AssignmentExpression n); + + /** + * 
+    * f0 -> ( "=" | "*=" | "/=" | "%=" | "+=" | "-=" | "<<=" | ">>=" | "&=" | "^=" | "|=" )
+    *
+ */ + public void visit(AssignmentOperator n); + + /** + * 
+    * f0 -> LogicalORExpression()
+    * f1 -> [ "?" Expression() ":" ConditionalExpression() ]
+    *
+ */ + public void visit(ConditionalExpression n); + + /** + * 
+    * f0 -> ConditionalExpression()
+    *
+ */ + public void visit(ConstantExpression n); + + /** + * 
+    * f0 -> LogicalANDExpression()
+    * f1 -> [ "||" LogicalORExpression() ]
+    *
+ */ + public void visit(LogicalORExpression n); + + /** + * 
+    * f0 -> InclusiveORExpression()
+    * f1 -> [ "&&" LogicalANDExpression() ]
+    *
+ */ + public void visit(LogicalANDExpression n); + + /** + * 
+    * f0 -> ExclusiveORExpression()
+    * f1 -> [ "|" InclusiveORExpression() ]
+    *
+ */ + public void visit(InclusiveORExpression n); + + /** + * 
+    * f0 -> ANDExpression()
+    * f1 -> [ "^" ExclusiveORExpression() ]
+    *
+ */ + public void visit(ExclusiveORExpression n); + + /** + * 
+    * f0 -> EqualityExpression()
+    * f1 -> [ "&" ANDExpression() ]
+    *
+ */ + public void visit(ANDExpression n); + + /** + * 
+    * f0 -> RelationalExpression()
+    * f1 -> [ ( "==" | "!=" ) EqualityExpression() ]
+    *
+ */ + public void visit(EqualityExpression n); + + /** + * 
+    * f0 -> ShiftExpression()
+    * f1 -> [ ( "<" | ">" | "<=" | ">=" ) RelationalExpression() ]
+    *
+ */ + public void visit(RelationalExpression n); + + /** + * 
+    * f0 -> AdditiveExpression()
+    * f1 -> [ ( "<<" | ">>" ) ShiftExpression() ]
+    *
+ */ + public void visit(ShiftExpression n); + + /** + * 
+    * f0 -> MultiplicativeExpression()
+    * f1 -> [ ( "+" | "-" ) AdditiveExpression() ]
+    *
+ */ + public void visit(AdditiveExpression n); + + /** + * 
+    * f0 -> CastExpression()
+    * f1 -> [ ( "*" | "/" | "%" ) MultiplicativeExpression() ]
+    *
+ */ + public void visit(MultiplicativeExpression n); + + /** + * 
+    * f0 -> ( "(" TypeSpecifier() ")" CastExpression() | UnaryExpression() )
+    *
+ */ + public void visit(CastExpression n); + + /** + * 
+    * f0 -> ( PostfixExpression() | "++" UnaryExpression() | "--" UnaryExpression() | UnaryOperator() CastExpression() | <SIZEOF> ( UnaryExpression() | "(" TypeSpecifier() ")" ) )
+    *
+ */ + public void visit(UnaryExpression n); + + /** + * 
+    * f0 -> ( "&" | "*" | "+" | "-" | "~" | "!" )
+    *
+ */ + public void visit(UnaryOperator n); + + /** + * 
+    * f0 -> PrimaryExpression()
+    * f1 -> ( "[" Expression() "]" | "(" [ ArgumentExpressionList() ] ")" | "." <IDENTIFIER> | "->" <IDENTIFIER> | "++" | "--" )*
+    *
+ */ + public void visit(PostfixExpression n); + + /** + * 
+    * f0 -> <IDENTIFIER>
+    *       | Constant()
+    *       | "(" Expression() ")"
+    *
+ */ + public void visit(PrimaryExpression n); + + /** + * 
+    * f0 -> AssignmentOrTypeExpression()
+    * f1 -> ( "," AssignmentOrTypeExpression() )*
+    *
+ */ + public void visit(ArgumentExpressionList n); + + /** + * 
+    * f0 -> NoIdentifierTypeSpecifier()
+    *       | AssignmentExpression()
+    *
+ */ + public void visit(AssignmentOrTypeExpression n); + + /** + * 
+    * f0 -> <INTEGER_LITERAL>
+    *       | <FLOATING_POINT_LITERAL>
+    *       | <CHARACTER_LITERAL>
+    *       | <STRING_LITERAL>
+    *
+ */ + public void visit(Constant n); + +} + -- cgit v1.2.3