URL https://opencores.org/ocsvn/tcp_socket/tcp_socket/trunk

Subversion Repositories tcp_socket

[/] [tcp_socket/] [trunk/] [chips2/] [chips/] [compiler/] [parse_tree.py] - Blame information for rev 4

Details | Compare with Previous | View Log


__author__ = "Jon Dawson"
__copyright__ = "Copyright (C) 2012, Jonathan P Dawson"
__version__ = "0.1"
 
import struct
 
class NotConstant(Exception):
    pass
 
 
def constant_fold(expression):
 
    """Replace an expression with a constant if possible"""
 
    try:
        return Constant(expression.value(), expression.type_(), expression.size(), expression.signed())
    except NotConstant:
        return expression
 
 
class Process:
 
    def generate(self):
        instructions = []
        for function in self.functions:
            if hasattr(function, "declarations"):
                instructions.extend(function.generate())
 
        instructions.append(
            {"op"   :"jmp_and_link",
             "dest" :self.main.return_address,
             "label":"function_%s"%id(self.main)})
 
        instructions.append(
            {"op":"stop"})
 
        for function in self.functions:
            if not hasattr(function, "declarations"):
                instructions.extend(function.generate())
        return instructions
 
 
class Function:
 
    def generate(self):
        instructions = []
        instructions.append({"op":"label", "label":"function_%s"%id(self)})
        instructions.extend(self.statement.generate())
        if not hasattr(self, "return_value"):
            instructions.append({"op":"jmp_to_reg", "src":self.return_address})
        return instructions
 
 
class Break:
 
    def generate(self): return [
        {"op":"goto", "label":"break_%s"%id(self.loop)}]
 
 
class Continue:
 
    def generate(self): return [
        {"op":"goto", "label":"continue_%s"%id(self.loop)}]
 
 
class Assert:
 
    def generate(self):
        result = self.allocator.new(self.expression.size())
        instructions = self.expression.generate(result, self.allocator)
        self.allocator.free(result)
 
        instructions.append(
            {"op":"assert",
             "src":result,
             "line":self.line,
             "file":self.filename})
 
        return instructions
 
 
class Return:
 
    def generate(self):
        if hasattr(self, "expression"):
 
            result = self.allocator.new(self.function.size)
            instructions=self.function.return_value.copy(
                self.expression,
                result,
                self.allocator)
            self.allocator.free(result)
 
        else:
            instructions = []
 
        instructions.append(
            {"op":"jmp_to_reg",
             "src":self.function.return_address})
 
        return instructions
 
 
class Report:
 
    def generate(self):
        result = self.allocator.new(self.expression.size())
        instructions = self.expression.generate(result, self.allocator)
        self.allocator.free(result)
 
        instructions.append(
            {"op":"report",
             "src":result,
             "line":self.line,
             "file":self.filename,
             "type":self.expression.type_(),
             "signed":self.expression.signed()})
 
        return instructions
 
 
class WaitClocks:
 
    def generate(self):
        result = self.allocator.new(self.expression.size())
        instructions = self.expression.generate(result, self.allocator)
        self.allocator.free(result)
        instructions.append({"op":"wait_clocks", "src":result})
        return instructions
 
 
class If:
 
    def generate(self):
 
        try:
 
            if self.expression.value():
                return self.true_statement.generate()
            else:
                if self.false_statement:
                    return self.false_statement.generate()
                else:
                    return []
 
        except NotConstant:
 
            result = self.allocator.new(self.expression.size())
            instructions = []
            instructions.extend(self.expression.generate(result, self.allocator))
 
            instructions.append(
                {"op"    : "jmp_if_false",
                 "src"   : result,
                 "label" : "else_%s"%id(self)})
 
            self.allocator.free(result)
            instructions.extend(self.true_statement.generate())
            instructions.append({"op":"goto", "label":"end_%s"%id(self)})
            instructions.append({"op":"label", "label":"else_%s"%id(self)})
            if self.false_statement:
                instructions.extend(self.false_statement.generate())
            instructions.append({"op":"label", "label":"end_%s"%id(self)})
            return instructions
 
 
class Switch:
 
    def generate(self):
        result = self.allocator.new(self.expression.size())
        test = self.allocator.new(self.expression.size())
        instructions = self.expression.generate(result, self.allocator)
        for value, case in self.cases.iteritems():
 
            instructions.append(
                {"op":"==",
                 "dest":test,
                 "src":result,
                 "right":value,
                 "size": self.expression.size(),
                 "signed":True})
 
            instructions.append(
                {"op":"jmp_if_true",
                 "src":test,
                 "label":"case_%s"%id(case)})
 
        if hasattr(self, "default"):
 
            instructions.append(
                {"op":"goto",
                 "label":"case_%s"%id(self.default)})
 
        self.allocator.free(result)
        self.allocator.free(test)
        instructions.extend(self.statement.generate())
        instructions.append({"op":"label", "label":"break_%s"%id(self)})
        return instructions
 
 
class Case:
 
    def generate(self):
        return [{"op":"label", "label":"case_%s"%id(self)}]
 
 
class Default:
 
    def generate(self):
        return [{"op":"label", "label":"case_%s"%id(self)}]
 
 
