Subversion Repositories tcp_socket

__author__ = "Jon Dawson"
__copyright__ = "Copyright (C) 2012, Jonathan P Dawson"
__version__ = "0.1"
 
import struct
from copy import copy
 
from parse_tree import *
from tokens import Tokens
from allocator import Allocator
 
types = ["float", "signed", "unsigned", "short", "long", "char", "int", "void"]
numeric_types = ["float", "signed", "unsigned", "short", "long", "char", "int"]
storage_specifiers = ["const"]
 
class Parser:
 
    """Turn the C input file into a tree of expressions and statements."""
 
    def __init__(self, input_file, reuse, initialize_memory):
        self.scope = {}
        self.function = None
        self.loop = None
        self.tokens = Tokens(input_file)
        self.allocator = Allocator(reuse)
        self.structs = []
        self.initialize_memory = initialize_memory
 
    def parse_process(self):
        process = Process()
        process.allocator = self.allocator
        process.inputs = []
        process.outputs = []
        process.functions = []
        while not self.tokens.end():
            if self.tokens.peek() == "struct":
                self.parse_define_struct()
            elif self.tokens.peek() == "typedef":
                self.parse_typedef_struct()
            else:
                process.functions.append(self.parse_function())
        process.main = self.main
        return process
 
    def parse_type_specifier(self):
        type_specifiers = []
 
        while self.tokens.peek() in types + self.structs + storage_specifiers:
            type_specifiers.append(self.tokens.get())
 
        signed = True
        if "unsigned" in type_specifiers:
            signed = False
            if "signed" in type_specifiers:
                self.tokens.error("Cannot be signed and unsigned")
 
        size = 2
        if "long" in type_specifiers:
            if "short" in type_specifiers:
                self.tokens.error("Cannot be long and short")
            size = 4
 
        type_ = "int"
        for i in type_specifiers:
            if i in self.structs:
                type_ = i
                size = 2
                signed = False
 
        if "float" in type_specifiers:
            if "short" in type_specifiers:
                self.tokens.error("Float cannot be short")
            if "long" in type_specifiers:
                self.tokens.error("Float cannot be long (but double can)")
            if "unsigned" in type_specifiers:
                self.tokens.error("Float cannot be unsigned")
            type_ = "float"
            size = 4
            signed = True
 
        const = False 
        if "const" in type_specifiers:
            const = True
 
        if "void" in type_specifiers:
            type_ = "void"
            size = 2
            signed = False
 
 
        return type_, size, signed, const
 
    def parse_argument(self):
        type_, size, signed, const = self.parse_type_specifier()
 
        if type_ in ["void"]:
            self.tokens.error("argument cannot be void")
        else:
            argument = self.tokens.get()
            if type_ in self.structs:
                declaration = self.scope[type_]
            else:
                if self.tokens.peek() == "[":
                    self.tokens.expect("[")
                    self.tokens.expect("]")
                    declaration = ArrayDeclaration(
                        self.allocator,
                        2,
                        type_+"[]",
                        type_,
                        size,
                        signed, 
                        None,
                        self.initialize_memory)
                else:
                    declaration = VariableDeclaration(
                        self.allocator,
                        None,
                        argument,
                        type_,
                        size,
                        signed,
                        const)
        instance = declaration.instance()
        self.scope[argument] = instance
        return instance.reference()
 
    def parse_function(self):
        function = Function()
        function.allocator = self.allocator
        stored_scope = copy(self.scope)
        type_, size, signed, const = self.parse_type_specifier()
        name = self.tokens.get()
 
        #check if it is a global declaration
        if self.tokens.peek() != "(":
            return self.parse_global_declaration(type_, size, signed, const, name)
 
        #otherwise continue parsing a function
        self.tokens.expect("(")
        function.name = name
        function.type_ = type_
        function.size = size
        function.signed = signed
 
        function.return_address = self.allocator.new(2, 
            function.name+" return address")
 
        if type_ != "void":
 
            if type_ in self.structs:
                declaration = self.scope[type_]
            else:
                if self.tokens.peek() == "[":
                    self.tokens.error(
                        "Functions cannot return arrays")
                else:
                    declaration = VariableDeclaration(
                        self.allocator,
                        None,
                        function.name+" return value",
                        type_,
                        size,
                        signed,
                        const)
 
            function.return_value = declaration.instance().reference()
 
        function.arguments = []
        while self.tokens.peek() != ")":
            function.arguments.append(self.parse_argument())
            if self.tokens.peek() == ",":
                self.tokens.expect(",")
            else:
                break
 
        self.tokens.expect(")")
        self.function = function
        function.statement = self.parse_statement()
        if type_ != "void" and not hasattr(function, "return_statement"):
            self.tokens.error("Function must have a return statement")
        self.function = None
        self.scope = stored_scope
        self.scope[function.name] = function
        #main thread is last function
        self.main = function
        return function
 
    def parse_break(self):
        break_ = Break()
        break_.loop = self.loop
        self.tokens.expect("break")
        self.tokens.expect(";")
        return break_
 
    def parse_continue(self):
        continue_ = Continue()
        continue_.loop = self.loop
        self.tokens.expect("continue")
        self.tokens.expect(";")
        return continue_
 
    def parse_return(self):
        return_ = Return()
        return_.function = self.function
        return_.allocator = self.allocator
        self.function.return_statement = return_
        self.tokens.expect("return")
        if hasattr(self.function, "return_value"):
            return_.expression = self.parse_expression()
        self.tokens.expect(";")
        return return_
 
    def parse_assert(self):
        assert_ = Assert()
        assert_.allocator = self.allocator
        self.tokens.expect("assert")
        self.tokens.expect("(")
        assert_.expression = self.parse_expression()
        self.tokens.expect(")")
        self.tokens.expect(";")
        assert_.line = self.tokens.lineno
        assert_.filename = self.tokens.filename
        return assert_
 
    def parse_report(self):
        report_ = Report()
        report_.allocator = self.allocator
        self.tokens.expect("report")
        self.tokens.expect("(")
        report_.expression = self.parse_expression()
        self.tokens.expect(")")
        self.tokens.expect(";")
        report_.line = self.tokens.lineno
        report_.filename = self.tokens.filename
        return report_
 
    def parse_wait_clocks(self):
        wait_clocks = WaitClocks()
        wait_clocks.allocator = self.allocator
        self.tokens.expect("wait_clocks")
        self.tokens.expect("(")
        wait_clocks.expression = self.parse_expression()
        self.tokens.expect(")")
        self.tokens.expect(";")
        wait_clocks.line = self.tokens.lineno
        return wait_clocks
 
    def parse_statement(self):
        if self.tokens.peek() in numeric_types + self.structs + storage_specifiers:
            return self.parse_compound_declaration()
        elif self.tokens.peek() == "struct":
            return self.parse_struct_declaration()
        elif self.tokens.peek() == "if":
            return self.parse_if()
        elif self.tokens.peek() == "while":
            return self.parse_while()
        elif self.tokens.peek() == "for":
            return self.parse_for()
        elif self.tokens.peek() == "return":
            return self.parse_return()
        elif self.tokens.peek() == "break":
            return self.parse_break()
        elif self.tokens.peek() == "continue":
            return self.parse_continue()
        elif self.tokens.peek() == "{":
            return self.parse_block()
        elif self.tokens.peek() == "assert":
            return self.parse_assert()
        elif self.tokens.peek() == "report":
            return self.parse_report()
        elif self.tokens.peek() == "switch":
            return self.parse_switch()
        elif self.tokens.peek() == "case":
            return self.parse_case()
        elif self.tokens.peek() == "default":
            return self.parse_default()
        elif self.tokens.peek() == "wait_clocks":
            return self.parse_wait_clocks()
        else:
            expression = self.parse_discard()
            self.tokens.expect(";")
            return expression
 
    def parse_discard(self):
        return DiscardExpression(self.parse_expression(), self.allocator)
 
    def parse_assignment(self):
        assignment_operators = [
            "=", "+=", "-=", "*=", "/=", "%=", "&=", "|=", "^=", "<<=", ">>="
        ]
        lvalue = self.parse_ternary_expression()
        if self.tokens.peek() in assignment_operators:
            if lvalue.const():
 
                self.tokens.error(
                    "left hand operand of assignment is not modifiable")
 
            operator = self.tokens.get()
            if operator == "=":
                expression = self.parse_ternary_expression()
            else:
 
                expression = self.parse_ternary_expression()
                left = lvalue
                left, expression = self.coerce_types(left, expression)
                expression = Binary(operator[:-1], left, expression)
 
            if expression.type_() != lvalue.type_():
                if expression.type_() == "int" and lvalue.type_() == "float":
                    expression = IntToFloat(expression)
                elif expression.type_() == "float" and lvalue.type_() == "int":
                    expression = FloatToInt(expression)
                else:
                    self.tokens.error(
                        "type mismatch in assignment expected: %s actual: %s"%(
                            lvalue.type_(),
                            expression.type_()))
 
            return Assignment(lvalue, expression, self.allocator)
        else:
            return lvalue
 
    def parse_if(self):
        if_ = If()
        if_.allocator = self.allocator
        self.tokens.expect("if")
        self.tokens.expect("(")
        if_.expression = self.parse_expression()
        if if_.expression.type_() not in ["unsigned", "int", "short", "long", "char"]:
            self.tokens.error(
                "if statement conditional must be an integer like expression")
        self.tokens.expect(")")
        if_.true_statement = self.parse_statement()
        if self.tokens.peek() == "else":
            self.tokens.expect("else")
            if_.false_statement = self.parse_statement()
        else:
            if_.false_statement = None
        return if_
 
    def parse_switch(self):
        switch = Switch()
        switch.cases = {}
        self.tokens.expect("switch")
        self.tokens.expect("(")
        expression = self.parse_expression()
        if expression.type_() not in ["unsigned", "int", "short", "long", "char"]:
            self.tokens.error(
                "switch statement expression must be an integer like expression")
        self.tokens.expect(")")
        stored_loop = self.loop
        self.loop = switch
        statement = self.parse_statement()
        self.loop = stored_loop
        switch.expression = expression
        switch.allocator = self.allocator
        switch.statement = statement
        return switch
 
    def parse_case(self):
        self.tokens.expect("case")
        expression = self.parse_expression()
        if expression.type_() not in ["int"]:
            self.tokens.error(
                "case expression must be an integer like expression")
        self.tokens.expect(":")
        try:
            expression = expression.value()
            case = Case()
            self.loop.cases[expression] = case
        except NotConstant:
            self.tokens.error("case expression must be constant")
        except AttributeError:
            self.tokens.error(
                "case statements may only be use inside a switch statment")
        return case
 
    def parse_default(self):
        self.tokens.expect("default")
        self.tokens.expect(":")
        default = Default()
        if not hasattr(self.loop, "cases"):
            self.tokens.error(
                "default statements may only be used inside a switch statment")
        if hasattr(self.loop, "default"):
            self.tokens.error(
                "A switch statement may only have one default statement")
        self.loop.default=default
        return default
 
    def parse_while(self):
        loop = Loop()
        self.tokens.expect("while")
        self.tokens.expect("(")
        expression = self.parse_expression()
        self.tokens.expect(")")
        stored_loop = self.loop
        self.loop = loop
        statement = self.parse_statement()
        self.loop = stored_loop
 
        if_ = If()
        loop.statement = if_
        break_ = Break()
        break_.loop = loop
        if_.allocator = self.allocator
        if expression.type_() not in ["int"]:
            self.tokens.error(
                "while statement conditional must be an integer like expression")
        if_.expression = expression
        if_.false_statement = break_
        if_.true_statement = statement
 
        return loop
 
    def parse_for(self):
        for_ = For()
        for_.allocator = self.allocator
        self.tokens.expect("for")
        self.tokens.expect("(")
        if self.tokens.peek() != ";":
            for_.statement1 = self.parse_discard()
        self.tokens.expect(";")
        if self.tokens.peek() != ";":
            for_.expression = self.parse_expression()
            if for_.expression.type_() not in [
                "unsigned", 
                "int", 
                "short", 
                "long", 
                "char"]:
 
                self.tokens.error(
            "For statement conditional must be an integer like expression")
 
        self.tokens.expect(";")
        if self.tokens.peek() != ")":
            for_.statement2 = self.parse_discard()
        self.tokens.expect(")")
        stored_loop = self.loop
        self.loop = for_
        for_.statement3 = self.parse_statement()
        self.loop = stored_loop
        return for_
 
    def parse_block(self):
        block = Block()
        stored_scope = copy(self.scope)
        self.tokens.expect("{")
        block.statements = []
        while self.tokens.peek() != "}":
            block.statements.append(self.parse_statement())
        self.tokens.expect("}")
        self.scope = stored_scope
        return block
 
    def parse_struct_body(self):
        self.tokens.expect("{")
        members = {}
        while self.tokens.peek() != "}":
            type_, size, signed, const = self.parse_type_specifier()
            name = self.tokens.get()
 
            members[name] = self.parse_declaration(
                type_, 
                size, 
                signed, 
                const,
                name)
 
            self.tokens.expect(";")
        self.tokens.expect("}")
        return members
 
    def parse_typedef_struct(self):
        self.tokens.expect("typedef")
        self.tokens.expect("struct")
        declaration = StructDeclaration(self.parse_struct_body())
        name = self.tokens.get()
        self.tokens.expect(";")
        self.scope[name] = declaration
        self.structs.append(name)
 
    def parse_define_struct(self):
        self.tokens.expect("struct")
        name = self.tokens.get()
        declaration = StructDeclaration(self.parse_struct_body())
        self.tokens.expect(";")
        self.scope[name] = declaration
 
    def parse_struct_declaration(self):
        self.tokens.expect("struct")
        struct_name = self.tokens.get()
        name = self.tokens.get()
        self.tokens.expect(";")
        instance = self.scope[struct_name].instance()
        self.scope[name] = instance
        return instance
 
    def parse_global_declaration(self, type_, size, signed, const, name):
        instances = []
        while True:
 
            instance = self.parse_declaration(
                type_, 
                size, 
                signed, 
                const,
                name).instance()
 
            self.scope[name] = instance
            instances.append(instance)
            if self.tokens.peek() == ",":
                self.tokens.expect(",")
            else:
                break
            name = self.tokens.get()
        self.tokens.expect(";")
        return CompoundDeclaration(instances)
 
    def parse_compound_declaration(self):
        type_, size, signed, const = self.parse_type_specifier()
        instances = []
        while True:
            name = self.tokens.get()
 
            instance = self.parse_declaration(
                type_, 
                size, 
                signed, 
                const,
                name).instance()
 
            self.scope[name] = instance
            instances.append(instance)
            if self.tokens.peek() == ",":
                self.tokens.expect(",")
            else:
                break
            name = None
        self.tokens.expect(";")
        return CompoundDeclaration(instances)
 
    def parse_declaration(self, type_, size, signed, const, name):
        #struct declaration
        if type_ in self.structs:
            declaration = self.scope[type_]
        elif type_ in ["int", "float"]:
            #array declaration
            if self.tokens.peek() == "[":
                array_size = None
                self.tokens.expect("[")
                if self.tokens.peek() != "]":
                    size_expression = self.parse_ternary_expression()
                    if size_expression.type_() != "int":
                        self.tokens.error("Array size must be an integer like expression")
                    try:
                        array_size = size_expression.value()
                    except NotConstant:
                        self.tokens.error("Array size must be constant")
 
                self.tokens.expect("]")
                initializer = None
                if self.tokens.peek() == "=":
                    self.tokens.expect("=")
                    initializer = self.tokens.get()
                    initializer = [ord(i) for i in initializer.strip('"').decode("string_escape")] + [0]
                    array_size = len(initializer)
                if array_size is None:
 
                    self.tokens.error(
                        "array size must be specified if not initialized")
 
                array_type=type_+"[]"
                initialize_memory = self.initialize_memory
                declaration = ArrayDeclaration(
                    self.allocator,
                    array_size,
                    array_type,
                    type_,
                    size,
                    signed,
                    initializer,
                    self.initialize_memory)
 
            #simple variable declaration
            else:
                if self.tokens.peek() == "=":
                    self.tokens.expect("=")
                    initializer = self.parse_ternary_expression()
                else:
                    initializer = Constant(0, type_, size, signed)
 
                if type_ != initializer.type_():
 
                    if type_ == "int" and initializer.type_() == "float":
                        initializer = FloatToInt(initializer)
                    elif type_ == "float" and initializer.type_() == "int":
                        initializer = IntToFloat(initializer)
                    else:
                        self.tokens.error(
                            "type mismatch in intializer expected: %s actual: %s"%(
                                type_,
                                intitializer.type_()))
                declaration = VariableDeclaration(
                    self.allocator,
                    initializer,
                    name,
                    type_,
                    size,
                    signed,
                    const
                )
 
        return declaration
 
    def parse_expression(self):
        expression = self.parse_assignment()
        return expression
 
    def parse_ternary_expression(self):
        expression = constant_fold(self.parse_or_expression())
        while self.tokens.peek() in ["?"]:
            self.tokens.expect("?")
            true_expression = constant_fold(self.parse_or_expression())
            self.tokens.expect(":")
            false_expression = constant_fold(self.parse_or_expression())
            expression = OR(AND(expression, true_expression), false_expression)
        return expression
 
    def parse_or_expression(self):
        expression = self.parse_and_expression()
        while self.tokens.peek() in ["||"]:
            self.tokens.expect("||")
            expression = OR(expression, self.parse_and_expression())
        return expression
 
    def parse_and_expression(self):
        expression = self.parse_binary_expression(["|"])
        while self.tokens.peek() in ["&&"]:
            self.tokens.expect("&&")
            expression = AND(expression, self.parse_binary_expression(["|"]))
        return expression
 
    def substitute_function(self, binary_expression):
 
        """
        For some operations are more easily implemented in sofftware.
        This function substitutes a call to the builtin library function.
        """
 
        functions = {
           "False,int,int,4,/" : "long_unsigned_divide_xxxx",
           "True,int,int,4,/" : "long_divide_xxxx",
           "False,int,int,2,/" : "unsigned_divide_xxxx",
           "True,int,int,2,/" : "divide_xxxx",
           "False,int,int,4,%" : "long_unsigned_modulo_xxxx",
           "True,int,int,4,%" : "long_modulo_xxxx",
           "False,int,int,2,%" : "unsigned_modulo_xxxx",
           "True,int,int,2,%" : "modulo_xxxx",
           "True,float,float,4,==" : "float_equal_xxxx",
           "True,float,float,4,!=" : "float_ne_xxxx",
           "True,float,float,4,<" : "float_lt_xxxx",
           "True,float,float,4,>" : "float_gt_xxxx",
           "True,float,float,4,<=" : "float_le_xxxx",
           "True,float,float,4,>=" : "float_ge_xxxx",
        }
 
        #select a function that matches the template.
        signature = ",".join([
            str(binary_expression.signed()), 
            binary_expression.left.type_(), 
            binary_expression.right.type_(), 
            str(binary_expression.size()), 
            binary_expression.operator])
 
        #Some things can't be implemented in verilog, substitute them with a function
        if signature in functions:
            function = self.scope[functions[signature]]
            function_call = FunctionCall(function)
            function_call.arguments = [binary_expression.left, binary_expression.right]
            return function_call
        else:
            return binary_expression
 
    def coerce_types(self, left, right):
 
        """
        Convert numeric types in expressions.
        """
 
        if left.type_() != right.type_():
            if left.type_() == "float" and right.type_() == "int":
                return left, IntToFloat(right)
            elif left.type_() == "int" and right.type_() == "float":
                return IntToFloat(left), right
            else:
                self.tokens.error("Incompatible types : %s %s"%(
                    left.type_(),
                    right.type_()))
 
        return left, right
 
    def parse_binary_expression(self, operators):
        operator_precedence = {
                "|": ["^"],
                "^": ["&"],
                "&": ["==", "!="],
                "==": ["<", ">", "<=", ">="],
                "<": ["<<", ">>"],
                "<<": ["+", "-"],
                "+": ["*", "/", "%"],
        }
        if operators[0] not in operator_precedence:
            left = self.parse_unary_expression()
            while self.tokens.peek() in operators:
                operator = self.tokens.get()
                right = self.parse_unary_expression()
                left, right = self.coerce_types(left, right)
                left = Binary(operator, left, right)
                left = self.substitute_function(left)
            return left
        else:
            next_operators = operator_precedence[operators[0]]
            left = self.parse_binary_expression(next_operators)
            while self.tokens.peek() in operators:
                operator = self.tokens.get()
                right = self.parse_binary_expression(next_operators)
                left, right = self.coerce_types(left, right)
                left = Binary(operator, left, right)
                left = self.substitute_function(left)
            return left
 
    def parse_unary_expression(self):
        if self.tokens.peek() == "!":
            operator = self.tokens.get()
            expression = self.parse_postfix_expression()
            return Binary("==", expression, Constant(0))
        elif self.tokens.peek() == "-":
            operator = self.tokens.get()
            expression = self.parse_postfix_expression()
            return Binary("-", Constant(0, 
                expression.type_(), 
                expression.size(), 
                expression.signed()), 
                expression)
        elif self.tokens.peek() == "~":
            operator = self.tokens.get()
            expression = self.parse_postfix_expression()
            return Unary("~", expression)
        elif self.tokens.peek() == "sizeof":
            operator = self.tokens.get()
            expression = self.parse_unary_expression()
            return SizeOf(expression)
        else:
            return self.parse_postfix_expression()
 
    def parse_postfix_expression(self):
        expression = self.parse_paren_expression()
        while self.tokens.peek() in ["++", "--"]:
            operator = self.tokens.get()
            expression = PostIncrement(
                operator[:-1],
                expression,
                self.allocator
            )
        return expression
 
    def parse_paren_expression(self):
        if self.tokens.peek() == "(":
            self.tokens.expect("(")
            expression = self.parse_expression()
            self.tokens.expect(")")
        else:
            expression = self.parse_number_or_variable()
        return expression
 
    def parse_number_or_variable(self):
        if self.tokens.peek()[0].isalpha():
            name = self.tokens.get()
            if self.tokens.peek() == "(":
                return self.parse_function_call(name)
            else:
                return self.parse_variable(name)
        else:
            return self.parse_number()
 
    def parse_file_read(self):
        self.tokens.expect("(")
        file_name = self.tokens.get()
        file_name = file_name.strip('"').decode("string_escape")
        self.tokens.expect(")")
        return FileRead(file_name)
 
    def parse_file_write(self):
        self.tokens.expect("(")
        expression = self.parse_expression()
        self.tokens.expect(",")
        file_name = self.tokens.get()
        file_name = file_name.strip('"').decode("string_escape")
        self.tokens.expect(")")
        return FileWrite(file_name, expression)
 
    def parse_input(self, name):
        input_name = name.replace("input_", "")
        self.tokens.expect("(")
        self.tokens.expect(")")
        return Input(input_name)
 
    def parse_ready(self, name):
        input_name = name.replace("ready_", "")
        self.tokens.expect("(")
        self.tokens.expect(")")
        return Ready(input_name)
 
    def parse_output(self, name):
        output_name = name.replace("output_", "")
        self.tokens.expect("(")
        expression = self.parse_expression()
        self.tokens.expect(")")
        return Output(output_name, expression)
 
    def parse_function_call(self, name):
        if name.startswith("input_"):
            return self.parse_input(name)
        if name.startswith("ready_"):
            return self.parse_ready(name)
        if name.startswith("output_"):
            return self.parse_output(name)
        if name == "file_read":
            return self.parse_file_read()
        if name == "file_write":
            return self.parse_file_write()
        if name not in self.scope:
            self.tokens.error("Unknown function: %s"%name)
        function = self.scope[name]
        function_call = FunctionCall(function)
        function_call.arguments = []
        self.tokens.expect("(")
        while self.tokens.peek() != ")":
            function_call.arguments.append(self.parse_expression())
            if self.tokens.peek() == ",":
                self.tokens.expect(",")
            else:
                break
        self.tokens.expect(")")
 
 
        required_arguments = len(function_call.function.arguments)
        actual_arguments = len(function_call.arguments)
        if required_arguments != actual_arguments:
            self.tokens.error("Function %s takes %s arguments %s given."%(
                name,
                len(function_call.function.arguments),
                len(function_call.arguments)))
        required_arguments = function_call.function.arguments
        actual_arguments = function_call.arguments
        corrected_arguments = []
        for required, actual in zip(required_arguments, actual_arguments):
            if not compatible(required, actual):
                if actual.type_() == "int" and required.type_() == "float":
                    actual = IntToFloat(actual)
                elif actual.type_() == "float" and required.type_() == "int":
                    actual = FloatToInt(actual)
                else:
                    self.tokens.error(
                        "type mismatch in assignment expected: %s actual: %s"%(
                            required.type_(),
                            actual.type_()))
            corrected_arguments.append(actual)
        function_call.arguments = corrected_arguments
 
        return function_call
 
    def parse_number(self):
        token = self.tokens.get()
        type_ = "int"
        size = 2
        signed = True
        if token.startswith("'"):
            try:
                token = eval(token)
                value = ord(token)
            except SyntaxError:
                self.tokens.error("%s is not a character literal"%token)
        elif token.startswith('"'):
            try:
                initializer = [ord(i) for i in token.strip('"').decode("string_escape")] + [0]
                size = len(initializer)
                initialize_memory = self.initialize_memory
                declaration = ArrayDeclaration(
                    self.allocator,
                    size,
                    "int[]",
                    "int",
                    2,
                    False,
                    initializer,
                    self.initialize_memory)
                return ConstArray(declaration.instance())
            except SyntaxError:
                self.tokens.error("%s is not a character literal"%token)
        elif "." in token:
            #float literal
            try:
                type_ = "float"
                signed = True
                size = 4
                token = token.upper().replace("F", "")
                token = token.upper().replace("L", "")
                value = float(eval(token))
 
                try:
                    byte_value = struct.pack(">f", value)
                except OverflowError:
                    self.tokens.error("value too large")
 
            except SyntaxError:
                self.tokens.error("%s is not a floating point literal"%token)
        else:
            #integer literal
            try:
                if "U" in token.upper():
                    signed = False
                if "L" in token.upper():
                    size = 4
                token = token.upper().replace("U", "")
                value = int(eval(token))
 
                if signed:
                    if value > 2**((size * 8)-1) - 1:
                        self.tokens.error("value too large")
                    if value < -(2**((size * 8)-1)):
                        self.tokens.error("value too small")
                else:
                    if value > 2**(size * 8) - 1:
                        self.tokens.error("value too large")
                    if value < 0:
                        self.tokens.error("value too small")
 
            except SyntaxError:
                self.tokens.error("%s is not an integer literal"%token)
 
        return Constant(value, type_, size, signed)
 
    def parse_variable(self, name):
        if name not in self.scope:
            self.tokens.error("Unknown variable: %s"%name)
        instance = self.scope[name]
        return self.parse_variable_array_struct(instance)
 
    def parse_variable_array_struct(self, instance):
        if instance.type_() in numeric_types:
 
            if not hasattr(instance, "reference"):
 
                self.tokens.error(
                    "Not an expression")
 
            return Variable(instance)
        elif instance.type_().endswith("[]"):
            if self.tokens.peek() == "[":
                self.tokens.expect("[")
                index_expression = self.parse_expression()
                self.tokens.expect("]")
                if index_expression.type_() not in ["int"]:
 
                    self.tokens.error(
                        "Array indices must be an integer like expression")
 
                return ArrayIndex(instance, index_expression)
            else:
                return Array(instance)
        elif instance.type_().startswith("struct"):
            if self.tokens.peek() == ".":
                self.tokens.expect(".")
                member = self.tokens.get()
                instance = instance.members[member]
                return self.parse_variable_array_struct(instance)
            else:
                return Struct(instance)
 
def compatible(left, right):
    return left.type_() == right.type_()