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)