diff options
Diffstat (limited to 'src/minijava/syntaxtree')
50 files changed, 2216 insertions, 0 deletions
diff --git a/src/minijava/syntaxtree/AllocationExpression.java b/src/minijava/syntaxtree/AllocationExpression.java new file mode 100644 index 0000000..d31b05e --- /dev/null +++ b/src/minijava/syntaxtree/AllocationExpression.java @@ -0,0 +1,47 @@ +// +// Generated by JTB 1.3.2 +//
+
+package minijava.syntaxtree;
+
+/**
+ * Grammar production:
+ * f0 -> "new"
+ * f1 -> Identifier()
+ * f2 -> "("
+ * f3 -> ")"
+ */
+public class AllocationExpression implements Node {
+ public NodeToken f0;
+ public Identifier f1;
+ public NodeToken f2;
+ public NodeToken f3;
+
+ public AllocationExpression(NodeToken n0, Identifier n1, NodeToken n2, NodeToken n3) {
+ f0 = n0;
+ f1 = n1;
+ f2 = n2;
+ f3 = n3;
+ }
+
+ public AllocationExpression(Identifier n0) {
+ f0 = new NodeToken("new");
+ f1 = n0;
+ f2 = new NodeToken("(");
+ f3 = new NodeToken(")");
+ }
+
+ public void accept(minijava.visitor.Visitor v) {
+ v.visit(this);
+ }
+ public <R,A> R accept(minijava.visitor.GJVisitor<R,A> v, A argu) {
+ return v.visit(this,argu);
+ }
+ public <R> R accept(minijava.visitor.GJNoArguVisitor<R> v) {
+ return v.visit(this);
+ }
+ public <A> void accept(minijava.visitor.GJVoidVisitor<A> v, A argu) {
+ v.visit(this,argu);
+ }
+}
+
diff --git a/src/minijava/syntaxtree/AndExpression.java b/src/minijava/syntaxtree/AndExpression.java new file mode 100644 index 0000000..bf7637b --- /dev/null +++ b/src/minijava/syntaxtree/AndExpression.java @@ -0,0 +1,43 @@ +// +// Generated by JTB 1.3.2 +//
+
+package minijava.syntaxtree;
+
+/**
+ * Grammar production:
+ * f0 -> PrimaryExpression()
+ * f1 -> "&&"
+ * f2 -> PrimaryExpression()
+ */
+public class AndExpression implements Node {
+ public PrimaryExpression f0;
+ public NodeToken f1;
+ public PrimaryExpression f2;
+
+ public AndExpression(PrimaryExpression n0, NodeToken n1, PrimaryExpression n2) {
+ f0 = n0;
+ f1 = n1;
+ f2 = n2;
+ }
+
+ public AndExpression(PrimaryExpression n0, PrimaryExpression n1) {
+ f0 = n0;
+ f1 = new NodeToken("&&");
+ f2 = n1;
+ }
+
+ public void accept(minijava.visitor.Visitor v) {
+ v.visit(this);
+ }
+ public <R,A> R accept(minijava.visitor.GJVisitor<R,A> v, A argu) {
+ return v.visit(this,argu);
+ }
+ public <R> R accept(minijava.visitor.GJNoArguVisitor<R> v) {
+ return v.visit(this);
+ }
+ public <A> void accept(minijava.visitor.GJVoidVisitor<A> v, A argu) {
+ v.visit(this,argu);
+ }
+}
+
diff --git a/src/minijava/syntaxtree/ArrayAllocationExpression.java b/src/minijava/syntaxtree/ArrayAllocationExpression.java new file mode 100644 index 0000000..b7e8d07 --- /dev/null +++ b/src/minijava/syntaxtree/ArrayAllocationExpression.java @@ -0,0 +1,51 @@ +// +// Generated by JTB 1.3.2 +//
+
+package minijava.syntaxtree;
+
+/**
+ * Grammar production:
+ * f0 -> "new"
+ * f1 -> "int"
+ * f2 -> "["
+ * f3 -> Expression()
+ * f4 -> "]"
+ */
+public class ArrayAllocationExpression implements Node {
+ public NodeToken f0;
+ public NodeToken f1;
+ public NodeToken f2;
+ public Expression f3;
+ public NodeToken f4;
+
+ public ArrayAllocationExpression(NodeToken n0, NodeToken n1, NodeToken n2, Expression n3, NodeToken n4) {
+ f0 = n0;
+ f1 = n1;
+ f2 = n2;
+ f3 = n3;
+ f4 = n4;
+ }
+
+ public ArrayAllocationExpression(Expression n0) {
+ f0 = new NodeToken("new");
+ f1 = new NodeToken("int");
+ f2 = new NodeToken("[");
+ f3 = n0;
+ f4 = new NodeToken("]");
+ }
+
+ public void accept(minijava.visitor.Visitor v) {
+ v.visit(this);
+ }
+ public <R,A> R accept(minijava.visitor.GJVisitor<R,A> v, A argu) {
+ return v.visit(this,argu);
+ }
+ public <R> R accept(minijava.visitor.GJNoArguVisitor<R> v) {
+ return v.visit(this);
+ }
+ public <A> void accept(minijava.visitor.GJVoidVisitor<A> v, A argu) {
+ v.visit(this,argu);
+ }
+}
+
diff --git a/src/minijava/syntaxtree/ArrayAssignmentStatement.java b/src/minijava/syntaxtree/ArrayAssignmentStatement.java new file mode 100644 index 0000000..9ac2eaa --- /dev/null +++ b/src/minijava/syntaxtree/ArrayAssignmentStatement.java @@ -0,0 +1,59 @@ +// +// Generated by JTB 1.3.2 +//
+
+package minijava.syntaxtree;
+
+/**
+ * Grammar production:
+ * f0 -> Identifier()
+ * f1 -> "["
+ * f2 -> Expression()
+ * f3 -> "]"
+ * f4 -> "="
+ * f5 -> Expression()
+ * f6 -> ";"
+ */
+public class ArrayAssignmentStatement implements Node {
+ public Identifier f0;
+ public NodeToken f1;
+ public Expression f2;
+ public NodeToken f3;
+ public NodeToken f4;
+ public Expression f5;
+ public NodeToken f6;
+
+ public ArrayAssignmentStatement(Identifier n0, NodeToken n1, Expression n2, NodeToken n3, NodeToken n4, Expression n5, NodeToken n6) {
+ f0 = n0;
+ f1 = n1;
+ f2 = n2;
+ f3 = n3;
+ f4 = n4;
+ f5 = n5;
+ f6 = n6;
+ }
+
+ public ArrayAssignmentStatement(Identifier n0, Expression n1, Expression n2) {
+ f0 = n0;
+ f1 = new NodeToken("[");
+ f2 = n1;
+ f3 = new NodeToken("]");
+ f4 = new NodeToken("=");
+ f5 = n2;
+ f6 = new NodeToken(";");
+ }
+
+ public void accept(minijava.visitor.Visitor v) {
+ v.visit(this);
+ }
+ public <R,A> R accept(minijava.visitor.GJVisitor<R,A> v, A argu) {
+ return v.visit(this,argu);
+ }
+ public <R> R accept(minijava.visitor.GJNoArguVisitor<R> v) {
+ return v.visit(this);
+ }
+ public <A> void accept(minijava.visitor.GJVoidVisitor<A> v, A argu) {
+ v.visit(this,argu);
+ }
+}
+
diff --git a/src/minijava/syntaxtree/ArrayLength.java b/src/minijava/syntaxtree/ArrayLength.java new file mode 100644 index 0000000..bb9755e --- /dev/null +++ b/src/minijava/syntaxtree/ArrayLength.java @@ -0,0 +1,43 @@ +// +// Generated by JTB 1.3.2 +//
+
+package minijava.syntaxtree;
+
+/**
+ * Grammar production:
+ * f0 -> PrimaryExpression()
+ * f1 -> "."
+ * f2 -> "length"
+ */
+public class ArrayLength implements Node {
+ public PrimaryExpression f0;
+ public NodeToken f1;
+ public NodeToken f2;
+
+ public ArrayLength(PrimaryExpression n0, NodeToken n1, NodeToken n2) {
+ f0 = n0;
+ f1 = n1;
+ f2 = n2;
+ }
+
+ public ArrayLength(PrimaryExpression n0) {
+ f0 = n0;
+ f1 = new NodeToken(".");
+ f2 = new NodeToken("length");
+ }
+
+ public void accept(minijava.visitor.Visitor v) {
+ v.visit(this);
+ }
+ public <R,A> R accept(minijava.visitor.GJVisitor<R,A> v, A argu) {
+ return v.visit(this,argu);
+ }
+ public <R> R accept(minijava.visitor.GJNoArguVisitor<R> v) {
+ return v.visit(this);
+ }
+ public <A> void accept(minijava.visitor.GJVoidVisitor<A> v, A argu) {
+ v.visit(this,argu);
+ }
+}
+
diff --git a/src/minijava/syntaxtree/ArrayLookup.java b/src/minijava/syntaxtree/ArrayLookup.java new file mode 100644 index 0000000..248756e --- /dev/null +++ b/src/minijava/syntaxtree/ArrayLookup.java @@ -0,0 +1,47 @@ +// +// Generated by JTB 1.3.2 +//
+
+package minijava.syntaxtree;
+
+/**
+ * Grammar production:
+ * f0 -> PrimaryExpression()
+ * f1 -> "["
+ * f2 -> PrimaryExpression()
+ * f3 -> "]"
+ */
+public class ArrayLookup implements Node {
+ public PrimaryExpression f0;
+ public NodeToken f1;
+ public PrimaryExpression f2;
+ public NodeToken f3;
+
+ public ArrayLookup(PrimaryExpression n0, NodeToken n1, PrimaryExpression n2, NodeToken n3) {
+ f0 = n0;
+ f1 = n1;
+ f2 = n2;
+ f3 = n3;
+ }
+
+ public ArrayLookup(PrimaryExpression n0, PrimaryExpression n1) {
+ f0 = n0;
+ f1 = new NodeToken("[");
+ f2 = n1;
+ f3 = new NodeToken("]");
+ }
+
+ public void accept(minijava.visitor.Visitor v) {
+ v.visit(this);
+ }
+ public <R,A> R accept(minijava.visitor.GJVisitor<R,A> v, A argu) {
+ return v.visit(this,argu);
+ }
+ public <R> R accept(minijava.visitor.GJNoArguVisitor<R> v) {
+ return v.visit(this);
+ }
+ public <A> void accept(minijava.visitor.GJVoidVisitor<A> v, A argu) {
+ v.visit(this,argu);
+ }
+}
+
diff --git a/src/minijava/syntaxtree/ArrayType.java b/src/minijava/syntaxtree/ArrayType.java new file mode 100644 index 0000000..44cf566 --- /dev/null +++ b/src/minijava/syntaxtree/ArrayType.java @@ -0,0 +1,43 @@ +// +// Generated by JTB 1.3.2 +//
+
+package minijava.syntaxtree;
+
+/**
+ * Grammar production:
+ * f0 -> "int"
+ * f1 -> "["
+ * f2 -> "]"
+ */
+public class ArrayType implements Node {
+ public NodeToken f0;
+ public NodeToken f1;
+ public NodeToken f2;
+
+ public ArrayType(NodeToken n0, NodeToken n1, NodeToken n2) {
+ f0 = n0;
+ f1 = n1;
+ f2 = n2;
+ }
+
+ public ArrayType() {
+ f0 = new NodeToken("int");
+ f1 = new NodeToken("[");
+ f2 = new NodeToken("]");
+ }
+
+ public void accept(minijava.visitor.Visitor v) {
+ v.visit(this);
+ }
+ public <R,A> R accept(minijava.visitor.GJVisitor<R,A> v, A argu) {
+ return v.visit(this,argu);
+ }
+ public <R> R accept(minijava.visitor.GJNoArguVisitor<R> v) {
+ return v.visit(this);
+ }
+ public <A> void accept(minijava.visitor.GJVoidVisitor<A> v, A argu) {
+ v.visit(this,argu);
+ }
+}
+
diff --git a/src/minijava/syntaxtree/AssignmentStatement.java b/src/minijava/syntaxtree/AssignmentStatement.java new file mode 100644 index 0000000..9ad3efa --- /dev/null +++ b/src/minijava/syntaxtree/AssignmentStatement.java @@ -0,0 +1,47 @@ +// +// Generated by JTB 1.3.2 +//
+
+package minijava.syntaxtree;
+
+/**
+ * Grammar production:
+ * f0 -> Identifier()
+ * f1 -> "="
+ * f2 -> Expression()
+ * f3 -> ";"
+ */
+public class AssignmentStatement implements Node {
+ public Identifier f0;
+ public NodeToken f1;
+ public Expression f2;
+ public NodeToken f3;
+
+ public AssignmentStatement(Identifier n0, NodeToken n1, Expression n2, NodeToken n3) {
+ f0 = n0;
+ f1 = n1;
+ f2 = n2;
+ f3 = n3;
+ }
+
+ public AssignmentStatement(Identifier n0, Expression n1) {
+ f0 = n0;
+ f1 = new NodeToken("=");
+ f2 = n1;
+ f3 = new NodeToken(";");
+ }
+
+ public void accept(minijava.visitor.Visitor v) {
+ v.visit(this);
+ }
+ public <R,A> R accept(minijava.visitor.GJVisitor<R,A> v, A argu) {
+ return v.visit(this,argu);
+ }
+ public <R> R accept(minijava.visitor.GJNoArguVisitor<R> v) {
+ return v.visit(this);
+ }
+ public <A> void accept(minijava.visitor.GJVoidVisitor<A> v, A argu) {
+ v.visit(this,argu);
+ }
+}
+
diff --git a/src/minijava/syntaxtree/Block.java b/src/minijava/syntaxtree/Block.java new file mode 100644 index 0000000..1546cc7 --- /dev/null +++ b/src/minijava/syntaxtree/Block.java @@ -0,0 +1,43 @@ +// +// Generated by JTB 1.3.2 +//
+
+package minijava.syntaxtree;
+
+/**
+ * Grammar production:
+ * f0 -> "{"
+ * f1 -> ( Statement() )*
+ * f2 -> "}"
+ */
+public class Block implements Node {
+ public NodeToken f0;
+ public NodeListOptional f1;
+ public NodeToken f2;
+
+ public Block(NodeToken n0, NodeListOptional n1, NodeToken n2) {
+ f0 = n0;
+ f1 = n1;
+ f2 = n2;
+ }
+
+ public Block(NodeListOptional n0) {
+ f0 = new NodeToken("{");
+ f1 = n0;
+ f2 = new NodeToken("}");
+ }
+
+ public void accept(minijava.visitor.Visitor v) {
+ v.visit(this);
+ }
+ public <R,A> R accept(minijava.visitor.GJVisitor<R,A> v, A argu) {
+ return v.visit(this,argu);
+ }
+ public <R> R accept(minijava.visitor.GJNoArguVisitor<R> v) {
+ return v.visit(this);
+ }
+ public <A> void accept(minijava.visitor.GJVoidVisitor<A> v, A argu) {
+ v.visit(this,argu);
+ }
+}
+
diff --git a/src/minijava/syntaxtree/BooleanType.java b/src/minijava/syntaxtree/BooleanType.java new file mode 100644 index 0000000..e482c93 --- /dev/null +++ b/src/minijava/syntaxtree/BooleanType.java @@ -0,0 +1,35 @@ +// +// Generated by JTB 1.3.2 +//
+
+package minijava.syntaxtree;
+
+/**
+ * Grammar production:
+ * f0 -> "boolean"
+ */
+public class BooleanType implements Node {
+ public NodeToken f0;
+
+ public BooleanType(NodeToken n0) {
+ f0 = n0;
+ }
+
+ public BooleanType() {
+ f0 = new NodeToken("boolean");
+ }
+
+ public void accept(minijava.visitor.Visitor v) {
+ v.visit(this);
+ }
+ public <R,A> R accept(minijava.visitor.GJVisitor<R,A> v, A argu) {
+ return v.visit(this,argu);
+ }
+ public <R> R accept(minijava.visitor.GJNoArguVisitor<R> v) {
+ return v.visit(this);
+ }
+ public <A> void accept(minijava.visitor.GJVoidVisitor<A> v, A argu) {
+ v.visit(this,argu);
+ }
+}
+
diff --git a/src/minijava/syntaxtree/BracketExpression.java b/src/minijava/syntaxtree/BracketExpression.java new file mode 100644 index 0000000..47f83dd --- /dev/null +++ b/src/minijava/syntaxtree/BracketExpression.java @@ -0,0 +1,43 @@ +// +// Generated by JTB 1.3.2 +//
+
+package minijava.syntaxtree;
+
+/**
+ * Grammar production:
+ * f0 -> "("
+ * f1 -> Expression()
+ * f2 -> ")"
+ */
+public class BracketExpression implements Node {
+ public NodeToken f0;
+ public Expression f1;
+ public NodeToken f2;
+
+ public BracketExpression(NodeToken n0, Expression n1, NodeToken n2) {
+ f0 = n0;
+ f1 = n1;
+ f2 = n2;
+ }
+
+ public BracketExpression(Expression n0) {
+ f0 = new NodeToken("(");
+ f1 = n0;
+ f2 = new NodeToken(")");
+ }
+
+ public void accept(minijava.visitor.Visitor v) {
+ v.visit(this);
+ }
+ public <R,A> R accept(minijava.visitor.GJVisitor<R,A> v, A argu) {
+ return v.visit(this,argu);
+ }
+ public <R> R accept(minijava.visitor.GJNoArguVisitor<R> v) {
+ return v.visit(this);
+ }
+ public <A> void accept(minijava.visitor.GJVoidVisitor<A> v, A argu) {
+ v.visit(this,argu);
+ }
+}
+
diff --git a/src/minijava/syntaxtree/ClassDeclaration.java b/src/minijava/syntaxtree/ClassDeclaration.java new file mode 100644 index 0000000..01df615 --- /dev/null +++ b/src/minijava/syntaxtree/ClassDeclaration.java @@ -0,0 +1,55 @@ +// +// Generated by JTB 1.3.2 +//
+
+package minijava.syntaxtree;
+
+/**
+ * Grammar production:
+ * f0 -> "class"
+ * f1 -> Identifier()
+ * f2 -> "{"
+ * f3 -> ( VarDeclaration() )*
+ * f4 -> ( MethodDeclaration() )*
+ * f5 -> "}"
+ */
+public class ClassDeclaration implements Node {
+ public NodeToken f0;
+ public Identifier f1;
+ public NodeToken f2;
+ public NodeListOptional f3;
+ public NodeListOptional f4;
+ public NodeToken f5;
+
+ public ClassDeclaration(NodeToken n0, Identifier n1, NodeToken n2, NodeListOptional n3, NodeListOptional n4, NodeToken n5) {
+ f0 = n0;
+ f1 = n1;
+ f2 = n2;
+ f3 = n3;
+ f4 = n4;
+ f5 = n5;
+ }
+
+ public ClassDeclaration(Identifier n0, NodeListOptional n1, NodeListOptional n2) {
+ f0 = new NodeToken("class");
+ f1 = n0;
+ f2 = new NodeToken("{");
+ f3 = n1;
+ f4 = n2;
+ f5 = new NodeToken("}");
+ }
+
+ public void accept(minijava.visitor.Visitor v) {
+ v.visit(this);
+ }
+ public <R,A> R accept(minijava.visitor.GJVisitor<R,A> v, A argu) {
+ return v.visit(this,argu);
+ }
+ public <R> R accept(minijava.visitor.GJNoArguVisitor<R> v) {
+ return v.visit(this);
+ }
+ public <A> void accept(minijava.visitor.GJVoidVisitor<A> v, A argu) {
+ v.visit(this,argu);
+ }
+}
+
diff --git a/src/minijava/syntaxtree/ClassExtendsDeclaration.java b/src/minijava/syntaxtree/ClassExtendsDeclaration.java new file mode 100644 index 0000000..fcadb56 --- /dev/null +++ b/src/minijava/syntaxtree/ClassExtendsDeclaration.java @@ -0,0 +1,63 @@ +// +// Generated by JTB 1.3.2 +//
+
+package minijava.syntaxtree;
+
+/**
+ * Grammar production:
+ * f0 -> "class"
+ * f1 -> Identifier()
+ * f2 -> "extends"
+ * f3 -> Identifier()
+ * f4 -> "{"
+ * f5 -> ( VarDeclaration() )*
+ * f6 -> ( MethodDeclaration() )*
+ * f7 -> "}"
+ */
+public class ClassExtendsDeclaration implements Node {
+ public NodeToken f0;
+ public Identifier f1;
+ public NodeToken f2;
+ public Identifier f3;
+ public NodeToken f4;
+ public NodeListOptional f5;
+ public NodeListOptional f6;
+ public NodeToken f7;
+
+ public ClassExtendsDeclaration(NodeToken n0, Identifier n1, NodeToken n2, Identifier n3, NodeToken n4, NodeListOptional n5, NodeListOptional n6, NodeToken n7) {
+ f0 = n0;
+ f1 = n1;
+ f2 = n2;
+ f3 = n3;
+ f4 = n4;
+ f5 = n5;
+ f6 = n6;
+ f7 = n7;
+ }
+
+ public ClassExtendsDeclaration(Identifier n0, Identifier n1, NodeListOptional n2, NodeListOptional n3) {
+ f0 = new NodeToken("class");
+ f1 = n0;
+ f2 = new NodeToken("extends");
+ f3 = n1;
+ f4 = new NodeToken("{");
+ f5 = n2;
+ f6 = n3;
+ f7 = new NodeToken("}");
+ }
+
+ public void accept(minijava.visitor.Visitor v) {
+ v.visit(this);
+ }
+ public <R,A> R accept(minijava.visitor.GJVisitor<R,A> v, A argu) {
+ return v.visit(this,argu);
+ }
+ public <R> R accept(minijava.visitor.GJNoArguVisitor<R> v) {
+ return v.visit(this);
+ }
+ public <A> void accept(minijava.visitor.GJVoidVisitor<A> v, A argu) {
+ v.visit(this,argu);
+ }
+}
+
diff --git a/src/minijava/syntaxtree/CompareExpression.java b/src/minijava/syntaxtree/CompareExpression.java new file mode 100644 index 0000000..e4f2c4c --- /dev/null +++ b/src/minijava/syntaxtree/CompareExpression.java @@ -0,0 +1,43 @@ +// +// Generated by JTB 1.3.2 +//
+
+package minijava.syntaxtree;
+
+/**
+ * Grammar production:
+ * f0 -> PrimaryExpression()
+ * f1 -> "<"
+ * f2 -> PrimaryExpression()
+ */
+public class CompareExpression implements Node {
+ public PrimaryExpression f0;
+ public NodeToken f1;
+ public PrimaryExpression f2;
+
+ public CompareExpression(PrimaryExpression n0, NodeToken n1, PrimaryExpression n2) {
+ f0 = n0;
+ f1 = n1;
+ f2 = n2;
+ }
+
+ public CompareExpression(PrimaryExpression n0, PrimaryExpression n1) {
+ f0 = n0;
+ f1 = new NodeToken("<");
+ f2 = n1;
+ }
+
+ public void accept(minijava.visitor.Visitor v) {
+ v.visit(this);
+ }
+ public <R,A> R accept(minijava.visitor.GJVisitor<R,A> v, A argu) {
+ return v.visit(this,argu);
+ }
+ public <R> R accept(minijava.visitor.GJNoArguVisitor<R> v) {
+ return v.visit(this);
+ }
+ public <A> void accept(minijava.visitor.GJVoidVisitor<A> v, A argu) {
+ v.visit(this,argu);
+ }
+}
+
diff --git a/src/minijava/syntaxtree/Expression.java b/src/minijava/syntaxtree/Expression.java new file mode 100644 index 0000000..cc138d8 --- /dev/null +++ b/src/minijava/syntaxtree/Expression.java @@ -0,0 +1,39 @@ +// +// Generated by JTB 1.3.2 +//
+
+package minijava.syntaxtree;
+
+/**
+ * Grammar production:
+ * f0 -> AndExpression()
+ * | CompareExpression()
+ * | PlusExpression()
+ * | MinusExpression()
+ * | TimesExpression()
+ * | ArrayLookup()
+ * | ArrayLength()
+ * | MessageSend()
+ * | PrimaryExpression()
+ */
+public class Expression implements Node {
+ public NodeChoice f0;
+
+ public Expression(NodeChoice n0) {
+ f0 = n0;
+ }
+
+ public void accept(minijava.visitor.Visitor v) {
+ v.visit(this);
+ }
+ public <R,A> R accept(minijava.visitor.GJVisitor<R,A> v, A argu) {
+ return v.visit(this,argu);
+ }
+ public <R> R accept(minijava.visitor.GJNoArguVisitor<R> v) {
+ return v.visit(this);
+ }
+ public <A> void accept(minijava.visitor.GJVoidVisitor<A> v, A argu) {
+ v.visit(this,argu);
+ }
+}
+
diff --git a/src/minijava/syntaxtree/ExpressionList.java b/src/minijava/syntaxtree/ExpressionList.java new file mode 100644 index 0000000..4be4f6b --- /dev/null +++ b/src/minijava/syntaxtree/ExpressionList.java @@ -0,0 +1,34 @@ +// +// Generated by JTB 1.3.2 +//
+
+package minijava.syntaxtree;
+
+/**
+ * Grammar production:
+ * f0 -> Expression()
+ * f1 -> ( ExpressionRest() )*
+ */
+public class ExpressionList implements Node {
+ public Expression f0;
+ public NodeListOptional f1;
+
+ public ExpressionList(Expression n0, NodeListOptional n1) {
+ f0 = n0;
+ f1 = n1;
+ }
+
+ public void accept(minijava.visitor.Visitor v) {
+ v.visit(this);
+ }
+ public <R,A> R accept(minijava.visitor.GJVisitor<R,A> v, A argu) {
+ return v.visit(this,argu);
+ }
+ public <R> R accept(minijava.visitor.GJNoArguVisitor<R> v) {
+ return v.visit(this);
+ }
+ public <A> void accept(minijava.visitor.GJVoidVisitor<A> v, A argu) {
+ v.visit(this,argu);
+ }
+}
+
diff --git a/src/minijava/syntaxtree/ExpressionRest.java b/src/minijava/syntaxtree/ExpressionRest.java new file mode 100644 index 0000000..ec730da --- /dev/null +++ b/src/minijava/syntaxtree/ExpressionRest.java @@ -0,0 +1,39 @@ +// +// Generated by JTB 1.3.2 +//
+
+package minijava.syntaxtree;
+
+/**
+ * Grammar production:
+ * f0 -> ","
+ * f1 -> Expression()
+ */
+public class ExpressionRest implements Node {
+ public NodeToken f0;
+ public Expression f1;
+
+ public ExpressionRest(NodeToken n0, Expression n1) {
+ f0 = n0;
+ f1 = n1;
+ }
+
+ public ExpressionRest(Expression n0) {
+ f0 = new NodeToken(",");
+ f1 = n0;
+ }
+
+ public void accept(minijava.visitor.Visitor v) {
+ v.visit(this);
+ }
+ public <R,A> R accept(minijava.visitor.GJVisitor<R,A> v, A argu) {
+ return v.visit(this,argu);
+ }
+ public <R> R accept(minijava.visitor.GJNoArguVisitor<R> v) {
+ return v.visit(this);
+ }
+ public <A> void accept(minijava.visitor.GJVoidVisitor<A> v, A argu) {
+ v.visit(this,argu);
+ }
+}
+
diff --git a/src/minijava/syntaxtree/FalseLiteral.java b/src/minijava/syntaxtree/FalseLiteral.java new file mode 100644 index 0000000..9903c27 --- /dev/null +++ b/src/minijava/syntaxtree/FalseLiteral.java @@ -0,0 +1,35 @@ +// +// Generated by JTB 1.3.2 +//
+
+package minijava.syntaxtree;
+
+/**
+ * Grammar production:
+ * f0 -> "false"
+ */
+public class FalseLiteral implements Node {
+ public NodeToken f0;
+
+ public FalseLiteral(NodeToken n0) {
+ f0 = n0;
+ }
+
+ public FalseLiteral() {
+ f0 = new NodeToken("false");
+ }
+
+ public void accept(minijava.visitor.Visitor v) {
+ v.visit(this);
+ }
+ public <R,A> R accept(minijava.visitor.GJVisitor<R,A> v, A argu) {
+ return v.visit(this,argu);
+ }
+ public <R> R accept(minijava.visitor.GJNoArguVisitor<R> v) {
+ return v.visit(this);
+ }
+ public <A> void accept(minijava.visitor.GJVoidVisitor<A> v, A argu) {
+ v.visit(this,argu);
+ }
+}
+
diff --git a/src/minijava/syntaxtree/FormalParameter.java b/src/minijava/syntaxtree/FormalParameter.java new file mode 100644 index 0000000..7be4878 --- /dev/null +++ b/src/minijava/syntaxtree/FormalParameter.java @@ -0,0 +1,34 @@ +// +// Generated by JTB 1.3.2 +//
+
+package minijava.syntaxtree;
+
+/**
+ * Grammar production:
+ * f0 -> Type()
+ * f1 -> Identifier()
+ */
+public class FormalParameter implements Node {
+ public Type f0;
+ public Identifier f1;
+
+ public FormalParameter(Type n0, Identifier n1) {
+ f0 = n0;
+ f1 = n1;
+ }
+
+ public void accept(minijava.visitor.Visitor v) {
+ v.visit(this);
+ }
+ public <R,A> R accept(minijava.visitor.GJVisitor<R,A> v, A argu) {
+ return v.visit(this,argu);
+ }
+ public <R> R accept(minijava.visitor.GJNoArguVisitor<R> v) {
+ return v.visit(this);
+ }
+ public <A> void accept(minijava.visitor.GJVoidVisitor<A> v, A argu) {
+ v.visit(this,argu);
+ }
+}
+
diff --git a/src/minijava/syntaxtree/FormalParameterList.java b/src/minijava/syntaxtree/FormalParameterList.java new file mode 100644 index 0000000..00a2e0d --- /dev/null +++ b/src/minijava/syntaxtree/FormalParameterList.java @@ -0,0 +1,34 @@ +// +// Generated by JTB 1.3.2 +//
+
+package minijava.syntaxtree;
+
+/**
+ * Grammar production:
+ * f0 -> FormalParameter()
+ * f1 -> ( FormalParameterRest() )*
+ */
+public class FormalParameterList implements Node {
+ public FormalParameter f0;
+ public NodeListOptional f1;
+
+ public FormalParameterList(FormalParameter n0, NodeListOptional n1) {
+ f0 = n0;
+ f1 = n1;
+ }
+
+ public void accept(minijava.visitor.Visitor v) {
+ v.visit(this);
+ }
+ public <R,A> R accept(minijava.visitor.GJVisitor<R,A> v, A argu) {
+ return v.visit(this,argu);
+ }
+ public <R> R accept(minijava.visitor.GJNoArguVisitor<R> v) {
+ return v.visit(this);
+ }
+ public <A> void accept(minijava.visitor.GJVoidVisitor<A> v, A argu) {
+ v.visit(this,argu);
+ }
+}
+
diff --git a/src/minijava/syntaxtree/FormalParameterRest.java b/src/minijava/syntaxtree/FormalParameterRest.java new file mode 100644 index 0000000..797b1a5 --- /dev/null +++ b/src/minijava/syntaxtree/FormalParameterRest.java @@ -0,0 +1,39 @@ +// +// Generated by JTB 1.3.2 +//
+
+package minijava.syntaxtree;
+
+/**
+ * Grammar production:
+ * f0 -> ","
+ * f1 -> FormalParameter()
+ */
+public class FormalParameterRest implements Node {
+ public NodeToken f0;
+ public FormalParameter f1;
+
+ public FormalParameterRest(NodeToken n0, FormalParameter n1) {
+ f0 = n0;
+ f1 = n1;
+ }
+
+ public FormalParameterRest(FormalParameter n0) {
+ f0 = new NodeToken(",");
+ f1 = n0;
+ }
+
+ public void accept(minijava.visitor.Visitor v) {
+ v.visit(this);
+ }
+ public <R,A> R accept(minijava.visitor.GJVisitor<R,A> v, A argu) {
+ return v.visit(this,argu);
+ }
+ public <R> R accept(minijava.visitor.GJNoArguVisitor<R> v) {
+ return v.visit(this);
+ }
+ public <A> void accept(minijava.visitor.GJVoidVisitor<A> v, A argu) {
+ v.visit(this,argu);
+ }
+}
+
diff --git a/src/minijava/syntaxtree/Goal.java b/src/minijava/syntaxtree/Goal.java new file mode 100644 index 0000000..9f8b0ae --- /dev/null +++ b/src/minijava/syntaxtree/Goal.java @@ -0,0 +1,43 @@ +// +// Generated by JTB 1.3.2 +//
+
+package minijava.syntaxtree;
+
+/**
+ * Grammar production:
+ * f0 -> MainClass()
+ * f1 -> ( TypeDeclaration() )*
+ * f2 -> <EOF>
+ */
+public class Goal implements Node {
+ public MainClass f0;
+ public NodeListOptional f1;
+ public NodeToken f2;
+
+ public Goal(MainClass n0, NodeListOptional n1, NodeToken n2) {
+ f0 = n0;
+ f1 = n1;
+ f2 = n2;
+ }
+
+ public Goal(MainClass n0, NodeListOptional n1) {
+ f0 = n0;
+ f1 = n1;
+ f2 = new NodeToken("");
+ }
+
+ public void accept(minijava.visitor.Visitor v) {
+ v.visit(this);
+ }
+ public <R,A> R accept(minijava.visitor.GJVisitor<R,A> v, A argu) {
+ return v.visit(this,argu);
+ }
+ public <R> R accept(minijava.visitor.GJNoArguVisitor<R> v) {
+ return v.visit(this);
+ }
+ public <A> void accept(minijava.visitor.GJVoidVisitor<A> v, A argu) {
+ v.visit(this,argu);
+ }
+}
+
diff --git a/src/minijava/syntaxtree/Identifier.java b/src/minijava/syntaxtree/Identifier.java new file mode 100644 index 0000000..c36e2ba --- /dev/null +++ b/src/minijava/syntaxtree/Identifier.java @@ -0,0 +1,31 @@ +// +// Generated by JTB 1.3.2 +//
+
+package minijava.syntaxtree;
+
+/**
+ * Grammar production:
+ * f0 -> <IDENTIFIER>
+ */
+public class Identifier implements Node {
+ public NodeToken f0;
+
+ public Identifier(NodeToken n0) {
+ f0 = n0;
+ }
+
+ public void accept(minijava.visitor.Visitor v) {
+ v.visit(this);
+ }
+ public <R,A> R accept(minijava.visitor.GJVisitor<R,A> v, A argu) {
+ return v.visit(this,argu);
+ }
+ public <R> R accept(minijava.visitor.GJNoArguVisitor<R> v) {
+ return v.visit(this);
+ }
+ public <A> void accept(minijava.visitor.GJVoidVisitor<A> v, A argu) {
+ v.visit(this,argu);
+ }
+}
+
diff --git a/src/minijava/syntaxtree/IfStatement.java b/src/minijava/syntaxtree/IfStatement.java new file mode 100644 index 0000000..9b67278 --- /dev/null +++ b/src/minijava/syntaxtree/IfStatement.java @@ -0,0 +1,59 @@ +// +// Generated by JTB 1.3.2 +//
+
+package minijava.syntaxtree;
+
+/**
+ * Grammar production:
+ * f0 -> "if"
+ * f1 -> "("
+ * f2 -> Expression()
+ * f3 -> ")"
+ * f4 -> Statement()
+ * f5 -> "else"
+ * f6 -> Statement()
+ */
+public class IfStatement implements Node {
+ public NodeToken f0;
+ public NodeToken f1;
+ public Expression f2;
+ public NodeToken f3;
+ public Statement f4;
+ public NodeToken f5;
+ public Statement f6;
+
+ public IfStatement(NodeToken n0, NodeToken n1, Expression n2, NodeToken n3, Statement n4, NodeToken n5, Statement n6) {
+ f0 = n0;
+ f1 = n1;
+ f2 = n2;
+ f3 = n3;
+ f4 = n4;
+ f5 = n5;
+ f6 = n6;
+ }
+
+ public IfStatement(Expression n0, Statement n1, Statement n2) {
+ f0 = new NodeToken("if");
+ f1 = new NodeToken("(");
+ f2 = n0;
+ f3 = new NodeToken(")");
+ f4 = n1;
+ f5 = new NodeToken("else");
+ f6 = n2;
+ }
+
+ public void accept(minijava.visitor.Visitor v) {
+ v.visit(this);
+ }
+ public <R,A> R accept(minijava.visitor.GJVisitor<R,A> v, A argu) {
+ return v.visit(this,argu);
+ }
+ public <R> R accept(minijava.visitor.GJNoArguVisitor<R> v) {
+ return v.visit(this);
+ }
+ public <A> void accept(minijava.visitor.GJVoidVisitor<A> v, A argu) {
+ v.visit(this,argu);
+ }
+}
+
diff --git a/src/minijava/syntaxtree/IntegerLiteral.java b/src/minijava/syntaxtree/IntegerLiteral.java new file mode 100644 index 0000000..2a1d25a --- /dev/null +++ b/src/minijava/syntaxtree/IntegerLiteral.java @@ -0,0 +1,31 @@ +// +// Generated by JTB 1.3.2 +//
+
+package minijava.syntaxtree;
+
+/**
+ * Grammar production:
+ * f0 -> <INTEGER_LITERAL>
+ */
+public class IntegerLiteral implements Node {
+ public NodeToken f0;
+
+ public IntegerLiteral(NodeToken n0) {
+ f0 = n0;
+ }
+
+ public void accept(minijava.visitor.Visitor v) {
+ v.visit(this);
+ }
+ public <R,A> R accept(minijava.visitor.GJVisitor<R,A> v, A argu) {
+ return v.visit(this,argu);
+ }
+ public <R> R accept(minijava.visitor.GJNoArguVisitor<R> v) {
+ return v.visit(this);
+ }
+ public <A> void accept(minijava.visitor.GJVoidVisitor<A> v, A argu) {
+ v.visit(this,argu);
+ }
+}
+
diff --git a/src/minijava/syntaxtree/IntegerType.java b/src/minijava/syntaxtree/IntegerType.java new file mode 100644 index 0000000..6c88bf1 --- /dev/null +++ b/src/minijava/syntaxtree/IntegerType.java @@ -0,0 +1,35 @@ +// +// Generated by JTB 1.3.2 +//
+
+package minijava.syntaxtree;
+
+/**
+ * Grammar production:
+ * f0 -> "int"
+ */
+public class IntegerType implements Node {
+ public NodeToken f0;
+
+ public IntegerType(NodeToken n0) {
+ f0 = n0;
+ }
+
+ public IntegerType() {
+ f0 = new NodeToken("int");
+ }
+
+ public void accept(minijava.visitor.Visitor v) {
+ v.visit(this);
+ }
+ public <R,A> R accept(minijava.visitor.GJVisitor<R,A> v, A argu) {
+ return v.visit(this,argu);
+ }
+ public <R> R accept(minijava.visitor.GJNoArguVisitor<R> v) {
+ return v.visit(this);
+ }
+ public <A> void accept(minijava.visitor.GJVoidVisitor<A> v, A argu) {
+ v.visit(this,argu);
+ }
+}
+
diff --git a/src/minijava/syntaxtree/MainClass.java b/src/minijava/syntaxtree/MainClass.java new file mode 100644 index 0000000..7a2e91f --- /dev/null +++ b/src/minijava/syntaxtree/MainClass.java @@ -0,0 +1,99 @@ +// +// Generated by JTB 1.3.2 +//
+
+package minijava.syntaxtree;
+
+/**
+ * Grammar production:
+ * f0 -> "class"
+ * f1 -> Identifier()
+ * f2 -> "{"
+ * f3 -> "public"
+ * f4 -> "static"
+ * f5 -> "void"
+ * f6 -> "main"
+ * f7 -> "("
+ * f8 -> "String"
+ * f9 -> "["
+ * f10 -> "]"
+ * f11 -> Identifier()
+ * f12 -> ")"
+ * f13 -> "{"
+ * f14 -> PrintStatement()
+ * f15 -> "}"
+ * f16 -> "}"
+ */
+public class MainClass implements Node {
+ public NodeToken f0;
+ public Identifier f1;
+ public NodeToken f2;
+ public NodeToken f3;
+ public NodeToken f4;
+ public NodeToken f5;
+ public NodeToken f6;
+ public NodeToken f7;
+ public NodeToken f8;
+ public NodeToken f9;
+ public NodeToken f10;
+ public Identifier f11;
+ public NodeToken f12;
+ public NodeToken f13;
+ public PrintStatement f14;
+ public NodeToken f15;
+ public NodeToken f16;
+
+ public MainClass(NodeToken n0, Identifier n1, NodeToken n2, NodeToken n3, NodeToken n4, NodeToken n5, NodeToken n6, NodeToken n7, NodeToken n8, NodeToken n9, NodeToken n10, Identifier n11, NodeToken n12, NodeToken n13, PrintStatement n14, NodeToken n15, NodeToken n16) {
+ f0 = n0;
+ f1 = n1;
+ f2 = n2;
+ f3 = n3;
+ f4 = n4;
+ f5 = n5;
+ f6 = n6;
+ f7 = n7;
+ f8 = n8;
+ f9 = n9;
+ f10 = n10;
+ f11 = n11;
+ f12 = n12;
+ f13 = n13;
+ f14 = n14;
+ f15 = n15;
+ f16 = n16;
+ }
+
+ public MainClass(Identifier n0, Identifier n1, PrintStatement n2) {
+ f0 = new NodeToken("class");
+ f1 = n0;
+ f2 = new NodeToken("{");
+ f3 = new NodeToken("public");
+ f4 = new NodeToken("static");
+ f5 = new NodeToken("void");
+ f6 = new NodeToken("main");
+ f7 = new NodeToken("(");
+ f8 = new NodeToken("String");
+ f9 = new NodeToken("[");
+ f10 = new NodeToken("]");
+ f11 = n1;
+ f12 = new NodeToken(")");
+ f13 = new NodeToken("{");
+ f14 = n2;
+ f15 = new NodeToken("}");
+ f16 = new NodeToken("}");
+ }
+
+ public void accept(minijava.visitor.Visitor v) {
+ v.visit(this);
+ }
+ public <R,A> R accept(minijava.visitor.GJVisitor<R,A> v, A argu) {
+ return v.visit(this,argu);
+ }
+ public <R> R accept(minijava.visitor.GJNoArguVisitor<R> v) {
+ return v.visit(this);
+ }
+ public <A> void accept(minijava.visitor.GJVoidVisitor<A> v, A argu) {
+ v.visit(this,argu);
+ }
+}
+
diff --git a/src/minijava/syntaxtree/MessageSend.java b/src/minijava/syntaxtree/MessageSend.java new file mode 100644 index 0000000..0828f52 --- /dev/null +++ b/src/minijava/syntaxtree/MessageSend.java @@ -0,0 +1,55 @@ +// +// Generated by JTB 1.3.2 +//
+
+package minijava.syntaxtree;
+
+/**
+ * Grammar production:
+ * f0 -> PrimaryExpression()
+ * f1 -> "."
+ * f2 -> Identifier()
+ * f3 -> "("
+ * f4 -> ( ExpressionList() )?
+ * f5 -> ")"
+ */
+public class MessageSend implements Node {
+ public PrimaryExpression f0;
+ public NodeToken f1;
+ public Identifier f2;
+ public NodeToken f3;
+ public NodeOptional f4;
+ public NodeToken f5;
+
+ public MessageSend(PrimaryExpression n0, NodeToken n1, Identifier n2, NodeToken n3, NodeOptional n4, NodeToken n5) {
+ f0 = n0;
+ f1 = n1;
+ f2 = n2;
+ f3 = n3;
+ f4 = n4;
+ f5 = n5;
+ }
+
+ public MessageSend(PrimaryExpression n0, Identifier n1, NodeOptional n2) {
+ f0 = n0;
+ f1 = new NodeToken(".");
+ f2 = n1;
+ f3 = new NodeToken("(");
+ f4 = n2;
+ f5 = new NodeToken(")");
+ }
+
+ public void accept(minijava.visitor.Visitor v) {
+ v.visit(this);
+ }
+ public <R,A> R accept(minijava.visitor.GJVisitor<R,A> v, A argu) {
+ return v.visit(this,argu);
+ }
+ public <R> R accept(minijava.visitor.GJNoArguVisitor<R> v) {
+ return v.visit(this);
+ }
+ public <A> void accept(minijava.visitor.GJVoidVisitor<A> v, A argu) {
+ v.visit(this,argu);
+ }
+}
+
diff --git a/src/minijava/syntaxtree/MethodDeclaration.java b/src/minijava/syntaxtree/MethodDeclaration.java new file mode 100644 index 0000000..f1caae2 --- /dev/null +++ b/src/minijava/syntaxtree/MethodDeclaration.java @@ -0,0 +1,83 @@ +// +// Generated by JTB 1.3.2 +//
+
+package minijava.syntaxtree;
+
+/**
+ * Grammar production:
+ * f0 -> "public"
+ * f1 -> Type()
+ * f2 -> Identifier()
+ * f3 -> "("
+ * f4 -> ( FormalParameterList() )?
+ * f5 -> ")"
+ * f6 -> "{"
+ * f7 -> ( VarDeclaration() )*
+ * f8 -> ( Statement() )*
+ * f9 -> "return"
+ * f10 -> Expression()
+ * f11 -> ";"
+ * f12 -> "}"
+ */
+public class MethodDeclaration implements Node {
+ public NodeToken f0;
+ public Type f1;
+ public Identifier f2;
+ public NodeToken f3;
+ public NodeOptional f4;
+ public NodeToken f5;
+ public NodeToken f6;
+ public NodeListOptional f7;
+ public NodeListOptional f8;
+ public NodeToken f9;
+ public Expression f10;
+ public NodeToken f11;
+ public NodeToken f12;
+
+ public MethodDeclaration(NodeToken n0, Type n1, Identifier n2, NodeToken n3, NodeOptional n4, NodeToken n5, NodeToken n6, NodeListOptional n7, NodeListOptional n8, NodeToken n9, Expression n10, NodeToken n11, NodeToken n12) {
+ f0 = n0;
+ f1 = n1;
+ f2 = n2;
+ f3 = n3;
+ f4 = n4;
+ f5 = n5;
+ f6 = n6;
+ f7 = n7;
+ f8 = n8;
+ f9 = n9;
+ f10 = n10;
+ f11 = n11;
+ f12 = n12;
+ }
+
+ public MethodDeclaration(Type n0, Identifier n1, NodeOptional n2, NodeListOptional n3, NodeListOptional n4, Expression n5) {
+ f0 = new NodeToken("public");
+ f1 = n0;
+ f2 = n1;
+ f3 = new NodeToken("(");
+ f4 = n2;
+ f5 = new NodeToken(")");
+ f6 = new NodeToken("{");
+ f7 = n3;
+ f8 = n4;
+ f9 = new NodeToken("return");
+ f10 = n5;
+ f11 = new NodeToken(";");
+ f12 = new NodeToken("}");
+ }
+
+ public void accept(minijava.visitor.Visitor v) {
+ v.visit(this);
+ }
+ public <R,A> R accept(minijava.visitor.GJVisitor<R,A> v, A argu) {
+ return v.visit(this,argu);
+ }
+ public <R> R accept(minijava.visitor.GJNoArguVisitor<R> v) {
+ return v.visit(this);
+ }
+ public <A> void accept(minijava.visitor.GJVoidVisitor<A> v, A argu) {
+ v.visit(this,argu);
+ }
+}
+
diff --git a/src/minijava/syntaxtree/MinusExpression.java b/src/minijava/syntaxtree/MinusExpression.java new file mode 100644 index 0000000..141f73b --- /dev/null +++ b/src/minijava/syntaxtree/MinusExpression.java @@ -0,0 +1,43 @@ +// +// Generated by JTB 1.3.2 +//
+
+package minijava.syntaxtree;
+
+/**
+ * Grammar production:
+ * f0 -> PrimaryExpression()
+ * f1 -> "-"
+ * f2 -> PrimaryExpression()
+ */
+public class MinusExpression implements Node {
+ public PrimaryExpression f0;
+ public NodeToken f1;
+ public PrimaryExpression f2;
+
+ public MinusExpression(PrimaryExpression n0, NodeToken n1, PrimaryExpression n2) {
+ f0 = n0;
+ f1 = n1;
+ f2 = n2;
+ }
+
+ public MinusExpression(PrimaryExpression n0, PrimaryExpression n1) {
+ f0 = n0;
+ f1 = new NodeToken("-");
+ f2 = n1;
+ }
+
+ public void accept(minijava.visitor.Visitor v) {
+ v.visit(this);
+ }
+ public <R,A> R accept(minijava.visitor.GJVisitor<R,A> v, A argu) {
+ return v.visit(this,argu);
+ }
+ public <R> R accept(minijava.visitor.GJNoArguVisitor<R> v) {
+ return v.visit(this);
+ }
+ public <A> void accept(minijava.visitor.GJVoidVisitor<A> v, A argu) {
+ v.visit(this,argu);
+ }
+}
+
diff --git a/src/minijava/syntaxtree/Node.java b/src/minijava/syntaxtree/Node.java new file mode 100644 index 0000000..2825b98 --- /dev/null +++ b/src/minijava/syntaxtree/Node.java @@ -0,0 +1,16 @@ +// +// Generated by JTB 1.3.2 +//
+
+package minijava.syntaxtree; + +/** + * The interface which all syntax tree classes must implement. + */ +public interface Node extends java.io.Serializable { + public void accept(minijava.visitor.Visitor v); + public <R,A> R accept(minijava.visitor.GJVisitor<R,A> v, A argu); + public <R> R accept(minijava.visitor.GJNoArguVisitor<R> v); + public <A> void accept(minijava.visitor.GJVoidVisitor<A> v, A argu); +} +
diff --git a/src/minijava/syntaxtree/NodeChoice.java b/src/minijava/syntaxtree/NodeChoice.java new file mode 100644 index 0000000..fc164cd --- /dev/null +++ b/src/minijava/syntaxtree/NodeChoice.java @@ -0,0 +1,36 @@ +// +// Generated by JTB 1.3.2 +//
+
+package minijava.syntaxtree; + +/** + * 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(minijava.visitor.Visitor v) { + choice.accept(v); + } + public <R,A> R accept(minijava.visitor.GJVisitor<R,A> v, A argu) { + return choice.accept(v,argu); + } + public <R> R accept(minijava.visitor.GJNoArguVisitor<R> v) { + return choice.accept(v); + } + public <A> void accept(minijava.visitor.GJVoidVisitor<A> v, A argu) { + choice.accept(v,argu); + } + + public Node choice; + public int which; +} +
diff --git a/src/minijava/syntaxtree/NodeList.java b/src/minijava/syntaxtree/NodeList.java new file mode 100644 index 0000000..e447306 --- /dev/null +++ b/src/minijava/syntaxtree/NodeList.java @@ -0,0 +1,45 @@ +// +// Generated by JTB 1.3.2 +//
+
+package minijava.syntaxtree; + +import java.util.Enumeration; +import java.util.Vector; + +/** + * Represents a grammar list, e.g. ( A )+ + */ +public class NodeList implements NodeListInterface { + public NodeList() { + nodes = new Vector<Node>(); + } + + public NodeList(Node firstNode) { + nodes = new Vector<Node>(); + addNode(firstNode); + } + + public void addNode(Node n) { + nodes.addElement(n); + } + + public Enumeration<Node> elements() { return nodes.elements(); } + public Node elementAt(int i) { return nodes.elementAt(i); } + public int size() { return nodes.size(); } + public void accept(minijava.visitor.Visitor v) { + v.visit(this); + } + public <R,A> R accept(minijava.visitor.GJVisitor<R,A> v, A argu) { + return v.visit(this,argu); + } + public <R> R accept(minijava.visitor.GJNoArguVisitor<R> v) { + return v.visit(this); + } + public <A> void accept(minijava.visitor.GJVoidVisitor<A> v, A argu) { + v.visit(this,argu); + } + + public Vector<Node> nodes; +} +
diff --git a/src/minijava/syntaxtree/NodeListInterface.java b/src/minijava/syntaxtree/NodeListInterface.java new file mode 100644 index 0000000..be433ee --- /dev/null +++ b/src/minijava/syntaxtree/NodeListInterface.java @@ -0,0 +1,22 @@ +// +// Generated by JTB 1.3.2 +//
+
+package minijava.syntaxtree; + +/** + * 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<Node> elements(); + public int size(); + + public void accept(minijava.visitor.Visitor v); + public <R,A> R accept(minijava.visitor.GJVisitor<R,A> v, A argu); + public <R> R accept(minijava.visitor.GJNoArguVisitor<R> v); + public <A> void accept(minijava.visitor.GJVoidVisitor<A> v, A argu); +} +
diff --git a/src/minijava/syntaxtree/NodeListOptional.java b/src/minijava/syntaxtree/NodeListOptional.java new file mode 100644 index 0000000..a89923e --- /dev/null +++ b/src/minijava/syntaxtree/NodeListOptional.java @@ -0,0 +1,46 @@ +// +// Generated by JTB 1.3.2 +//
+
+package minijava.syntaxtree; + +import java.util.Enumeration; +import java.util.Vector; + +/** + * Represents an optional grammar list, e.g. ( A )* + */ +public class NodeListOptional implements NodeListInterface { + public NodeListOptional() { + nodes = new Vector<Node>(); + } + + public NodeListOptional(Node firstNode) { + nodes = new Vector<Node>(); + addNode(firstNode); + } + + public void addNode(Node n) { + nodes.addElement(n); + } + + public Enumeration<Node> 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(minijava.visitor.Visitor v) { + v.visit(this); + } + public <R,A> R accept(minijava.visitor.GJVisitor<R,A> v, A argu) { + return v.visit(this,argu); + } + public <R> R accept(minijava.visitor.GJNoArguVisitor<R> v) { + return v.visit(this); + } + public <A> void accept(minijava.visitor.GJVoidVisitor<A> v, A argu) { + v.visit(this,argu); + } + + public Vector<Node> nodes; +} +
diff --git a/src/minijava/syntaxtree/NodeOptional.java b/src/minijava/syntaxtree/NodeOptional.java new file mode 100644 index 0000000..c88fa21 --- /dev/null +++ b/src/minijava/syntaxtree/NodeOptional.java @@ -0,0 +1,41 @@ +// +// Generated by JTB 1.3.2 +//
+
+package minijava.syntaxtree; + +/** + * 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(minijava.visitor.Visitor v) { + v.visit(this); + } + public <R,A> R accept(minijava.visitor.GJVisitor<R,A> v, A argu) { + return v.visit(this,argu); + } + public <R> R accept(minijava.visitor.GJNoArguVisitor<R> v) { + return v.visit(this); + } + public <A> void accept(minijava.visitor.GJVoidVisitor<A> v, A argu) { + v.visit(this,argu); + } + public boolean present() { return node != null; } + + public Node node; +} +
diff --git a/src/minijava/syntaxtree/NodeSequence.java b/src/minijava/syntaxtree/NodeSequence.java new file mode 100644 index 0000000..5e04993 --- /dev/null +++ b/src/minijava/syntaxtree/NodeSequence.java @@ -0,0 +1,46 @@ +// +// Generated by JTB 1.3.2 +//
+
+package minijava.syntaxtree; + +import java.util.Enumeration; +import java.util.Vector; + +/** + * 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<Node>(n); + } + + public NodeSequence(Node firstNode) { + nodes = new Vector<Node>(); + addNode(firstNode); + } + + public void addNode(Node n) { + nodes.addElement(n); + } + + public Node elementAt(int i) { return nodes.elementAt(i); } + public Enumeration<Node> elements() { return nodes.elements(); } + public int size() { return nodes.size(); } + public void accept(minijava.visitor.Visitor v) { + v.visit(this); + } + public <R,A> R accept(minijava.visitor.GJVisitor<R,A> v, A argu) { + return v.visit(this,argu); + } + public <R> R accept(minijava.visitor.GJNoArguVisitor<R> v) { + return v.visit(this); + } + public <A> void accept(minijava.visitor.GJVoidVisitor<A> v, A argu) { + v.visit(this,argu); + } + + public Vector<Node> nodes; +} +
diff --git a/src/minijava/syntaxtree/NodeToken.java b/src/minijava/syntaxtree/NodeToken.java new file mode 100644 index 0000000..eb20b7b --- /dev/null +++ b/src/minijava/syntaxtree/NodeToken.java @@ -0,0 +1,88 @@ +// +// Generated by JTB 1.3.2 +//
+
+package minijava.syntaxtree; + +import java.util.Enumeration; +import java.util.Vector; +/** + * 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<NodeToken>(); + 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<NodeToken> e = specialTokens.elements(); e.hasMoreElements(); ) + buf.append(e.nextElement().toString()); + + buf.append(tokenImage); + return buf.toString(); + } + + public void accept(minijava.visitor.Visitor v) { + v.visit(this); + } + public <R,A> R accept(minijava.visitor.GJVisitor<R,A> v, A argu) { + return v.visit(this,argu); + } + public <R> R accept(minijava.visitor.GJNoArguVisitor<R> v) { + return v.visit(this); + } + public <A> void accept(minijava.visitor.GJVoidVisitor<A> v, A argu) { + v.visit(this,argu); + } + + public String tokenImage; + + // Stores a list of NodeTokens + public Vector<NodeToken> 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/minijava/syntaxtree/NotExpression.java b/src/minijava/syntaxtree/NotExpression.java new file mode 100644 index 0000000..015a51e --- /dev/null +++ b/src/minijava/syntaxtree/NotExpression.java @@ -0,0 +1,39 @@ +// +// Generated by JTB 1.3.2 +//
+
+package minijava.syntaxtree;
+
+/**
+ * Grammar production:
+ * f0 -> "!"
+ * f1 -> Expression()
+ */
+public class NotExpression implements Node {
+ public NodeToken f0;
+ public Expression f1;
+
+ public NotExpression(NodeToken n0, Expression n1) {
+ f0 = n0;
+ f1 = n1;
+ }
+
+ public NotExpression(Expression n0) {
+ f0 = new NodeToken("!");
+ f1 = n0;
+ }
+
+ public void accept(minijava.visitor.Visitor v) {
+ v.visit(this);
+ }
+ public <R,A> R accept(minijava.visitor.GJVisitor<R,A> v, A argu) {
+ return v.visit(this,argu);
+ }
+ public <R> R accept(minijava.visitor.GJNoArguVisitor<R> v) {
+ return v.visit(this);
+ }
+ public <A> void accept(minijava.visitor.GJVoidVisitor<A> v, A argu) {
+ v.visit(this,argu);
+ }
+}
+
diff --git a/src/minijava/syntaxtree/PlusExpression.java b/src/minijava/syntaxtree/PlusExpression.java new file mode 100644 index 0000000..5448ad1 --- /dev/null +++ b/src/minijava/syntaxtree/PlusExpression.java @@ -0,0 +1,43 @@ +// +// Generated by JTB 1.3.2 +//
+
+package minijava.syntaxtree;
+
+/**
+ * Grammar production:
+ * f0 -> PrimaryExpression()
+ * f1 -> "+"
+ * f2 -> PrimaryExpression()
+ */
+public class PlusExpression implements Node {
+ public PrimaryExpression f0;
+ public NodeToken f1;
+ public PrimaryExpression f2;
+
+ public PlusExpression(PrimaryExpression n0, NodeToken n1, PrimaryExpression n2) {
+ f0 = n0;
+ f1 = n1;
+ f2 = n2;
+ }
+
+ public PlusExpression(PrimaryExpression n0, PrimaryExpression n1) {
+ f0 = n0;
+ f1 = new NodeToken("+");
+ f2 = n1;
+ }
+
+ public void accept(minijava.visitor.Visitor v) {
+ v.visit(this);
+ }
+ public <R,A> R accept(minijava.visitor.GJVisitor<R,A> v, A argu) {
+ return v.visit(this,argu);
+ }
+ public <R> R accept(minijava.visitor.GJNoArguVisitor<R> v) {
+ return v.visit(this);
+ }
+ public <A> void accept(minijava.visitor.GJVoidVisitor<A> v, A argu) {
+ v.visit(this,argu);
+ }
+}
+
diff --git a/src/minijava/syntaxtree/PrimaryExpression.java b/src/minijava/syntaxtree/PrimaryExpression.java new file mode 100644 index 0000000..04e90a8 --- /dev/null +++ b/src/minijava/syntaxtree/PrimaryExpression.java @@ -0,0 +1,39 @@ +// +// Generated by JTB 1.3.2 +//
+
+package minijava.syntaxtree;
+
+/**
+ * Grammar production:
+ * f0 -> IntegerLiteral()
+ * | TrueLiteral()
+ * | FalseLiteral()
+ * | Identifier()
+ * | ThisExpression()
+ * | ArrayAllocationExpression()
+ * | AllocationExpression()
+ * | NotExpression()
+ * | BracketExpression()
+ */
+public class PrimaryExpression implements Node {
+ public NodeChoice f0;
+
+ public PrimaryExpression(NodeChoice n0) {
+ f0 = n0;
+ }
+
+ public void accept(minijava.visitor.Visitor v) {
+ v.visit(this);
+ }
+ public <R,A> R accept(minijava.visitor.GJVisitor<R,A> v, A argu) {
+ return v.visit(this,argu);
+ }
+ public <R> R accept(minijava.visitor.GJNoArguVisitor<R> v) {
+ return v.visit(this);
+ }
+ public <A> void accept(minijava.visitor.GJVoidVisitor<A> v, A argu) {
+ v.visit(this,argu);
+ }
+}
+
diff --git a/src/minijava/syntaxtree/PrintStatement.java b/src/minijava/syntaxtree/PrintStatement.java new file mode 100644 index 0000000..15bbbba --- /dev/null +++ b/src/minijava/syntaxtree/PrintStatement.java @@ -0,0 +1,51 @@ +// +// Generated by JTB 1.3.2 +//
+
+package minijava.syntaxtree;
+
+/**
+ * Grammar production:
+ * f0 -> "System.out.println"
+ * f1 -> "("
+ * f2 -> Expression()
+ * f3 -> ")"
+ * f4 -> ";"
+ */
+public class PrintStatement implements Node {
+ public NodeToken f0;
+ public NodeToken f1;
+ public Expression f2;
+ public NodeToken f3;
+ public NodeToken f4;
+
+ public PrintStatement(NodeToken n0, NodeToken n1, Expression n2, NodeToken n3, NodeToken n4) {
+ f0 = n0;
+ f1 = n1;
+ f2 = n2;
+ f3 = n3;
+ f4 = n4;
+ }
+
+ public PrintStatement(Expression n0) {
+ f0 = new NodeToken("System.out.println");
+ f1 = new NodeToken("(");
+ f2 = n0;
+ f3 = new NodeToken(")");
+ f4 = new NodeToken(";");
+ }
+
+ public void accept(minijava.visitor.Visitor v) {
+ v.visit(this);
+ }
+ public <R,A> R accept(minijava.visitor.GJVisitor<R,A> v, A argu) {
+ return v.visit(this,argu);
+ }
+ public <R> R accept(minijava.visitor.GJNoArguVisitor<R> v) {
+ return v.visit(this);
+ }
+ public <A> void accept(minijava.visitor.GJVoidVisitor<A> v, A argu) {
+ v.visit(this,argu);
+ }
+}
+
diff --git a/src/minijava/syntaxtree/Statement.java b/src/minijava/syntaxtree/Statement.java new file mode 100644 index 0000000..db2c5d3 --- /dev/null +++ b/src/minijava/syntaxtree/Statement.java @@ -0,0 +1,36 @@ +// +// Generated by JTB 1.3.2 +//
+
+package minijava.syntaxtree;
+
+/**
+ * Grammar production:
+ * f0 -> Block()
+ * | AssignmentStatement()
+ * | ArrayAssignmentStatement()
+ * | IfStatement()
+ * | WhileStatement()
+ * | PrintStatement()
+ */
+public class Statement implements Node {
+ public NodeChoice f0;
+
+ public Statement(NodeChoice n0) {
+ f0 = n0;
+ }
+
+ public void accept(minijava.visitor.Visitor v) {
+ v.visit(this);
+ }
+ public <R,A> R accept(minijava.visitor.GJVisitor<R,A> v, A argu) {
+ return v.visit(this,argu);
+ }
+ public <R> R accept(minijava.visitor.GJNoArguVisitor<R> v) {
+ return v.visit(this);
+ }
+ public <A> void accept(minijava.visitor.GJVoidVisitor<A> v, A argu) {
+ v.visit(this,argu);
+ }
+}
+
diff --git a/src/minijava/syntaxtree/ThisExpression.java b/src/minijava/syntaxtree/ThisExpression.java new file mode 100644 index 0000000..cfb0d97 --- /dev/null +++ b/src/minijava/syntaxtree/ThisExpression.java @@ -0,0 +1,35 @@ +// +// Generated by JTB 1.3.2 +//
+
+package minijava.syntaxtree;
+
+/**
+ * Grammar production:
+ * f0 -> "this"
+ */
+public class ThisExpression implements Node {
+ public NodeToken f0;
+
+ public ThisExpression(NodeToken n0) {
+ f0 = n0;
+ }
+
+ public ThisExpression() {
+ f0 = new NodeToken("this");
+ }
+
+ public void accept(minijava.visitor.Visitor v) {
+ v.visit(this);
+ }
+ public <R,A> R accept(minijava.visitor.GJVisitor<R,A> v, A argu) {
+ return v.visit(this,argu);
+ }
+ public <R> R accept(minijava.visitor.GJNoArguVisitor<R> v) {
+ return v.visit(this);
+ }
+ public <A> void accept(minijava.visitor.GJVoidVisitor<A> v, A argu) {
+ v.visit(this,argu);
+ }
+}
+
diff --git a/src/minijava/syntaxtree/TimesExpression.java b/src/minijava/syntaxtree/TimesExpression.java new file mode 100644 index 0000000..fa38fd0 --- /dev/null +++ b/src/minijava/syntaxtree/TimesExpression.java @@ -0,0 +1,43 @@ +// +// Generated by JTB 1.3.2 +//
+
+package minijava.syntaxtree;
+
+/**
+ * Grammar production:
+ * f0 -> PrimaryExpression()
+ * f1 -> "*"
+ * f2 -> PrimaryExpression()
+ */
+public class TimesExpression implements Node {
+ public PrimaryExpression f0;
+ public NodeToken f1;
+ public PrimaryExpression f2;
+
+ public TimesExpression(PrimaryExpression n0, NodeToken n1, PrimaryExpression n2) {
+ f0 = n0;
+ f1 = n1;
+ f2 = n2;
+ }
+
+ public TimesExpression(PrimaryExpression n0, PrimaryExpression n1) {
+ f0 = n0;
+ f1 = new NodeToken("*");
+ f2 = n1;
+ }
+
+ public void accept(minijava.visitor.Visitor v) {
+ v.visit(this);
+ }
+ public <R,A> R accept(minijava.visitor.GJVisitor<R,A> v, A argu) {
+ return v.visit(this,argu);
+ }
+ public <R> R accept(minijava.visitor.GJNoArguVisitor<R> v) {
+ return v.visit(this);
+ }
+ public <A> void accept(minijava.visitor.GJVoidVisitor<A> v, A argu) {
+ v.visit(this,argu);
+ }
+}
+
diff --git a/src/minijava/syntaxtree/TrueLiteral.java b/src/minijava/syntaxtree/TrueLiteral.java new file mode 100644 index 0000000..6d9b04d --- /dev/null +++ b/src/minijava/syntaxtree/TrueLiteral.java @@ -0,0 +1,35 @@ +// +// Generated by JTB 1.3.2 +//
+
+package minijava.syntaxtree;
+
+/**
+ * Grammar production:
+ * f0 -> "true"
+ */
+public class TrueLiteral implements Node {
+ public NodeToken f0;
+
+ public TrueLiteral(NodeToken n0) {
+ f0 = n0;
+ }
+
+ public TrueLiteral() {
+ f0 = new NodeToken("true");
+ }
+
+ public void accept(minijava.visitor.Visitor v) {
+ v.visit(this);
+ }
+ public <R,A> R accept(minijava.visitor.GJVisitor<R,A> v, A argu) {
+ return v.visit(this,argu);
+ }
+ public <R> R accept(minijava.visitor.GJNoArguVisitor<R> v) {
+ return v.visit(this);
+ }
+ public <A> void accept(minijava.visitor.GJVoidVisitor<A> v, A argu) {
+ v.visit(this,argu);
+ }
+}
+
diff --git a/src/minijava/syntaxtree/Type.java b/src/minijava/syntaxtree/Type.java new file mode 100644 index 0000000..2c6980b --- /dev/null +++ b/src/minijava/syntaxtree/Type.java @@ -0,0 +1,34 @@ +// +// Generated by JTB 1.3.2 +//
+
+package minijava.syntaxtree;
+
+/**
+ * Grammar production:
+ * f0 -> ArrayType()
+ * | BooleanType()
+ * | IntegerType()
+ * | Identifier()
+ */
+public class Type implements Node {
+ public NodeChoice f0;
+
+ public Type(NodeChoice n0) {
+ f0 = n0;
+ }
+
+ public void accept(minijava.visitor.Visitor v) {
+ v.visit(this);
+ }
+ public <R,A> R accept(minijava.visitor.GJVisitor<R,A> v, A argu) {
+ return v.visit(this,argu);
+ }
+ public <R> R accept(minijava.visitor.GJNoArguVisitor<R> v) {
+ return v.visit(this);
+ }
+ public <A> void accept(minijava.visitor.GJVoidVisitor<A> v, A argu) {
+ v.visit(this,argu);
+ }
+}
+
diff --git a/src/minijava/syntaxtree/TypeDeclaration.java b/src/minijava/syntaxtree/TypeDeclaration.java new file mode 100644 index 0000000..6c895f2 --- /dev/null +++ b/src/minijava/syntaxtree/TypeDeclaration.java @@ -0,0 +1,32 @@ +// +// Generated by JTB 1.3.2 +//
+
+package minijava.syntaxtree;
+
+/**
+ * Grammar production:
+ * f0 -> ClassDeclaration()
+ * | ClassExtendsDeclaration()
+ */
+public class TypeDeclaration implements Node {
+ public NodeChoice f0;
+
+ public TypeDeclaration(NodeChoice n0) {
+ f0 = n0;
+ }
+
+ public void accept(minijava.visitor.Visitor v) {
+ v.visit(this);
+ }
+ public <R,A> R accept(minijava.visitor.GJVisitor<R,A> v, A argu) {
+ return v.visit(this,argu);
+ }
+ public <R> R accept(minijava.visitor.GJNoArguVisitor<R> v) {
+ return v.visit(this);
+ }
+ public <A> void accept(minijava.visitor.GJVoidVisitor<A> v, A argu) {
+ v.visit(this,argu);
+ }
+}
+
diff --git a/src/minijava/syntaxtree/VarDeclaration.java b/src/minijava/syntaxtree/VarDeclaration.java new file mode 100644 index 0000000..db5198f --- /dev/null +++ b/src/minijava/syntaxtree/VarDeclaration.java @@ -0,0 +1,43 @@ +// +// Generated by JTB 1.3.2 +//
+
+package minijava.syntaxtree;
+
+/**
+ * Grammar production:
+ * f0 -> Type()
+ * f1 -> Identifier()
+ * f2 -> ";"
+ */
+public class VarDeclaration implements Node {
+ public Type f0;
+ public Identifier f1;
+ public NodeToken f2;
+
+ public VarDeclaration(Type n0, Identifier n1, NodeToken n2) {
+ f0 = n0;
+ f1 = n1;
+ f2 = n2;
+ }
+
+ public VarDeclaration(Type n0, Identifier n1) {
+ f0 = n0;
+ f1 = n1;
+ f2 = new NodeToken(";");
+ }
+
+ public void accept(minijava.visitor.Visitor v) {
+ v.visit(this);
+ }
+ public <R,A> R accept(minijava.visitor.GJVisitor<R,A> v, A argu) {
+ return v.visit(this,argu);
+ }
+ public <R> R accept(minijava.visitor.GJNoArguVisitor<R> v) {
+ return v.visit(this);
+ }
+ public <A> void accept(minijava.visitor.GJVoidVisitor<A> v, A argu) {
+ v.visit(this,argu);
+ }
+}
+
diff --git a/src/minijava/syntaxtree/WhileStatement.java b/src/minijava/syntaxtree/WhileStatement.java new file mode 100644 index 0000000..e0983e6 --- /dev/null +++ b/src/minijava/syntaxtree/WhileStatement.java @@ -0,0 +1,51 @@ +// +// Generated by JTB 1.3.2 +//
+
+package minijava.syntaxtree;
+
+/**
+ * Grammar production:
+ * f0 -> "while"
+ * f1 -> "("
+ * f2 -> Expression()
+ * f3 -> ")"
+ * f4 -> Statement()
+ */
+public class WhileStatement implements Node {
+ public NodeToken f0;
+ public NodeToken f1;
+ public Expression f2;
+ public NodeToken f3;
+ public Statement f4;
+
+ public WhileStatement(NodeToken n0, NodeToken n1, Expression n2, NodeToken n3, Statement n4) {
+ f0 = n0;
+ f1 = n1;
+ f2 = n2;
+ f3 = n3;
+ f4 = n4;
+ }
+
+ public WhileStatement(Expression n0, Statement n1) {
+ f0 = new NodeToken("while");
+ f1 = new NodeToken("(");
+ f2 = n0;
+ f3 = new NodeToken(")");
+ f4 = n1;
+ }
+
+ public void accept(minijava.visitor.Visitor v) {
+ v.visit(this);
+ }
+ public <R,A> R accept(minijava.visitor.GJVisitor<R,A> v, A argu) {
+ return v.visit(this,argu);
+ }
+ public <R> R accept(minijava.visitor.GJNoArguVisitor<R> v) {
+ return v.visit(this);
+ }
+ public <A> void accept(minijava.visitor.GJVoidVisitor<A> v, A argu) {
+ v.visit(this,argu);
+ }
+}
+
|