Subversion Repositories tcp_socket

__author__ = "Jon Dawson"

__copyright__ = "Copyright (C) 2012, Jonathan P Dawson"

__version__ = "0.1"

class NotConstant(Exception):

  pass

def value(expression):

  """If an expression can be evaluated at compile time, return the value"""

  if hasattr(expression, "value"):

    return truncate(expression.value())

  else:

    raise NotConstant

def constant_fold(expression):

  """Replace an expression with a constant if possible"""

  try:

    return Constant(value(expression))

  except NotConstant:

    return expression

def truncate(number):

  """Truncate arithmetic results to the target number of bits"""

  #sign = number & 0x10000

  #number = number & 0xffff

  #if sign:

    #number =  ~0xffff | number

  return int(number)

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.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"):

        instructions = self.expression.generate(self.function.return_value)

    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.free(result)

    instructions.append({"op":"report",

                         "src":result,

                         "line":self.line,

                         "file":self.filename,

                         "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.free(result)

    instructions.append({"op":"wait_clocks", "src":result})

    return instructions

class If:

  def generate(self):

    try:

      if value(self.expression):

        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))

      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)

    for value, case in self.cases.iteritems():

      instructions.append({"op":"==", "dest":test, "src":result, "right":value, "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))

      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):

    self.initializer = initializer

    self.allocator = allocator

    self.type_ = type_

    self.size = size

    self.signed = signed

    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)

class VariableInstance:

  def __init__(self, register, initializer, type_, size, signed):

    self.register = register

    self.type_ = type_

    self.initializer = initializer

    self.size = size

    self.signed = signed

  def generate(self):

    return self.initializer.generate(self.register)

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)

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

    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 = 0

          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

      })

      #this bit here is to make string literals work, 

      #in this case an array instance is created implicitly, 

      #but the value of the expression is the array register.

      if result is not None and result != self.register:

          instructions.append({

              "op"  :"move",

              "dest":result,

              "src" :self.register

          })

      return instructions

class StructDeclaration:

  def __init__(self, members):

    self.members = members

  def instance(self):

    instances = {}

    for name, declaration in self.members.iteritems():

      instances[name] = declaration.instance()

    return StructInstance(instances)

class StructInstance:

  def __init__(self, members):

    self.members = members

    self.type_ = "struct"

  def generate(self):

    instructions = []

    for member in self.members.values():

      instructions.extend(member.generate())

    return instructions

class Argument:

  def __init__(self,

        name,

        type_,

        size,

        signed,

        parser,

        element_type,

        element_size,

        element_signed):

    self.type_=type_

    self.size=size

    self.signed=signed

    self.element_type = element_type

    self.element_size = element_size

    self.element_signed = element_signed

    parser.scope[name] = self

    self.register = parser.allocator.new(size, "function argument "+name)

  def generate(self): return []

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.free(result)

    return instructions

#...then Expressions...

#Expressions generate methods accept a result argument.

#This indicates which register to put the result in.

#Expressions may also provide a value method which returns the value of an xpression

#if it can be calculated at compile time.

def AND(left, right):

  return ANDOR(left, right, "jmp_if_false")

def OR(left, right):

  return ANDOR(left, right, "jmp_if_true")

class ANDOR:

  def __init__(self, left, right, op):

    self.left = constant_fold(left)

    self.right = constant_fold(right)

    self.op = op

    self.type_ = "int"

    self.size = left.size

    self.signed = left.signed

  def generate(self, result):

    instructions = self.left.generate(result)

    instructions.append({"op":self.op, "src":result, "label":"end_%s"%id(self)})

    instructions.extend(self.right.generate(result))

    instructions.append({"op":"label", "label":"end_%s"%id(self)})

    return instructions

  def value(self):

    if self.op == "jmp_if_false":

      return value(self.left) and value(self.right)

    else:

      return value(self.left) or value(self.right)

class Binary:

  def __init__(self, operator, left, right, allocator):

    self.left = constant_fold(left)

    self.right = constant_fold(right)

    self.operator = operator

    self.allocator = allocator

    self.type_ = self.left.type_

    self.size = max(left.size, right.size)

    self.signed = left.signed and right.signed

  def generate(self, result):

    new_register = self.allocator.new(self.size)

    try:

      instructions = self.right.generate(new_register)

      instructions.append({"op"  :self.operator,

                           "dest":result,

                           "left":value(self.left),

                           "src":new_register,

                           "signed":self.signed})

    except NotConstant:

      try:

        instructions = self.left.generate(new_register)

        instructions.append({"op"   :self.operator,

                             "dest" :result,

                             "src"  :new_register,

                             "right":value(self.right),

                             "signed" :self.signed})

      except NotConstant:

        instructions = self.left.generate(new_register)

        right = self.allocator.new(self.right.size)

        instructions.extend(self.right.generate(right))

        instructions.append({"op"  :self.operator,

                             "dest":result,

                             "src" :new_register,

                             "srcb":right,

                             "signed":self.signed})

        self.allocator.free(right)

    self.allocator.free(new_register)

    return instructions

  def value(self):

    return eval("%s %s %s"%(value(self.left), self.operator, value(self.right)))

