def toObject(self, env): # print 31, self, env if not isinstance(self.symbol, Symbol): return self.symbol try: possibleEnv = Symbol.getEnv(self, env) # print 36 except NameError: if hasattr(self, 'altEnv'): # print 38 try: possibleEnv = Symbol.getEnv(self.symbol, self.altEnv) # print 40, possibleEnv return Symbol.toObject(self.symbol, self.altEnv) except NameError: possibleEnv = None else: possibleEnv = None # print 44, possibleEnv if possibleEnv is not None: keys = possibleEnv.keys() if self in keys: possibleSymbol = keys[keys.index(self)] if isinstance(possibleSymbol, SyntaxSymbol) and possibleSymbol.transformer == self.transformer: return possibleEnv[self] try: return self.symbol.toObject(self.env) except NameError as e: if hasattr(self, 'altEnv'): # print 59 return self.symbol.toObject(self.altEnv) if possibleEnv: import scheme.processer as p return MacroSymbol(self.symbol).setObj(possibleEnv[self]) raise e
def toObject(self, env): # self.env.parent=env if env is not None else scheme.Globals.Globals if hasattr(self, 'obj'): return self.obj e = env while e is not None: if e is self.env: return Symbol.toObject(self, env) if hasattr(e, 'parent'): e = e.parent else: e = None return Symbol.toObject(self, self.env)
def __call__(self, processer, params): if not isinstance(params[0], list): env = processer.cenv.parent name = params[0] initialCallDepth = processer.callDepth processer.pushStack(params[1:]) processer.stackPointer = 2 value = processer.process(params[1:], env) while initialCallDepth < processer.callDepth: processer.popStackN() processer.ast[2] = value processer.ast[0] = Symbol('set!') if not name.isBound(env): raise NameError("Name %s unbound in enclosing namespaces" % name) name.getEnv(env)[name] = value else: name = params[0][0] args = params[0][1:] rest = params[1:] env = processer.cenv.parent if processer.cenv is not Globals.Globals else Globals.Globals if isinstance(name, list): x = name o = [] while isinstance(x, list): o.append(x) x = x[0] name = x if not name.isBound(env): raise NameError("Name %s unbound in enclosing namespaces" % name) retval = [ Symbol('define'), o[-1], [Symbol('lambda'), args, [Symbol('begin')] + rest] ] processer.process(retval, env) else: if not name.isBound(env): raise NameError("Name %s unbound in enclosing namespaces" % name) env[name] = SimpleProcedure([args] + rest, env).setName(name) if jit.enabled: f = jit.makeFunction(env[name]) if f: env[name] = f processer.popStack(None) # processer.ast[processer.stackPointer]=None processer.stackPointer += 1 return None
def __call__(self, processer, params): if isinstance(params[0], list): key = processer.process([params[0]], processer.cenv) else: key = params[0].toObject(processer.cenv) clauses = params[1:] ret = [] begun = False for clause in clauses: if clause[0] == 'else': begun = True if begun: if clause[-1] == 'break': ret.extend(clause[1:-1]) break ret.extend(clause[1:]) else: if isinstance(clause[0], list): val = processer.process([clause[0]], processer.cenv) else: val = clause[0].toObject(processer.cenv) if key == val or (isinstance(val, list) and key in val): begun = True if clause[-1] == 'break': ret.extend(clause[1:-1]) break ret.extend(clause[1:]) return [Symbol('begin')] + ret
def __call__(self, processer, params): if (len(params)) > 3: raise SyntaxError("if accepts a maximum of 3 params") conditional = params[0] if_true = params[1] if_false = params[2] if len(params) == 3 else False env = processer.cenv if isinstance(conditional, list): old_stack_pointer = processer.stackPointer processer.stackPointer = 1 processer.pushStack(conditional) # noinspection PyTypeChecker ret = processer.process([Symbol('Begin')] + [conditional], env) processer.popStack(ret) processer.stackPointer = old_stack_pointer if ret: return if_true else: return if_false else: if (isinstance(conditional, Symbol) and conditional.toObject(env) ) or (not isinstance(conditional, Symbol) and conditional): return if_true else: return if_false
def getEnv(self, env): possibleEnv=None try: possibleEnv = Symbol.getEnv(self.symbol, env) except NameError: try: possibleEnv = Symbol.getEnv(self.symbol, self.altEnv) except NameError: pass if possibleEnv is not None: keys = possibleEnv.keys() if self in keys: possibleSymbol = keys[keys.index(self)] if isinstance(possibleSymbol, SyntaxSymbol) and possibleSymbol.transformer == self.transformer: return possibleEnv return self.symbol.getEnv(self.env)
def getEnv(self, env): possibleEnv = None try: possibleEnv = Symbol.getEnv(self.symbol, env) except NameError: try: possibleEnv = Symbol.getEnv(self.symbol, self.altEnv) except NameError: pass if possibleEnv is not None: keys = possibleEnv.keys() if self in keys: possibleSymbol = keys[keys.index(self)] if isinstance( possibleSymbol, SyntaxSymbol ) and possibleSymbol.transformer == self.transformer: return possibleEnv return self.symbol.getEnv(self.env)
def __call__(self, processer, params): if not isinstance(params[0], list): env = processer.cenv.parent name = params[0] if not isinstance(name, Symbol): name = processer.callStack.queue[-1][0][0][1] processer.stackPointer = 2 initialCallDepth = processer.callDepth processer.pushStack(params[1:]) value = processer.process(params[1:], env) while initialCallDepth < processer.callDepth: processer.popStack(value) env[name] = value if processer.callDepth: processer.popStack(value) else: name = params[0][0] args = params[0][1:] rest = params[1:] env = processer.cenv.parent if processer.cenv is not Globals.Globals else Globals.Globals if isinstance(name, list): x = name o = [] while isinstance(x, list): o.append(x) x = x[0] name = o[-1] retval = [ Symbol('define'), name, [Symbol('lambda'), args, [Symbol('begin')] + rest] ] processer.process(retval, env) else: env[name] = SimpleProcedure([args] + rest, env).setName(name) if jit.enabled: f = jit.makeFunction(env[name]) if f: env[name] = f processer.popStack(None) # processer.ast[processer.stackPointer]=None processer.stackPointer += 1 return None
def toObject(self, env): # print 31, self, env if not isinstance(self.symbol, Symbol): return self.symbol try: possibleEnv = Symbol.getEnv(self, env) # print 36 except NameError: if hasattr(self, 'altEnv'): # print 38 try: possibleEnv = Symbol.getEnv(self.symbol, self.altEnv) # print 40, possibleEnv return Symbol.toObject(self.symbol, self.altEnv) except NameError: possibleEnv = None else: possibleEnv = None # print 44, possibleEnv if possibleEnv is not None: keys = possibleEnv.keys() if self in keys: possibleSymbol = keys[keys.index(self)] if isinstance( possibleSymbol, SyntaxSymbol ) and possibleSymbol.transformer == self.transformer: return possibleEnv[self] try: return self.symbol.toObject(self.env) except NameError as e: if hasattr(self, 'altEnv'): # print 59 return self.symbol.toObject(self.altEnv) if possibleEnv: import scheme.processer as p return MacroSymbol(self.symbol).setObj(possibleEnv[self]) raise e
def __call__(self, processer, args): if self.wrapped: if Procedure in providedBy(self.wrapped): return self.wrapped(processer, args) return self.wrapped(args) retval = None env = Environment(self.env) if (isinstance(self.ast[0], list)): # if len(self.ast[0])==1: # env[self.ast[0][0]] = [Symbol('quote'), args] if '.' in self.ast[0]: idx = -1 item = None for idx, item in enumerate(self.ast[0][:-2]): i = args[idx] env[item] = i env[self.ast[0][-1]] = args[idx + 1:] else: if len(self.ast[0]) != len(args): raise SyntaxError( "Macro %r requires exactly %i args, %i given" % (self, len(self.ast[0]), len(args))) for idx, item in enumerate(self.ast[0]): i = args[idx] env[item] = i else: env[self.ast[0]] = [Symbol('quote'), args] o = [] retval = copy_with_quasiquote(processer, env, deepcopy(self.ast[1:]), o_stack=o)[0] LOG("macro", retval) retval = processer.process(retval, processer.cenv) processer.popStack(retval) return
def process(self, _ast, env=None, callDepth=None, quotesExpanded=True): global current_processer current_processer = self if _ast == [[]]: raise SyntaxError() """ :rtype : object :param _ast: :param env: Environment :return: """ try: if callDepth is not None: self.initialCallDepth = callDepth else: self.initialCallDepth = self.callDepth if env is None: self.cenv = self.env else: self.cenv = env self.ast = _ast if not quotesExpanded: self.ast = expand_quotes(self.ast) self.stackPointer = 0 if not isinstance(self.ast, list): if isinstance(self.ast, Symbol): this = self.ast.toObject(self.cenv) else: this = self.ast if self.callDepth: self.popStack(this) else: return this if len(self.ast) == 1 and not isinstance(self.ast[0], list): if isinstance(self.ast[0], Symbol): this = self.ast[0].toObject(self.cenv) else: this = self.ast[0] if self.callDepth > self.initialCallDepth: self.popStack(this) else: return this while True: if self.shouldAbort: raise self.shouldAbort if self.stackPointer >= len( self.ast) and self.callDepth <= self.initialCallDepth: return self.ast[-1] if self.stackPointer >= len(self.ast): for idx, i in enumerate(self.ast): if isinstance(i, Symbol) and i.isBound(self.cenv): self.ast[idx] = i.toObject(self.cenv) initial_call_depth = self.initialCallDepth if isinstance(self.ast[0], Symbol): self.ast[0] = self.ast[0].toObject(self.cenv) if isinstance(self.ast[0], SimpleProcedure): this = self.ast[0] args = self.ast[1:] params = deepcopy(this.ast[0]) e = Environment(this.env) if isinstance(params, list): if '.' in params: iter_args = iter(args) for idx, item in enumerate(params[:-2]): e[item] = iter_args.next() e[params[-1]] = list(iter_args) else: if (isinstance(args, list) and len(args) != len(params)): raise TypeError( "%r expected exactly %i arguments, got %i" % (self.ast[0], len(params), len(args))) if (not isinstance(args, list) and 1 != len(params)): raise TypeError( "%r expected exactly %i arguments, got %i" % (self.ast[0], len(params), len(args))) iter_args = iter(args) for idx, item in enumerate(params): e[item] = iter_args.next() else: e[params] = args self.popStackN() self.pushStack( deepcopy([ Symbol('last'), [Symbol('list')] + this.ast[1:] ])) self.cenv = Environment(e) continue elif Procedure in providedBy(self.ast[0]): r = self.ast[0](self, self.ast[1:]) self.popStack(r) elif Macro in providedBy(self.ast[0]): r = self.ast[0](self, self.ast[1:]) if r is None: continue self.popStack(r) else: r = self.ast[0](*self.ast[1:]) self.popStack(r) self.initialCallDepth = initial_call_depth self.stackPointer += 1 continue this = self.ast[self.stackPointer] if isinstance(this, SyntaxSymbol): this = this.toObject(self.cenv) if isinstance(this, list): self.pushStack(this) continue if isinstance(this, Symbol) and this.isBound(self.cenv): t = this.toObject(self.cenv) while isinstance(t, Symbol) and t.isBound(self.cenv): t = t.toObject(self.cenv) else: t = this if self.stackPointer == 0 and Macro in providedBy(t): initial_call_depth = self.initialCallDepth r = t(self, self.ast[1:]) self.initialCallDepth = initial_call_depth if r is None: continue if isinstance(r, SyntaxSymbol): self.popStack(r) elif not isinstance(r, list): r1 = [lambda *x: r] # self.ast[:] = r1 self.popStack(r1) else: self.ast[:] = r continue if isinstance(this, Symbol) and this.isBound(self.cenv): self.ast[self.stackPointer] = this.toObject(self.cenv) self.stackPointer += 1 except Empty as e: if hasattr(e, 'ret'): return e.ret return self.ast[-1]
def __repr__(self): return "<SyntaxSymbol %s>" % Symbol.__repr__(self)