Add test file, fix minor issues in SymbolTable

6 files changed, 137 insertions, 43 deletions

diff --git a/Playground.java b/Playground.java
index aae1af6..8e9cbc0 100644
--- a/Playground.java
+++ b/Playground.java
@@ -17,28 +17,104 @@ public class Playground {
     }
 
     public static void main(String[] args) {
-        HashMap<String,AbstractInstance> symt = new HashMap<>();
 
-        symt.put("x", new TypeInstance("x", TypeEnum.integer));
-        symt.put("a", new MethodInstance("a", TypeEnum.intarray));
-        symt.put("A", new ClassInstance("A", new ClassInstance("B")));
-        System.out.println("Our symbol table has lots of symbols: " + HashMapToString(symt));
-        System.out.println("It seems class A extends B, but B isn't in the table... " +
-                           ((ClassInstance) symt.get("A")).getExtend());
+        /*
+          class Factorial{
+          ....public static void main(String[] a){
+          ........System.out.println(new Fac().ComputeFac(10));
+          ....}
+          }
+          class Fac {
+          ....int[] useless_var ;
+          ....public int ComputeFac(int num){
+          ........int num_aux ;
+          ........if (num < 1)
+          ............num_aux = 1 ;
+          ........else
+          ............num_aux = num * (this.ComputeFac(num-1)) ;
+          ........return num_aux ;
+          ....}
+          }
+          class Fac2 extends Fac {
+          }
+
+          The below is a manual practice run of the SymbolTable class.
+        */
 
         SymbolTable ssymt = new SymbolTable();
 
-        ssymt.put("x", new TypeInstance("x", TypeEnum.integer));
-        ssymt.put("A", new ClassInstance("A"));
-	System.out.println("A smarter approach. Here's type 'x':" +
-			   ssymt.getType("x"));
-        System.out.println("Null class 'x':" +
-                           ssymt.getClass("x"));
-        System.out.println("Null method 'x':" +
-                           ssymt.getMethod("x"));
-        System.out.println("Null type 'y':" +
-                           ssymt.getType("y"));
-        System.out.println("Null type 'A':" +
-                           ssymt.getType("A"));
+        /* pass one */
+        ssymt.put("Factorial", new ClassInstance("Factorial"));
+        ssymt.put("main", new MethodInstance("main", TypeEnum.ERROR));
+        ssymt.put("Fac", new ClassInstance("Fac"));
+        ssymt.put("useless_var", new TypeInstance("useless_var", TypeEnum.intarray));
+        ssymt.put("ComputeFac", new MethodInstance("ComputeFac", TypeEnum.integer));
+        ssymt.put("num", new TypeInstance("num", TypeEnum.integer));
+        ssymt.put("num_aux", new TypeInstance("num_aux", TypeEnum.integer));
+        ssymt.put("Fac2", new ClassInstance("Fac2"));
+
+        System.out.println("Post pass one: " + ssymt.toString());
+
+        /* pass two */
+        ssymt.setActive("Factorial", TypeEnum.classname);
+        ssymt.setActive("main", TypeEnum.method);
+        ssymt.addMethod("main");
+        ssymt.setActive("Fac", TypeEnum.classname);
+        ssymt.addAttribute("useless_var");
+        ssymt.setActive("ComputeFac", TypeEnum.method);
+        ssymt.addMethod("ComputeFac");
+        ssymt.addParameter("num");
+        ssymt.addLocal("num_aux");
+        ssymt.setActive("Fac2", TypeEnum.classname);
+        ssymt.setExtend("Fac");
+
+        ArrayList<TypeInstance> attrs_in_factorial = new ArrayList<>();
+        ArrayList<MethodInstance> mtds_in_factorial = new ArrayList<>();
+        mtds_in_factorial.add(ssymt.getMethod("main"));
+        ArrayList<TypeInstance> attrs_in_fac = new ArrayList<>();
+        attrs_in_fac.add(ssymt.getType("useless_var"));
+        ArrayList<MethodInstance> mtds_in_fac = new ArrayList<>();
+        mtds_in_fac.add(ssymt.getMethod("ComputeFac"));
+        ArrayList<TypeInstance> attrs_in_fac2 = new ArrayList<>(); // FIXME
+        ArrayList<MethodInstance> mtds_in_fac2 = new ArrayList<>(); // FIXME
+
+        System.out.println("test class children");
+        System.out.println(ssymt.getClass("Factorial").getAttributes().equals(attrs_in_factorial));
+        System.out.println(ssymt.getClass("Factorial").getMethods().equals(mtds_in_factorial));
+        System.out.println(ssymt.getClass("Fac").getAttributes().equals(attrs_in_fac));
+        System.out.println(ssymt.getClass("Fac").getMethods().equals(mtds_in_fac));
+        System.out.println(ssymt.getClass("Fac2").getAttributes().equals(attrs_in_fac2));
+        System.out.println(ssymt.getClass("Fac2").getMethods().equals(mtds_in_fac2));
+
+        ArrayList<TypeInstance> args_in_computefac = new ArrayList<>();
+        args_in_computefac.add(ssymt.getType("num"));
+        ArrayList<TypeInstance> locals_in_computefac = new ArrayList<>(args_in_computefac);
+        locals_in_computefac.add(ssymt.getType("num_aux"));
+
+        System.out.println("test method children");
+        System.out.println(ssymt.getMethod("ComputeFac").getArguments().equals(args_in_computefac));
+        System.out.println(ssymt.getMethod("ComputeFac").getLocals().equals(locals_in_computefac));
+
+        ClassInstance exts_factorial = null;
+        ClassInstance exts_fac = null;
+        ClassInstance exts_fac2 = ssymt.getClass("Fac");
+
+        System.out.println("test inheritance");
+        System.out.println(ssymt.getClass("Factorial").getExtend() == exts_factorial);
+        System.out.println(ssymt.getClass("Fac").getExtend() == exts_fac);
+        System.out.println(ssymt.getClass("Fac2").getExtend() == exts_fac2);
+
+        AbstractInstance scope_main = ssymt.getClass("Factorial");
+        AbstractInstance scope_computefac = ssymt.getClass("Fac");
+        AbstractInstance scope_uselessvar = ssymt.getClass("Fac");
+        AbstractInstance scope_num = ssymt.getMethod("ComputeFac");
+        AbstractInstance scope_numaux = ssymt.getMethod("ComputeFac");
+
+        System.out.println("test scope");
+        System.out.println(ssymt.getMethod("main").getScope() == scope_main);
+        System.out.println(ssymt.getMethod("ComputeFac").getScope() == scope_computefac);
+        System.out.println(ssymt.getType("useless_var").getScope() == scope_uselessvar);
+        System.out.println(ssymt.getType("num").getScope() == scope_num);
+        System.out.println(ssymt.getType("num_aux").getScope() == scope_numaux);
     }
 }