def SizeOf(expression):

    return Constant(expression.size)

class Unary:

  def __init__(self, operator, expression, allocator):

    self.expression = constant_fold(expression)

    self.operator = operator

    self.type_ = self.expression.type_

    self.size = expression.size

    self.signed = expression.signed

    self.allocator = allocator

  def generate(self, result):

    new_register = self.allocator.new(self.size)

    instructions = self.expression.generate(new_register)

    instructions.extend([{"op":self.operator, "dest":result, "src":new_register}])

    self.allocator.free(new_register)

    return instructions

  def value(self):

    return eval("%s%s"%(self.operator, value(self.expression)))

class FunctionCall:

  def generate(self, result):

    instructions = []

    for expression, argument in zip(self.arguments, self.function.arguments):

      instructions.extend(expression.generate(argument.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.append({"op"   :"move",

                             "dest" :result,

                             "src"  :self.function.return_value})

    return instructions

class Output:

  def __init__(self, name, expression):

    self.name = name

    self.expression = expression

    self.type_ = "int"

    self.size = expression.size

  def generate(self, result):

    instructions = self.expression.generate(result);

    instructions.append({"op"   :"write", "src"  :result, "output":self.name})

    return instructions

class FileWrite:

  def __init__(self, name, expression):

    self.name = name

    self.expression = expression

    self.type_ = "int"

    self.size = expression.size

  def generate(self, result):

    instructions = self.expression.generate(result);

    instructions.append({"op"   :"file_write", "src"  :result, "file_name":self.name})

    return instructions

class Input:

  def __init__(self, name):

    self.name = name

    self.type_ = "int"

    self.size = 2

    self.signed = True

  def generate(self, result):

      return [{"op"   :"read", "dest" :result, "input":self.name}]

class FileRead:

  def __init__(self, name):

    self.name = name

    self.type_ = "int"

    self.size = 2

    self.signed = True

  def generate(self, result):

      return [{"op"   :"file_read", "dest" :result, "file_name":self.name}]

class Ready:

  def __init__(self, name):

    self.name = name

    self.type_ = "int"

    self.size = 2

    self.signed = True

  def generate(self, result):

      return [{"op"   :"ready", "dest" :result, "input":self.name}]

class Array:

  def __init__(self, declaration, allocator):

    self.declaration = declaration

    self.allocator = allocator

    self.storage = "register"

    self.type_ = self.declaration.type_

    self.size = int(self.declaration.size) * 2

    self.signed = False

  def generate(self, result):

    instructions = []

    if result != self.declaration.register:

      instructions.append({"op"  :"move",

                           "dest":result,

                           "src" :self.declaration.register})

    return instructions

class ArrayIndex:

  def __init__(self, declaration, index_expression, allocator):

    self.declaration = declaration

    self.allocator = allocator

    self.index_expression = index_expression

    self.storage = "memory"

    self.type_  = self.declaration.element_type

    self.size   = self.declaration.element_size

    self.signed = self.declaration.element_signed

  def generate(self, result):

    instructions = []

    offset = self.allocator.new(2)

    address = self.allocator.new(2)

    instructions.extend(self.index_expression.generate(offset))

    instructions.append({"op"    :"+",

                         "dest"  :address,

                         "src"   :offset,

                         "srcb"  :self.declaration.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})

    self.allocator.free(address)

    self.allocator.free(offset)

    return instructions

class Variable:

  def __init__(self, declaration, allocator):

    self.declaration = declaration

    self.allocator = allocator

    self.storage = "register"

    self.type_ = self.declaration.type_

    self.size = self.declaration.size

    self.signed = self.declaration.signed

  def generate(self, result):

    instructions = []

    if result != self.declaration.register:

      instructions.append({"op"  :"move",

                           "dest":result,

                           "src" :self.declaration.register})

    return instructions

class PostIncrement:

  def  __init__(self, operator, lvalue, allocator):

    self.operator = operator

    self.lvalue = lvalue

    self.allocator = allocator

    self.type_ = self.lvalue.declaration.type_

    self.size = self.lvalue.declaration.size

    self.signed = self.lvalue.declaration.signed

  def generate(self, result):

    instructions = []

    instructions.append({"op"    :"move",

                         "src"   :self.lvalue.declaration.register,

                         "dest"  :result})

    instructions.append({"op"    :self.operator,

                         "dest"  :self.lvalue.declaration.register,

                         "right" :1,

                         "src"   :self.lvalue.declaration.register,

                         "signed":self.signed})

    return instructions

class Assignment:

  def __init__(self, lvalue, expression, allocator):