def execute_ea(self,*evalArgs):
arg=evalArgs[0]
if(arg == new(LispSymbol,"pack")):
self.value.pack(side=RIGHT, fill=Y)
if(arg == new(LispSymbol,"setParent")):
parent = evalArgs[1]
self.value.configure(command=parent.value.yview)
def execute(self,env, *unEvalArgs):
arg = LISP.Eval.evall(unEvalArgs[0], env)
if(arg == new(LispSymbol,"pack")):
self.value.pack(side=RIGHT, fill=Y)
if(arg == new(LispSymbol,"setParent")):
parent = LISP.Eval.evall(unEvalArgs[1], env)
self.value.configure(command=parent.value.yview)
def execute_ea(self,*args):
if(args[0] == new(LispSymbol,"pack")):
self.value.pack(side="left")
if(args[0] == new(LispSymbol,"setCMD")):
self.value.configure(command=args[1].execute_ea)
if(args[0]==new(LispSymbol,'setBG')):
self.value.configure(bg=args[1])
if(args[0]==new(LispSymbol,'setFG')):
self.value.configure(fg=args[1])
def execute_ea(self, *evalArgs):
body = evalArgs[0].rest
param = evalArgs[0].first
if body.rest is not new(LispNull):
body2 = LispCons(new(LispSymbol,"begin"))
body2.rest=body
body=body2
# param = evalArgs[-2]
env=evalArgs[-1]
return UserFunction(param,body,env)
def execute(self,env, *unEvalArgs):
arg = LISP.Eval.evall(unEvalArgs[0], env)
if(arg == new(LispSymbol,"pack")):
self.value.pack(side="left")
if(arg == new(LispSymbol,"setCMD")):
arg1 = LISP.Eval.evall(unEvalArgs[1], env)
self.value.configure(command=arg1.execute_ea)
if(arg ==new(LispSymbol,'setBG')):
val = LISP.Eval.evall(unEvalArgs[1], env)
self.value.configure(bg=val.value)
if(arg ==new(LispSymbol,'setFG')):
val = LISP.Eval.evall(unEvalArgs[1], env)
self.value.configure(fg=val.value)
def __getOptFunction(func,env,param_list):
if func.first == new(LispSymbol,"lambda"):
first = getOptCode(func.first, env, param_list)
return LispCons(first,func.rest)
if func.first == new(LispSymbol,"define"):
env.put(func.rest.first,new(LispNull))
first = getOptCode(func.first, env, param_list)
symb = func.rest.first
rest = getOptCode(func.rest.rest, env, param_list)
return lispList(first,symb,rest)
if func.first == new(LispSymbol,"+"):
func = _normalizeFunction(func)
print func
first = getOptCode(func.first, env, param_list)
rest = getOptCode(func.rest, env, param_list)
return LispCons(first,rest)
def execute(self,env, *unEvalArgs):
file_name = LISP.Eval.evall(unEvalArgs[0],env)
txt = LISP.Eval.evall(unEvalArgs[1],env)
file = open(file_name.value,'w')
file.write(txt.value)
file.close()
return new(LispString,txt)
def execute_ea(self,*evalArgs):
file_name = evalArgs[0]
file = open(file_name.value,'r')
ret =""
for line in file:
ret+=line
file.close()
return new(LispString,ret)
def execute(self,env, *unEvalArgs):
file_name = LISP.Eval.evall(unEvalArgs[0],env)
file = open(file_name.value,'r')
ret =""
for line in file:
ret+=line
file.close()
return new(LispString,ret)
def execute(self,env, *unEvalArgs):
body = unEvalArgs[1];
if len(unEvalArgs) > 2:
body = LispCons(new(LispSymbol,"begin"))
element = body
for i in range(1,len(unEvalArgs)):
element.rest=LispCons(unEvalArgs[i])
element=element.rest
return UserFunction(unEvalArgs[0],body,env)
def _lispList2PythonList(lispList):
args = []
element = lispList
if isinstance(element, LispAtom):
return [element]
while element.rest is not new(LispNull):
args.append(element.first)
element = element.rest
args.append(element.first)
return args
def execute_ea(self,*evalArgs):
symbol = evalArgs[0]
env = evalArgs[-1]
if isinstance(symbol, LispCons):
func = Lambda().execute_ea(env,symbol.rest,*evalArgs[1:len(evalArgs)])
return self.execute_ea(env,symbol.first,func)
if not isinstance(symbol, LispSymbol):
print "first argument was not a symbol"
return new(LispNull)
value = evalArgs[1]
env.put(symbol,value)
return value
def execute(self,env,*unEvalArgTuple):
symbol = unEvalArgTuple[0]
if isinstance(symbol, LispCons):
func = Lambda().execute(env,symbol.rest,*unEvalArgTuple[1:len(unEvalArgTuple)])
return self.execute(env,symbol.first,func)
if not isinstance(symbol, LispSymbol):
print "first argument was not a symbol"
return new(LispNull)
value = LISP.evall(unEvalArgTuple[1],env)
env.put(symbol,value)
return value
def _readLisp(inp):
# print inp
inp = inp.strip()
if inp[0] == '(':
lastBracket = findClosingBracket(inp,0)
if lastBracket+1 >= len(inp):
content= _readListContent(inp[1:lastBracket])
if isinstance(content,LispAtom):
content = new(LispCons,content)
return content;
# else:
# return LispCons(_readLisp(inp[1:lastBracket]), _readLisp(inp[lastBracket+1:len(inp)]) )
else:
return _readListContent(inp)
def _readListContent(inp):
inp = inp.strip()
if isQuote(inp):
return _readLisp("(quote "+inp[1:len(inp)]+")")
if isZahl(inp):
return new(LispInteger,inp)
if isString(inp):
inp=inp.replace("~","")
return new(LispString,inp[1:len(inp)-1])
if isSymbol(inp):
return new(LispSymbol,inp)
else:
cmds = _splitCommands(inp)
last = None;
first = None;
for cmd in cmds:
element = _readLisp(cmd)
cons = new(LispCons,element)
if last!=None:
last.rest=cons
else:
first = cons
last=cons
return first;
def getOptCode(body,env, param_list):
if isinstance(body,LispSymbol):
index = _getParameter(param_list,body)
if index > -1:
return lispList(new(LispSymbol,"getParam"),LispInteger(index))
else:
index = _getLocal(env,body)
if index > -1:
return lispList(new(LispSymbol,"getLocal"),LispInteger(index))
else:
(index,super) =_getSuperParam(env,body)
if index >-1:
return lispList(new(LispSymbol,"getSuperParam"),LispInteger(index),LispInteger(super))
else:
(index,super) =_getSuperLocal(env,body)
if index >-1:
return lispList(new(LispSymbol,"getSuperLocal"),LispInteger(index),LispInteger(super))
else:
index = _getGlobal(env,body)
if index > -1:
return lispList(new(LispSymbol,"getGlobal"),LispInteger(index))
if isinstance(body,LispCons):
return __getOptFunction(body, env, param_list)
return body
def printLisp(lispTyp):
null = new(LispNull)
if lispTyp==None:
return ""
if isinstance(lispTyp, LispAtom):
return str(lispTyp.value)
elif isinstance(lispTyp, UserFunction):
return lispTyp.__repr__()
else:
string = '('
while (not lispTyp.rest is null):
string+=__getString(lispTyp," ")
lispTyp = lispTyp.rest;
string += __getString(lispTyp,"")+")"
return string
def execute_ea(self,*evalArgs):
if(evalArgs[0] ==new(LispSymbol,"pack")):
self.value.pack(expand=YES, fill=BOTH,side="left")
if(evalArgs[0] == new(LispSymbol,"getText")):
foo= new(LispString,self.value.get(1.0,END))
print foo
return foo
if(evalArgs[0]==new(LispSymbol,'setText')):
self.value.delete(0.1,END)
self.value.insert(0.1, printLisp(evalArgs[1]))
if(evalArgs[0]==new(LispSymbol,'setBG')):
self.value.configure(bg=evalArgs[1])
if(evalArgs[0]==new(LispSymbol,'setFG')):
self.value.configure(fg=evalArgs[1])
if(evalArgs[0]==new(LispSymbol,'setCursorColor')):
self.value.configure(insertbackground=evalArgs[1])
if(evalArgs[0] ==new(LispSymbol,'setScrollbar')):
self.value.configure(yscrollcommand=evalArgs[1].value.set)
def execute(self,env, *unEvalArgs):
arg = LISP.Eval.evall(unEvalArgs[0], env)
if(arg == new(LispSymbol,"pack")):
self.value.pack(expand=YES, fill=BOTH,side="left")
if(arg == new(LispSymbol,"getText")):
foo= new(LispString,self.value.get(1.0,END))
print foo
return foo
if(arg == new(LispSymbol,"setText")):
text = LISP.Eval.evall(unEvalArgs[1], env)
self.value.delete(0.1,END)
self.value.insert(0.1, text.value)
if(arg ==new(LispSymbol,'setBG')):
val = LISP.Eval.evall(unEvalArgs[1], env)
self.value.configure(bg=val.value)
if(arg ==new(LispSymbol,'setFG')):
val = LISP.Eval.evall(unEvalArgs[1], env)
self.value.configure(fg=val.value)
if(arg ==new(LispSymbol,'setCursorColor')):
val = LISP.Eval.evall(unEvalArgs[1], env)
self.value.configure(insertbackground=val.value)
if(arg ==new(LispSymbol,'setScrollbar')):
val = LISP.Eval.evall(unEvalArgs[1], env)
self.value.configure(yscrollcommand=val.value.set)
def __init__ (self, superEnv=None):
self.map = OrderedDict()
self.map_index = []
self.superEnv=superEnv
if superEnv==None:
Enviroment. __global_env=self
self.put(new(LispSymbol,"+"),Plus())
self.put(new(LispSymbol,"-"),Minus())
self.put(new(LispSymbol,"define"),Define())
self.put(new(LispSymbol,"if"),If())
self.put(new(LispSymbol,"eq?"),Eq())
self.put(new(LispSymbol,">?"),Grt())
self.put(new(LispSymbol,"<?"),Lwt())
self.put(new(LispSymbol,"lambda"),Lambda())
self.put(new(LispSymbol,"begin"),Begin())
self.put(new(LispSymbol,"set!"),Set())
self.put(new(LispSymbol,"quote"),Quote())
self.put(new(LispSymbol,"write"),Write())
self.put(new(LispSymbol,"print"),BuildInFunctions.Print())
self.put(new(LispSymbol,"getParam"),GetParam())
self.put(new(LispSymbol,"getLocal"),GetLocal())
self.put(new(LispSymbol,"getSuperParam"),GetSuperParam())
self.put(new(LispSymbol,"getSuperLocal"),GetSuperLocal())
self.put(new(LispSymbol,"getGlobal"),GetGlobal())
self.put(new(LispSymbol,"label$"),LispTKLabel())
self.put(new(LispSymbol,"tk$"),LispTK())
self.put(new(LispSymbol,"text$"),LispTKText())
self.put(new(LispSymbol,"button$"),LispTKButton())
self.put(new(LispSymbol,"frame$"),LispTKFrame())
self.put(new(LispSymbol,"toplevel$"),LispTKToplevel())
self.put(new(LispSymbol,"scrollbar$"),LispTKScrollbar())
self.put(new(LispSymbol,"eval"),Eval())
self.put(new(LispSymbol,"str_concat"),Str_Concat())
self.put(new(LispSymbol,"load"),Load())
self.put(new(LispSymbol,"save"),Save())
self.put(new(LispSymbol,"type"),Type())
self.put(new(LispSymbol,"call"),Call())
def _getByteCode(bytecode,literals,optcode,env,begin=False,drop=False):
if(optcode is not LispNull and drop):
bytecode.bytecode_txt.append("DROP 1")
if isinstance(optcode ,LispNull):
return bytecode,literals
if isinstance(optcode,LispInteger):
bytecode.bytecode_txt.append("PUSH-INT %s" % optcode.value)
return bytecode,literals
if isinstance(optcode,LispAtom):
literals.append(optcode)
bytecode.bytecode_txt.append("PUSH-CONSTANT %s" % (len(literals)-1))
return bytecode,literals
if isinstance(optcode.first, LispCons):
push2=None
if isinstance(optcode.first.first, LispSymbol):
inst = optcode.first
if inst.first.value =='getParam':
push = "PUSH-PARAM %s"
real_value = env.get_parameter_by_index(inst.rest.first.value)
if inst.first.value =='getGlobal':
push = "PUSH-GLOBAL %s"
real_value = env.get_global_by_index(inst.rest.first.value)
if inst.first.value =='getLocal':
push = "PUSH-LOCAL %s"
real_value = env.get_local_by_index(inst.rest.first.value)
if inst.first.value =='getSuperLocal':
push2 = inst.third()
push = "PUSH-SUPER-LOCAL %s"
real_value = env.get_super_local_by_index(inst.second().value,inst.third().value)
if inst.first.value =='getSuperParam':
push2 = inst.third()
push = "PUSH-SUPER-PARAM %s"
real_value = env.get_super_parameter_by_index(inst.second().value,inst.third().value)
skip =False;
_begin=False
if isinstance(real_value,Begin):
_begin=True
elif isinstance(real_value,Lambda):
literals.append(optcode.rest)
call_count=len(optcode.rest)
# bytecode.bytecode_txt.append("CALL %s "%call_count)
bytecode.bytecode_txt.append("CALL 2")
#symbols = env.getParameterSymbols()
pushes=[]
#for i,_ in enumerate(symbols):
# pushes.append("PUSH-PARAM %s" %i)
pushes.append("PUSH-CONSTANT %s" % (len(literals)-1))
skip=True
elif isinstance(real_value,If):
make_if_bytecode(optcode,bytecode,literals,env)
return bytecode,literals
elif _isFunctionCallNeeded(real_value):
if not optcode.rest is new(LispNull): #Sonst ist die Funktion zu einem Wert geworden
bytecode.bytecode_txt.append("CALL %s"%len(optcode.rest))
if(push2 != None):
bytecode.bytecode_txt.append(push2)
if not _begin:
bytecode.bytecode_txt.append(push %inst.rest.first.value)
if not skip:
_getByteCode(bytecode, literals, optcode.rest, env,begin=_begin)
else:
for push2 in pushes:
bytecode.bytecode_txt.append(push2)
return bytecode,literals
if isinstance(optcode,LispCons):
_drop=True
if(optcode.rest is new(LispNull)):
_drop=False
if begin:
_getByteCode(bytecode,literals,optcode.rest,env, begin=True)
_getByteCode(bytecode,literals,optcode.first,env,drop=_drop)
else:
_getByteCode(bytecode,literals,optcode.first,env)
_getByteCode(bytecode,literals,optcode.rest,env)
return bytecode,literals
def execute(self,env, *unEvalArgs):
ret =""
for uarg in unEvalArgs:
arg = LISP.Eval.evall(uarg,env)
ret +=arg.value
return new(LispString,ret)
def execute(self,env,*unEvalArgTuple):
condition = LISP.evall(unEvalArgTuple[0],env)
if condition is new(LispTrue):
return LISP.evall(unEvalArgTuple[1],env)
else:
return LISP.evall(unEvalArgTuple[2],env)
def execute(self,env, *unEvalArgs):
val = LISP.Eval.evall(unEvalArgs[0],env)
ret = type(val).__name__
ret = ret.replace("'","--")
return new(LispString,ret)
def execute_ea(self,*args):
ret =""
for arg in args:
ret+=arg.value
return new(LispString,ret)
def execute_ea(self,*evalArgs):
val = evalArgs[0]
ret = type(val).__name__
ret = ret.replace("'","--")
return new(LispString,ret)
def execute(self,env, *unEvalArgs):
arg = LISP.Eval.evall(unEvalArgs[0], env)
if(arg == new(LispSymbol,"pack")):
self.value.pack()
def execute_ea(self,*args):
if(args[0] == new(LispSymbol,"setTitle")):
self.value.title(args[0])
def execute(self,env, *unEvalArgs):
arg = LISP.Eval.evall(unEvalArgs[0], env)
if(arg == new(LispSymbol,"setTitle")):
arg1 = LISP.Eval.evall(unEvalArgs[1], env)
self.value.title(arg1)
def execute_ea(self,*args):
if(args[0] == new(LispSymbol,"pack")):
self.value.pack(expand=YES, fill=BOTH)
