diff --git a/docs/PA2.pdf b/docs/PA2.pdf
new file mode 100644
index 0000000..895503d
Binary files /dev/null and b/docs/PA2.pdf differ
diff --git a/miniJava/src/miniJava/AbstractSyntaxTrees/AST.java b/miniJava/src/miniJava/AbstractSyntaxTrees/AST.java
new file mode 100644
index 0000000..f7f5194
--- /dev/null
+++ b/miniJava/src/miniJava/AbstractSyntaxTrees/AST.java
@@ -0,0 +1,27 @@
+/**
+ * miniJava Abstract Syntax Tree classes
+ * @author prins
+ * @version COMP 520 (v2.2)
+ */
+package miniJava.AbstractSyntaxTrees;
+
+import miniJava.SyntacticAnalyzer.SourcePosition;
+
+public abstract class AST {
+
+ public AST (SourcePosition posn) {
+ this.posn = posn;
+ }
+
+ public String toString() {
+ String fullClassName = this.getClass().getName();
+ String cn = fullClassName.substring(1 + fullClassName.lastIndexOf('.'));
+ if (ASTDisplay.showPosition)
+ cn = cn + " " + posn.toString();
+ return cn;
+ }
+
+ public abstract R visit(Visitor v, A o);
+
+ public SourcePosition posn;
+}
diff --git a/miniJava/src/miniJava/AbstractSyntaxTrees/ASTDisplay.java b/miniJava/src/miniJava/AbstractSyntaxTrees/ASTDisplay.java
new file mode 100644
index 0000000..be328a3
--- /dev/null
+++ b/miniJava/src/miniJava/AbstractSyntaxTrees/ASTDisplay.java
@@ -0,0 +1,353 @@
+/**
+ * miniJava Abstract Syntax Tree classes
+ * @author prins
+ * @version COMP 520 (v2.2)
+ */
+package miniJava.AbstractSyntaxTrees;
+
+/*
+ * Display AST in text form
+ * In-order traversal of AST, visiting each node with a method of the form
+ *
+ * public Object visitXXX( XXX astnode, String arg)
+ *
+ * where arg is a prefix string (indentation) to precede display of ast node
+ * and a null Object is returned as the result.
+ *
+ * implements Visitor
+ */
+public class ASTDisplay implements Visitor {
+
+ public static boolean showPosition = false;
+
+ /**
+ * print text representation of AST to stdout
+ * @param ast root node of AST
+ */
+ public void showTree(AST ast){
+ System.out.println("======= AST Display =========================");
+ ast.visit(this, "");
+ System.out.println("=============================================");
+ }
+
+ // methods to format output
+
+ /**
+ * display arbitrary text for a node
+ * @param prefix spacing to indicate depth in AST
+ * @param text preformatted node display
+ */
+ private void show(String prefix, String text) {
+ System.out.println(prefix + text);
+ }
+
+ /**
+ * display AST node by name
+ * @param prefix spacing to indicate depth in AST
+ * @param node AST node, will be shown by name
+ */
+ private void show(String prefix, AST node) {
+ System.out.println(prefix + node.toString());
+ }
+
+ /**
+ * quote a string
+ * @param text string to quote
+ */
+ private String quote(String text) {
+ return ("\"" + text + "\"");
+ }
+
+ /**
+ * increase depth in AST
+ * @param prefix current spacing to indicate depth in AST
+ * @return new spacing
+ */
+ private String indent(String prefix) {
+ return prefix + " ";
+ }
+
+
+ ///////////////////////////////////////////////////////////////////////////////
+ //
+ // PACKAGE
+ //
+ ///////////////////////////////////////////////////////////////////////////////
+
+ public Object visitPackage(Package prog, String arg){
+ show(arg, prog);
+ ClassDeclList cl = prog.classDeclList;
+ show(arg," ClassDeclList [" + cl.size() + "]");
+ String pfx = arg + " . ";
+ for (ClassDecl c: prog.classDeclList){
+ c.visit(this, pfx);
+ }
+ return null;
+ }
+
+
+ ///////////////////////////////////////////////////////////////////////////////
+ //
+ // DECLARATIONS
+ //
+ ///////////////////////////////////////////////////////////////////////////////
+
+ public Object visitClassDecl(ClassDecl clas, String arg){
+ show(arg, clas);
+ show(indent(arg), quote(clas.name) + " classname");
+ show(arg," FieldDeclList [" + clas.fieldDeclList.size() + "]");
+ String pfx = arg + " . ";
+ for (FieldDecl f: clas.fieldDeclList)
+ f.visit(this, pfx);
+ show(arg," MethodDeclList [" + clas.methodDeclList.size() + "]");
+ for (MethodDecl m: clas.methodDeclList)
+ m.visit(this, pfx);
+ return null;
+ }
+
+ public Object visitFieldDecl(FieldDecl f, String arg){
+ show(arg, "(" + (f.isPrivate ? "private": "public")
+ + (f.isStatic ? " static) " :") ") + f.toString());
+ f.type.visit(this, indent(arg));
+ show(indent(arg), quote(f.name) + " fieldname");
+ return null;
+ }
+
+ public Object visitMethodDecl(MethodDecl m, String arg){
+ show(arg, "(" + (m.isPrivate ? "private": "public")
+ + (m.isStatic ? " static) " :") ") + m.toString());
+ m.type.visit(this, indent(arg));
+ show(indent(arg), quote(m.name) + " methodname");
+ ParameterDeclList pdl = m.parameterDeclList;
+ show(arg, " ParameterDeclList [" + pdl.size() + "]");
+ String pfx = ((String) arg) + " . ";
+ for (ParameterDecl pd: pdl) {
+ pd.visit(this, pfx);
+ }
+ StatementList sl = m.statementList;
+ show(arg, " StmtList [" + sl.size() + "]");
+ for (Statement s: sl) {
+ s.visit(this, pfx);
+ }
+ if (m.returnExp != null) {
+ m.returnExp.visit(this, indent(arg));
+ }
+ return null;
+ }
+
+ public Object visitParameterDecl(ParameterDecl pd, String arg){
+ show(arg, pd);
+ pd.type.visit(this, indent(arg));
+ show(indent(arg), quote(pd.name) + "parametername ");
+ return null;
+ }
+
+ public Object visitVarDecl(VarDecl vd, String arg){
+ show(arg, vd);
+ vd.type.visit(this, indent(arg));
+ show(indent(arg), quote(vd.name) + " varname");
+ return null;
+ }
+
+
+ ///////////////////////////////////////////////////////////////////////////////
+ //
+ // TYPES
+ //
+ ///////////////////////////////////////////////////////////////////////////////
+
+ public Object visitBaseType(BaseType type, String arg){
+ show(arg, type.typeKind + " " + type.toString());
+ return null;
+ }
+
+ public Object visitClassType(ClassType type, String arg){
+ show(arg, type);
+ show(indent(arg), quote(type.className.spelling) + " classname");
+ return null;
+ }
+
+ public Object visitArrayType(ArrayType type, String arg){
+ show(arg, type);
+ type.eltType.visit(this, indent(arg));
+ return null;
+ }
+
+
+ ///////////////////////////////////////////////////////////////////////////////
+ //
+ // STATEMENTS
+ //
+ ///////////////////////////////////////////////////////////////////////////////
+
+ public Object visitBlockStmt(BlockStmt stmt, String arg){
+ show(arg, stmt);
+ StatementList sl = stmt.sl;
+ show(arg," StatementList [" + sl.size() + "]");
+ String pfx = arg + " . ";
+ for (Statement s: sl) {
+ s.visit(this, pfx);
+ }
+ return null;
+ }
+
+ public Object visitVardeclStmt(VarDeclStmt stmt, String arg){
+ show(arg, stmt);
+ stmt.varDecl.visit(this, indent(arg));
+ stmt.initExp.visit(this, indent(arg));
+ return null;
+ }
+
+ public Object visitAssignStmt(AssignStmt stmt, String arg){
+ show(arg,stmt);
+ stmt.ref.visit(this, indent(arg));
+ stmt.val.visit(this, indent(arg));
+ return null;
+ }
+
+ public Object visitCallStmt(CallStmt stmt, String arg){
+ show(arg,stmt);
+ stmt.methodRef.visit(this, indent(arg));
+ ExprList al = stmt.argList;
+ show(arg," ExprList [" + al.size() + "]");
+ String pfx = arg + " . ";
+ for (Expression e: al) {
+ e.visit(this, pfx);
+ }
+ return null;
+ }
+
+ public Object visitIfStmt(IfStmt stmt, String arg){
+ show(arg,stmt);
+ stmt.cond.visit(this, indent(arg));
+ stmt.thenStmt.visit(this, indent(arg));
+ if (stmt.elseStmt != null)
+ stmt.elseStmt.visit(this, indent(arg));
+ return null;
+ }
+
+ public Object visitWhileStmt(WhileStmt stmt, String arg){
+ show(arg, stmt);
+ stmt.cond.visit(this, indent(arg));
+ stmt.body.visit(this, indent(arg));
+ return null;
+ }
+
+
+ ///////////////////////////////////////////////////////////////////////////////
+ //
+ // EXPRESSIONS
+ //
+ ///////////////////////////////////////////////////////////////////////////////
+
+ public Object visitUnaryExpr(UnaryExpr expr, String arg){
+ show(arg, expr);
+ expr.operator.visit(this, indent(arg));
+ expr.expr.visit(this, indent(indent(arg)));
+ return null;
+ }
+
+ public Object visitBinaryExpr(BinaryExpr expr, String arg){
+ show(arg, expr);
+ expr.operator.visit(this, indent(arg));
+ expr.left.visit(this, indent(indent(arg)));
+ expr.right.visit(this, indent(indent(arg)));
+ return null;
+ }
+
+ public Object visitRefExpr(RefExpr expr, String arg){
+ show(arg, expr);
+ expr.ref.visit(this, indent(arg));
+ return null;
+ }
+
+ public Object visitCallExpr(CallExpr expr, String arg){
+ show(arg, expr);
+ expr.functionRef.visit(this, indent(arg));
+ ExprList al = expr.argList;
+ show(arg," ExprList + [" + al.size() + "]");
+ String pfx = arg + " . ";
+ for (Expression e: al) {
+ e.visit(this, pfx);
+ }
+ return null;
+ }
+
+ public Object visitLiteralExpr(LiteralExpr expr, String arg){
+ show(arg, expr);
+ expr.literal.visit(this, indent(arg));
+ return null;
+ }
+
+ public Object visitNewArrayExpr(NewArrayExpr expr, String arg){
+ show(arg, expr);
+ expr.eltType.visit(this, indent(arg));
+ expr.sizeExpr.visit(this, indent(arg));
+ return null;
+ }
+
+ public Object visitNewObjectExpr(NewObjectExpr expr, String arg){
+ show(arg, expr);
+ expr.classtype.visit(this, indent(arg));
+ return null;
+ }
+
+
+ ///////////////////////////////////////////////////////////////////////////////
+ //
+ // REFERENCES
+ //
+ ///////////////////////////////////////////////////////////////////////////////
+
+ public Object visitQualifiedRef(QualifiedRef qr, String arg) {
+ show(arg, qr);
+ qr.id.visit(this, indent(arg));
+ qr.ref.visit(this, indent(arg));
+ return null;
+ }
+
+ public Object visitIndexedRef(IndexedRef ir, String arg) {
+ show(arg, ir);
+ ir.indexExpr.visit(this, indent(arg));
+ ir.ref.visit(this, indent(arg));
+ return null;
+ }
+
+ public Object visitIdRef(IdRef ref, String arg) {
+ show(arg,ref);
+ ref.id.visit(this, indent(arg));
+ return null;
+ }
+
+ public Object visitThisRef(ThisRef ref, String arg) {
+ show(arg,ref);
+ return null;
+ }
+
+
+ ///////////////////////////////////////////////////////////////////////////////
+ //
+ // TERMINALS
+ //
+ ///////////////////////////////////////////////////////////////////////////////
+
+ public Object visitIdentifier(Identifier id, String arg){
+ show(arg, quote(id.spelling) + " " + id.toString());
+ return null;
+ }
+
+ public Object visitOperator(Operator op, String arg){
+ show(arg, quote(op.spelling) + " " + op.toString());
+ return null;
+ }
+
+ public Object visitIntLiteral(IntLiteral num, String arg){
+ show(arg, quote(num.spelling) + " " + num.toString());
+ return null;
+ }
+
+ public Object visitBooleanLiteral(BooleanLiteral bool, String arg){
+ show(arg, quote(bool.spelling) + " " + bool.toString());
+ return null;
+ }
+}
diff --git a/miniJava/src/miniJava/AbstractSyntaxTrees/ArrayType.java b/miniJava/src/miniJava/AbstractSyntaxTrees/ArrayType.java
new file mode 100644
index 0000000..d8a5358
--- /dev/null
+++ b/miniJava/src/miniJava/AbstractSyntaxTrees/ArrayType.java
@@ -0,0 +1,24 @@
+/**
+ * miniJava Abstract Syntax Tree classes
+ * @author prins
+ * @version COMP 520 (v2.2)
+ */
+
+package miniJava.AbstractSyntaxTrees;
+
+import miniJava.SyntacticAnalyzer.SourcePosition;
+
+public class ArrayType extends Type {
+
+ public ArrayType(Type eltType, SourcePosition posn){
+ super(TypeKind.ARRAY, posn);
+ this.eltType = eltType;
+ }
+
+ public R visit(Visitor v, A o) {
+ return v.visitArrayType(this, o);
+ }
+
+ public Type eltType;
+ }
+
diff --git a/miniJava/src/miniJava/AbstractSyntaxTrees/AssignStmt.java b/miniJava/src/miniJava/AbstractSyntaxTrees/AssignStmt.java
new file mode 100644
index 0000000..1a6db99
--- /dev/null
+++ b/miniJava/src/miniJava/AbstractSyntaxTrees/AssignStmt.java
@@ -0,0 +1,24 @@
+/**
+ * miniJava Abstract Syntax Tree classes
+ * @author prins
+ * @version COMP 520 (v2.2)
+ */
+package miniJava.AbstractSyntaxTrees;
+
+import miniJava.SyntacticAnalyzer.SourcePosition;
+
+public class AssignStmt extends Statement
+{
+ public AssignStmt(Reference r, Expression e, SourcePosition posn){
+ super(posn);
+ ref = r;
+ val = e;
+ }
+
+ public R visit(Visitor v, A o) {
+ return v.visitAssignStmt(this, o);
+ }
+
+ public Reference ref;
+ public Expression val;
+}
\ No newline at end of file
diff --git a/miniJava/src/miniJava/AbstractSyntaxTrees/BaseType.java b/miniJava/src/miniJava/AbstractSyntaxTrees/BaseType.java
new file mode 100644
index 0000000..38ad09f
--- /dev/null
+++ b/miniJava/src/miniJava/AbstractSyntaxTrees/BaseType.java
@@ -0,0 +1,19 @@
+/**
+ * miniJava Abstract Syntax Tree classes
+ * @author prins
+ * @version COMP 520 (v2.2)
+ */
+package miniJava.AbstractSyntaxTrees;
+
+import miniJava.SyntacticAnalyzer.SourcePosition;
+
+public class BaseType extends Type
+{
+ public BaseType(TypeKind t, SourcePosition posn){
+ super(t, posn);
+ }
+
+ public R visit(Visitor v, A o) {
+ return v.visitBaseType(this, o);
+ }
+}
diff --git a/miniJava/src/miniJava/AbstractSyntaxTrees/BinaryExpr.java b/miniJava/src/miniJava/AbstractSyntaxTrees/BinaryExpr.java
new file mode 100644
index 0000000..91fcc28
--- /dev/null
+++ b/miniJava/src/miniJava/AbstractSyntaxTrees/BinaryExpr.java
@@ -0,0 +1,26 @@
+/**
+ * miniJava Abstract Syntax Tree classes
+ * @author prins
+ * @version COMP 520 (v2.2)
+ */
+package miniJava.AbstractSyntaxTrees;
+
+import miniJava.SyntacticAnalyzer.SourcePosition;
+
+public class BinaryExpr extends Expression
+{
+ public BinaryExpr(Operator o, Expression e1, Expression e2, SourcePosition posn){
+ super(posn);
+ operator = o;
+ left = e1;
+ right = e2;
+ }
+
+ public R visit(Visitor v, A o) {
+ return v.visitBinaryExpr(this, o);
+ }
+
+ public Operator operator;
+ public Expression left;
+ public Expression right;
+}
\ No newline at end of file
diff --git a/miniJava/src/miniJava/AbstractSyntaxTrees/BlockStmt.java b/miniJava/src/miniJava/AbstractSyntaxTrees/BlockStmt.java
new file mode 100644
index 0000000..933909c
--- /dev/null
+++ b/miniJava/src/miniJava/AbstractSyntaxTrees/BlockStmt.java
@@ -0,0 +1,22 @@
+/**
+ * miniJava Abstract Syntax Tree classes
+ * @author prins
+ * @version COMP 520 (v2.2)
+ */
+package miniJava.AbstractSyntaxTrees;
+
+import miniJava.SyntacticAnalyzer.SourcePosition;
+
+public class BlockStmt extends Statement
+{
+ public BlockStmt(StatementList sl, SourcePosition posn){
+ super(posn);
+ this.sl = sl;
+ }
+
+ public R visit(Visitor v, A o) {
+ return v.visitBlockStmt(this, o);
+ }
+
+ public StatementList sl;
+}
\ No newline at end of file
diff --git a/miniJava/src/miniJava/AbstractSyntaxTrees/BooleanLiteral.java b/miniJava/src/miniJava/AbstractSyntaxTrees/BooleanLiteral.java
new file mode 100644
index 0000000..47b5f3f
--- /dev/null
+++ b/miniJava/src/miniJava/AbstractSyntaxTrees/BooleanLiteral.java
@@ -0,0 +1,19 @@
+/**
+ * miniJava Abstract Syntax Tree classes
+ * @author prins
+ * @version COMP 520 (v2.2)
+ */
+package miniJava.AbstractSyntaxTrees;
+
+import miniJava.SyntacticAnalyzer.SourcePosition;
+
+public class BooleanLiteral extends Literal {
+
+ public BooleanLiteral(String spelling, SourcePosition posn) {
+ super (spelling,posn);
+ }
+
+ public R visit(Visitor v, A o) {
+ return v.visitBooleanLiteral(this, o);
+ }
+}
diff --git a/miniJava/src/miniJava/AbstractSyntaxTrees/CallExpr.java b/miniJava/src/miniJava/AbstractSyntaxTrees/CallExpr.java
new file mode 100644
index 0000000..1e17bbb
--- /dev/null
+++ b/miniJava/src/miniJava/AbstractSyntaxTrees/CallExpr.java
@@ -0,0 +1,24 @@
+/**
+ * miniJava Abstract Syntax Tree classes
+ * @author prins
+ * @version COMP 520 (v2.2)
+ */
+package miniJava.AbstractSyntaxTrees;
+
+import miniJava.SyntacticAnalyzer.SourcePosition;
+
+public class CallExpr extends Expression
+{
+ public CallExpr(Reference f, ExprList el, SourcePosition posn){
+ super(posn);
+ functionRef = f;
+ argList = el;
+ }
+
+ public R visit(Visitor v, A o) {
+ return v.visitCallExpr(this, o);
+ }
+
+ public Reference functionRef;
+ public ExprList argList;
+}
\ No newline at end of file
diff --git a/miniJava/src/miniJava/AbstractSyntaxTrees/CallStmt.java b/miniJava/src/miniJava/AbstractSyntaxTrees/CallStmt.java
new file mode 100644
index 0000000..a8aa63e
--- /dev/null
+++ b/miniJava/src/miniJava/AbstractSyntaxTrees/CallStmt.java
@@ -0,0 +1,24 @@
+/**
+ * miniJava Abstract Syntax Tree classes
+ * @author prins
+ * @version COMP 520 (v2.2)
+ */
+package miniJava.AbstractSyntaxTrees;
+
+import miniJava.SyntacticAnalyzer.SourcePosition;
+
+public class CallStmt extends Statement
+{
+ public CallStmt(Reference m, ExprList el, SourcePosition posn){
+ super(posn);
+ methodRef = m;
+ argList = el;
+ }
+
+ public R visit(Visitor v, A o) {
+ return v.visitCallStmt(this, o);
+ }
+
+ public Reference methodRef;
+ public ExprList argList;
+}
\ No newline at end of file
diff --git a/miniJava/src/miniJava/AbstractSyntaxTrees/ClassDecl.java b/miniJava/src/miniJava/AbstractSyntaxTrees/ClassDecl.java
new file mode 100644
index 0000000..bd776a8
--- /dev/null
+++ b/miniJava/src/miniJava/AbstractSyntaxTrees/ClassDecl.java
@@ -0,0 +1,24 @@
+/**
+ * miniJava Abstract Syntax Tree classes
+ * @author prins
+ * @version COMP 520 (v2.2)
+ */
+package miniJava.AbstractSyntaxTrees;
+
+import miniJava.SyntacticAnalyzer.SourcePosition;
+
+public class ClassDecl extends Declaration {
+
+ public ClassDecl(String cn, FieldDeclList fdl, MethodDeclList mdl, SourcePosition posn) {
+ super(cn, null, posn);
+ fieldDeclList = fdl;
+ methodDeclList = mdl;
+ }
+
+ public R visit(Visitor v, A o) {
+ return v.visitClassDecl(this, o);
+ }
+
+ public FieldDeclList fieldDeclList;
+ public MethodDeclList methodDeclList;
+}
diff --git a/miniJava/src/miniJava/AbstractSyntaxTrees/ClassDeclList.java b/miniJava/src/miniJava/AbstractSyntaxTrees/ClassDeclList.java
new file mode 100644
index 0000000..489de35
--- /dev/null
+++ b/miniJava/src/miniJava/AbstractSyntaxTrees/ClassDeclList.java
@@ -0,0 +1,34 @@
+/**
+ * miniJava Abstract Syntax Tree classes
+ * @author prins
+ * @version COMP 520 (v2.2)
+ */
+package miniJava.AbstractSyntaxTrees;
+
+import java.util.*;
+
+public class ClassDeclList implements Iterable
+{
+ public ClassDeclList() {
+ classDeclList = new ArrayList();
+ }
+
+ public void add(ClassDecl cd){
+ classDeclList.add(cd);
+ }
+
+ public ClassDecl get(int i){
+ return classDeclList.get(i);
+ }
+
+ public int size() {
+ return classDeclList.size();
+ }
+
+ public Iterator iterator() {
+ return classDeclList.iterator();
+ }
+
+ private List classDeclList;
+}
+
diff --git a/miniJava/src/miniJava/AbstractSyntaxTrees/ClassType.java b/miniJava/src/miniJava/AbstractSyntaxTrees/ClassType.java
new file mode 100644
index 0000000..980d07f
--- /dev/null
+++ b/miniJava/src/miniJava/AbstractSyntaxTrees/ClassType.java
@@ -0,0 +1,22 @@
+/**
+ * miniJava Abstract Syntax Tree classes
+ * @author prins
+ * @version COMP 520 (v2.2)
+ */
+package miniJava.AbstractSyntaxTrees;
+
+import miniJava.SyntacticAnalyzer.SourcePosition;
+
+public class ClassType extends Type
+{
+ public ClassType(Identifier cn, SourcePosition posn){
+ super(TypeKind.CLASS, posn);
+ className = cn;
+ }
+
+ public R visit(Visitor v, A o) {
+ return v.visitClassType(this, o);
+ }
+
+ public Identifier className;
+}
diff --git a/miniJava/src/miniJava/AbstractSyntaxTrees/Declaration.java b/miniJava/src/miniJava/AbstractSyntaxTrees/Declaration.java
new file mode 100644
index 0000000..2be0aae
--- /dev/null
+++ b/miniJava/src/miniJava/AbstractSyntaxTrees/Declaration.java
@@ -0,0 +1,20 @@
+/**
+ * miniJava Abstract Syntax Tree classes
+ * @author prins
+ * @version COMP 520 (v2.2)
+ */
+package miniJava.AbstractSyntaxTrees;
+
+import miniJava.SyntacticAnalyzer.SourcePosition;
+
+public abstract class Declaration extends AST {
+
+ public Declaration(String name, Type type, SourcePosition posn) {
+ super(posn);
+ this.name = name;
+ this.type = type;
+ }
+
+ public String name;
+ public Type type;
+}
diff --git a/miniJava/src/miniJava/AbstractSyntaxTrees/Declarators.java b/miniJava/src/miniJava/AbstractSyntaxTrees/Declarators.java
new file mode 100644
index 0000000..b42e736
--- /dev/null
+++ b/miniJava/src/miniJava/AbstractSyntaxTrees/Declarators.java
@@ -0,0 +1,14 @@
+package miniJava.AbstractSyntaxTrees;
+
+public class Declarators {
+
+ public Declarators(boolean isPrivate, boolean isStatic, Type mt) {
+ this.isPrivate = isPrivate;
+ this.isStatic = isStatic;
+ this.mt = mt;
+ }
+
+ public boolean isPrivate;
+ public boolean isStatic;
+ public Type mt;
+}
diff --git a/miniJava/src/miniJava/AbstractSyntaxTrees/ExprList.java b/miniJava/src/miniJava/AbstractSyntaxTrees/ExprList.java
new file mode 100644
index 0000000..1a55c0d
--- /dev/null
+++ b/miniJava/src/miniJava/AbstractSyntaxTrees/ExprList.java
@@ -0,0 +1,33 @@
+/**
+ * miniJava Abstract Syntax Tree classes
+ * @author prins
+ * @version COMP 520 (v2.2)
+ */
+package miniJava.AbstractSyntaxTrees;
+
+import java.util.*;
+
+public class ExprList implements Iterable
+{
+ public ExprList() {
+ elist = new ArrayList();
+ }
+
+ public void add(Expression e){
+ elist.add(e);
+ }
+
+ public Expression get(int i){
+ return elist.get(i);
+ }
+
+ public int size() {
+ return elist.size();
+ }
+
+ public Iterator iterator() {
+ return elist.iterator();
+ }
+
+ private List elist;
+}
\ No newline at end of file
diff --git a/miniJava/src/miniJava/AbstractSyntaxTrees/Expression.java b/miniJava/src/miniJava/AbstractSyntaxTrees/Expression.java
new file mode 100644
index 0000000..2c33a62
--- /dev/null
+++ b/miniJava/src/miniJava/AbstractSyntaxTrees/Expression.java
@@ -0,0 +1,16 @@
+/**
+ * miniJava Abstract Syntax Tree classes
+ * @author prins
+ * @version COMP 520 (v2.2)
+ */
+package miniJava.AbstractSyntaxTrees;
+
+import miniJava.SyntacticAnalyzer.SourcePosition;
+
+public abstract class Expression extends AST {
+
+ public Expression(SourcePosition posn) {
+ super (posn);
+ }
+
+}
diff --git a/miniJava/src/miniJava/AbstractSyntaxTrees/FieldDecl.java b/miniJava/src/miniJava/AbstractSyntaxTrees/FieldDecl.java
new file mode 100644
index 0000000..5802447
--- /dev/null
+++ b/miniJava/src/miniJava/AbstractSyntaxTrees/FieldDecl.java
@@ -0,0 +1,24 @@
+/**
+ * miniJava Abstract Syntax Tree classes
+ * @author prins
+ * @version COMP 520 (v2.2)
+ */
+package miniJava.AbstractSyntaxTrees;
+
+import miniJava.SyntacticAnalyzer.SourcePosition;
+
+public class FieldDecl extends MemberDecl {
+
+ public FieldDecl(boolean isPrivate, boolean isStatic, Type t, String name, SourcePosition posn){
+ super(isPrivate, isStatic, t, name, posn);
+ }
+
+ public FieldDecl(MemberDecl md, SourcePosition posn) {
+ super(md,posn);
+ }
+
+ public R visit(Visitor v, A o) {
+ return v.visitFieldDecl(this, o);
+ }
+}
+
diff --git a/miniJava/src/miniJava/AbstractSyntaxTrees/FieldDeclList.java b/miniJava/src/miniJava/AbstractSyntaxTrees/FieldDeclList.java
new file mode 100644
index 0000000..2f6d96c
--- /dev/null
+++ b/miniJava/src/miniJava/AbstractSyntaxTrees/FieldDeclList.java
@@ -0,0 +1,34 @@
+/**
+ * miniJava Abstract Syntax Tree classes
+ * @author prins
+ * @version COMP 520 (v2.2)
+ */
+package miniJava.AbstractSyntaxTrees;
+
+import java.util.*;
+
+public class FieldDeclList implements Iterable
+{
+ public FieldDeclList() {
+ fieldDeclList = new ArrayList();
+ }
+
+ public void add(FieldDecl cd){
+ fieldDeclList.add(cd);
+ }
+
+ public FieldDecl get(int i){
+ return fieldDeclList.get(i);
+ }
+
+ public int size() {
+ return fieldDeclList.size();
+ }
+
+ public Iterator iterator() {
+ return fieldDeclList.iterator();
+ }
+
+ private List fieldDeclList;
+}
+
diff --git a/miniJava/src/miniJava/AbstractSyntaxTrees/IdRef.java b/miniJava/src/miniJava/AbstractSyntaxTrees/IdRef.java
new file mode 100644
index 0000000..bf62d7d
--- /dev/null
+++ b/miniJava/src/miniJava/AbstractSyntaxTrees/IdRef.java
@@ -0,0 +1,22 @@
+/**
+ * miniJava Abstract Syntax Tree classes
+ * @author prins
+ * @version COMP 520 (v2.2)
+ */
+package miniJava.AbstractSyntaxTrees;
+
+import miniJava.SyntacticAnalyzer.SourcePosition;
+
+public class IdRef extends Reference {
+
+ public IdRef(Identifier id, SourcePosition posn){
+ super(posn);
+ this.id = id;
+ }
+
+ public R visit(Visitor v, A o) {
+ return v.visitIdRef(this, o);
+ }
+
+ public Identifier id;
+}
diff --git a/miniJava/src/miniJava/AbstractSyntaxTrees/Identifier.java b/miniJava/src/miniJava/AbstractSyntaxTrees/Identifier.java
new file mode 100644
index 0000000..ebffefa
--- /dev/null
+++ b/miniJava/src/miniJava/AbstractSyntaxTrees/Identifier.java
@@ -0,0 +1,20 @@
+/**
+ * miniJava Abstract Syntax Tree classes
+ * @author prins
+ * @version COMP 520 (v2.2)
+ */
+package miniJava.AbstractSyntaxTrees;
+
+import miniJava.SyntacticAnalyzer.SourcePosition;
+
+public class Identifier extends Terminal {
+
+ public Identifier (String s, SourcePosition posn) {
+ super (s,posn);
+ }
+
+ public R visit(Visitor v, A o) {
+ return v.visitIdentifier(this, o);
+ }
+
+}
diff --git a/miniJava/src/miniJava/AbstractSyntaxTrees/IfStmt.java b/miniJava/src/miniJava/AbstractSyntaxTrees/IfStmt.java
new file mode 100644
index 0000000..b22c31f
--- /dev/null
+++ b/miniJava/src/miniJava/AbstractSyntaxTrees/IfStmt.java
@@ -0,0 +1,33 @@
+/**
+ * miniJava Abstract Syntax Tree classes
+ * @author prins
+ * @version COMP 520 (v2.2)
+ */
+package miniJava.AbstractSyntaxTrees;
+
+import miniJava.SyntacticAnalyzer.SourcePosition;
+
+public class IfStmt extends Statement
+{
+ public IfStmt(Expression b, Statement t, Statement e, SourcePosition posn){
+ super(posn);
+ cond = b;
+ thenStmt = t;
+ elseStmt = e;
+ }
+
+ public IfStmt(Expression b, Statement t, SourcePosition posn){
+ super(posn);
+ cond = b;
+ thenStmt = t;
+ elseStmt = null;
+ }
+
+ public R visit(Visitor v, A o) {
+ return v.visitIfStmt(this, o);
+ }
+
+ public Expression cond;
+ public Statement thenStmt;
+ public Statement elseStmt;
+}
\ No newline at end of file
diff --git a/miniJava/src/miniJava/AbstractSyntaxTrees/IndexedRef.java b/miniJava/src/miniJava/AbstractSyntaxTrees/IndexedRef.java
new file mode 100644
index 0000000..c226b3f
--- /dev/null
+++ b/miniJava/src/miniJava/AbstractSyntaxTrees/IndexedRef.java
@@ -0,0 +1,24 @@
+/**
+ * miniJava Abstract Syntax Tree classes
+ * @author prins
+ * @version COMP 520 (v2.2)
+ */
+package miniJava.AbstractSyntaxTrees;
+
+import miniJava.SyntacticAnalyzer.SourcePosition;
+
+public class IndexedRef extends Reference {
+
+ public IndexedRef(Reference ref, Expression expr, SourcePosition posn){
+ super(posn);
+ this.ref = ref;
+ this.indexExpr = expr;
+ }
+
+ public R visit(Visitor v, A o){
+ return v.visitIndexedRef(this, o);
+ }
+
+ public Reference ref;
+ public Expression indexExpr;
+}
diff --git a/miniJava/src/miniJava/AbstractSyntaxTrees/IntLiteral.java b/miniJava/src/miniJava/AbstractSyntaxTrees/IntLiteral.java
new file mode 100644
index 0000000..7926b9a
--- /dev/null
+++ b/miniJava/src/miniJava/AbstractSyntaxTrees/IntLiteral.java
@@ -0,0 +1,19 @@
+/**
+ * miniJava Abstract Syntax Tree classes
+ * @author prins
+ * @version COMP 520 (v2.2)
+ */
+package miniJava.AbstractSyntaxTrees;
+
+import miniJava.SyntacticAnalyzer.SourcePosition;
+
+public class IntLiteral extends Literal {
+
+ public IntLiteral(String s, SourcePosition posn) {
+ super(s, posn);
+ }
+
+ public R visit(Visitor v, A o) {
+ return v.visitIntLiteral(this, o);
+ }
+}
\ No newline at end of file
diff --git a/miniJava/src/miniJava/AbstractSyntaxTrees/Literal.java b/miniJava/src/miniJava/AbstractSyntaxTrees/Literal.java
new file mode 100644
index 0000000..5c0f5cc
--- /dev/null
+++ b/miniJava/src/miniJava/AbstractSyntaxTrees/Literal.java
@@ -0,0 +1,15 @@
+/**
+ * miniJava Abstract Syntax Tree classes
+ * @author prins
+ * @version COMP 520 (v2.2)
+ */
+package miniJava.AbstractSyntaxTrees;
+
+import miniJava.SyntacticAnalyzer.SourcePosition;
+
+public abstract class Literal extends Terminal {
+
+ public Literal(String spelling, SourcePosition posn) {
+ super(spelling, posn);
+ }
+}
diff --git a/miniJava/src/miniJava/AbstractSyntaxTrees/LiteralExpr.java b/miniJava/src/miniJava/AbstractSyntaxTrees/LiteralExpr.java
new file mode 100644
index 0000000..49ab09f
--- /dev/null
+++ b/miniJava/src/miniJava/AbstractSyntaxTrees/LiteralExpr.java
@@ -0,0 +1,22 @@
+/**
+ * miniJava Abstract Syntax Tree classes
+ * @author prins
+ * @version COMP 520 (v2.2)
+ */
+package miniJava.AbstractSyntaxTrees;
+
+import miniJava.SyntacticAnalyzer.SourcePosition;
+
+public class LiteralExpr extends Expression
+{
+ public LiteralExpr(Literal c, SourcePosition posn){
+ super(posn);
+ literal = c;
+ }
+
+ public R visit(Visitor v, A o){
+ return v.visitLiteralExpr(this, o);
+ }
+
+ public Literal literal;
+}
\ No newline at end of file
diff --git a/miniJava/src/miniJava/AbstractSyntaxTrees/LocalDecl.java b/miniJava/src/miniJava/AbstractSyntaxTrees/LocalDecl.java
new file mode 100644
index 0000000..ce86df1
--- /dev/null
+++ b/miniJava/src/miniJava/AbstractSyntaxTrees/LocalDecl.java
@@ -0,0 +1,16 @@
+/**
+ * miniJava Abstract Syntax Tree classes
+ * @author prins
+ * @version COMP 520 (v2.2)
+ */
+package miniJava.AbstractSyntaxTrees;
+
+import miniJava.SyntacticAnalyzer.SourcePosition;
+
+public abstract class LocalDecl extends Declaration {
+
+ public LocalDecl(String name, Type t, SourcePosition posn){
+ super(name,t,posn);
+ }
+
+}
diff --git a/miniJava/src/miniJava/AbstractSyntaxTrees/MemberDecl.java b/miniJava/src/miniJava/AbstractSyntaxTrees/MemberDecl.java
new file mode 100644
index 0000000..6db1e30
--- /dev/null
+++ b/miniJava/src/miniJava/AbstractSyntaxTrees/MemberDecl.java
@@ -0,0 +1,26 @@
+/**
+ * miniJava Abstract Syntax Tree classes
+ * @author prins
+ * @version COMP 520 (v2.2)
+ */
+package miniJava.AbstractSyntaxTrees;
+
+import miniJava.SyntacticAnalyzer.SourcePosition;
+
+abstract public class MemberDecl extends Declaration {
+
+ public MemberDecl(boolean isPrivate, boolean isStatic, Type mt, String name, SourcePosition posn) {
+ super(name, mt, posn);
+ this.isPrivate = isPrivate;
+ this.isStatic = isStatic;
+ }
+
+ public MemberDecl(MemberDecl md, SourcePosition posn){
+ super(md.name, md.type, posn);
+ this.isPrivate = md.isPrivate;
+ this.isStatic = md.isStatic;
+ }
+
+ public boolean isPrivate;
+ public boolean isStatic;
+}
diff --git a/miniJava/src/miniJava/AbstractSyntaxTrees/MethodDecl.java b/miniJava/src/miniJava/AbstractSyntaxTrees/MethodDecl.java
new file mode 100644
index 0000000..276dfd1
--- /dev/null
+++ b/miniJava/src/miniJava/AbstractSyntaxTrees/MethodDecl.java
@@ -0,0 +1,26 @@
+/**
+ * miniJava Abstract Syntax Tree classes
+ * @author prins
+ * @version COMP 520 (v2.2)
+ */
+package miniJava.AbstractSyntaxTrees;
+
+import miniJava.SyntacticAnalyzer.SourcePosition;
+
+public class MethodDecl extends MemberDecl {
+
+ public MethodDecl(MemberDecl md, ParameterDeclList pl, StatementList sl, Expression e, SourcePosition posn){
+ super(md,posn);
+ parameterDeclList = pl;
+ statementList = sl;
+ returnExp = e;
+ }
+
+ public R visit(Visitor v, A o) {
+ return v.visitMethodDecl(this, o);
+ }
+
+ public ParameterDeclList parameterDeclList;
+ public StatementList statementList;
+ public Expression returnExp;
+}
diff --git a/miniJava/src/miniJava/AbstractSyntaxTrees/MethodDeclList.java b/miniJava/src/miniJava/AbstractSyntaxTrees/MethodDeclList.java
new file mode 100644
index 0000000..f9b98a9
--- /dev/null
+++ b/miniJava/src/miniJava/AbstractSyntaxTrees/MethodDeclList.java
@@ -0,0 +1,34 @@
+/**
+ * miniJava Abstract Syntax Tree classes
+ * @author prins
+ * @version COMP 520 (v2.2)
+ */
+package miniJava.AbstractSyntaxTrees;
+
+import java.util.*;
+
+public class MethodDeclList implements Iterable
+{
+ public MethodDeclList() {
+ methodDeclList = new ArrayList();
+ }
+
+ public void add(MethodDecl cd){
+ methodDeclList.add(cd);
+ }
+
+ public MethodDecl get(int i){
+ return methodDeclList.get(i);
+ }
+
+ public int size() {
+ return methodDeclList.size();
+ }
+
+ public Iterator iterator() {
+ return methodDeclList.iterator();
+ }
+
+ private List methodDeclList;
+}
+
diff --git a/miniJava/src/miniJava/AbstractSyntaxTrees/NewArrayExpr.java b/miniJava/src/miniJava/AbstractSyntaxTrees/NewArrayExpr.java
new file mode 100644
index 0000000..4d16a72
--- /dev/null
+++ b/miniJava/src/miniJava/AbstractSyntaxTrees/NewArrayExpr.java
@@ -0,0 +1,24 @@
+/**
+ * miniJava Abstract Syntax Tree classes
+ * @author prins
+ * @version COMP 520 (v2.2)
+ */
+package miniJava.AbstractSyntaxTrees;
+
+import miniJava.SyntacticAnalyzer.SourcePosition;
+
+public class NewArrayExpr extends NewExpr
+{
+ public NewArrayExpr(Type et, Expression e, SourcePosition posn){
+ super(posn);
+ eltType = et;
+ sizeExpr = e;
+ }
+
+ public R visit(Visitor v, A o) {
+ return v.visitNewArrayExpr(this, o);
+ }
+
+ public Type eltType;
+ public Expression sizeExpr;
+}
\ No newline at end of file
diff --git a/miniJava/src/miniJava/AbstractSyntaxTrees/NewExpr.java b/miniJava/src/miniJava/AbstractSyntaxTrees/NewExpr.java
new file mode 100644
index 0000000..6e7876a
--- /dev/null
+++ b/miniJava/src/miniJava/AbstractSyntaxTrees/NewExpr.java
@@ -0,0 +1,15 @@
+/**
+ * miniJava Abstract Syntax Tree classes
+ * @author prins
+ * @version COMP 520 (v2.2)
+ */
+package miniJava.AbstractSyntaxTrees;
+
+import miniJava.SyntacticAnalyzer.SourcePosition;
+
+public abstract class NewExpr extends Expression {
+
+ public NewExpr(SourcePosition posn) {
+ super (posn);
+ }
+}
diff --git a/miniJava/src/miniJava/AbstractSyntaxTrees/NewObjectExpr.java b/miniJava/src/miniJava/AbstractSyntaxTrees/NewObjectExpr.java
new file mode 100644
index 0000000..1f8b134
--- /dev/null
+++ b/miniJava/src/miniJava/AbstractSyntaxTrees/NewObjectExpr.java
@@ -0,0 +1,22 @@
+/**
+ * miniJava Abstract Syntax Tree classes
+ * @author prins
+ * @version COMP 520 (v2.2)
+ */
+package miniJava.AbstractSyntaxTrees;
+
+import miniJava.SyntacticAnalyzer.SourcePosition;
+
+public class NewObjectExpr extends NewExpr
+{
+ public NewObjectExpr(ClassType ct, SourcePosition posn){
+ super(posn);
+ classtype = ct;
+ }
+
+ public R visit(Visitor v, A o) {
+ return v.visitNewObjectExpr(this, o);
+ }
+
+ public ClassType classtype;
+}
diff --git a/miniJava/src/miniJava/AbstractSyntaxTrees/Operator.java b/miniJava/src/miniJava/AbstractSyntaxTrees/Operator.java
new file mode 100644
index 0000000..88e291d
--- /dev/null
+++ b/miniJava/src/miniJava/AbstractSyntaxTrees/Operator.java
@@ -0,0 +1,22 @@
+/**
+ * miniJava Abstract Syntax Tree classes
+ * @author prins
+ * @version COMP 520 (v2.2)
+ */
+package miniJava.AbstractSyntaxTrees;
+
+import miniJava.SyntacticAnalyzer.SourcePosition;
+import miniJava.SyntacticAnalyzer.Token;
+
+public class Operator extends Terminal {
+
+ public Operator (Token t, SourcePosition posn) {
+ super (t.spelling, posn);
+ }
+
+ public R visit(Visitor v, A o) {
+ return v.visitOperator(this, o);
+ }
+
+ public Token token;
+}
diff --git a/miniJava/src/miniJava/AbstractSyntaxTrees/Package.java b/miniJava/src/miniJava/AbstractSyntaxTrees/Package.java
new file mode 100644
index 0000000..dc29d7d
--- /dev/null
+++ b/miniJava/src/miniJava/AbstractSyntaxTrees/Package.java
@@ -0,0 +1,22 @@
+/**
+ * miniJava Abstract Syntax Tree classes
+ * @author prins
+ * @version COMP 520 (v2.2)
+ */
+package miniJava.AbstractSyntaxTrees;
+
+import miniJava.SyntacticAnalyzer.SourcePosition;
+
+public class Package extends AST {
+
+ public Package(ClassDeclList cdl, SourcePosition posn) {
+ super(posn);
+ classDeclList = cdl;
+ }
+
+ public R visit(Visitor v, A o) {
+ return v.visitPackage(this, o);
+ }
+
+ public ClassDeclList classDeclList;
+}
diff --git a/miniJava/src/miniJava/AbstractSyntaxTrees/ParameterDecl.java b/miniJava/src/miniJava/AbstractSyntaxTrees/ParameterDecl.java
new file mode 100644
index 0000000..1bbee69
--- /dev/null
+++ b/miniJava/src/miniJava/AbstractSyntaxTrees/ParameterDecl.java
@@ -0,0 +1,20 @@
+/**
+ * miniJava Abstract Syntax Tree classes
+ * @author prins
+ * @version COMP 520 (v2.2)
+ */
+package miniJava.AbstractSyntaxTrees;
+
+import miniJava.SyntacticAnalyzer.SourcePosition;
+
+public class ParameterDecl extends LocalDecl {
+
+ public ParameterDecl(Type t, String name, SourcePosition posn){
+ super(name, t, posn);
+ }
+
+ public R visit(Visitor v, A o) {
+ return v.visitParameterDecl(this, o);
+ }
+}
+
diff --git a/miniJava/src/miniJava/AbstractSyntaxTrees/ParameterDeclList.java b/miniJava/src/miniJava/AbstractSyntaxTrees/ParameterDeclList.java
new file mode 100644
index 0000000..64ae1cc
--- /dev/null
+++ b/miniJava/src/miniJava/AbstractSyntaxTrees/ParameterDeclList.java
@@ -0,0 +1,33 @@
+/**
+ * miniJava Abstract Syntax Tree classes
+ * @author prins
+ * @version COMP 520 (v2.2)
+ */
+package miniJava.AbstractSyntaxTrees;
+
+import java.util.*;
+
+public class ParameterDeclList implements Iterable
+{
+ public ParameterDeclList() {
+ parameterDeclList = new ArrayList();
+ }
+
+ public void add(ParameterDecl s){
+ parameterDeclList.add(s);
+ }
+
+ public ParameterDecl get(int i){
+ return parameterDeclList.get(i);
+ }
+
+ public int size() {
+ return parameterDeclList.size();
+ }
+
+ public Iterator iterator() {
+ return parameterDeclList.iterator();
+ }
+
+ private List parameterDeclList;
+}
diff --git a/miniJava/src/miniJava/AbstractSyntaxTrees/QualifiedRef.java b/miniJava/src/miniJava/AbstractSyntaxTrees/QualifiedRef.java
new file mode 100644
index 0000000..3659a45
--- /dev/null
+++ b/miniJava/src/miniJava/AbstractSyntaxTrees/QualifiedRef.java
@@ -0,0 +1,25 @@
+/**
+ * miniJava Abstract Syntax Tree classes
+ * @author prins
+ * @version COMP 520 (v2.2)
+ */
+package miniJava.AbstractSyntaxTrees;
+
+import miniJava.SyntacticAnalyzer.SourcePosition;
+
+public class QualifiedRef extends Reference {
+
+ public QualifiedRef(Reference ref, Identifier id, SourcePosition posn){
+ super(posn);
+ this.ref = ref;
+ this.id = id;
+ }
+
+ @Override
+ public R visit(Visitor v, A o) {
+ return v.visitQualifiedRef(this, o);
+ }
+
+ public Reference ref;
+ public Identifier id;
+}
diff --git a/miniJava/src/miniJava/AbstractSyntaxTrees/RefExpr.java b/miniJava/src/miniJava/AbstractSyntaxTrees/RefExpr.java
new file mode 100644
index 0000000..48917dc
--- /dev/null
+++ b/miniJava/src/miniJava/AbstractSyntaxTrees/RefExpr.java
@@ -0,0 +1,22 @@
+/**
+ * miniJava Abstract Syntax Tree classes
+ * @author prins
+ * @version COMP 520 (v2.2)
+ */
+package miniJava.AbstractSyntaxTrees;
+
+import miniJava.SyntacticAnalyzer.SourcePosition;
+
+public class RefExpr extends Expression
+{
+ public RefExpr(Reference r, SourcePosition posn){
+ super(posn);
+ ref = r;
+ }
+
+ public R visit(Visitor v, A o) {
+ return v.visitRefExpr(this, o);
+ }
+
+ public Reference ref;
+}
diff --git a/miniJava/src/miniJava/AbstractSyntaxTrees/Reference.java b/miniJava/src/miniJava/AbstractSyntaxTrees/Reference.java
new file mode 100644
index 0000000..7ba8450
--- /dev/null
+++ b/miniJava/src/miniJava/AbstractSyntaxTrees/Reference.java
@@ -0,0 +1,16 @@
+/**
+ * miniJava Abstract Syntax Tree classes
+ * @author prins
+ * @version COMP 520 (v2.2)
+ */
+package miniJava.AbstractSyntaxTrees;
+
+import miniJava.SyntacticAnalyzer.SourcePosition;
+
+public abstract class Reference extends AST
+{
+ public Reference(SourcePosition posn){
+ super(posn);
+ }
+
+}
diff --git a/miniJava/src/miniJava/AbstractSyntaxTrees/Statement.java b/miniJava/src/miniJava/AbstractSyntaxTrees/Statement.java
new file mode 100644
index 0000000..4fa1af9
--- /dev/null
+++ b/miniJava/src/miniJava/AbstractSyntaxTrees/Statement.java
@@ -0,0 +1,16 @@
+/**
+ * miniJava Abstract Syntax Tree classes
+ * @author prins
+ * @version COMP 520 (v2.2)
+ */
+package miniJava.AbstractSyntaxTrees;
+
+import miniJava.SyntacticAnalyzer.SourcePosition;
+
+public abstract class Statement extends AST {
+
+ public Statement(SourcePosition posn) {
+ super (posn);
+ }
+
+}
diff --git a/miniJava/src/miniJava/AbstractSyntaxTrees/StatementList.java b/miniJava/src/miniJava/AbstractSyntaxTrees/StatementList.java
new file mode 100644
index 0000000..2b21f76
--- /dev/null
+++ b/miniJava/src/miniJava/AbstractSyntaxTrees/StatementList.java
@@ -0,0 +1,33 @@
+/**
+ * miniJava Abstract Syntax Tree classes
+ * @author prins
+ * @version COMP 520 (v2.2)
+ */
+package miniJava.AbstractSyntaxTrees;
+
+import java.util.*;
+
+public class StatementList implements Iterable
+{
+ public StatementList() {
+ slist = new ArrayList();
+ }
+
+ public void add(Statement s){
+ slist.add(s);
+ }
+
+ public Statement get(int i){
+ return slist.get(i);
+ }
+
+ public int size() {
+ return slist.size();
+ }
+
+ public Iterator iterator() {
+ return slist.iterator();
+ }
+
+ private List slist;
+}
diff --git a/miniJava/src/miniJava/AbstractSyntaxTrees/Terminal.java b/miniJava/src/miniJava/AbstractSyntaxTrees/Terminal.java
new file mode 100644
index 0000000..5b3f7e6
--- /dev/null
+++ b/miniJava/src/miniJava/AbstractSyntaxTrees/Terminal.java
@@ -0,0 +1,18 @@
+/**
+ * miniJava Abstract Syntax Tree classes
+ * @author prins
+ * @version COMP 520 (v2.2)
+ */
+package miniJava.AbstractSyntaxTrees;
+
+import miniJava.SyntacticAnalyzer.SourcePosition;
+
+abstract public class Terminal extends AST {
+
+ public Terminal (String s, SourcePosition posn) {
+ super(posn);
+ spelling = s;
+ }
+
+ public String spelling;
+}
diff --git a/miniJava/src/miniJava/AbstractSyntaxTrees/ThisRef.java b/miniJava/src/miniJava/AbstractSyntaxTrees/ThisRef.java
new file mode 100644
index 0000000..3beab4e
--- /dev/null
+++ b/miniJava/src/miniJava/AbstractSyntaxTrees/ThisRef.java
@@ -0,0 +1,21 @@
+/**
+ * miniJava Abstract Syntax Tree classes
+ * @author prins
+ * @version COMP 520 (v2.2)
+ */
+package miniJava.AbstractSyntaxTrees;
+
+import miniJava.SyntacticAnalyzer.SourcePosition;
+
+public class ThisRef extends Reference {
+
+ public ThisRef(SourcePosition posn) {
+ super(posn);
+ }
+
+ @Override
+ public R visit(Visitor v, A o) {
+ return v.visitThisRef(this, o);
+ }
+
+}
diff --git a/miniJava/src/miniJava/AbstractSyntaxTrees/Type.java b/miniJava/src/miniJava/AbstractSyntaxTrees/Type.java
new file mode 100644
index 0000000..cbcaa10
--- /dev/null
+++ b/miniJava/src/miniJava/AbstractSyntaxTrees/Type.java
@@ -0,0 +1,21 @@
+/**
+ * miniJava Abstract Syntax Tree classes
+ * @author prins
+ * @version COMP 520 (v2.2)
+ */
+package miniJava.AbstractSyntaxTrees;
+
+import miniJava.SyntacticAnalyzer.SourcePosition;
+
+abstract public class Type extends AST {
+
+ public Type(TypeKind typ, SourcePosition posn){
+ super(posn);
+ typeKind = typ;
+ }
+
+ public TypeKind typeKind;
+
+}
+
+
\ No newline at end of file
diff --git a/miniJava/src/miniJava/AbstractSyntaxTrees/TypeKind.java b/miniJava/src/miniJava/AbstractSyntaxTrees/TypeKind.java
new file mode 100644
index 0000000..b6bd818
--- /dev/null
+++ b/miniJava/src/miniJava/AbstractSyntaxTrees/TypeKind.java
@@ -0,0 +1,16 @@
+/**
+ * miniJava Abstract Syntax Tree classes
+ * @author prins
+ * @version COMP 520 (v2.2)
+ */
+package miniJava.AbstractSyntaxTrees;
+
+public enum TypeKind {
+ VOID,
+ INT,
+ BOOLEAN,
+ CLASS,
+ ARRAY,
+ UNSUPPORTED,
+ ERROR;
+}
diff --git a/miniJava/src/miniJava/AbstractSyntaxTrees/UnaryExpr.java b/miniJava/src/miniJava/AbstractSyntaxTrees/UnaryExpr.java
new file mode 100644
index 0000000..6bff8ce
--- /dev/null
+++ b/miniJava/src/miniJava/AbstractSyntaxTrees/UnaryExpr.java
@@ -0,0 +1,24 @@
+/**
+ * miniJava Abstract Syntax Tree classes
+ * @author prins
+ * @version COMP 520 (v2.2)
+ */
+package miniJava.AbstractSyntaxTrees;
+
+import miniJava.SyntacticAnalyzer.SourcePosition;
+
+public class UnaryExpr extends Expression
+{
+ public UnaryExpr(Operator o, Expression e, SourcePosition posn){
+ super(posn);
+ operator = o;
+ expr = e;
+ }
+
+ public R visit(Visitor v, A o) {
+ return v.visitUnaryExpr(this, o);
+ }
+
+ public Operator operator;
+ public Expression expr;
+}
\ No newline at end of file
diff --git a/miniJava/src/miniJava/AbstractSyntaxTrees/VarDecl.java b/miniJava/src/miniJava/AbstractSyntaxTrees/VarDecl.java
new file mode 100644
index 0000000..3fe19a8
--- /dev/null
+++ b/miniJava/src/miniJava/AbstractSyntaxTrees/VarDecl.java
@@ -0,0 +1,19 @@
+/**
+ * miniJava Abstract Syntax Tree classes
+ * @author prins
+ * @version COMP 520 (v2.2)
+ */
+package miniJava.AbstractSyntaxTrees;
+
+import miniJava.SyntacticAnalyzer.SourcePosition;
+
+public class VarDecl extends LocalDecl {
+
+ public VarDecl(Type t, String name, SourcePosition posn) {
+ super(name, t, posn);
+ }
+
+ public R visit(Visitor v, A o) {
+ return v.visitVarDecl(this, o);
+ }
+}
diff --git a/miniJava/src/miniJava/AbstractSyntaxTrees/VarDeclStmt.java b/miniJava/src/miniJava/AbstractSyntaxTrees/VarDeclStmt.java
new file mode 100644
index 0000000..b960b2e
--- /dev/null
+++ b/miniJava/src/miniJava/AbstractSyntaxTrees/VarDeclStmt.java
@@ -0,0 +1,24 @@
+/**
+ * miniJava Abstract Syntax Tree classes
+ * @author prins
+ * @version COMP 520 (v2.2)
+ */
+package miniJava.AbstractSyntaxTrees;
+
+import miniJava.SyntacticAnalyzer.SourcePosition;
+
+public class VarDeclStmt extends Statement
+{
+ public VarDeclStmt(VarDecl vd, Expression e, SourcePosition posn){
+ super(posn);
+ varDecl = vd;
+ initExp = e;
+ }
+
+ public R visit(Visitor v, A o) {
+ return v.visitVardeclStmt(this, o);
+ }
+
+ public VarDecl varDecl;
+ public Expression initExp;
+}
diff --git a/miniJava/src/miniJava/AbstractSyntaxTrees/Visitor.java b/miniJava/src/miniJava/AbstractSyntaxTrees/Visitor.java
new file mode 100644
index 0000000..74506e0
--- /dev/null
+++ b/miniJava/src/miniJava/AbstractSyntaxTrees/Visitor.java
@@ -0,0 +1,57 @@
+/**
+ * miniJava Abstract Syntax Tree classes
+ * @author prins
+ * @version COMP 520 (v2.2)
+ */
+package miniJava.AbstractSyntaxTrees;
+
+/**
+ * An implementation of the Visitor interface provides a method visitX
+ * for each non-abstract AST class X.
+ */
+public interface Visitor {
+
+ // Package
+ public ResultType visitPackage(Package prog, ArgType arg);
+
+ // Declarations
+ public ResultType visitClassDecl(ClassDecl cd, ArgType arg);
+ public ResultType visitFieldDecl(FieldDecl fd, ArgType arg);
+ public ResultType visitMethodDecl(MethodDecl md, ArgType arg);
+ public ResultType visitParameterDecl(ParameterDecl pd, ArgType arg);
+ public ResultType visitVarDecl(VarDecl decl, ArgType arg);
+
+ // Types
+ public ResultType visitBaseType(BaseType type, ArgType arg);
+ public ResultType visitClassType(ClassType type, ArgType arg);
+ public ResultType visitArrayType(ArrayType type, ArgType arg);
+
+ // Statements
+ public ResultType visitBlockStmt(BlockStmt stmt, ArgType arg);
+ public ResultType visitVardeclStmt(VarDeclStmt stmt, ArgType arg);
+ public ResultType visitAssignStmt(AssignStmt stmt, ArgType arg);
+ public ResultType visitCallStmt(CallStmt stmt, ArgType arg);
+ public ResultType visitIfStmt(IfStmt stmt, ArgType arg);
+ public ResultType visitWhileStmt(WhileStmt stmt, ArgType arg);
+
+ // Expressions
+ public ResultType visitUnaryExpr(UnaryExpr expr, ArgType arg);
+ public ResultType visitBinaryExpr(BinaryExpr expr, ArgType arg);
+ public ResultType visitRefExpr(RefExpr expr, ArgType arg);
+ public ResultType visitCallExpr(CallExpr expr, ArgType arg);
+ public ResultType visitLiteralExpr(LiteralExpr expr, ArgType arg);
+ public ResultType visitNewObjectExpr(NewObjectExpr expr, ArgType arg);
+ public ResultType visitNewArrayExpr(NewArrayExpr expr, ArgType arg);
+
+ // References
+ public ResultType visitQualifiedRef(QualifiedRef ref, ArgType arg);
+ public ResultType visitIndexedRef(IndexedRef ref, ArgType arg);
+ public ResultType visitIdRef(IdRef ref, ArgType arg);
+ public ResultType visitThisRef(ThisRef ref, ArgType arg);
+
+ // Terminals
+ public ResultType visitIdentifier(Identifier id, ArgType arg);
+ public ResultType visitOperator(Operator op, ArgType arg);
+ public ResultType visitIntLiteral(IntLiteral num, ArgType arg);
+ public ResultType visitBooleanLiteral(BooleanLiteral bool, ArgType arg);
+}
diff --git a/miniJava/src/miniJava/AbstractSyntaxTrees/WhileStmt.java b/miniJava/src/miniJava/AbstractSyntaxTrees/WhileStmt.java
new file mode 100644
index 0000000..d76ac87
--- /dev/null
+++ b/miniJava/src/miniJava/AbstractSyntaxTrees/WhileStmt.java
@@ -0,0 +1,24 @@
+/**
+ * miniJava Abstract Syntax Tree classes
+ * @author prins
+ * @version COMP 520 (v2.2)
+ */
+package miniJava.AbstractSyntaxTrees;
+
+import miniJava.SyntacticAnalyzer.SourcePosition;
+
+public class WhileStmt extends Statement
+{
+ public WhileStmt(Expression b, Statement s, SourcePosition posn){
+ super(posn);
+ cond = b;
+ body = s;
+ }
+
+ public R visit(Visitor v, A o) {
+ return v.visitWhileStmt(this, o);
+ }
+
+ public Expression cond;
+ public Statement body;
+}
diff --git a/miniJava/src/miniJava/Compiler.java b/miniJava/src/miniJava/Compiler.java
index 40fe744..c850c20 100644
--- a/miniJava/src/miniJava/Compiler.java
+++ b/miniJava/src/miniJava/Compiler.java
@@ -1,7 +1,10 @@
package miniJava;
import java.io.*;
+
import miniJava.SyntacticAnalyzer.*;
+import miniJava.AbstractSyntaxTrees.*;
+import miniJava.AbstractSyntaxTrees.Package;
public class Compiler {
@@ -16,18 +19,19 @@ public class Compiler {
try(FileReader input = new FileReader(args[0])) {
+ // Setup
Scanner scanner = new Scanner(new BufferedReader(input));
Parser parser = new Parser(scanner);
- parser.parse();
+ Package p = parser.parse();
- System.out.println("Works");
+ // Display
+ ASTDisplay display = new ASTDisplay();
+ display.showTree(p);
System.exit(0);
} catch(FileNotFoundException e) {
- System.out.println("Not Found");
System.exit(rc);
} catch(IOException e) {
- System.out.println("Not Works");
System.exit(rc);
}
}
diff --git a/miniJava/src/miniJava/SyntacticAnalyzer/Parser.java b/miniJava/src/miniJava/SyntacticAnalyzer/Parser.java
index 068cf4b..6930c9a 100644
--- a/miniJava/src/miniJava/SyntacticAnalyzer/Parser.java
+++ b/miniJava/src/miniJava/SyntacticAnalyzer/Parser.java
@@ -2,6 +2,8 @@ package miniJava.SyntacticAnalyzer;
import java.io.*;
import java.util.LinkedList;
+import miniJava.AbstractSyntaxTrees.*;
+import miniJava.AbstractSyntaxTrees.Package;
public class Parser {
@@ -13,191 +15,271 @@ public class Parser {
this.stream = new LinkedList();
}
-
/**
* Program ::= (ClassDeclaration)* eot
+ * @return
* @throws IOException
*/
- public void parse() throws IOException {
- while(peek(1).type == Token.TYPE.CLASS) parseClassDeclaration();
+ public Package parse() throws IOException {
+ ClassDeclList decls = new ClassDeclList();
+ while(peek(1).type == Token.TYPE.CLASS) {
+ decls.add(parseClassDeclaration());
+ }
+
accept(Token.TYPE.EOT);
+ return new Package(decls, null);
}
-
/**
* ClassDeclaration ::=
* class id {
* (Declarators id (; | MethodDeclaration))*
* }
+ * @return
* @throws IOException
*/
- private void parseClassDeclaration() throws IOException {
+ private ClassDecl parseClassDeclaration() throws IOException {
// Class Header
accept(Token.TYPE.CLASS);
- accept(Token.TYPE.ID);
+ String cn = accept(Token.TYPE.ID).spelling;
accept(Token.TYPE.LBRACKET);
+ // Setup
+ FieldDeclList fdl = new FieldDeclList();
+ MethodDeclList mdl = new MethodDeclList();
+
// Class Body
while(peek(1).type != Token.TYPE.RBRACKET) {
- parseDeclarators();
- accept(Token.TYPE.ID);
- if(peek(1).type == Token.TYPE.SEMICOLON) accept(Token.TYPE.SEMICOLON);
- else parseMethodDeclaration();
+ Declarators d = parseDeclarators();
+ String name = accept(Token.TYPE.ID).spelling;
+ FieldDecl f = new FieldDecl(d.isPrivate, d.isStatic, d.mt, name, null);
+
+ // Field Declarations
+ if(peek(1).type == Token.TYPE.SEMICOLON) {
+ accept(Token.TYPE.SEMICOLON);
+ fdl.add(f);
+ }
+
+ // Method Declarations
+ else mdl.add(parseMethodDeclaration(f));
}
- accept(Token.TYPE.RBRACKET);
+ accept(Token.TYPE.RBRACKET);
+ return new ClassDecl(cn, fdl, mdl, null);
}
+ /**
+ * Declarators ::= (public | private)? static? Type
+ * @return
+ * @throws IOException
+ */
+ private Declarators parseDeclarators() throws IOException {
+
+ // Visibility
+ boolean isPrivate = false;
+ if(peek(1).type == Token.TYPE.PUBLIC) {
+ accept(Token.TYPE.PUBLIC);
+ } else if(peek(1).type == Token.TYPE.PRIVATE) {
+ isPrivate = true;
+ accept(Token.TYPE.PRIVATE);
+ }
+
+ // Class Methods
+ boolean isStatic = false;
+ if(peek(1).type == Token.TYPE.STATIC) {
+ isStatic = true;
+ accept(Token.TYPE.STATIC);
+ }
+
+ Type t = parseType();
+ return new Declarators(isPrivate, isStatic, t);
+ }
/**
- * MethodDeclaration ::=
+ * * MethodDeclaration ::=
* (ParameterList?) {
* Statement* (return Expression ;)?
* }
+ * @param f describes the declaratory aspect of the method
+ * @return
* @throws IOException
*/
- private void parseMethodDeclaration() throws IOException {
-
+ private MethodDecl parseMethodDeclaration(FieldDecl f) throws IOException {
+
// Method Header
accept(Token.TYPE.LPAREN);
- if(peek(1).type != Token.TYPE.RPAREN) parseParameterList();
+
+ // Parameter List
+ ParameterDeclList pdl = new ParameterDeclList();
+ if(peek(1).type != Token.TYPE.RPAREN) pdl = parseParameterList();
+
accept(Token.TYPE.RPAREN);
accept(Token.TYPE.LBRACKET);
// Method Body
+ Expression re = null;
+ StatementList stl = new StatementList();
while(peek(1).type != Token.TYPE.RBRACKET) {
if(peek(1).type == Token.TYPE.RETURN) {
accept(Token.TYPE.RETURN);
- parseExpression();
+ re = parseExpression();
accept(Token.TYPE.SEMICOLON);
break;
}
- parseStatement();
+ stl.add(parseStatement());
}
accept(Token.TYPE.RBRACKET);
+ return new MethodDecl(f, pdl, stl, re, null);
}
-
- /**
- * Declarators ::= (public | private)? static? Type
- * @throws IOException
- */
- private void parseDeclarators() throws IOException {
-
- if(peek(1).type == Token.TYPE.PUBLIC) accept(Token.TYPE.PUBLIC);
- else if(peek(1).type == Token.TYPE.PRIVATE) accept(Token.TYPE.PRIVATE);
-
- if(peek(1).type == Token.TYPE.STATIC) accept(Token.TYPE.STATIC);
- parseType();
- }
-
-
/**
* Type ::= boolean | void | int ([])? | id ([])?
+ * @return
* @throws IOException
*/
- private void parseType() throws IOException {
+ private Type parseType() throws IOException {
- Token.TYPE type = peek(1).type;
-
- switch(type) {
+ switch(peek(1).type) {
case BOOLEAN:
- case VOID:
- accept(type);
- break;
+ accept(Token.TYPE.BOOLEAN);
+ return new BaseType(TypeKind.BOOLEAN, null);
+
+ case VOID:
+ accept(Token.TYPE.VOID);
+ return new BaseType(TypeKind.VOID, null);
+
+ case INT: {
+ accept(Token.TYPE.INT);
+ BaseType b = new BaseType(TypeKind.INT, null);
- case INT:
- case ID:
- accept(type);
if(peek(1).type == Token.TYPE.LSQUARE) {
accept(Token.TYPE.LSQUARE);
accept(Token.TYPE.RSQUARE);
+ return new ArrayType(b, null);
}
- break;
+
+ return b;
+ }
+
+ case ID: {
+ String cn = accept(peek(1).type).spelling;
+ Identifier i = new Identifier(cn, null);
+ ClassType c = new ClassType(i, null);
+
+ if(peek(1).type == Token.TYPE.LSQUARE) {
+ accept(Token.TYPE.LSQUARE);
+ accept(Token.TYPE.RSQUARE);
+ return new ArrayType(c, null);
+ }
+
+ return c;
+ }
default:
throw new IOException();
}
}
-
/**
* ParameterList ::= Type id (, Type id)*
+ * @return
* @throws IOException
*/
- private void parseParameterList() throws IOException {
- parseType();
- accept(Token.TYPE.ID);
+ private ParameterDeclList parseParameterList() throws IOException {
+
+ ParameterDeclList decls = new ParameterDeclList();
+
+ // First Parameter
+ Type t = parseType();
+ String name = accept(Token.TYPE.ID).spelling;
+ decls.add(new ParameterDecl(t, name, null));
+
+ // Remainder of List
while(peek(1).type == Token.TYPE.COMMA) {
accept(Token.TYPE.COMMA);
- parseType();
- accept(Token.TYPE.ID);
+ t = parseType();
+ name = accept(Token.TYPE.ID).spelling;
+ decls.add(new ParameterDecl(t, name, null));
}
+
+ return decls;
}
-
/**
* ArgumentList ::= Expression (, Expression)*
+ * @return
* @throws IOException
*/
- private void parseArgumentList() throws IOException {
- parseExpression();
+ private ExprList parseArgumentList() throws IOException {
+ ExprList e = new ExprList();
+ e.add(parseExpression());
while(peek(1).type == Token.TYPE.COMMA) {
accept(Token.TYPE.COMMA);
- parseExpression();
+ e.add(parseExpression());
}
+
+ return e;
}
-
/**
* Reference ::= BaseRef (. BaseRef)*
+ * @return
* @throws IOException
*/
- private void parseReference() throws IOException {
- parseBaseRef();
+ private Reference parseReference() throws IOException {
+ Reference r = parseBaseRef();
while(peek(1).type == Token.TYPE.PERIOD) {
accept(Token.TYPE.PERIOD);
- accept(Token.TYPE.ID);
+ String name = accept(Token.TYPE.ID).spelling;
+ Identifier id = new Identifier(name, null);
+ r = new QualifiedRef(r, id, null);
+
if(peek(1).type == Token.TYPE.LSQUARE) {
accept(Token.TYPE.LSQUARE);
- parseExpression();
+ Expression e = parseExpression();
accept(Token.TYPE.RSQUARE);
+ r = new IndexedRef(r, e, null);
+ }
+ }
+
+ return r;
+ }
+
+ /**
+ * BaseRef ::= this | id ([ Expression])?
+ * @return
+ * @throws IOException
+ */
+ private Reference parseBaseRef() throws IOException {
+
+ switch(peek(1).type) {
+ case THIS:
+ accept(Token.TYPE.THIS);
+ return new ThisRef(null);
+
+ // id ([ Expression])?
+ default: {
+ String id = accept(Token.TYPE.ID).spelling;
+ Identifier i = new Identifier(id, null);
+ IdRef r = new IdRef(i, null);
+
+ if(peek(1).type == Token.TYPE.LSQUARE) {
+ accept(Token.TYPE.LSQUARE);
+ Expression e = parseExpression();
+ accept(Token.TYPE.RSQUARE);
+ return new IndexedRef(r, e, null);
+ }
+
+ return r;
}
}
}
-
- /**
- * BaseRef ::= this | id ([ Expression])?
- * @throws IOException
- */
- private void parseBaseRef() throws IOException {
-
- switch(peek(1).type) {
-
- // this
- case THIS:
- accept(Token.TYPE.THIS);
- break;
-
- // id ([ Expression])?
- default:
- accept(Token.TYPE.ID);
- if(peek(1).type == Token.TYPE.LSQUARE) {
- accept(Token.TYPE.LSQUARE);
- parseExpression();
- accept(Token.TYPE.RSQUARE);
- }
- break;
- }
- }
-
-
/**
* Statement ::=
* {Statement*}
@@ -206,82 +288,100 @@ public class Parser {
* | Reference ( ArgumentList? );
* | if (Expression) Statement (else Statement)?
* | while (Expression) Statement
+ * @return
* @throws IOException
*/
- private void parseStatement() throws IOException {
+ private Statement parseStatement() throws IOException {
switch(peek(1).type) {
// { Statement* }
- case LBRACKET:
+ case LBRACKET: {
accept(Token.TYPE.LBRACKET);
+ StatementList stl = new StatementList();
while(peek(1).type != Token.TYPE.RBRACKET) {
- parseStatement();
+ stl.add(parseStatement());
}
accept(Token.TYPE.RBRACKET);
- break;
+
+ return new BlockStmt(stl, null);
+ }
// if (Expression) Statement (else Statement)?
- case IF:
+ case IF: {
accept(Token.TYPE.IF);
accept(Token.TYPE.LPAREN);
- parseExpression();
+ Expression e = parseExpression();
accept(Token.TYPE.RPAREN);
- parseStatement();
+ Statement s1 = parseStatement();
if(peek(1).type == Token.TYPE.ELSE) {
accept(Token.TYPE.ELSE);
- parseStatement();
+ Statement s2 = parseStatement();
+ return new IfStmt(e, s1, s2, null);
}
- break;
+
+ return new IfStmt(e, s1, null);
+ }
// while (Expression) Statement
- case WHILE:
+ case WHILE: {
accept(Token.TYPE.WHILE);
accept(Token.TYPE.LPAREN);
- parseExpression();
+ Expression e = parseExpression();
accept(Token.TYPE.RPAREN);
- parseStatement();
- break;
+ Statement s = parseStatement();
+
+ return new WhileStmt(e, s, null);
+ }
// Type id = Expression ;
- case BOOLEAN:
- case VOID:
- case INT:
- case ID:
+ case BOOLEAN: case VOID: case INT: case ID: {
// Must be a type though there is a possibility of a reference
- if(peek(1).type != Token.TYPE.ID
- || peek(2).type == Token.TYPE.ID
+ if(peek(1).type != Token.TYPE.ID || peek(2).type == Token.TYPE.ID
||(peek(2).type == Token.TYPE.LSQUARE && peek(3).type == Token.TYPE.RSQUARE)) {
- parseType();
- accept(Token.TYPE.ID);
+ Type t = parseType();
+ String name = accept(Token.TYPE.ID).spelling;
+ VarDecl v = new VarDecl(t, name, null);
+
accept(Token.TYPE.EQUALS);
- parseExpression();
+ Expression e = parseExpression();
accept(Token.TYPE.SEMICOLON);
- break;
+
+ return new VarDeclStmt(v, e, null);
}
/* Fall Through */
+ }
+
+ default: {
+ Statement s = null;
+ Reference r = parseReference();
- // Reference = Expression ; | Reference ( ArgumentList? ) ;
- default:
- parseReference();
-
+ // Reference ( ArgumentList? ) ;
if(peek(1).type == Token.TYPE.LPAREN) {
+ ExprList e = new ExprList();
accept(Token.TYPE.LPAREN);
- if(peek(1).type != Token.TYPE.RPAREN) parseArgumentList();
+ if(peek(1).type != Token.TYPE.RPAREN) {
+ e = parseArgumentList();
+ }
accept(Token.TYPE.RPAREN);
- } else {
+ s = new CallStmt(r, e, null);
+ }
+
+ // Reference = Expression ;
+ else {
accept(Token.TYPE.EQUALS);
- parseExpression();
+ Expression e = parseExpression();
+ s = new AssignStmt(r, e, null);
}
accept(Token.TYPE.SEMICOLON);
- break;
- }
+ return s;
+ }
+ }
}
-
/**
* Expression ::=
* Reference
@@ -291,92 +391,198 @@ public class Parser {
* | ( Expression )
* | num | true | false
* | new (id() | int [ Expression ] | id [ Expression ] )
+ * @return
* @throws IOException
*/
- private void parseExpression() throws IOException {
+ private Expression parseExpression() throws IOException {
+ Expression e = null;
switch(peek(1).type) {
- // num | true | false
- case NUM:
- case TRUE:
- case FALSE:
- accept(peek(1).type);
+ // num
+ case NUM: {
+ String number = accept(Token.TYPE.NUM).spelling;
+ IntLiteral i = new IntLiteral(number, null);
+ e = new LiteralExpr(i, null);
break;
+ }
+
+ // true | false
+ case TRUE:
+ case FALSE: {
+ String bool = accept(peek(1).type).spelling;
+ BooleanLiteral b = new BooleanLiteral(bool, null);
+ e = new LiteralExpr(b, null);
+ break;
+ }
// ( Expression )
- case LPAREN:
+ case LPAREN: {
accept(Token.TYPE.LPAREN);
- parseExpression();
+ e = parseExpression();
accept(Token.TYPE.RPAREN);
break;
+ }
// unop Expression
case UNOP:
- accept(Token.TYPE.UNOP);
- parseExpression();
- break;
-
- // Must be a minus sign
- case BINOP:
- if(peek(1).attr.equals("-")) {
- accept(Token.TYPE.BINOP);
- parseExpression();
- }
+ case BINOP: {
+ if(peek(1).spelling.equals("!") || peek(1).spelling.equals("-")) {
+ Operator o = new Operator(accept(peek(1).type), null);
+ e = new UnaryExpr(o, parseExpression(), null);
+ }
else throw new IOException();
break;
+ }
// new ( int [ Expression ] | id ( ) | id [ Expression ] )
- case NEW:
+ case NEW: {
accept(Token.TYPE.NEW);
if(peek(1).type == Token.TYPE.INT) {
accept(Token.TYPE.INT);
accept(Token.TYPE.LSQUARE);
- parseExpression();
+ Expression e2 = parseExpression();
accept(Token.TYPE.RSQUARE);
+
+ BaseType b = new BaseType(TypeKind.INT, null);
+ e = new NewArrayExpr(b, e2, null);
}
else {
- accept(Token.TYPE.ID);
+ String cn = accept(Token.TYPE.ID).spelling;
+ Identifier i = new Identifier(cn, null);
+ ClassType c = new ClassType(i, null);
if(peek(1).type == Token.TYPE.LPAREN){
accept(Token.TYPE.LPAREN);
accept(Token.TYPE.RPAREN);
- }
-
- else {
+ e = new NewObjectExpr(c, null);
+ } else {
accept(Token.TYPE.LSQUARE);
- parseExpression();
+ Expression e2 = parseExpression();
accept(Token.TYPE.RSQUARE);
+ e = new NewArrayExpr(c, e2, null);
}
}
break;
+ }
- // Reference | Reference (ArgumentList?)
- case THIS:
- case ID:
- parseReference();
+ // Reference ((ArgumentList?))?
+ case THIS: case ID: {
+ Reference r = parseReference();
if(peek(1).type == Token.TYPE.LPAREN) {
accept(Token.TYPE.LPAREN);
- if(peek(1).type != Token.TYPE.RPAREN) parseArgumentList();
+ ExprList el = new ExprList();
+ if(peek(1).type != Token.TYPE.RPAREN) {
+ el = parseArgumentList();
+ }
accept(Token.TYPE.RPAREN);
+ e = new CallExpr(r, el, null);
+ } else {
+ e = new RefExpr(r, null);
}
- break;
- // Expression binop Expression
- default:
- accept(Token.TYPE.BINOP);
- parseExpression();
break;
+ }
+
+ default:
+ throw new IOException();
}
// Expression binop Expression
if(peek(1).type == Token.TYPE.BINOP) {
- accept(Token.TYPE.BINOP);
- parseExpression();
+ Operator o = new Operator(accept(Token.TYPE.BINOP), null);
+ e = new BinaryExpr(o, e, parseDExpression(), null);
}
+
+ return e;
+ }
+
+ /**
+ * Disjunction
+ * @throws IOException
+ */
+ private Expression parseDExpression() throws IOException {
+ Expression e = parseCExpression();
+ while(peek(1).spelling.equals("||")) {
+ Operator o = new Operator(accept(Token.TYPE.BINOP), null);
+ e = new BinaryExpr(o, e, parseCExpression(), null);
+ }
+
+ return e;
+ }
+
+ /**
+ * Conjunction
+ * @throws IOException
+ */
+ private Expression parseCExpression() throws IOException {
+ Expression e = parseEExpression();
+ while(peek(1).spelling.equals("&&")) {
+ Operator o = new Operator(accept(Token.TYPE.BINOP), null);
+ e = new BinaryExpr(o, e, parseEExpression(), null);
+ }
+
+ return e;
+ }
+
+ /**
+ * Equality
+ * @throws IOException
+ */
+ private Expression parseEExpression() throws IOException {
+ Expression e = parseRExpression();
+ while(peek(1).spelling.equals("==") || peek(1).spelling.equals("!=")) {
+ Operator o = new Operator(accept(Token.TYPE.BINOP), null);
+ e = new BinaryExpr(o, e, parseRExpression(), null);
+ }
+
+ return e;
+ }
+
+ /**
+ * Relational
+ * @throws IOException
+ */
+ private Expression parseRExpression() throws IOException {
+ Expression e = parseAExpression();
+ while(peek(1).spelling.equals("<=") || peek(1).spelling.equals(">=")
+ || peek(1).spelling.equals("<") || peek(1).spelling.equals(">")) {
+ Operator o = new Operator(accept(Token.TYPE.BINOP), null);
+ e = new BinaryExpr(o, e, parseAExpression(), null);
+ }
+
+ return e;
+ }
+
+ /**
+ * Additive
+ * @throws IOException
+ */
+ private Expression parseAExpression() throws IOException {
+ Expression e = parseMExpression();
+ while(peek(1).spelling.equals("+") || peek(1).spelling.equals("-")) {
+ Operator o = new Operator(accept(Token.TYPE.BINOP), null);
+ e = new BinaryExpr(o, e, parseMExpression(), null);
+ }
+
+ return e;
+ }
+
+ /**
+ * Multiplicative
+ * @throws IOException
+ */
+ private Expression parseMExpression() throws IOException {
+ Expression e = parseExpression();
+ while(peek(1).spelling.equals("*") || peek(1).spelling.equals("/")) {
+ Operator o = new Operator(accept(Token.TYPE.BINOP), null);
+ e = new BinaryExpr(o, e, parseExpression(), null);
+ }
+
+ return e;
}
@@ -401,9 +607,11 @@ public class Parser {
* Consumes token or throws exception.
* @throws IOException
*/
- private void accept(Token.TYPE type) throws IOException {
+ private Token accept(Token.TYPE type) throws IOException {
Token next = peek(1);
if(next.type == type) stream.poll();
else throw new IOException();
+
+ return next;
}
}
diff --git a/miniJava/src/miniJava/SyntacticAnalyzer/Scanner.java b/miniJava/src/miniJava/SyntacticAnalyzer/Scanner.java
index 49cb14d..98a6cb2 100644
--- a/miniJava/src/miniJava/SyntacticAnalyzer/Scanner.java
+++ b/miniJava/src/miniJava/SyntacticAnalyzer/Scanner.java
@@ -153,7 +153,7 @@ public class Scanner {
break;
}
}
- System.out.println(token.type);
+
return token;
}
diff --git a/miniJava/src/miniJava/SyntacticAnalyzer/SourcePosition.java b/miniJava/src/miniJava/SyntacticAnalyzer/SourcePosition.java
new file mode 100644
index 0000000..38ddb6c
--- /dev/null
+++ b/miniJava/src/miniJava/SyntacticAnalyzer/SourcePosition.java
@@ -0,0 +1,12 @@
+package miniJava.SyntacticAnalyzer;
+
+public class SourcePosition {
+
+ public final int col;
+ public final int line;
+
+ public SourcePosition(int line, int col) {
+ this.col = col;
+ this.line = line;
+ }
+}
diff --git a/miniJava/src/miniJava/SyntacticAnalyzer/Token.java b/miniJava/src/miniJava/SyntacticAnalyzer/Token.java
index f2593b2..7c78681 100644
--- a/miniJava/src/miniJava/SyntacticAnalyzer/Token.java
+++ b/miniJava/src/miniJava/SyntacticAnalyzer/Token.java
@@ -69,10 +69,10 @@ public class Token {
}
public final TYPE type;
- public final String attr;
+ public final String spelling;
- public Token(String attr, TYPE type) {
+ public Token(String spelling, TYPE type) {
this.type = type;
- this.attr = attr;
+ this.spelling = spelling;
}
}
diff --git a/miniJava/src/miniJava/SyntacticAnalyzer/grammar.txt b/miniJava/src/miniJava/grammar.txt
similarity index 89%
rename from miniJava/src/miniJava/SyntacticAnalyzer/grammar.txt
rename to miniJava/src/miniJava/grammar.txt
index 0cf2bc3..b0947d8 100644
--- a/miniJava/src/miniJava/SyntacticAnalyzer/grammar.txt
+++ b/miniJava/src/miniJava/grammar.txt
@@ -31,10 +31,10 @@ Statement ::=
| while (Expression) Statement
Expression ::=
- Reference
- | Reference ( ArgumentList? )
+ Reference ((ArgumentList?))?
| unop Expression
| Expression binop Expression
| ( Expression )
| num | true | false
- | new (id() | int [ Expression ] | id [ Expression ] )
\ No newline at end of file
+ | new (id() | int [ Expression ] | id [ Expression ] )
+
\ No newline at end of file
diff --git a/miniJava/src/miniJava/stratified.txt b/miniJava/src/miniJava/stratified.txt
new file mode 100644
index 0000000..fd62abf
--- /dev/null
+++ b/miniJava/src/miniJava/stratified.txt
@@ -0,0 +1,50 @@
+Program ::= (ClassDeclaration)* eot
+
+ClassDeclaration ::=
+ class id {
+ (Declarators id (; | MethodDeclaration))*
+ }
+
+MethodDeclaration ::=
+ (ParameterList?) {
+ Statement* (return Expression ;)?
+ }
+
+Declarators ::= (public | private)? static? Type
+
+Type ::= boolean | void | int ([])? | id ([])?
+
+ParameterList ::= Type id (, Type id)*
+
+ArgumentList ::= Expression (, Expression)*
+
+Reference ::= BaseRef (. id ([ Expression])?)*
+
+BaseRef ::= this | id ([ Expression])?
+
+Statement ::=
+ {Statement*}
+ | Type id = Expression;
+ | Reference = Expression;
+ | Reference ( ArgumentList? );
+ | if (Expression) Statement (else Statement)?
+ | while (Expression) Statement
+
+Expression ::=
+ num | true | false
+ | ( Expression )
+ | new (id() | int [ Expression ] | id [ Expression ] )
+ | Reference ((ArgumentList?))?
+ | DExpression
+
+DExpression ::= CExpression (|| CExpression)*
+CExpression ::= EExpression (&& EExpression)*
+EExpression ::= RExpression ((==|!=) RExpression)*
+RExpression ::= AExpression ((<=|<|>|>=) AExpression)*
+AExpression ::= MExpression ((+|-) MExpression)*
+MExpression ::= Expression ((*|/) Expression)*
+
+
+
+
+
\ No newline at end of file
diff --git a/miniJava/test.java b/miniJava/test.java
index eb38ef4..b4ffe40 100644
--- a/miniJava/test.java
+++ b/miniJava/test.java
@@ -1,7 +1,12 @@
-// PA1 parse assign fail
-class Test {
+// Simple PA2 Example
+class PA2 {
- void p(int a) {
- that.this = 4;
- }
+ public boolean c;
+
+ public static void main(String[] args) {
+ if(x > 1)
+ x = 1 + 2 * x;
+ else
+ b[3].a = 4;
+ }
}
\ No newline at end of file