class Loop:
 
    def generate(self):
        instructions = [{"op":"label", "label":"begin_%s"%id(self)}]
        instructions.append({"op":"label", "label":"continue_%s"%id(self)})
        instructions.extend(self.statement.generate())
        instructions.append({"op":"goto", "label":"begin_%s"%id(self)})
        instructions.append({"op":"label", "label":"break_%s"%id(self)})
        return instructions
 
 
class For:
 
    def generate(self):
        instructions = []
        if hasattr(self, "statement1"):
            instructions.extend(self.statement1.generate())
        instructions.append({"op":"label", "label":"begin_%s"%id(self)})
        if hasattr(self, "expression"):
            result = self.allocator.new(self.expression.size())
 
            instructions.extend(
                self.expression.generate(result, self.allocator))
 
            instructions.append(
                {"op":"jmp_if_false",
                 "src":result,
                 "label":"end_%s"%id(self)})
 
            self.allocator.free(result)
        instructions.extend(self.statement3.generate())
        instructions.append({"op":"label", "label":"continue_%s"%id(self)})
        if hasattr(self, "statement2"):
            instructions.extend(self.statement2.generate())
        instructions.append({"op":"goto", "label":"begin_%s"%id(self)})
        instructions.append({"op":"label", "label":"end_%s"%id(self)})
        instructions.append({"op":"label", "label":"break_%s"%id(self)})
        return instructions
 
 
class Block:
 
    def generate(self):
        instructions = []
        for statement in self.statements:
            instructions.extend(statement.generate())
        return instructions
 
 
class CompoundDeclaration:
 
    def __init__(self, declarations):
        self.declarations = declarations
 
    def generate(self):
        instructions = []
        for declaration in self.declarations:
            instructions.extend(declaration.generate());
        return instructions
 
 
class VariableDeclaration:
 
    def __init__(self, allocator, initializer, name, type_, size, signed, const):
        self.initializer = initializer
        self.allocator = allocator
        self._type = type_
        self._size = size
        self._signed = signed
        self._const = const
        self.name = name
 
    def instance(self):
        register = self.allocator.new(self.size(), "variable "+self.name)
 
        return VariableInstance(
            register,
            self.initializer,
            self.type_(),
            self.size(),
            self.signed(),
            self.const(),
            self.allocator)
 
    def type_(self):
        return self._type
 
    def size(self):
        return self._size
 
    def signed(self):
        return self._signed
 
    def const(self):
        return self._const
 
 
class VariableInstance:
 
    def __init__(self, register, initializer, type_, size, signed, const, allocator):
        self.register = register
        self._type = type_
        self.initializer = initializer
        self._size = size
        self._signed = signed
        self._const = const
        self.allocator = allocator
 
    def generate(self):
        return self.initializer.generate(self.register, self.allocator)
 
    def reference(self):
        return Variable(self)
 
    def type_(self):
        return self._type
 
    def size(self):
        return self._size
 
    def signed(self):
        return self._signed
 
    def const(self):
        return self._const
 
 
class ArrayDeclaration:
 
    def __init__(self,
                 allocator,
                 size,
                 type_,
                 element_type,
                 element_size,
                 element_signed,
                 initializer = None,
                 initialize_memory = False):
 
        self.allocator = allocator
        self._type = type_
        self._size = size
        self._signed = False
        self.element_type = element_type
        self.element_size = element_size
        self.element_signed = element_signed
        self.initializer = initializer
        self.initialize_memory = initialize_memory
 
    def instance(self):
 
        location = self.allocator.new_array(
            self.size(),
            self.initializer,
            self.element_size)
 
        register = self.allocator.new(2, "array")
 
        return ArrayInstance(
            location,
            register,
            self.size(),
            self.type_(),
            self.initializer,
            self.initialize_memory,
            self.element_type,
            self.element_size,
            self.element_signed)
 
    def type_(self):
        return self._type
 
    def size(self):
        return self._size
 
    def signed(self):
        return self._signed
 
class ArrayInstance:
 
    def __init__(self,
                 location,
                 register,
                 size,
                 type_,
                 initializer,
                 initialize_memory,
                 element_type,
                 element_size,
                 element_signed):
 
        self.register = register
        self.location = location
        self._type = type_
        self._size = size * element_size
        self._signed = False
        self.element_type = element_type
        self.element_size = element_size
        self.element_signed = element_signed
        self.initializer = initializer
        self.initialize_memory = initialize_memory
 
    def generate(self, result=None):
        instructions = []
        #If initialize memory is true, the memory content will initialised (as at configuration time)
        #If initialize memory is false, then the memory will need to be filled by the program.
        if not self.initialize_memory and self.initializer is not None:
            location=self.location
            for value in self.initializer:
 
                instructions.append(
                    {"op":"memory_write_literal",
                     "address":location,
                     "value":value,
                     "element_size":self.element_size})
                location += 1
 
        instructions.append(
            {"op":"literal",
             "literal":self.location,
             "dest":self.register})
 
        return instructions
 
 
    def reference(self):
        return Array(self)
 
    def type_(self):
        return self._type
 
    def size(self):
        return self._size
 
    def signed(self):
        return self._signed
 
 