diff --git a/st/AbstractInstance.java b/st/AbstractInstance.java
index 7acc3e5..a6c2ca1 100644
--- a/st/AbstractInstance.java
+++ b/st/AbstractInstance.java
@@ -16,7 +16,8 @@ public abstract class AbstractInstance {
     }
 
     public boolean equals(AbstractInstance other) {
-        return this.name == other.getName();
+        return this.name == other.getName() &&
+            this.type == this.type;
     }
 
     public int hashCode() {
diff --git a/st/ClassInstance.java b/st/ClassInstance.java
index a5f1493..f926fa6 100644
--- a/st/ClassInstance.java
+++ b/st/ClassInstance.java
@@ -13,20 +13,7 @@ public class ClassInstance extends AbstractInstance {
         this.mtds = new ArrayList<>();
     }
 
-    public ClassInstance(String name, ClassInstance ext) {
-        super(name, TypeEnum.classname);
-        this.ext = ext;
-    }
-
-    public void addAttribute(TypeInstance attr) {
-        this.attrs.add(attr);
-    }
-
-    public void addMethod(MethodInstance mtd) {
-        this.mtds.add(mtd);
-    }
-
-    public AbstractInstance getExtend() {
+    public ClassInstance getExtend() {
         /**
          * Returns the parent class, or
          * `null' if unset.
@@ -38,8 +25,23 @@ public class ClassInstance extends AbstractInstance {
         return this.attrs;
     }
 
-    public ArrayList<MethodInstance> getMethod() {
+    public ArrayList<MethodInstance> getMethods() {
         return this.mtds;
     }
 
+    protected void addAttribute(TypeInstance attr) {
+        this.attrs.add(attr);
+    }
+
+    protected void addMethod(MethodInstance mtd) {
+        this.mtds.add(mtd);
+    }
+
+    protected void setExtend(ClassInstance ext) {
+        if (this.ext != null)
+            throw new RuntimeException("setExtend: Attempted to set extended class twice!");
+
+        this.ext = ext;
+    }
+
 }
diff --git a/st/MethodInstance.java b/st/MethodInstance.java
index 25096d2..c7df92f 100644
--- a/st/MethodInstance.java
+++ b/st/MethodInstance.java
@@ -6,7 +6,6 @@ public class MethodInstance extends AbstractInstance {
     private ArrayList<TypeInstance> args;       // the list of arguments
     private ArrayList<TypeInstance> lvars;      // the list of local variables
     private TypeEnum rtrn;                      // the returned type
-    private ClassInstance scope;                // the surrounding class
 
     public MethodInstance(String name, TypeEnum rtrn) {
         super(name, TypeEnum.method);
@@ -15,12 +14,20 @@ public class MethodInstance extends AbstractInstance {
         this.rtrn = rtrn;
     }
 
-    public void addArgument(TypeInstance arg) {
+    public ArrayList<TypeInstance> getArguments() {
+        return this.args;
+    }
+
+    public ArrayList<TypeInstance> getLocals() {
+        return this.lvars;
+    }
+
+    protected void addArgument(TypeInstance arg) {
         this.args.add(arg);
         this.lvars.add(arg);
     }
 
-    public void addLocal(TypeInstance lvar) {
+    protected void addLocal(TypeInstance lvar) {
         this.lvars.add(lvar);
     }
 
diff --git a/st/SymbolTable.java b/st/SymbolTable.java
index d6bba37..154c142 100644
--- a/st/SymbolTable.java
+++ b/st/SymbolTable.java
@@ -19,7 +19,7 @@ public class SymbolTable {
     public String toString() {
         StringBuilder mapAsString = new StringBuilder("{");
         for (String key : this.symt.keySet()) {
-            mapAsString.append(key + ":" + this.symt.get(key) + ", ");
+            mapAsString.append(key + ":" + this.symt.get(key).getType() + ", ");
         }
         mapAsString.delete(mapAsString.length()-2, mapAsString.length()).append("}");
         return mapAsString.toString();
@@ -37,10 +37,20 @@ public class SymbolTable {
     /**
      * Methods intended to be used during the second pass
      */
-    public void setActive(TypeEnum type, String id) {
+    public void setActive(String id, TypeEnum type) {
         this.active.put(type, id);
     }
 
+    public void setExtend(String arg) {
+        String str = this.active.get(TypeEnum.classname);
+        ClassInstance cls = this.getClass(str);
+        ClassInstance ext = this.getClass(arg);
+
+        cls.setExtend(ext);
+        // for (TypeInstance : ext.attrs) //FIXME add the extended classes' stuff
+        //     cls.add
+    }
+
     public void addAttribute(String arg) {
         String str = this.active.get(TypeEnum.classname);
         ClassInstance cls = this.getClass(str);
@@ -74,7 +84,7 @@ public class SymbolTable {
         TypeInstance var = this.getType(lvar);
 
         var.setScope(mtd);
-        mtd.addArgument(var);
+        mtd.addLocal(var);
     }
 
 
diff --git a/st/TypeInstance.java b/st/TypeInstance.java
index b4031d9..302f9f0 100644
--- a/st/TypeInstance.java
+++ b/st/TypeInstance.java
@@ -2,8 +2,6 @@ package st;
 
 public class TypeInstance extends AbstractInstance {
 
-    private AbstractInstance scope;
-
     public TypeInstance(String name, TypeEnum type) {
         super(name, type);
     }