tac and ast updates - added eval to ast-elems

every ast-element now has a .eval-method that creates the
ThreeAddressCode for said element.
Also: tac-elements are stored linear in a list (, duh)

3 files changed, 163 insertions, 44 deletions

diff --git a/.gitignore b/.gitignore
index 0d20b64..d18402d 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1 +1,2 @@
 *.pyc
+.*.swp
diff --git a/src/back/tac.py b/src/back/tac.py
index 2b288f8..a875a7d 100644
--- a/src/back/tac.py
+++ b/src/back/tac.py
@@ -8,43 +8,61 @@ class Op(object):
         return self.name
 
     def __repr__(self):
-        return "<Tag: %s>" % self
+        return """<Operator: "%s">""" % self
 
+#                                               arg1 arg2
+Op.ADD      = Op("ADD")    # x + y            -> x    y
+Op.SUB      = Op("SUB")    # x - y            -> x    y
+Op.MUL      = Op("MUL")    # x * y            -> x    y
+Op.DIV      = Op("DIV")    # x / y            -> x    y
+Op.MOD      = Op("MOD")    # x % y            -> x    y
+Op.AND      = Op("AND")    # x AND y          -> x    y
+Op.OR       = Op("OR")     # x OR y           -> x    y
 
-Op.ADD      = Op("ADD") # x = y + z   -> y z x
-Op.SUB      = Op("SUB") # x = y - z   -> y z x
-Op.MUL      = Op("MUL") # x = y * z   -> y z x
-Op.DIV      = Op("DIV") # x = y / z   -> y z x
-Op.MOD      = Op("MOD") # x = y % z   -> y z x
-Op.AND      = Op("AND") # x = y AND z -> y z x
-Op.OR       = Op("OR")  # x = y OR z  -> y z x
+Op.NOT      = Op("NOT")    # !x               -> x
+Op.MINUS    = Op("MINUS")  # -x               -> x
 
-Op.NOT      = Op("NOT") # x = !y      -> y None x
-Op.MINUS    = Op("MINUS") # x = - y   -> y None x
+Op.ASSIGN   = Op("ASSIGN") # x = y            -> x    y
 
-Op.ASSIGN   = Op("ASSIGN") # x = y    -> y None x
+Op.JMP      = Op("JMP")    # "goto" x         -> x
+Op.BEQ      = Op("EQ")     # "if x == y"      -> x    y
+Op.BNE      = Op("NE")     # "if x != y"      -> x    y
+Op.BLE      = Op("LE")     # ...
+Op.BGE      = Op("GE")
+Op.BLT      = Op("LT")
+Op.BGT      = Op("GT")
 
-Op.JMP      = Op("JMP") # "goto" x           -> x
-Op.BEQ      = Op("BEQ") # "if y == z" goto x -> y z x
-Op.BNE      = Op("BNE") # "if y != z" goto x -> y z x
-Op.BLE      = Op("BLE") # ...
-Op.BGE      = Op("BGE")
-Op.BLT      = Op("BLT")
-Op.BGT      = Op("BGT")
+Op.PARAM    = Op("PARAM")  # param x          -> x
+Op.CALL     = Op("CALL")   # fun x (y-args..) -> x    y
+Op.RETURN   = Op("RETURN") # return x         -> x
 
-Op.PARAM    = Op("PARAM") # param x -> x
-Op.CALL     = Op("CALL")  # fun y (z-args..) -> y z
-Op.RETURN   = Op("RETURN") # return x -> x
+# maybe in the future
+#Op.ARRAYGET = Op("ARRAYGET") # x =  y[i]     -> i
+#Op.ARRAYSET = Op("ARRAYSET") # x[i] = y      -> y    i
 
-Op.ARRAYGET = Op("ARRAYGET") # x = y[i] -> y i x
-Op.ARRAYSET = Op("ARRAYSET") # x[i] = y -> y i x
 
+class TacElem:
 
-class ThreeAddressCode:
-
-    def __init__(self,op,arg1=None,arg2=None,result=None):
+    def __init__(self,op,arg1=None,arg2=None):
         self.op = op
         self.arg1 = arg1
         self.arg2 = arg2
-        self.result = result
+
+    def __repr__(self):
+        return "<TacElem, Op: %s, Arg1: %s, Arg2: %s>" % (self.op,self.arg1,self.arg2)
+
+class TacArray:
+    def __init__(self):
+        self.liste = []
+
+    def append(self,arg):
+        self.liste.append(arg)
+        return len(self.liste)-1
+
+    def createList(self):
+        i = 0
+        output = ""
+        for item in self.liste:
+            print "%08d | %s\t%s\t%s" % (i,item.op,item.arg1,item.arg2)
+
 
diff --git a/src/front/ast.py b/src/front/ast.py
index 26cda51..5b4def7 100644
--- a/src/front/ast.py
+++ b/src/front/ast.py
@@ -1,87 +1,187 @@
+from back.tac import *
+
 class Node(object):
     pass
 
 class Program(Node):
-    def __init__(self, functions, lineno = None):
+    def __init__(self, functions, lineno = -1):
         self.functions = functions
         self.lineno = lineno
 
+    def eval(self,tacarray):
+        for function in self.functions:
+            function = function.eval(tacarray)
+
+        return 0
+
 class Function(Node):
-    def __init__(self, name, params, statements, lineno = None):
+    def __init__(self, name, params, statements, lineno = -1):
         self.name = name
         self.params = params
         self.statements = statements
         self.lineno = lineno
 
     def __repr__(self):
