path: root/prototype/sketch.py

#! /bin/env python

class EvalObj(object):
    def prepare(self, pc):
        pass
    def __str__(self):
        return "#<Object>"

class UnspecObj(EvalObj):
    def __str__(self):
        return "#<Unspecified>"
    def ext_repr(self):
        return self.__str__()

class NumberObj(EvalObj):
    def __str__(selfl):
        return "#<Number>"

class IntObj(NumberObj):
    def __init__(self, num):
        self.val = int(num)
    def __str__(self):
        return "#<Integer>"
    def ext_repr(self):
        return str(self.val)

class FloatObj(NumberObj):
    def __init__(self, num):
        self.val = float(num)
    def __str__(self):
        return "#<Float>"
    def ext_repr(self):
        return str(self.val)

class BoolObj(EvalObj):
    def __init__(self, b):
        self.val = b
    def __str__(self):
        return "#<Boolean>"
    def ext_repr(self):
        if self.val:
            return "#t"
        else:
            return "#f"

class SymObj(EvalObj):
    def __init__(self, string):
        self.name = string
    def __str__(self):
        return "#<Symbol: " + self.name + ">"
    def get_name():
        return self.name

class OptObj(EvalObj):
    pass

class ProcObj(OptObj):
    def __init__(self, body, envt, para_list):
        self.body = body
        self.envt = envt
        self.para_list = para_list
    def call(self, arg_list, envt, cont, stack, top, ret_addr):
        # Create a new continuation
        ncont = Continuation(envt, ret_addr, cont, self.body)  
        cont = ncont                         # Add to the cont chain
        envt = Environment(self.envt)        # Create local env and recall the closure
        #TODO: Compare the arguments to the parameters
        for i in xrange(1, len(arg_list)):
            envt.add_binding(self.para_list[i - 1], arg_list[i])      
                                             # Create bindings
        stack[top] = RetAddr(False)          # Continuation mark 
        pc = self.body[0]                         # Move to the proc entry point
        return (pc, top, envt, cont)

    def ext_repr(self):
        return "#<Procedure>"
    def __str__(self):
        return self.ext_repr()

class SpecialOptObj(OptObj):
        pass

class BuiltinProcObj(OptObj):
    def __init__(self, f, name):
        self.handler = f
        self.name = name
    def ext_repr(self):
        return "#<Builtin Procedure: " + self.name + ">"
    def __str__(self):
        return self.ext_repr()
    def call(self, arg_list, envt, cont, stack, top, ret_addr):
        stack[top] = self.handler(arg_list[1:])
        return (ret_addr.func.next, top, envt, cont)

# Convert an obj to boolean
def to_bool(obj):
    if obj.val is False:
        return BoolObj(False)
    else:
        return BoolObj(True)

# Mark all children of pc as flag
def _fill_marks(pc, flag):
    pc = pc.cdr
    while not (pc is empty_list):
        pc.func.skip = flag
        pc = pc.cdr

class _builtin_if(SpecialOptObj):
    def prepare(self, pc):
        # TODO: check number of arguments 
        # Evaluate the condition first
        self.state = 0 # Prepared
        pc = pc.cdr
        pc.func.skip = False
        pc.cdr.func.skip = True
        if not (pc.cdr.cdr is empty_list):
            pc.cdr.cdr.func.skip = True

    def pre_call(self, arg_list, pc, envt, cont):
        pc = pc.car
        # Condition evaluated and the decision is made
        self.state = 1 
        if (to_bool(arg_list[1])).val:
            pc = pc.cdr
            pc.func.skip = True
            pc.cdr.func.skip = False
            if not (pc.cdr.cdr is empty_list):
                # Eval the former
                pc.cdr.cdr.func.skip = True
        else:
            pc = pc.cdr
            pc.func.skip = True
            pc.cdr.func.skip = True
            if not (pc.cdr.cdr is empty_list):
                # Eval the latter
                pc.cdr.cdr.func.skip = False

    def post_call(self, arg_list, pc, envt, cont):
        # Value already evaluated, so just return it
        return arg_list[1]

    def call(self, arg_list, envt, cont, stack, top, ret_addr):
        if self.state == 0:
            self.pre_call(arg_list, ret_addr, envt, cont)
            top += 1
            pc = ret_addr.car.func.next     # Invoke again
        else:
            stack[top] = self.post_call(arg_list, ret_addr, envt, cont)
            pc = ret_addr.func.next
        return (pc, top, envt, cont)

    def ext_repr(self):
        return "#<Builtin Macro: if>"
    def __str__(self):
        return self.ext_repr()