class StructDeclaration:
 
    def __init__(self, members):
        self.members = members
        self._type = "struct {%s}"%"; ".join(
            [i.type_() for i in members.values()])
        self._size = sum([i.size() for i in members.values()])
        self._signed = False
 
    def instance(self):
        instances = {}
        for name, declaration in self.members.iteritems():
            instances[name] = declaration.instance()
        return StructInstance(instances)
 
    def type_(self):
        return self._type
 
    def size(self):
        return self._size
 
    def signed(self):
        return self._signed
 
 
class StructInstance:
 
    def __init__(self, members):
        self.members = members
        self._type = "struct {%s}"%"; ".join(
            [i.type_() for i in members.values()])
        self._size = sum([i.size() for i in members.values()])
        self._signed = False
 
    def generate(self):
        instructions = []
        for member in self.members.values():
            instructions.extend(member.generate())
        return instructions
 
    def reference(self):
        return Struct(self)
 
    def type_(self):
        return self._type
 
    def size(self):
        return self._size
 
    def signed(self):
        return self._signed
 
 
class DiscardExpression:
 
    def __init__(self, expression, allocator):
        self.expression = expression
        self.allocator = allocator
 
    def generate(self):
        result = self.allocator.new(self.expression.size())
        instructions = self.expression.generate(result, self.allocator)
        self.allocator.free(result)
        return instructions
 
 
class Expression:
 
    def __init__(self, t, size, signed):
        self.type_var=t
        self.size_var=size
        self.signed_var=signed
 
    def type_(self):
        return self.type_var
 
    def size(self):
        return self.size_var
 
    def signed(self):
        return self.signed_var
 
    def value(self):
        raise NotConstant
 
    def const(self):
        return True
 
    def int_value(self):
        if self.type_() == "float":
            byte_value = struct.pack(">f", self.value())
            value  = ord(byte_value[0]) << 24
            value |= ord(byte_value[1]) << 16
            value |= ord(byte_value[2]) << 8
            value |= ord(byte_value[3])
            return value
        else:
            return self.value()
 
 
class Object(Expression):
 
    def __init__(self, instance):
        Expression.__init__(self, instance.type_(), instance.size(), instance.signed())
        self.instance = instance
 
    def value(self):
        raise NotConstant
 
    def const(self):
        return False
 
 
def AND(left, right):
    return ANDOR(left, right, "jmp_if_false")
 
 
def OR(left, right):
    return ANDOR(left, right, "jmp_if_true")
 
 
class ANDOR(Expression):
 
    def __init__(self, left, right, op):
        self.left = constant_fold(left)
        self.right = constant_fold(right)
        self.op = op
 
        Expression.__init__(
            self,
            "int",
            max(left.size(), right.size()),
            left.signed() and right.signed())
 
    def generate(self, result, allocator):
        instructions = self.left.generate(result, allocator)
        instructions.append({"op":self.op, "src":result, "label":"end_%s"%id(self)})
        instructions.extend(self.right.generate(result, allocator))
        instructions.append({"op":"label", "label":"end_%s"%id(self)})
        return instructions
 
    def value(self):
        if self.op == "jmp_if_false":
            return self.left.value() and self.right.value()
        else:
            return self.left.value() or self.right.value()
 
 
def get_binary_type(left, right, operator):
    """
    Given the type of the left and right hand operators, determine the type
    of the resulting value.
    """
 
    binary_types = {
        "float,float,+"  : ("float", 4, True),
        "float,float,-"  : ("float", 4, True),
        "float,float,*"  : ("float", 4, True),
        "float,float,/"  : ("float", 4, True),
        "float,float,==" : ("int", 4, True),
        "float,float,!=" : ("int", 4, True),
        "float,float,<"  : ("int", 4, True),
        "float,float,>"  : ("int", 4, True),
        "float,float,<=" : ("int", 4, True),
        "float,float,>=" : ("int", 4, True)}
 
    signature = ",".join([left.type_(), right.type_(), operator])
    if signature in binary_types:
        type_, size, signed = binary_types[signature]
    else:
        type_ = left.type_()
        size = max(left.size(), right.size())
        signed = left.signed() and right.signed()
 
    return type_, size, signed
 
class Binary(Expression):
 
    def __init__(self, operator, left, right):
        self.left = constant_fold(left)
        self.right = constant_fold(right)
        self.operator = operator
        type_, size, signed = get_binary_type(left, right, operator)
 
        Expression.__init__(
            self,
            type_,
            size,
            signed)
 
    def generate(self, result, allocator):
        new_register = allocator.new(self.size())
        try:
            instructions = self.right.generate(new_register, allocator)
 
            instructions.append(
                {"op"  :self.operator,
                 "dest":result,
                 "left":self.left.int_value(),
                 "src":new_register,
                 "type":self.type_(),
                 "size":self.size(),
                 "signed":self.signed()})
 
        except NotConstant:
            try:
                instructions = self.left.generate(new_register, allocator)
 
                instructions.append(
                    {"op"   :self.operator,
                     "dest" :result,
                     "src"  :new_register,
                     "right":self.right.int_value(),
                     "type":self.type_(),
                     "size":self.size(),
                     "signed" :self.signed()})
 
            except NotConstant:
                instructions = self.left.generate(new_register, allocator)
                right = allocator.new(self.size())
                instructions.extend(self.right.generate(right, allocator))
 
                instructions.append(
                    {"op"  :self.operator,
                     "dest":result,
                     "src" :new_register,
                     "srcb":right,
                     "type":self.type_(),
                     "size":self.size(),
                     "signed":self.signed()})
 
                allocator.free(right)
        allocator.free(new_register)
        return instructions
 
    def value(self):
 
        if self.type_() == "int":
 
            return int(eval("%s %s %s"%(
                self.left.value(),
                self.operator,
                self.right.value())))
 
        else:
 
            return float(eval("%s %s %s"%(
                self.left.value(),
                self.operator,
                self.right.value())))
 
 
 
