Done

Author: n2o

Block.java

@@ -1,3 +1,7 @@
+/**
+ * Structure for the liveness analysis. Here are the information about DEF, USE, IN and OUT stored
+ */
+
 import java.util.LinkedList;
 
 public class Block {
@@ -59,9 +63,6 @@ public LinkedList<Block> getSuccessor() {
     public String getDef() {
         return def;
     }
-    public Block getSuccessor(int i) {
-        return successor.get(i);
-    }
     public boolean hasSuccessor() {
         return hasSuccessor;
     }

CodeGenerator.class

@@ -121,10 +121,10 @@ public void caseAAssignmentExpr(AAssignmentExpr node) {
     @Override
     public void caseANumberExpr(ANumberExpr node) {
         int number = Integer.parseInt(node.getNumber().toString().replaceAll(" ", ""));
-        if (number > 255)
+//        if (number > 255)
             code += "\tldc "+number+"\n";
-        else
-            code += "\tbipush "+number+"\n";
+//        else
+//            code += "\tbipush "+number+"\n";
         stackHeight++;
         type = "integer";
     }

CodeGenerator.java

@@ -8,7 +8,6 @@ public class GraphVisitor extends DepthFirstAdapter{
     private LinkedList<Block> blocks = new LinkedList<Block>();
     private Block lastBlock;
     private Block currentBlock;
-    private Block startBlock;
     private int blockID = 1;
     private HashMap<Integer, Integer> addSuccessors = new HashMap<Integer, Integer>();
 
@@ -22,7 +21,7 @@ public void caseAAssignmentExpr(AAssignmentExpr node) {
         String identifier = node.getIdentifier().toString().toLowerCase().replaceAll(" ","");
         currentBlock = new Block(identifier, blockID++);
         node.getExpr().apply(this);         // evaluate the expression
-        setStartAndSuccessor();
+        setNextSuccessor();
     }
     /**
      * For writeln(). Nearly same as Assignment
@@ -31,7 +30,7 @@ public void caseAAssignmentExpr(AAssignmentExpr node) {
     public void caseAPrintExpr(APrintExpr node) {
         currentBlock = new Block(blockID++);
         node.getExpr().apply(this);         // evaluate the expression
-        setStartAndSuccessor();
+        setNextSuccessor();
     }
     /**
      * If then
@@ -41,7 +40,7 @@ public void caseAIfThenExpr(AIfThenExpr node) {
         int temp = blockID;
         currentBlock = new Block(blockID++);
         node.getLeft().apply(this);         // evaluate the expression
-        setStartAndSuccessor();
+        setNextSuccessor();
         node.getRight().apply(this);
         addSuccessors.put(temp, blockID);
     }
@@ -54,7 +53,7 @@ public void caseAIfThenElseExpr(AIfThenElseExpr node) {
         int ifPointer = blockID;
         currentBlock = new Block(blockID++);
         node.getIf().apply(this);         // evaluate the expression
-        setStartAndSuccessor();
+        setNextSuccessor();
         node.getThen().apply(this);
         thenPointer = blockID-1;                   // last element of then
         addSuccessors.put(ifPointer, blockID);
@@ -63,7 +62,6 @@ public void caseAIfThenElseExpr(AIfThenElseExpr node) {
 
         // because of the normal algorithm according to setStartAndSuccessor() I need to remove the
         // first successor, because this one points to else, which is simply wrong at this point.
-//        blocks.get(thenPointer-1).getSuccessor().removeFirst();
         removeSuccessors.add(thenPointer-1);
         addSuccessors.put(thenPointer, flow);       // Add normal program flow after the then block
     }
@@ -75,29 +73,12 @@ public void caseAWhileExpr(AWhileExpr node) {
         int temp = blockID;
         currentBlock = new Block(blockID++);
         node.getLeft().apply(this);         // evaluate the expression
-        setStartAndSuccessor();
+        setNextSuccessor();
         node.getRight().apply(this);
         addSuccessors.put(temp, blockID);   // Add second successor for while loop
         addSuccessors.put(blockID - 1, temp);
-//        blocks.get(blockID-2).getSuccessor().removeFirst();
         removeSuccessors.add(blockID - 1);    // Remove later the first successor
     }
-
-//    @Override
-//    public void caseAStartExpr(AStartExpr node) {
-//        currentBlock = new Block(blockID++);
-//        node.getStatementList().apply(this);
-//        setStartAndSuccessor();
-//    }
-
-    private void setStartAndSuccessor() {
-        if (lastBlock != null)              // if it is the first block, do nothing
-            lastBlock.addSuccessor(currentBlock);
-        else
-            startBlock = currentBlock;
-        blocks.add(currentBlock);       // Add currentBlock to the global list of blocks
-        lastBlock = currentBlock;
-    }
     /**
      * Add to the current visited block a new item to the Use list
      */
@@ -117,7 +98,16 @@ public void caseAIdentifierExpr(AIdentifierExpr node) {
     }
     public void exitNode() {
         currentBlock = new Block(blockID++);
-        setStartAndSuccessor();
+        setNextSuccessor();
+    }
+    /**
+     * Method to set the standard successor for one node
+     */
+    private void setNextSuccessor() {
+        if (lastBlock != null)              // if it is the first block, do nothing
+            lastBlock.addSuccessor(currentBlock);
+        blocks.add(currentBlock);       // Add currentBlock to the global list of blocks
+        lastBlock = currentBlock;
     }
 
     /************************************************************************************************/

GraphVisitor.java

@@ -1,19 +1,28 @@
+/**
+ * Evaluating the information, I stored about IN and OUT.
+ */
+
 import java.util.HashMap;
 import java.util.LinkedList;
 
 public class Liveness {
     private GraphVisitor analysis;
+    private TypeChecker typeChecker;
     private LinkedList<Block> blocks;
 
-    public Liveness(GraphVisitor analysis) {
+    public Liveness(GraphVisitor analysis, TypeChecker typeChecker) {
         this.analysis = analysis;
         this.blocks = analysis.getBlocks();
+        this.analysis.exitNode();
+        this.typeChecker = typeChecker;
 
         addSuccessors();
         removeSuccessors();
 
         startLiveness();
-        debug();
+//        debug();
+
+        evaluateLiveness();
     }
 
     /**
@@ -30,9 +39,8 @@ private void addSuccessors() {
         }
     }
     private void removeSuccessors() {
-        for (Integer i : analysis.getRemoveSuccessors()) {
+        for (Integer i : analysis.getRemoveSuccessors())
             blocks.get(i-1).getSuccessor().removeFirst();
-        }
     }
 
     /**
@@ -43,22 +51,22 @@ private void debug() {
 
         Block currentBlock;
 
-        for (int i = 0; i < blocks.size(); i++) {
-            currentBlock = blocks.get(i);
-            System.out.print("\t#" + currentBlock.getBlockID() + "\tDef: " + currentBlock.getDef() + "\t\tUse: " + currentBlock.getUse()+"\t\tSuccessor: ");
-            if (currentBlock.hasSuccessor()) {
-                for (Block block : currentBlock.getSuccessor()) {
-                    System.out.print(block.getBlockID() + " ");
-                }
-            }
+        for (Block block : blocks) {
+            currentBlock = block;
+            System.out.print("\t#" + currentBlock.getBlockID() + "\tDef: " + currentBlock.getDef() + "\t\tUse: " + currentBlock.getUse() + "\t\tSuccessor: ");
+
+            if (currentBlock.hasSuccessor())
+                for (Block element : currentBlock.getSuccessor())
+                    System.out.print(element.getBlockID() + " ");
+
             System.out.print("\t\t IN: ");
-            for (String element : currentBlock.getIn()) {
+            for (String element : currentBlock.getIn())
                 System.out.print(element + " ");
-            }
+
             System.out.print("\t\t OUT: ");
-            for (String element : currentBlock.getOut()) {
-                System.out.print(element+" ");
-            }
+            for (String element : currentBlock.getOut())
+                System.out.print(element + " ");
+
             System.out.println();
         }
     }
@@ -72,51 +80,52 @@ private void startLiveness() {
             Block currentBlock = blocks.getFirst();
             boolean changed = true;
 
-            calcFirstIteration();       // Copy use to in in all the blocks!
+            calcFirstIteration();       // Copy USE to IN in all the blocks!
             LinkedList<String> diff;
             LinkedList<String> inSuccessor;
 
             while (changed) {
                 changed = false;
-                for (int i = 0; i < blocks.size(); i++) {
+                for (Block block : blocks) {
                     // Get IN
                     diff = calcDiff(currentBlock);
-                    for (String element : diff) {
+                    for (String element : diff)
                         if (!currentBlock.getIn().contains(element)) {
                             currentBlock.addIn(element);
                             changed = true;
                         }
-                    }
                     // Get OUT
                     inSuccessor = calcInOfSuccessor(currentBlock);
-                    for (String element : inSuccessor) {
+                    for (String element : inSuccessor)
                         if (!currentBlock.getOut().contains(element)) {
                             currentBlock.addOut(element);
                             changed = true;
                         }
-                    }
-                    currentBlock = blocks.get(i);
+                    currentBlock = block;
                 }
             }
         }
     }
 
+    /**
+     * Copy USE to IN of each Block. First step of algorithm.
+     */
     private void calcFirstIteration() {
-        for (Block block : blocks) {
-            if (block.hasUse()) {
-                for (String element : block.getUse()) {
+        for (Block block : blocks)
+            if (block.hasUse())
+                for (String element : block.getUse())
                     block.addIn(element);
-                }
-            }
-        }
     }
+
+    /**
+     * Calculate OUT[n] - DEF[n]
+     */
     private LinkedList<String> calcDiff(Block currentBlock) {
         LinkedList<String> output = new LinkedList<String>();
         boolean duplicate = false;
         for (String out : currentBlock.getOut()) {
-            if (out.equals(currentBlock.getDef())) {
+            if (out.equals(currentBlock.getDef()))
                 duplicate = true;
-            }
             if (!duplicate) {
                 output.add(out);
                 duplicate = false;
@@ -126,17 +135,77 @@ private LinkedList<String> calcDiff(Block currentBlock) {
     }
     private LinkedList<String> calcInOfSuccessor(Block currentBlock) {
         LinkedList<String> inSuccessor = new LinkedList<String>();
-        if (currentBlock.hasSuccessor()) {
-            for (Block successor : currentBlock.getSuccessor()) {
-                for (String element : successor.getIn()) {
+        if (currentBlock.hasSuccessor())
+            for (Block successor : currentBlock.getSuccessor())
+                for (String element : successor.getIn())
                     inSuccessor.add(element);
-                }
-            }
-        }
         return inSuccessor;
     }
 
-    private void printAdjacencyMatrix() {
+    /****************************************** Create Adjacency Matrix ******************************************/
+    private void evaluateLiveness() {
+        int registers = calcMaximum();
+        System.out.println("Registers: "+registers);
+        if (registers != 0)
+            createAdjacencyMatrix();    // if it is zero, there are no variables
+    }
+
+    /**
+     * Calculate maximum of all the OUTs to get the number of registers needed
+     */
+    private int calcMaximum() {
+        int max = 0;
+        for (Block block : blocks)
+            if (max < block.getOut().size())
+                max = block.getOut().size();
+        return max;
+    }
+
+    /**
+     * This method creates a Node for each identifier and calls a method to add edges to
+     * the other identifiers according to the liveness analysis.
+     */
+    private void createAdjacencyMatrix() {
+        LinkedList<Nodes> nodes = new LinkedList<Nodes>();
+
+        // Make a new Node for all identifier found by the typeChecker
+        for (String element : typeChecker.getSymbolTable().keySet())
+            nodes.add(new Nodes(element));
+
+        // Add edges to those Nodes
+        createEdges(nodes);
+
+        // Print those Edges
+        System.out.println();
+        for (Nodes node : nodes)
+            System.out.println("ID " + node.getIdentifier() + " -> " + node.getEdge());
+        System.out.println();
+        System.out.println("How to read it: ID x has edges to (->) all the IDs in Brackets.\n");
+    }
+
+    /**
+     * Creates an edge for all identifiers in conflict
+     */
+    private void createEdges(LinkedList<Nodes> nodes) {
+        Nodes node;
+        // find for each block
+        for (Block block : blocks)
+            for (String element : block.getOut()) {     // those variables in OUT
+                node = nodes.get(findNode(element, nodes));     // set current node
+                // and add new edges to node
+                for (String addOut : block.getOut())
+                    if (!node.getEdge().contains(addOut) && !node.getIdentifier().equals(addOut))
+                        node.addEdge(addOut);
+            }
+    }
 
+    private int findNode(String element, LinkedList<Nodes> nodes) {
+        int i = 0;
+        for (Nodes node : nodes)
+            if (node.getIdentifier().equals(element))
+                return i;
+            else
+                i++;
+        return -1;
     }
 }

Liveness.java

@@ -0,0 +1,19 @@
+import java.util.LinkedList;
+
+public class Nodes {
+    private String identifier;
+    private LinkedList<String> edge = new LinkedList<String>();
+
+    public Nodes(String identifier) {
+        this.identifier = identifier;
+    }
+    public void addEdge(String other) {
+        edge.add(other);
+    }
+    public LinkedList<String> getEdge() {
+        return edge;
+    }
+    public String getIdentifier() {
+        return identifier;
+    }
+}