class _builtin_lambda(SpecialOptObj):

    def prepare(self, pc):
        # TODO: check number of arguments 
        # Do not evaulate anything
        _fill_marks(pc, True)

    def call(self, arg_list, envt, cont, stack, top, ret_addr):
        pc = ret_addr.car
        para_list = list()              # paramter list TODO: use Cons to represent list
        par = pc.cdr.car                # Switch to the first parameter
        while not (par is empty_list): 
            para_list.append(par.car)
            par = par.cdr

        # Clear the flag to avoid side-effects (e.g. proc calling)
        _fill_marks(pc, False)

        pc = pc.cdr.cdr     # Move pc to procedure body
        #TODO: check body
        body = list()       # store a list of expressions inside <body> TODO: Cons

        while not (pc is empty_list):
            body.append(pc)
            pc.func.next = None # Make each expression a orphan 
                                # in order to ease the exit checking
            pc = pc.cdr

        stack[top] = ProcObj(body, envt, para_list)
        return (ret_addr.func.next, top, envt, cont)

    def ext_repr(self):
        return "#<Builtin Macro: lambda>"
    def __str__(self):
        return self.ext_repr()

class _builtin_define(SpecialOptObj):

    def prepare(self, pc):
        if is_arg(pc.cdr):              # Simple value assignment
            pc.cdr.func.skip = True     # Skip the identifier
            pc.cdr.cdr.func.skip = False
        else:                       # Procedure definition
            _fill_marks(pc, True)   # Skip all parts

    def call(self, arg_list, envt, cont, stack, top, ret_addr):
        pc = ret_addr.car
        # TODO: check identifier
        if is_arg(pc.cdr):          # Simple value assignment
            id = pc.cdr.car             
            obj = arg_list[1]
        else:                       # Procedure definition
            id = pc.cdr.car.car
            para_list = list()      # Parameter list
            par = pc.cdr.car
            if not (par.cdr is empty_list):
                # If there's at least one parameter
                par = par.cdr
                while not (par is empty_list):
                    para_list.append(par.car)
                    par = par.cdr

            # Clear the flag to avoid side-effects (e.g. proc calling)
            _fill_marks(pc, False)  
            pc = pc.cdr.cdr         # Move pc to procedure body
            #TODO: check body
            body = list()           # store a list of expressions inside <body>

            while not (pc is empty_list):
                body.append(pc)
                pc.func.next = None
                pc = pc.cdr

            obj = ProcObj(body, envt, para_list)
        
        envt.add_binding(id, obj)
        stack[top] = UnspecObj()
        return (ret_addr.func.next, top, envt, cont)

    def ext_repr(self):
        return "#<Builtin Macro: define>"
    def __str__(self):
        return self.ext_repr()

class _builtin_set(SpecialOptObj):
    def prepare(self, pc):
        # TODO: check number of arguments 
        pc.cdr.func.skip = True     # Skip the identifier
        pc.cdr.cdr.func.skip = False  

    def call(self, arg_list, envt, cont, stack, top, ret_addr):
        pc = ret_addr.car
        id = pc.cdr.car
        if envt.has_obj(id):
            envt.add_binding(id, arg_list[1])
        stack[top] = UnspecObj()
        return (ret_addr.func.next, top, envt, cont)

    def ext_repr(self):
        return "#<Builtin Macro: set!>"
    def __str__(self):
        return self.ext_repr()

class Tokenizor():

    def __init__(self):
        self.data = ""                  # string buffer
        self.tokenized = list()         # tokens

    def feed(self, data):               # Store the data in the buffer
        self.data = data

    def read(self): 
        if len(self.tokenized) == 0:        # no tokens available, let's produce
            if len(self