def eval(self, t, env):
newEnv = Environment(env)
bindings = t.getCdr().getCar()
for i in range(self.util.length(bindings)):
identifier = bindings.getCar().getCar()
val = bindings.getCar().getCdr().getCar().eval(env)
newEnv.define(identifier, Cons(val, Nil.getInstance()))
bindings = bindings.getCdr()
body = t.getCdr().getCdr()
return self.util.begin(body, newEnv)
def apply(self, args):
#sys.stdout.write('in closure.apply')
params = self.fun.getCdr().getCar()
rest = self.fun.getCdr().getCdr()
funcenv = Environment(self.env)
self.__closure(params, args, funcenv)
return Closure.util.begin(rest, funcenv)
def eval(self, exp, env):
if (Special.util.length(exp) < 3):
self._error('invalid expression: not enough arguments')
return Nil.getInstance()
bindings = exp.getCdr().getCar()
body = exp.getCdr().getCdr().getCar()
if (Special.util.length(bindings) < 1):
self._error('invalid expression: invalid bindings')
return Nil.getInstance()
letEnv = Environment(env)
while (not (bindings.isNull())):
bind = bindings.getCar()
if (Special.util.length(bind) < 1):
self._error('invalid expression: invalid binding')
return Nil.getInstance()
varName = bind.getCar()
varBody = bind.getCdr().getCar()
varBody = varBody.eval(env)
letEnv.define(varName, varBody)
bindings = bindings.getCdr()
return Special.util.begin(body, letEnv)
def apply(self, args):
params = self.fun.getCdr().getCar()
body = self.fun.getCdr().getCdr()
functionEnv = Environment(self.env)
while(not (params.isNull())):
if(args.isNull()):
self._error('invalid expression: arguments do not match parameters')
return Nil.getInstance()
if(params.isSymbol()):
functionEnv.define(params, args)
elif(not (params.isPair())):
self._error('invalid expression: invalid parameters')
return Nil.getInstance()
elif(args.isPair()):
if(params.getCar().getName() == '.'):
params = params.getCdr()
if(not params.isSymbol()):
self._error('invalid expression: invalid parameter')
return Nil.getInstance()
functionEnv.define(params.getCar(), args.getCar())
else:
self._error('invalid expression')
return Nil.getInstance()
args = args.getCdr()
params = params.getCdr()
return Closure.util.begin(body, functionEnv)
def eval(self, exp, env):
#sys.stdout.write('inside let.eval')
t = Special.util.length(exp)
if t < 3:
self._error("first let error")
return Nil.getInstance()
name = exp.getCdr().getCar()
rest = exp.getCdr().getCdr()
t = Special.util.length(bind)
if t < 1:
self._error("second let error")
return Nil.getInstance()
lenv = Environment(env)
if Let.__define(name, env, lenv) < 0:
self._error("third let error")
return Nil.getInstance()
else:
return Special.util.begin(rest, lenv)
def apply(self, args):
#create a new enviroment where env will be the current env then
#the frame variable of the new enviroment will represent the function environment
environment = Environment(self.getEnv())
parameters = self.fun.getCar()
body= self.fun.getCdr()
#Check that argument count is correct, if the parameters are a well-formed list
if self.util.length(parameters) != -1 and self.util.length(parameters) is not self.util.length(args):
sys.stdout.write("Invalid argument count\n")
return Nil.getInstance()
#Map all required parameters to arguments
while parameters.isPair():
environment.define(parameters.getCar(), Cons(args.getCar(), Nil.getInstance()))
args = args.getCdr()
parameters = parameters.getCdr()
#if there is a remaining list argument, define it
if not parameters.isNull():
environment.define(parameters, Cons(args, Nil.getInstance()))
#evaluating function
return self.util.begin(body,environment)
sys.stdout.write(", intVal = " + str(tok.getIntVal()) + "\n")
elif tt == TokenType.STR:
sys.stdout.write(", strVal = " + tok.getStrVal() + "\n")
elif tt == TokenType.IDENT:
sys.stdout.write(", name = " + tok.getName() + "\n")
else:
sys.stdout.write("\n")
sys.stdout.flush()
tok = scanner.getNextToken()
else:
# Create parser
builder = TreeBuilder()
parser = Parser(scanner, builder)
env = Environment()
# Environment.populateEnv(env, ini_file)
#env = Environment(env)
BuiltIn.setEnv(env)
Environment.populateEnvironment(env, ini_file)
# Read-eval-print loop
sys.stdout.write(prompt)
sys.stdout.flush()
root = parser.parseExp()
while root != None:
root.eval(env).print(0)
sys.stdout.write(prompt)
sys.stdout.flush()
root = parser.parseExp()
sys.stdout.write(", intVal = " + str(tok.getIntVal()) + "\n")
elif tt == TokenType.STR:
sys.stdout.write(", strVal = " + tok.getStrVal() + "\n")
elif tt == TokenType.IDENT:
sys.stdout.write(", name = " + tok.getName() + "\n")
else:
sys.stdout.write("\n")
sys.stdout.flush()
tok = scanner.getNextToken()
else:
# Create parser
builder = TreeBuilder()
parser = Parser(scanner, builder)
env = Environment()
BuiltIn.setEnv(env)
# Environment.populateEnv(env, ini_file)
env = Environment(env)
BuiltIn.setEnv(env)
# Read-eval-print loop
sys.stdout.write(prompt)
sys.stdout.flush()
root = parser.parseExp()
while root != None:
root.eval(env).print(0)
sys.stdout.write(prompt)
sys.stdout.flush()
root = parser.parseExp()
def eval(self, exp, env):
arg = exp.getCdr().getCar()
expression = exp.getCdr().getCdr().getCar()
curr = Environment(env)
arg = self.frame(arg, curr)
return expression.eval(curr)
sys.stdout.write(", intVal = " + str(tok.getIntVal()) + "\n")
elif tt == TokenType.STR:
sys.stdout.write(", strVal = " + tok.getStrVal() + "\n")
elif tt == TokenType.IDENT:
sys.stdout.write(", name = " + tok.getName() + "\n")
else:
sys.stdout.write("\n")
sys.stdout.flush()
tok = scanner.getNextToken()
else:
# Create parser
builder = TreeBuilder()
parser = Parser(scanner, builder)
env = Environment()
BuiltIn.setEnv(env)
#Environment.populateEnv(env, ini_file)
id = Ident("b+")
env.define(id, BuiltIn(id))
id = Ident("b-")
env.define(id, BuiltIn(id))
id = Ident("b*")
env.define(id, BuiltIn(id))
id = Ident("b/")
env.define(id, BuiltIn(id))