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 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)
def __repr__(self):
return "<SyntaxSymbol %s>" % Symbol.__repr__(self)