def SizeOf(expression):
    return Constant(expression.size())
 
 
class IntToFloat(Expression):
 
    def __init__(self, expression):
        self.expression = constant_fold(expression)
 
        Expression.__init__( self, "float", 4, True)
 
    def generate(self, result, allocator):
        new_register = allocator.new(self.size())
        instructions = self.expression.generate(new_register, allocator)
 
        instructions.extend([
            {"op"   : "int_to_float",
             "dest" : result,
             "src"  : new_register}])
 
        allocator.free(new_register)
        return instructions
 
    def value(self):
        return float(self.expression.value())
 
 
class FloatToInt(Expression):
 
    def __init__(self, expression):
        self.expression = constant_fold(expression)
 
        Expression.__init__( self, "int", 4, True)
 
    def generate(self, result, allocator):
        new_register = allocator.new(self.size())
        instructions = self.expression.generate(new_register, allocator)
 
        instructions.extend([
            {"op"   : "float_to_int",
             "dest" : result,
             "src"  : new_register}])
 
        allocator.free(new_register)
        return instructions
 
    def value(self):
        return int(self.expression.value())
 
 
class Unary(Expression):
 
    def __init__(self, operator, expression):
        self.expression = constant_fold(expression)
        self.operator = operator
 
        Expression.__init__(
            self,
            expression.type_(),
            expression.size(),
            expression.signed())
 
    def generate(self, result, allocator):
        new_register = allocator.new(self.size())
        instructions = self.expression.generate(new_register, allocator)
 
        instructions.extend([
            {"op":self.operator,
             "dest":result,
             "src":new_register}])
 
        allocator.free(new_register)
        return instructions
 
    def value(self):
        return eval("%s%s"%(self.operator, self.expression.value()))
 
 
class FunctionCall(Expression):
 
    def __init__(self, function):
        self.function = function
 
        Expression.__init__(
            self,
            function.type_,
            function.size,
            function.signed)
 
    def generate(self, result, allocator):
        instructions = []
 
        for expression, argument in zip(
            self.arguments,
            self.function.arguments):
 
            temp_register = allocator.new(expression.size())
            instructions.extend(
                argument.copy(expression, temp_register, allocator))
            allocator.free(temp_register)
 
        instructions.append(
            {"op"   :"jmp_and_link",
             "dest" :self.function.return_address,
             "label":"function_%s"%id(self.function)})
 
        if hasattr(self.function, "return_value"):
 
            instructions.extend(self.function.return_value.generate(
                result,
                allocator))
 
        return instructions
 
 
class Output(Expression):
 
    def __init__(self, name, expression):
        self.name = name
        self.expression = expression
        Expression.__init__(self, "int", 2, True)
 
    def generate(self, result, allocator):
        instructions = self.expression.generate(result, allocator)
 
        instructions.append(
            {"op"   :"write",
             "src"  :result,
             "output":self.name})
 
        return instructions
 
 
class FileWrite(Expression):
 
    def __init__(self, name, expression):
        self.name = name
        self.expression = expression
        Expression.__init__(
            self,
            expression.type_(),
            expression.size(),
            expression.signed())
 
    def generate(self, result, allocator):
        instructions = self.expression.generate(result, allocator)
 
        instructions.append(
            {"op"   :"file_write",
             "src"  :result,
             "type":self.expression.type_(),
             "file_name":self.name})
 
        return instructions
 
 
class Input(Expression):
 
    def __init__(self, name):
        self.name = name
        Expression.__init__(self, "int", 2, True)
 
    def generate(self, result, allocator):
        return [{"op"   :"read", "dest" :result, "input":self.name}]
 
 
class FileRead(Expression):
 
    def __init__(self, name):
        self.name = name
        Expression.__init__(self, "int", 2, True)
 
    def generate(self, result, allocator):
        return [{"op"   :"file_read", "dest" :result, "file_name":self.name}]
 
 
class Ready(Expression):
 
    def __init__(self, name):
        self.name = name
        Expression.__init__(self, "int", 2, True)
 
    def generate(self, result, allocator):
        return [{"op"   :"ready", "dest" :result, "input":self.name}]
 
 
class Struct(Object):
 
    def __init__(self, instance):
        Object.__init__(self, instance)
 
    def generate(self, result, allocator):
        instructions = []
        if result != self.declaration.register:
 
            instructions.append(
                {"op"  :"move",
                 "dest":result,
                 "src" :self.declaration.register})
 
        return instructions
 
    def copy(self, expression, result, allocator):
        instructions = []
 
        for lvalue, rvalue in zip(
            self.instance.members.values(),
            expression.instance.members.values()):
 
            instructions.extend(
                lvalue.reference().copy(rvalue.reference(), result, allocator))
 
        return instructions
 
 