-        return "<Function: %s at line %d>" % (name, lineno)
+        return "<Function: %s at line %d>" % (self.name, self.lineno)
+
+    def eval(self,tacarray):
+        return tacarray.append(te)
 
 class Statement(Node):
     pass
 
 class IfStatement(Statement):
-    def __init__(self, expression, true_statements, false_statements, lineno = None):
+    def __init__(self, expression, true_statements, false_statements, lineno = -1):
         self.expression = expression
         self.true_statements = true_statements
         self.false_statements = false_statements
         self.lineno = lineno
 
     def __repr__(self):
-        return "<IfStatement at line %d>" % lineno
+        return "<IfStatement at line %d>" % self.lineno
+
+    def eval(self,tacarray):
+        return tacarray.append(te)
 
 class WhileStatement(Statement):
-    def __init__(self, expression, statements, lineno = None):
+    def __init__(self, expression, statements, lineno = -1):
         self.expression = expression
         self.statements = statements
         self.lineno = lineno
 
     def __repr__(self):
-        return "<WhileStatement at line %d>" % lineno
+        return "<WhileStatement at line %d>" % self.lineno
+
+    def eval(self,tacarray):
+        return tacarray.append(te)
 
 class ReturnStatement(Statement):
-    def __init__(self, expression, lineno = None):
+    def __init__(self, expression, lineno = -1):
         self.expression = expression
         self.lineno = lineno
 
     def __repr__(self):
-        return "<ReturnStatement at line %d>" % lineno
+        return "<ReturnStatement at line %d>" % self.lineno
+
+    def eval(self,tacarray):
+
+        if isinstance(expression,Node):
+            expression = expression.eval(tacarray)
+
+        te = TacElem(Op.RETURN,expression)
+        return tacarray.append(te)
 
 class AssignStatement(Statement):
-    def __init__(self, ident, expression, lineno = None):
+    def __init__(self, ident, expression, lineno = -1):
         self.ident = ident
         self.expression = expression
         self.lineno = lineno
 
     def __repr__(self):
-        return "<AssignStatement for %s at line %d>" % (ident, lineno)
+        return "<AssignStatement for %s at line %d>" % (self.ident, self.lineno)
+
+    def eval(self,tacarray):
+        if isinstance(expression,Node):
+            expression = expression.eval(tacarray)
+        yield self.expression
+
 
 class FunctionCall(Statement):
-    def __init__(self, ident, arguments, lineno = None):
+    def __init__(self, ident, arguments = [], lineno = -1):
         self.ident = ident
         self.arguments = arguments
         self.lineno = lineno
 
     def __repr__(self):
-        return "<FunctionCall for %s at line %d>" % (ident, lineno)
+        return "<FunctionCall for %s at line %d>" % (self.ident, self.lineno)
+
+    def eval(self,tacarray):
+        """ Function call will be seperated in all the Op.PARAMs first, and the 
+        Op.CALL afterwards"""
+
+        # XXX can there be arguments with multiple expressions bla((x+y-3),z)?
+        # -> have to look into that, when it comes to param-number
+        # for every parameter create a TacElem
+        #for argument in self.arguments:
+        #    if isinstance(argument,Node):
+        #        argument = argument.eval(tacarray)
+        #    TacElem(Op.PARAM,argument)
+
+        # in the end create the CALL-TacElem with the number of parameters
+        te = TacElem(Op.CALL,self.ident,len(self.arguments))
+        return tacarray.append(te)
+
 
 class Expression(Node):
     pass
 
 class UnaryExpression(Expression):
-    def __init__(self, op, right, lineno = None):
+    """ Unary expressions are !x or -x ..."""
+    def __init__(self, op, right, lineno = -1):
         self.op = op
         self.right = right
         self.lineno = lineno
 
     def __repr__(self):
-        return "<UnaryExpression: %s(%s) at line %d>" % (op, right, lineno)
+        return "<UnaryExpression: %s(%s) at line %d>" % (self.op, self.right, self.lineno)
+
+    def eval(self,tacarray):
+        right = self.right
+        op = None
+
+        if (self.op == "not"):
+            op = Op.NOT
+        if (self.op == "minus"):
+            op = Op.MINUS
+
+        if op == None:
+            return None
+
+        if isinstance(right,Node):
+            right = right.eval(tacarray)
+
+        te = TacElem(op,right)
+        return tacarray.append(te)
+
 
 class BinaryExpression(Expression):
-    def __init__(self, left, op, right, lineno = None):
+    """ Biary expression are x+y, x-y, ... """
+    def __init__(self, left, op, right, lineno = -1):
         self.left = left
         self.op = op
         self.right = right
         self.lineno = lineno
 
     def __repr__(self):
-        return "<BinaryExpression: %s(%s, %s) at line %d>" % (op, left, right, lineno)
+        return "<BinaryExpression: %s(%s, %s) at line %d>" % (self.op, self.left, self.right, self.lineno)
+
+
+    def eval(self,tacarray):
+        op = None
+        if (self.op == "+"):
+            op = Op.ADD
+        if (self.op == "-"):
+            op = Op.SUB
+        if (self.op == "*"):
+            op= Op.MUL
+        if (self.op == "/"):
+            op= Op.DIV
+        if (self.op == "%"):
+            op= Op.MOD
+        if (self.op == "and"):
+            op= Op.AND
+        if (self.op == "or"):
+            op= Op.OR
+
+        if op == None:
+            return None
+
+        if isinstance(left,Node):
+            left = left.eval(tacarray)
+
+        if isinstance(right,Node):
+            right = right.eval(tacarray)
+
+        te = TacElem(op,left,right)
+        return tacarray.append(te)
+