path: root/sketch.py

#! /bin/env python

class EvalObj(object):
    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 StringObj(EvalObj):
    def __init__(self, string):
        self.val = string
    def __str__(self):
        return "#<String>"
    def ext_repr(self):
        return 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 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 ext_repr(self):
        return "#<Procedure>"
    def __str__(self):
        return self.ext_repr()

class SpecialOptObj(OptObj):
    def prepare(self, pc):
        pass
    def call(self, arg_list, pc, envt, cont):
        pass

class BuiltinProcObj():
    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):
        return self.handler(arg_list)

def to_bool(obj):
    if obj.val is False:
        return BoolObj(False)
    else:
        return BoolObj(True)

class _builtin_if(SpecialOptObj):
    def prepare(self, pc):
        self.state = 0 # prepare
        # TODO: check number of arguments 
        pc = pc.chd
        pc.skip = False
        pc.sib.skip = True
        if pc.sib.sib:
            pc.sib.sib.skip = True
        # Delay the calculation
    def pre_call(self, arg_list, pc, envt, cont):
        self.state = 1 # calling
        # print "Received if signal: " + str(arg_list[0].val)
        # print "And it is regared as: " + str(to_bool(arg_list[0]).val)
        if (to_bool(arg_list[0])).val:
            pc = pc.chd
            pc.skip = True
            pc.sib.skip = False
            if pc.sib.sib:
                pc.sib.sib.skip = True
            return (None, True) # Re-eval
        else:
            pc = pc.chd
            pc.skip = True
            pc.sib.skip = True
            if pc.sib.sib:
                pc.sib.sib.skip = False
            return (None, True) # Re-eval
    def post_call(self, arg_list, pc, envt, cont):
        return (arg_list[0], False)

    def call(self, arg_list, pc, envt, cont):
        if self.state == 0:
            return self.pre_call(arg_list, pc, envt, cont)
        else:
            return self.post_call(arg_list, pc, envt, cont)
    def ext_repr(self):
        return "#<Builtin Macro: if>"
    def __str__(self):
        return self.ext_repr()

class _builtin_lambda(SpecialOptObj):
    def _clear_marks(self, pc, flag):
        pc = pc.chd
        while pc:
            pc.skip = flag
            pc = pc.sib

    def prepare(self, pc):
        # TODO: check number of arguments 
        self._clear_marks(pc, True)

    def call(self, arg_list, pc, envt, cont):
        para_list = list()
        par = pc.chd
        if par.obj:
            para_list.append(par.obj)
            if par.chd: 
                par = par.chd
                while par: 
                    para_list.append(par.obj)
                    par = par.sib
        self._clear_marks(pc, False)
        pc = pc.chd.sib
        #TODO: check body
        body = list()
        while pc:
            body.append(pc)
            pc.next = None # Detach
            pc = pc.sib
            # Add exps
        return (ProcObj(body, envt, para_list), False)
    def ext_repr(self):
        return "#<Builtin Macro: lambda>"
    def __str__(self):
        return self.ext_repr()

class _builtin_define(SpecialOptObj):
    def _clear_marks(self, pc, flag):
        pc = pc.chd
        while pc:
            pc.skip = flag
            pc = pc.sib

    def prepare(self, pc):
        if is_arg(pc.chd): # Normal Def
            pc.chd.skip = True
            pc.chd.sib.skip = False
        else:
            self._clear_marks(pc, True)
        return (None, True) # Re-eval

    def call(self, arg_list, pc, envt, cont):
        # TODO: check identifier
        id = pc.chd.obj
        if is_arg(pc.chd): 
            obj = arg_list[0]
        else: # Function definition
            par = pc.chd
            para_list = list()
            if par.chd:
                par = par.chd
                while par:
                    para_list.append(par.obj)
                    par = par.sib
            # Collection para list
            self._clear_marks(pc, False)
            pc = pc.chd.sib
            body = list()
            while pc:
                body.append(pc)
                pc.next = None
                pc = pc.sib
            obj = ProcObj(body, envt, para_list)
        
        envt.add_binding(id, obj)
        return (UnspecObj(), False)

    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 = pc.chd
        pc.skip = True
        pc.sib.skip = False

    def call(self, arg_list, pc, envt, cont):
        id = pc.chd.obj
        if envt.has_obj(id):
            envt.add_binding(id, arg_list[0])
        return (UnspecObj(), False)

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

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

class Tokenizor():

    def __init__(self):
        self.data = ""
        self.tokenized = list()
        self.extended_chars = "!$%&*+-./:<=>?@^_~"

    def is_identifier(self, string):
        if string[0].isdigit(): return False
        for i in string[1:]:
            if not (i.isalnum() or i in self.extended_chars):
                return False
        return True

    def feed(self, data):
        self.data = data

    def read(self): 
        if len(self.tokenized) == 0:
            if len(self.data) == 0:
                return None
            self.tokenized = self.data.replace('(', '( ')\
                                    .replace(')', ' )')\
                                    .split()
            self.data = ""
            if len(self.tokenized) == 0:
                return None
        return self.tokenized.pop(0)

class Node(object):
    def __init__(self,<