class Array(Object):
 
    def __init__(self, instance):
        Object.__init__(self, instance)
 
    def generate(self, result, allocator):
        instructions = []
        if result != self.instance.register:
 
            instructions.append(
                {"op"   : "move",
                 "dest" : result,
                 "src"  : self.instance.register})
 
        return instructions
 
    def copy(self, expression, result, allocator):
        instructions = expression.generate(result, allocator)
        if result != self.instance.register:
 
            instructions.append(
                {"op"   : "move",
                 "dest" : self.instance.register,
                 "src"  : result})
 
        return instructions
 
 
class ConstArray(Object):
 
    def __init__(self, instance):
        Object.__init__(self, instance)
 
    def generate(self, result, allocator):
        instructions = []
        #If initialize memory is true, the memory content will initialised (as at configuration time)
        #If initialize memory is false, then the memory will need to be filled by the program.
        if not self.instance.initialize_memory and self.instance.initializer is not None:
            location = self.instance.location
            for value in self.instance.initializer:
 
                instructions.append(
                    {"op":"memory_write_literal",
                     "address":location,
                     "value":value,
                     "element_size":self.instance.element_size})
 
                location += 1
 
        instructions.append(
            {"op":"literal",
             "literal":self.instance.location,
             "dest":self.instance.register})
 
        if result != self.instance.register:
 
            instructions.append(
                {"op"   : "move",
                 "dest" : result,
                 "src"  : self.instance.register})
 
        return instructions
 
    def copy(self, expression, result, allocator):
        instructions = expression.generate(result, allocator)
        if result != self.instance.register:
 
            instructions.append(
                {"op"   : "move",
                 "dest" : self.instance.register,
                 "src"  : result})
 
        return instructions
 
 
class ArrayIndex(Object):
 
    def __init__(self, instance, index_expression):
        Object.__init__(self, instance)
        assert self.type_var.endswith("[]")
        self.type_var = self.type_var[:-2]
        self.size_var = instance.element_size
        self.index_expression = index_expression
 
    def generate(self, result, allocator):
        instructions = []
        offset = allocator.new(2)
        address = allocator.new(2)
        instructions.extend(self.index_expression.generate(offset, allocator))
 
        instructions.append(
            {"op"    :"+",
             "dest"  :address,
             "src"   :offset,
             "srcb"  :self.instance.register,
             "signed":False})
 
        instructions.append(
            {"op"    :"memory_read_request",
             "src"   :address,
             "sequence": id(self),
             "element_size":self.size()})
 
        instructions.append(
            {"op"    :"memory_read_wait",
             "src"   :address,
             "sequence": id(self),
             "element_size":self.size()})
 
        instructions.append(
            {"op"    :"memory_read",
             "src"   :address,
             "dest"  :result,
             "sequence": id(self),
             "element_size":self.size()})
 
        allocator.free(address)
        allocator.free(offset)
        return instructions
 
    def copy(self, expression, result, allocator):
        index = allocator.new(2)
        address = allocator.new(2)
        instructions = expression.generate(result, allocator)
        instructions.extend(self.index_expression.generate(index, allocator))
 
        instructions.append(
            {"op"     :"+",
             "dest"   :address,
             "src"    :index,
             "srcb"   :self.instance.register,
             "signed" :expression.signed()})
 
        instructions.append(
            {"op"    :"memory_write",
             "src"   :address,
             "srcb"  :result,
             "element_size" :self.instance.element_size})
 
        allocator.free(index)
        allocator.free(address)
        return instructions
 
 
class Variable(Object):
    def __init__(self, instance):
        Object.__init__(self, instance)
 
    def generate(self, result, allocator):
        instructions = []
        if result != self.instance.register:
 
            instructions.append(
                {"op"  :"move",
                 "dest":result,
                 "src" :self.instance.register})
 
        return instructions
 
    def copy(self, expression, result, allocator):
        instructions = expression.generate(result, allocator)
        if result != self.instance.register:
 
            instructions.append(
                {"op"   : "move",
                 "dest" : self.instance.register,
                 "src"  : result})
 
        return instructions
 
    def const(self):
        return self.instance.const()
 
    def value(self):
        if self.const():
            return self.instance.initializer.value()
        else:
            raise NotConstant
 
 
class PostIncrement(Expression):
 
    def  __init__(self, operator, lvalue, allocator):
        self.operator = operator
        self.lvalue = lvalue
        allocator = allocator
        Expression.__init__(self, lvalue.type_(), lvalue.size(), lvalue.signed())
 
    def generate(self, result, allocator):
 
        instructions = []
 
        instructions.append(
            {"op"    : "move",
             "src"   : self.lvalue.instance.register,
             "dest"  : result})
 
        instructions.append(
            {"op"    : self.operator,
             "dest"  : self.lvalue.instance.register,
             "right" : 1,
             "src"   : self.lvalue.instance.register,
             "size"  : self.size(),
             "signed": self.signed()})
 
        return instructions
 
 
class Assignment(Expression):
 
    def __init__(self, lvalue, expression, allocator):
        Expression.__init__(self, lvalue.type_(), lvalue.size(), lvalue.signed())
        self.lvalue = lvalue
        self.expression = expression
        self.allocator = allocator
 
    def generate(self, result, allocator):
        return self.lvalue.copy(self.expression, result, allocator)
 
 
