def _return(self, val):
if val is None:
pyval = ast.Const(None)
else:
assertResult(val, "return")
pyval = topy(val)
return ast.Return(pyval)
def _def(self, name, body, args=None):
flags, argnames, defaults = funcArgs(args)
if len(body) > 0 and type(body[0]) == str:
doc = body[0]
body2 = body[1:]
else:
doc = None
body2 = body
bod = ast.Return(block(body2, True))
return astFunction(str(name), argnames, defaults, flags, doc, bod)
def visitLambda(self, node):
assert not any(map((lambda a:a==tuple), map(type, node.argnames))), \
"unpacking tuples in function arguments not supported (lineno %d)" % self.lineno
code = ast.Return(node.code)
self.emit('function', Visitor.createFunction(node.argnames, code))
for default in node.defaults:
self.visit(default)
self.emit('maketuple', len(node.defaults))
self.emit(
'makefunction',
dict(varargs=bool(node.varargs),
kwargs=bool(node.kwargs),
argnames=node.argnames))
def _def(self, name, body, args=None):
flags, argnames, defaults = funcArgs(args)
if len(body) > 0:
bod = block(body, True)
stmts = bod.nodes
if len(stmts) > 1 and isinstance(stmts[0], ast.Pass):
first = 1
else:
first = 0
stmt1 = stmts[first]
if isinstance(stmt1, ast.Const) and isinstance(stmt1.value, str):
doc = stmt1.value
del stmts[:first+1]
if len(stmts) == 0:
bod = ast.Const(None)
else:
doc = None
else:
bod = ast.Const(None)
doc = None
return astFunction(str(name), argnames, defaults, flags, doc, ast.Return(bod))
def p_return_stmt(p):
"return_stmt : RETURN testlist"
p[0] = ast.Return(p[2])
def compileDefop(self, binding, ruledef, smartspace=None, assoc='left',
imp=None, lang=None):
if lang is None:
raise CompileError("invalid defop")
assertResult(ruledef, "use in defop")
assertResult(binding, "use in defop")
lineno = getmeta(self, 'lineno')
# {{{ token = extract from ruledef
def islit(x): return x[0][0] == 'LiteralRule'
if islit(ruledef):
token = ruledef[1]
elif ruledef[0][0] == 'SequenceRule':
rules = ruledef[1:]
if len(rules) > 1 and islit(rules[0]):
token = rules[0][1]
elif len(rules) > 1 and islit(rules[1]):
token = rules[1][1]
else:
raise CompileError("invalid ruledef")
else:
raise CompileError("invalid ruledef")
# }}}
if imp:
if imp['kind'] == 'm':
funcname = 'macro'
elif imp['kind'] == 'f':
funcname = 'func'
else:
assert 0, "invalid implementation kind: %s" % imp.kind
impfuncname = 'operator[%s]' % token
# {{{ impfunc =
argflags, argnames, argdefaults = funcArgs(imp.get('args'))
impfunc = astFunction(impfuncname,
argnames,
argdefaults,
argflags,
None, #docstring
ast.Return(block(imp['body'], True)))
impfunc.lineno = lineno
# }}}
else:
funcname = None
impfuncname = "None"
impfunc = None
lastdot = lang.rfind('.')
if lastdot == -1:
langexpr = GlobalName(lang)
else:
assert 0, "PROBE: Why are we adding an op to an imported language?"
langname = lang[lastdot+1:]
langmod = lang[:lastdot]
langexpr = ast.Getattr(ast.Subscript(logixglobal('lmodules'),
'OP_APPLY',
[ast.Const(langmod)]),
langname)
newOpCall = ast.CallFunc(
ast.Getattr(ast.Getattr(langexpr, '__impl__'), 'newOp'),
[ast.Const(token),
topy(binding),
topy(ruledef),
ast.Const(smartspace),
ast.Const(assoc),
ast.Const(funcname),
ast.Name(impfuncname)
])
if impfunc:
return ast.Stmt([impfunc, newOpCall])
else:
return newOpCall
def compileDefop(doc):
binding = doc['binding']
ruledef = doc['ruledef']
smartspace = doc.get('smartspace')
assoc = doc.get('assoc', 'left')
imp = doc.get('imp')
lang = doc.get('lang')
if lang is None:
raise CompileError("invalid defop")
assertResult(ruledef, "use in defop")
assertResult(binding, "use in defop")
lineno = getattr(doc, "lineno", None)
# {{{ token = extract from ruledef
def islit(x): return x[0][0] == 'LiteralRule'
if islit(ruledef):
token = ruledef[1]
elif ruledef[0][0] == 'SequenceRule':
rules = ruledef[1:]
if len(rules) > 1 and islit(rules[0]):
token = rules[0][1]
elif len(rules) > 1 and islit(rules[1]):
token = rules[1][1]
else:
raise CompileError("invalid ruledef")
else:
raise CompileError("invalid ruledef")
# }}}
if imp:
if imp['kind'] == 'm':
impkind = 'macro'
elif imp['kind'] == 'f':
impkind = 'func'
else:
assert 0, "invalid implementation kind: %s" % imp.kind
impfuncname = 'operator[%s]' % token
# {{{ impfunc =
argflags, argnames, argdefaults = funcArgs(imp.get('args'))
impfunc = astFunction(impfuncname,
argnames,
argdefaults,
argflags,
None, #docstring
ast.Return(block(imp['body'], True)))
impfunc.lineno = lineno
# }}}
impArgs = [ast.Const(impkind), ast.Name(impfuncname)]
else:
impArgs = []
lastdot = lang.rfind('.')
if lastdot == -1:
langexpr = GlobalName(lang)
else:
assert 0, "PROBE: Why are we adding an op to an imported language?"
langname = lang[lastdot+1:]
langmod = lang[:lastdot]
langexpr = ast.Getattr(ast.Subscript(logixglobal('lmodules'),
'OP_APPLY',
[ast.Const(langmod)]),
langname)
# If unmarshallable objects get into the code-object, you get a
# blanket error message, so check these before they go in.
assert isinstance(token, str)
assert isinstance(smartspace, str) or smartspace == None
assert isinstance(assoc, str)
newOpCall = ast.CallFunc(
ast.Getattr(ast.Getattr(langexpr, '__impl__'), 'newOp'),
[ast.Const(token),
topy(binding),
topy(ruledef),
ast.Const(smartspace),
ast.Const(assoc)]
+ impArgs)
if impArgs != []:
return ast.Stmt([impfunc, newOpCall])
else:
return newOpCall
def funcdef(self, nodelist):
if len(nodelist) == 6:
assert nodelist[0][0] == symbol.decorators
decorators = self.decorators(nodelist[0][1:])
else:
assert len(nodelist) == 5
decorators = None
lineno = nodelist[-4][2]
name = nodelist[-4][1]
args = nodelist[-3][2]
if not re.match('_q_((html|plain)_)?template_', name):
# just a normal function, let base class handle it
self.__template_type.append(None)
n = transformer.Transformer.funcdef(self, nodelist)
else:
if name.startswith(PLAIN_TEMPLATE_PREFIX):
name = name[len(PLAIN_TEMPLATE_PREFIX):]
template_type = "plain"
elif name.startswith(HTML_TEMPLATE_PREFIX):
name = name[len(HTML_TEMPLATE_PREFIX):]
template_type = "html"
elif name.startswith(TEMPLATE_PREFIX):
name = name[len(TEMPLATE_PREFIX):]
template_type = "plain"
else:
raise RuntimeError, 'unknown prefix on %s' % name
self.__template_type.append(template_type)
# Add "IO_INSTANCE = IO_CLASS()" statement at the beginning of
# the function and a "return IO_INSTANCE" at the end.
if args[0] == symbol.varargslist:
names, defaults, flags = self.com_arglist(args[1:])
else:
names = defaults = ()
flags = 0
doc = None # self.get_docstring(nodelist[-1])
# code for function
code = self.com_node(nodelist[-1])
# create an instance, assign to IO_INSTANCE
klass = ast.Name(IO_CLASS)
args = [ast.Const(template_type == "html")]
instance = ast.CallFunc(klass, args)
assign_name = ast.AssName(IO_INSTANCE, OP_ASSIGN)
assign = ast.Assign([assign_name], instance)
# return the IO_INSTANCE.getvalue(...)
func = ast.Getattr(ast.Name(IO_INSTANCE), "getvalue")
ret = ast.Return(ast.CallFunc(func, []))
# wrap original function code
code = ast.Stmt([assign, code, ret])
if sys.hexversion >= 0x20400a2:
n = ast.Function(decorators, name, names, defaults, flags, doc,
code)
else:
n = ast.Function(name, names, defaults, flags, doc, code)
n.lineno = lineno
self.__template_type.pop()
return n
def _do_ReturnStatement(self, node):
value = self.transform(node.Expression)
if value is None:
value = ast.Const(None)
return ast.Return(value)