spiglet symtab

9 files changed, 440 insertions, 4 deletions

diff --git a/src/spiglet/spiglet2kanga/Main.java b/src/spiglet/spiglet2kanga/Main.java
index e6e15f6..3778ef3 100644
--- a/src/spiglet/spiglet2kanga/Main.java
+++ b/src/spiglet/spiglet2kanga/Main.java
@@ -5,6 +5,7 @@ import spiglet.SpigletParser;
 import spiglet.TokenMgrError;

 import spiglet.syntaxtree.Node;

 import spiglet.visitor.GJDepthFirst;

+import spiglet.visitor.GenKangaVisitor;

 

 

 

@@ -18,10 +19,8 @@ public class Main {
     		 * TODO: Implement your own Visitors and other classes.

     		 * 

     		 */

-    		GJDepthFirst v = new GJDepthFirst<Object,Object>() {

-    		};

-    		//Traverse the Abstract Grammar Tree

-    		root.accept(v,null);

+    		SpgGoal goal = new SpgGoal();

+    		root.accept(new GenKangaVisitor(), goal);

     	}

     	catch(TokenMgrError e){

     		//Handle Lexical Errors

diff --git a/src/spiglet/spiglet2kanga/SpgExpr.java b/src/spiglet/spiglet2kanga/SpgExpr.java
new file mode 100644
index 0000000..da9fa46
--- /dev/null
+++ b/src/spiglet/spiglet2kanga/SpgExpr.java
@@ -0,0 +1,27 @@
+package spiglet.spiglet2kanga;
+
+import java.util.Vector;
+
+public class SpgExpr extends SpgSym {
+	public enum ExpType { CALL, ALLOC, BinOp, Simple };
+	
+	public ExpType type;
+	public String op;
+	public SpgTemp oprand;
+	public SpgSimpExpr se;
+	public Vector<SpgTemp> callParams;
+	
+	public SpgExpr(ExpType t) {
+		type = t;
+		callParams = new Vector<SpgTemp>();
+	}
+	
+	public void addCallParam(SpgTemp t) {
+		if (type!=ExpType.CALL) {
+			System.err.println("Error adding parameter, should be a CALL expression.");
+			return;
+		}
+		callParams.addElement(t);
+	}
+	
+}
diff --git a/src/spiglet/spiglet2kanga/SpgGoal.java b/src/spiglet/spiglet2kanga/SpgGoal.java
new file mode 100644
index 0000000..c7dd464
--- /dev/null
+++ b/src/spiglet/spiglet2kanga/SpgGoal.java
@@ -0,0 +1,15 @@
+package spiglet.spiglet2kanga;
+
+import java.util.Vector;
+
+public class SpgGoal extends SpgSym {
+	Vector<SpgProc> procs;
+	
+	public SpgGoal() {
+		procs = new Vector<SpgProc>();
+	}
+	
+	public void addProc(SpgProc p) {
+		procs.addElement(p);
+	}
+}
diff --git a/src/spiglet/spiglet2kanga/SpgProc.java b/src/spiglet/spiglet2kanga/SpgProc.java
new file mode 100644
index 0000000..5d62dfa
--- /dev/null
+++ b/src/spiglet/spiglet2kanga/SpgProc.java
@@ -0,0 +1,24 @@
+package spiglet.spiglet2kanga;
+
+import java.util.Vector;
+
+public class SpgProc extends SpgSym {
+	String name;
+	int argCount;
+	int stkCount;
+	int maxCallArgCount;
+	
+	public Vector<SpgStmt> statements;
+	public SpgSimpExpr retexp;
+	
+	public SpgProc(String s, int n) {
+		name = s;
+		argCount = n;
+		statements = new Vector<SpgStmt>();
+	}
+	
+	public void addStmt(SpgStmt s) {
+		statements.addElement(s);
+	}
+	
+}
diff --git a/src/spiglet/spiglet2kanga/SpgSimpExpr.java b/src/spiglet/spiglet2kanga/SpgSimpExpr.java
new file mode 100644
index 0000000..6b1b212
--- /dev/null
+++ b/src/spiglet/spiglet2kanga/SpgSimpExpr.java
@@ -0,0 +1,13 @@
+package spiglet.spiglet2kanga;
+
+public class SpgSimpExpr extends SpgExpr {
+	public enum SExprType { TEMP, INT, LB };
+	SExprType type;
+	public int num;
+	public String s;
+	
+	public SpgSimpExpr(SExprType t) {
+		super(SpgExpr.ExpType.Simple);
+		type = t;
+	}
+}
diff --git a/src/spiglet/spiglet2kanga/SpgStmt.java b/src/spiglet/spiglet2kanga/SpgStmt.java
new file mode 100644
index 0000000..832c489
--- /dev/null
+++ b/src/spiglet/spiglet2kanga/SpgStmt.java
@@ -0,0 +1,17 @@
+package spiglet.spiglet2kanga;
+
+public class SpgStmt extends SpgSym{
+	public enum StmtType { NOOP, ERROR, CJUMP, JUMP, STORE, LOAD, MOVE, PRINT };
+	StmtType type;
+	public SpgTemp tmp1, tmp2;
+	public int imm;
+	public String jmptarget;
+	public SpgExpr exp;
+	
+	public String lb;
+	public SpgStmt succ1, succ2;
+	
+	public SpgStmt(StmtType t) {
+		type = t;
+	}
+}
diff --git a/src/spiglet/spiglet2kanga/SpgSym.java b/src/spiglet/spiglet2kanga/SpgSym.java
new file mode 100644
index 0000000..43f2a99
--- /dev/null
+++ b/src/spiglet/spiglet2kanga/SpgSym.java
@@ -0,0 +1,5 @@
+package spiglet.spiglet2kanga;
+
+public class SpgSym {
+
+}
diff --git a/src/spiglet/spiglet2kanga/SpgTemp.java b/src/spiglet/spiglet2kanga/SpgTemp.java
new file mode 100644
index 0000000..3703a2e
--- /dev/null
+++ b/src/spiglet/spiglet2kanga/SpgTemp.java
@@ -0,0 +1,12 @@
+package spiglet.spiglet2kanga;
+
+public class SpgTemp extends SpgSimpExpr {
+	public SpgTemp(int n) {
+		super(SpgSimpExpr.SExprType.TEMP);
+		num = n;
+	}
+	
+	public int tempNum() {
+		return num;
+	}
+}
diff --git a/src/spiglet/visitor/GenKangaVisitor.java b/src/spiglet/visitor/GenKangaVisitor.java
new file mode 100644
index 0000000..dbd5ae1
--- /dev/null
+++ b/src/spiglet/visitor/GenKangaVisitor.java
@@ -0,0 +1,324 @@
+package spiglet.visitor;
+import spiglet.spiglet2kanga.SpgExpr;
+import spiglet.spiglet2kanga.SpgGoal;
+import spiglet.spiglet2kanga.SpgProc;
+import spiglet.spiglet2kanga.SpgSimpExpr;
+import spiglet.spiglet2kanga.SpgStmt;
+import spiglet.spiglet2kanga.SpgSym;
+import spiglet.spiglet2kanga.SpgTemp;
+import spiglet.syntaxtree.BinOp;
+import spiglet.syntaxtree.CJumpStmt;
+import spiglet.syntaxtree.Call;
+import spiglet.syntaxtree.ErrorStmt;
+import spiglet.syntaxtree.Exp;
+import spiglet.syntaxtree.Goal;
+import spiglet.syntaxtree.HAllocate;
+import spiglet.syntaxtree.HLoadStmt;
+import spiglet.syntaxtree.HStoreStmt;
+import spiglet.syntaxtree.IntegerLiteral;
+import spiglet.syntaxtree.JumpStmt;
+import spiglet.syntaxtree.Label;
+import spiglet.syntaxtree.MoveStmt;
+import spiglet.syntaxtree.NoOpStmt;
+import spiglet.syntaxtree.Operator;
+import spiglet.syntaxtree.PrintStmt;
+import spiglet.syntaxtree.Procedure;
+import spiglet.syntaxtree.SimpleExp;
+import spiglet.syntaxtree.Stmt;
+import spiglet.syntaxtree.StmtExp;
+import spiglet.syntaxtree.StmtList;
+import spiglet.syntaxtree.Temp;
+
+/**
+* Provides default methods which visit each node in the tree in depth-first
+* order.  Your visitors may extend this class.
+*/
+public class GenKangaVisitor extends GJDepthFirst<SpgSym, SpgSym> {
+
+	//
+	// User-generated visitor methods below
+	//
+	/**
+	 * f0 -> "MAIN"
+	 * f1 -> StmtList()
+	 * f2 -> "END"
+	 * f3 -> ( Procedure() )*
+	 * f4 -> <EOF>
+	 */
+	public SpgSym visit(Goal n, SpgSym argu) {
+		// argu is a SpgGoal instance
+		SpgGoal g = (SpgGoal)argu;
+		SpgProc mainproc = new SpgProc("MAIN", 0);
+		g.addProc(mainproc);
+		n.f1.accept(this, mainproc);
+		n.f3.accept(this, argu);
+		return null;
+	}
+
+	/**
+	 * f0 -> ( ( Label() )? Stmt() )*
+	 */
+	public SpgSym visit(StmtList n, SpgSym argu) {
+		n.f0.accept(this, argu);
+		return null;
+	}
+
+	/**
+	 * f0 -> Label()
+	 * f1 -> "["
+	 * f2 -> IntegerLiteral()
+	 * f3 -> "]"
+	 * f4 -> StmtExp()
+	 */
+	public SpgSym visit(Procedure n, SpgSym argu) {
+		// argu is a SpgGoal instance
+		SpgGoal g = (SpgGoal)argu;
+		String name = n.f0.f0.tokenImage;
+		int argc = Integer.parseInt(n.f2.f0.tokenImage);
+		SpgProc p = new SpgProc(name, argc);
+		g.addProc(p);
+		n.f4.accept(this, p);
+		return null;
+	}
+
+	/**
+	 * f0 -> NoOpStmt()
+	 *       | ErrorStmt()
+	 *       | CJumpStmt()
+	 *       | JumpStmt()
+	 *       | HStoreStmt()
+	 *       | HLoadStmt()
+	 *       | MoveStmt()
+	 *       | PrintStmt()
+	 */
+	public SpgSym visit(Stmt n, SpgSym argu) {
+		n.f0.accept(this, argu);
+		return null;
+	}
+
+	/**
+	 * f0 -> "NOOP"
+	 */
+	public SpgSym visit(NoOpStmt n, SpgSym argu) {
+		SpgProc p = (SpgProc)argu;
+		p.addStmt(new SpgStmt(SpgStmt.StmtType.NOOP));
+		return null;
+	}
+
+	/**
+	 * f0 -> "ERROR"
+	 */
+	public SpgSym visit(ErrorStmt n, SpgSym argu) {
+		SpgProc p = (SpgProc)argu;
+		p.addStmt(new SpgStmt(SpgStmt.StmtType.ERROR));
+		return null;
+	}
+
+	/**
+	 * f0 -> "CJUMP"
+	 * f1 -> Temp()
+	 * f2 -> Label()
+	 */
+	public SpgSym visit(CJumpStmt n, SpgSym argu) {
+		SpgProc p = (SpgProc)argu;
+		SpgStmt s = new SpgStmt(SpgStmt.StmtType.CJUMP);
+		s.tmp1 = (SpgTemp)n.f1.accept(this, null);
+		s.jmptarget = n.f2.f0.tokenImage;
+		p.addStmt(s);
+		return null;
+	}
+
+	/**
+	 * f0 -> "JUMP"
+	 * f1 -> Label()
+	 */
+	public SpgSym visit(JumpStmt n, SpgSym argu) {
+		SpgProc p = (SpgProc)argu;
+		SpgStmt s = new SpgStmt(SpgStmt.StmtType.JUMP);
+		s.jmptarget = n.f1.f0.tokenImage;
+		p.addStmt(s);
+		return null;
+	}
+
+	/**
+	 * f0 -> "HSTORE"
+	 * f1 -> Temp()
+	 * f2 -> IntegerLiteral()
+	 * f3 -> Temp()
+	 */
+	public SpgSym visit(HStoreStmt n, SpgSym argu) {
+		SpgProc p = (SpgProc)argu;
+		SpgStmt s = new SpgStmt(SpgStmt.StmtType.STORE);
+		s.tmp1 = (SpgTemp)n.f1.accept(this, null);
+		s.tmp2 = (SpgTemp)n.f3.accept(this, null);
+		s.imm = Integer.parseInt(n.f2.f0.tokenImage);
+		p.addStmt(s);
+		return null;
+	}
+
+	/**
+	 * f0 -> "HLOAD"
+	 * f1 -> Temp()
+	 * f2 -> Temp()
+	 * f3 -> IntegerLiteral()
+	 */
+	public SpgSym visit(HLoadStmt n, SpgSym argu) {
+		SpgProc p = (SpgProc)argu;
+		SpgStmt s = new SpgStmt(SpgStmt.StmtType.LOAD);
+		s.tmp1 = (SpgTemp)n.f1.accept(this, null);
+		s.tmp2 = (SpgTemp)n.f2.accept(this, null);
+		s.imm = Integer.parseInt(n.f3.f0.tokenImage);
+		p.addStmt(s);
+		return null;
+	}
+
+	/**
+	 * f0 -> "MOVE"
+	 * f1 -> Temp()
+	 * f2 -> Exp()
+	 */
+	public SpgSym visit(MoveStmt n, SpgSym argu) {
+		SpgProc p = (SpgProc)argu;
+		SpgStmt s = new SpgStmt(SpgStmt.StmtType.MOVE);
+		s.tmp1 = (SpgTemp)n.f1.accept(this, null);
+		s.exp = (SpgExpr)n.f2.accept(this, null);
+		p.addStmt(s);
+		return null;
+	}
+
+	/**
+	 * f0 -> "PRINT"
+	 * f1 -> SimpleExp()
+	 */
+	public SpgSym visit(PrintStmt n, SpgSym argu) {
+		SpgProc p = (SpgProc)argu;
+		SpgStmt s = new SpgStmt(SpgStmt.StmtType.PRINT);
+		s.exp = (SpgExpr)n.f1.accept(this, null);
+		p.addStmt(s);
+		return null;
+	}
+
+	/**
+	 * f0 -> Call()
+	 *       | HAllocate()
+	 *       | BinOp()
+	 *       | SimpleExp()
+	 */
+	public SpgSym visit(Exp n, SpgSym argu) {
+		return n.f0.accept(this, null);
+	}
+
+	/**
+	 * f0 -> "BEGIN"
+	 * f1 -> StmtList()
+	 * f2 -> "RETURN"
+	 * f3 -> SimpleExp()
+	 * f4 -> "END"
+	 */
+	public SpgSym visit(StmtExp n, SpgSym argu) {
+		// argu should be SpgProc
+		SpgProc p = (SpgProc)argu;
+		n.f1.accept(this, p);
+		p.retexp = (SpgSimpExpr)n.f3.accept(this, argu);
+		return null;
+	}
+
+	/**
+	 * f0 -> "CALL"
+	 * f1 -> SimpleExp()
+	 * f2 -> "("
+	 * f3 -> ( Temp() )*
+	 * f4 -> ")"
+	 */
+	public SpgSym visit(Call n, SpgSym argu) {
+		SpgExpr e = new SpgExpr(SpgExpr.ExpType.CALL);
+		e.se = (SpgSimpExpr)n.f1.accept(this, null);
+		n.f3.accept(this, e);
+		return e;
+	}
+
+	/**
+	 * f0 -> "HALLOCATE"
+	 * f1 -> SimpleExp()
+	 */
+	public SpgSym visit(HAllocate n, SpgSym argu) {
+		SpgExpr e = new SpgExpr(SpgExpr.ExpType.ALLOC);
+		e.se = (SpgSimpExpr)n.f1.accept(this, null);
+		return e;
+	}
+
+	/**
+	 * f0 -> Operator()
+	 * f1 -> Temp()
+	 * f2 -> SimpleExp()
+	 */
+	public SpgSym visit(BinOp n, SpgSym argu) {
+		SpgExpr e = new SpgExpr(SpgExpr.ExpType.BinOp);
+		n.f0.accept(this, e);
+		e.oprand = (SpgTemp)n.f1.accept(this, null);
+		e.se = (SpgSimpExpr)n.f2.accept(this, null);
+		return e;
+	}
+
+	/**
+	 * f0 -> "LT"
+	 *       | "PLUS"
+	 *       | "MINUS"
+	 *       | "TIMES"
+	 */
+	public SpgSym visit(Operator n, SpgSym argu) {
+		// argu should be a BinOp expression
+		final String[] ops = { "LT", "PLUS", "MINUS", "TIMES" };
+		SpgExpr e = (SpgExpr)argu;
+		e.op = ops[n.f0.which];
+		return null;
+	}
+
+	/**
+	 * f0 -> Temp()
+	 *       | IntegerLiteral()
+	 *       | Label()
+	 */
+	public SpgSym visit(SimpleExp n, SpgSym argu) {
+		return n.f0.accept(this, argu);
+	}
+
+	/**
+	 * f0 -> "TEMP"
+	 * f1 -> IntegerLiteral()
+	 */
+	public SpgSym visit(Temp n, SpgSym argu) {
+		int i = Integer.parseInt(n.f1.f0.tokenImage);
+		SpgTemp t = new SpgTemp(i);
+		if (argu!=null) {
+			// should be a call expression
+			SpgExpr e = (SpgExpr)argu;
+			e.addCallParam(t);
+		}
+		return t;
+	}
+
+	/**
+	 * f0 -> <INTEGER_LITERAL>
+	 */
+	public SpgSym visit(IntegerLiteral n, SpgSym argu) {
+		SpgSimpExpr e = new SpgSimpExpr(SpgSimpExpr.SExprType.INT);
+		e.num = Integer.parseInt(n.f0.tokenImage);
+		return e;
+	}
+
+	/**
+	 * f0 -> <IDENTIFIER>
+	 */
+	public SpgSym visit(Label n, SpgSym argu) {
+		SpgSimpExpr e = new SpgSimpExpr(SpgSimpExpr.SExprType.LB);
+		e.s = n.f0.tokenImage;
+		if (argu!=null) {
+			// should be a procedure
+			SpgProc p = (SpgProc)argu;
+			p.statements.lastElement().lb = e.s;
+		}
+		return e;
+	}
+
+}