class Constant(Expression):
 
    def __init__(self, value, type_="int", size=2, signed=True):
        self._value = value
        Expression.__init__(self, type_, size, signed)
 
    def generate(self, result, allocator):
 
        instructions = [{
            "op":"literal",
            "dest":result,
            "size":self.size(),
            "signed":self.size(),
            "literal":self.int_value()}]
        return instructions
 
    def value(self):
       return self._value
 
 

Line No.	Rev	Author	Line
1	2	jondawson	`__author__ = "Jon Dawson"`
2			`__copyright__ = "Copyright (C) 2012, Jonathan P Dawson"`
3			`__version__ = "0.1"`
4
5	4	jondawson	`import struct`
6
7	2	jondawson	`class NotConstant(Exception):`
8	4	jondawson	`pass`
9	2	jondawson
10
11	4	jondawson	`def constant_fold(expression):`
12	2	jondawson
13	4	jondawson	`"""Replace an expression with a constant if possible"""`
14	2	jondawson
15	4	jondawson	`try:`
16			`return Constant(expression.value(), expression.type_(), expression.size(), expression.signed())`
17			`except NotConstant:`
18			`return expression`
19	2	jondawson
20
21	4	jondawson	`class Process:`
22	2	jondawson
23	4	jondawson	`def generate(self):`
24			`instructions = []`
25			`for function in self.functions:`
26			`if hasattr(function, "declarations"):`
27			`instructions.extend(function.generate())`
28	2	jondawson
29	4	jondawson	`instructions.append(`
30			`{"op" :"jmp_and_link",`
31			`"dest" :self.main.return_address,`
32			`"label":"function_%s"%id(self.main)})`
33	2	jondawson
34	4	jondawson	`instructions.append(`
35			`{"op":"stop"})`
36	2	jondawson
37	4	jondawson	`for function in self.functions:`
38			`if not hasattr(function, "declarations"):`
39			`instructions.extend(function.generate())`
40			`return instructions`
41	2	jondawson
42	4	jondawson
43	2	jondawson	`class Function:`
44
45	4	jondawson	`def generate(self):`
46			`instructions = []`
47			`instructions.append({"op":"label", "label":"function_%s"%id(self)})`
48			`instructions.extend(self.statement.generate())`
49			`if not hasattr(self, "return_value"):`
50			`instructions.append({"op":"jmp_to_reg", "src":self.return_address})`
51			`return instructions`
52
53
54	2	jondawson	`class Break:`
55
56	4	jondawson	`def generate(self): return [`
57			`{"op":"goto", "label":"break_%s"%id(self.loop)}]`
58
59
60	2	jondawson	`class Continue:`
61
62	4	jondawson	`def generate(self): return [`
63			`{"op":"goto", "label":"continue_%s"%id(self.loop)}]`
64
65
66	2	jondawson	`class Assert:`
67
68	4	jondawson	`def generate(self):`
69			`result = self.allocator.new(self.expression.size())`
70			`instructions = self.expression.generate(result, self.allocator)`
71			`self.allocator.free(result)`
72
73			`instructions.append(`
74			`{"op":"assert",`
75			`"src":result,`
76			`"line":self.line,`
77			`"file":self.filename})`
78
79			`return instructions`
80
81
82	2	jondawson	`class Return:`
83
84	4	jondawson	`def generate(self):`
85			`if hasattr(self, "expression"):`
86
87			`result = self.allocator.new(self.function.size)`
88			`instructions=self.function.return_value.copy(`
89			`self.expression,`
90			`result,`
91			`self.allocator)`
92			`self.allocator.free(result)`
93
94			`else:`
95			`instructions = []`
96
97			`instructions.append(`
98			`{"op":"jmp_to_reg",`
99			`"src":self.function.return_address})`
100
101			`return instructions`
102
103
104	2	jondawson	`class Report:`
105
106	4	jondawson	`def generate(self):`
107			`result = self.allocator.new(self.expression.size())`
108			`instructions = self.expression.generate(result, self.allocator)`
109			`self.allocator.free(result)`
110
111			`instructions.append(`
112			`{"op":"report",`
113			`"src":result,`
114			`"line":self.line,`
115			`"file":self.filename,`
116			`"type":self.expression.type_(),`
117			`"signed":self.expression.signed()})`
118
119			`return instructions`
120
121
122	2	jondawson	`class WaitClocks:`
123
124	4	jondawson	`def generate(self):`
125			`result = self.allocator.new(self.expression.size())`
126			`instructions = self.expression.generate(result, self.allocator)`
127			`self.allocator.free(result)`
128			`instructions.append({"op":"wait_clocks", "src":result})`
129			`return instructions`
130
131
132	2	jondawson	`class If:`
133
134	4	jondawson	`def generate(self):`
135
136			`try:`
137
138			`if self.expression.value():`
139			`return self.true_statement.generate()`
140			`else:`
141			`if self.false_statement:`
142			`return self.false_statement.generate()`
143			`else:`
144			`return []`
145
146			`except NotConstant:`
147
148			`result = self.allocator.new(self.expression.size())`
149			`instructions = []`
150			`instructions.extend(self.expression.generate(result, self.allocator))`
151
152			`instructions.append(`
153			`{"op" : "jmp_if_false",`
154			`"src" : result,`
155			`"label" : "else_%s"%id(self)})`
156
157			`self.allocator.free(result)`
158			`instructions.extend(self.true_statement.generate())`
159			`instructions.append({"op":"goto", "label":"end_%s"%id(self)})`
160			`instructions.append({"op":"label", "label":"else_%s"%id(self)})`
161			`if self.false_statement:`
162			`instructions.extend(self.false_statement.generate())`
163			`instructions.append({"op":"label", "label":"end_%s"%id(self)})`
164			`return instructions`
165
166
167	2	jondawson	`class Switch:`
168
169	4	jondawson	`def generate(self):`
170			`result = self.allocator.new(self.expression.size())`
171			`test = self.allocator.new(self.expression.size())`
172			`instructions = self.expression.generate(result, self.allocator)`
173			`for value, case in self.cases.iteritems():`
174
175			`instructions.append(`
176			`{"op":"==",`
177			`"dest":test,`
178			`"src":result,`
179			`"right":value,`
180			`"size": self.expression.size(),`
181			`"signed":True})`
182
183			`instructions.append(`
184			`{"op":"jmp_if_true",`
185			`"src":test,`
186			`"label":"case_%s"%id(case)})`
187
188			`if hasattr(self, "default"):`
189
190			`instructions.append(`
191			`{"op":"goto",`
192			`"label":"case_%s"%id(self.default)})`
193
194			`self.allocator.free(result)`
195			`self.allocator.free(test)`
196			`instructions.extend(self.statement.generate())`
197			`instructions.append({"op":"label", "label":"break_%s"%id(self)})`
198			`return instructions`
199
200
201	2	jondawson	`class Case:`
202
203	4	jondawson	`def generate(self):`
204			`return [{"op":"label", "label":"case_%s"%id(self)}]`
205
206
207	2	jondawson	`class Default:`
208
209	4	jondawson	`def generate(self):`
210			`return [{"op":"label", "label":"case_%s"%id(self)}]`
211
212
213	2	jondawson	`class Loop:`
214
215	4	jondawson	`def generate(self):`
216			`instructions = [{"op":"label", "label":"begin_%s"%id(self)}]`
217			`instructions.append({"op":"label", "label":"continue_%s"%id(self)})`
218			`instructions.extend(self.statement.generate())`
219			`instructions.append({"op":"goto", "label":"begin_%s"%id(self)})`
220			`instructions.append({"op":"label", "label":"break_%s"%id(self)})`
221			`return instructions`
222
223
224	2	jondawson	`class For:`
225
226	4	jondawson	`def generate(self):`
227			`instructions = []`
228			`if hasattr(self, "statement1"):`
229			`instructions.extend(self.statement1.generate())`
230			`instructions.append({"op":"label", "label":"begin_%s"%id(self)})`
231			`if hasattr(self, "expression"):`
232			`result = self.allocator.new(self.expression.size())`
233
234			`instructions.extend(`
235			`self.expression.generate(result, self.allocator))`
236
237			`instructions.append(`
238			`{"op":"jmp_if_false",`
239			`"src":result,`
240			`"label":"end_%s"%id(self)})`
241
242			`self.allocator.free(result)`
243			`instructions.extend(self.statement3.generate())`
244			`instructions.append({"op":"label", "label":"continue_%s"%id(self)})`
245			`if hasattr(self, "statement2"):`
246			`instructions.extend(self.statement2.generate())`
247			`instructions.append({"op":"goto", "label":"begin_%s"%id(self)})`
248			`instructions.append({"op":"label", "label":"end_%s"%id(self)})`
249			`instructions.append({"op":"label", "label":"break_%s"%id(self)})`
250			`return instructions`
251
252
253	2	jondawson	`class Block:`
254
255	4	jondawson	`def generate(self):`
256			`instructions = []`
257			`for statement in self.statements:`
258			`instructions.extend(statement.generate())`
259			`return instructions`
260
261
262	2	jondawson	`class CompoundDeclaration:`
263
264	4	jondawson	`def __init__(self, declarations):`
265			`self.declarations = declarations`
266	2	jondawson
267	4	jondawson	`def generate(self):`
268			`instructions = []`
269			`for declaration in self.declarations:`
270			`instructions.extend(declaration.generate());`
271			`return instructions`
272
273
274	2	jondawson	`class VariableDeclaration:`
275
276	4	jondawson	`def __init__(self, allocator, initializer, name, type_, size, signed, const):`
277			`self.initializer = initializer`
278			`self.allocator = allocator`
279			`self._type = type_`
280			`self._size = size`
281			`self._signed = signed`
282			`self._const = const`
283			`self.name = name`
284
285			`def instance(self):`
286			`register = self.allocator.new(self.size(), "variable "+self.name)`
287
288			`return VariableInstance(`
289			`register,`
290			`self.initializer,`
291			`self.type_(),`
292			`self.size(),`
293			`self.signed(),`
294			`self.const(),`
295			`self.allocator)`
296
297			`def type_(self):`
298			`return self._type`
299
300			`def size(self):`
301			`return self._size`
302
303			`def signed(self):`
304			`return self._signed`
305
306			`def const(self):`
307			`return self._const`
308
309
310	2	jondawson	`class VariableInstance:`
311
312	4	jondawson	`def __init__(self, register, initializer, type_, size, signed, const, allocator):`
313			`self.register = register`
314			`self._type = type_`
315			`self.initializer = initializer`
316			`self._size = size`
317			`self._signed = signed`
318			`self._const = const`
319			`self.allocator = allocator`
320
321			`def generate(self):`
322			`return self.initializer.generate(self.register, self.allocator)`
323
324			`def reference(self):`
325			`return Variable(self)`
326
327			`def type_(self):`
328			`return self._type`
329
330			`def size(self):`
331			`return self._size`
332
333			`def signed(self):`
334			`return self._signed`
335
336			`def const(self):`
337			`return self._const`
338
339
340	2	jondawson	`class ArrayDeclaration:`
341
342	4	jondawson	`def __init__(self,`
343			`allocator,`
344			`size,`
345			`type_,`
346			`element_type,`
347			`element_size,`
348			`element_signed,`
349			`initializer = None,`
350			`initialize_memory = False):`
351	2	jondawson
352	4	jondawson	`self.allocator = allocator`
353			`self._type = type_`
354			`self._size = size`
355			`self._signed = False`
356			`self.element_type = element_type`
357			`self.element_size = element_size`
358			`self.element_signed = element_signed`
359			`self.initializer = initializer`
360			`self.initialize_memory = initialize_memory`
361	2	jondawson
362	4	jondawson	`def instance(self):`
363
364			`location = self.allocator.new_array(`
365			`self.size(),`
366			`self.initializer,`
367			`self.element_size)`
368
369			`register = self.allocator.new(2, "array")`
370
371			`return ArrayInstance(`
372			`location,`
373			`register,`
374			`self.size(),`
375			`self.type_(),`
376			`self.initializer,`
377			`self.initialize_memory,`
378			`self.element_type,`
379			`self.element_size,`
380			`self.element_signed)`
381
382			`def type_(self):`
383			`return self._type`
384
385			`def size(self):`
386			`return self._size`
387
388			`def signed(self):`
389			`return self._signed`
390
391	2	jondawson	`class ArrayInstance:`
392
393	4	jondawson	`def __init__(self,`
394			`location,`
395			`register,`
396			`size,`
397			`type_,`
398			`initializer,`
399			`initialize_memory,`
400			`element_type,`
401			`element_size,`
402			`element_signed):`
403	2	jondawson
404	4	jondawson	`self.register = register`
405			`self.location = location`
406			`self._type = type_`
407			`self._size = size * element_size`
408			`self._signed = False`
409			`self.element_type = element_type`
410			`self.element_size = element_size`
411			`self.element_signed = element_signed`
412			`self.initializer = initializer`
413			`self.initialize_memory = initialize_memory`
414	2	jondawson
415	4	jondawson	`def generate(self, result=None):`
416			`instructions = []`
417			`#If initialize memory is true, the memory content will initialised (as at configuration time)`
418			`#If initialize memory is false, then the memory will need to be filled by the program.`
419			`if not self.initialize_memory and self.initializer is not None:`
420			`location=self.location`
421			`for value in self.initializer:`
422
423			`instructions.append(`
424			`{"op":"memory_write_literal",`
425			`"address":location,`
426			`"value":value,`
427			`"element_size":self.element_size})`
428			`location += 1`
429
430			`instructions.append(`
431			`{"op":"literal",`
432			`"literal":self.location,`
433			`"dest":self.register})`
434
435			`return instructions`
436
437
438			`def reference(self):`
439			`return Array(self)`
440
441			`def type_(self):`
442			`return self._type`
443
444			`def size(self):`
445			`return self._size`
446
447			`def signed(self):`
448			`return self._signed`
449
450
451	2	jondawson	`class StructDeclaration:`
452
453	4	jondawson	`def __init__(self, members):`
454			`self.members = members`
455			`self._type = "struct {%s}"%"; ".join(`
456			`[i.type_() for i in members.values()])`
457			`self._size = sum([i.size() for i in members.values()])`
458			`self._signed = False`
459	2	jondawson
460	4	jondawson	`def instance(self):`
461			`instances = {}`
462			`for name, declaration in self.members.iteritems():`
463			`instances[name] = declaration.instance()`
464			`return StructInstance(instances)`
465
466			`def type_(self):`
467			`return self._type`
468
469			`def size(self):`
470			`return self._size`
471
472			`def signed(self):`
473			`return self._signed`
474
475
476	2	jondawson	`class StructInstance:`
477
478	4	jondawson	`def __init__(self, members):`
479			`self.members = members`
480			`self._type = "struct {%s}"%"; ".join(`
481			`[i.type_() for i in members.values()])`
482			`self._size = sum([i.size() for i in members.values()])`
483			`self._signed = False`
484	2	jondawson
485	4	jondawson	`def generate(self):`
486			`instructions = []`
487			`for member in self.members.values():`
488			`instructions.extend(member.generate())`
489			`return instructions`
490	2	jondawson
491	4	jondawson	`def reference(self):`
492			`return Struct(self)`
493
494			`def type_(self):`
495			`return self._type`
496
497			`def size(self):`
498			`return self._size`
499
500			`def signed(self):`

Browse

Tools

Subversion Repositories tcp_socket

[/] [tcp_socket/] [trunk/] [chips2/] [chips/] [compiler/] [parse_tree.py] - Blame information for rev 4