def prim_loop(compiler, src):
if src[2] != lisp.Symbol('<-'):
raise SyntaxError, src[:3]
loop_binding = src[1]
loop_init = src[3]
loop_body = src[4:]
loop_name = pycode.name('loop')
context.curr().setdefault('LOOP_STACK', []).append(loop_name)
tpl = \
'%s = $#\n' % (loop_name,) + \
'while True:\n' + \
' try:\n' + \
' $#\n' + \
' except _ME:\n' + \
' break\n' + \
' $#\n' + \
' break\n' + \
loop_name
output_code = pycode.create(
tpl,
compiler.compile(loop_init),
compiler.compile((lisp.Symbol('='), loop_binding, lisp.Symbol(loop_name))),
compiler.compile_block(loop_body, loop_name))
context.curr()['LOOP_STACK'].pop()
return output_code
def prim_for(compiler, src):
if lisp.Symbol('<-') != src[2]:
raise SyntaxError(src[:3])
matcher = src[1]
datasource = src[3]
body = src[4:]
queue_name = pycode.name('for_queue')
context.curr().setdefault('FOR_STACK', []).append(queue_name)
if type(matcher) is lisp.Symbol:
tpl = '%s = []\nfor %s in $#:\n %s.append($#)\n%s' % (
queue_name, matcher.name, queue_name, queue_name)
datasource_code = compiler.compile(datasource)
if body:
body_code = compiler.compile((lisp.Symbol('env'), matcher) + body)
else:
body_code = pycode.create(matcher.name)
output_code = pycode.create(tpl, datasource_code, body_code)
else:
datasource_code = compiler.compile(datasource)
if datasource_code.value == '_':
datasource_code = datasource.asname(pycode.name())
for_var = pycode.name('for_var')
proc_compiler = proc.Compiler(compiler)
matcher_code = proc_compiler.compile(for_var, matcher)
tpl = \
'%s = []\n' % (queue_name,) + \
'for %s in $#:\n' % (for_var,) + \
' try:\n' + \
' $#\n' + \
' except _ME, e:\n' + \
' continue\n' + \
' %s.append($#)\n' % (queue_name,) + \
queue_name
if body:
body_code = compiler.compile((lisp.Symbol('env'),
lisp.Symbol(matcher_code.value)) +
body)
else:
body_code = pycode.create(matcher_code.value)
output_code = pycode.create(tpl, datasource_code, matcher_code,
body_code)
context.curr()['FOR_STACK'].pop()
return output_code
def _parse_if(source):
"""Parse if chain into sections"""
chain = []
source_idx = 0
while source_idx < len(source):
node = source[source_idx]
if node == lisp.Symbol('if'):
chain.append((source[source_idx + 1], []))
source_idx += 1
elif node == lisp.Symbol('else'):
chain.append((None, []))
else:
chain[-1][1].append(node)
source_idx += 1
return chain
def prim_env(compiler, src):
env_name = pycode.name('env')
env_code = compiler.compile(src[1]).asname(env_name)
lisp.env_push(env_name)
body_code = compiler.compile_block((lisp.Symbol('_'), ) + src[2:])
lisp.env_pop()
return env_code + body_code
def is_prop_fetch(src):
if type(src) is not tuple:
return False
if len(src) > 2 and src[1] == lisp.Symbol('->') and (lisp.getop(
src[-1]) == ':' or not isinstance(src[-1], tuple)):
return True
return False
def prim_def(compiler, source):
fn_name = lisp.getop(source[1])
if fn_name is not None:
return compile_fn(compiler, fn_name, source[1][1:], source[2:])
else:
return compiler.compile((lisp.Symbol('='), source[1], source[2:]))