def file_input(self, nodelist):
# Add a "from IO_MODULE import IO_CLASS" statement to the
# beginning of the module.
doc = None # self.get_docstring(nodelist, symbol.file_input)
if sys.hexversion >= 0x02050000:
io_imp = ast.From(IO_MODULE, [(IO_CLASS, None)], 0)
markup_imp = ast.From(MARKUP_MODULE, [(MARKUP_CLASS, None)], 0)
else:
io_imp = ast.From(IO_MODULE, [(IO_CLASS, None)])
markup_imp = ast.From(MARKUP_MODULE, [(MARKUP_CLASS, None)])
markup_assign = ast.Assign(
[ast.AssName(MARKUP_MANGLED_CLASS, OP_ASSIGN)],
ast.Name(MARKUP_CLASS))
# Add an IO_INSTANCE binding for module level expressions (like
# doc strings). This instance will not be returned.
io_instance = ast.CallFunc(ast.Name(IO_CLASS), [])
io_assign_name = ast.AssName(IO_INSTANCE, OP_ASSIGN)
io_assign = ast.Assign([io_assign_name], io_instance)
stmts = [io_imp, io_assign, markup_imp, markup_assign]
for node in nodelist:
if node[0] != token.ENDMARKER and node[0] != token.NEWLINE:
self.com_append_stmt(stmts, node)
return ast.Module(doc, ast.Stmt(stmts))
def file_input(self, nodelist):
doc = None # self.get_docstring(nodelist, symbol.file_input)
if sys.hexversion >= 0x02050000:
html_imp = ast.From(
'quixote.html',
[('TemplateIO', '_q_TemplateIO'), ('htmltext', '_q_htmltext')],
0)
vars_imp = ast.From("__builtin__", [("vars", "_q_vars")], 0)
else:
html_imp = ast.From(
'quixote.html',
[('TemplateIO', '_q_TemplateIO'), ('htmltext', '_q_htmltext')])
vars_imp = ast.From("__builtin__", [("vars", "_q_vars")])
ptl_imports = [ vars_imp, html_imp ]
stmts = []
for node in nodelist:
if node[0] != token.ENDMARKER and node[0] != token.NEWLINE:
self.com_append_stmt(stmts, node)
# count __future__ statements
i = 0
for stmt in stmts:
if isinstance(stmt, ast.From) and stmt.modname == '__future__':
i += 1
else:
break
stmts[i:i] = ptl_imports
return ast.Module(doc, ast.Stmt(stmts))
def __init__(self, source, filename=None, lineno=-1, lookup='lenient'):
"""Create the code object, either from a string, or from an AST node.
:param source: either a string containing the source code, or an AST
node
:param filename: the (preferably absolute) name of the file containing
the code
:param lineno: the number of the line on which the code was found
:param lookup: the lookup class that defines how variables are looked
up in the context. Can be either `LenientLookup` (the
default), `StrictLookup`, or a custom lookup class
"""
if isinstance(source, basestring):
self.source = source
node = _parse(source, mode=self.mode)
else:
assert isinstance(source, ast.Node)
self.source = '?'
if self.mode == 'eval':
node = ast.Expression(source)
else:
node = ast.Module(None, source)
self.code = _compile(node,
self.source,
mode=self.mode,
filename=filename,
lineno=lineno)
if lookup is None:
lookup = LenientLookup
elif isinstance(lookup, basestring):
lookup = {'lenient': LenientLookup, 'strict': StrictLookup}[lookup]
self._globals = lookup.globals()
def transform(node, filename):
root = ast.Module(None, node, lineno=1)
nodes = [root]
while nodes:
node = nodes.pop()
node.filename = filename
if node.__class__ in (ast.Printnl, ast.Print):
node.dest = ast.Name('__context')
nodes.extend(node.getChildNodes())
return root
def run(self, frame):
# fall-back for unknown statement nodes
try:
expr = ast.Module(None, ast.Stmt([self.__obj__]))
expr.filename = '<run>'
co = pycodegen.ModuleCodeGenerator(expr).getCode()
frame.exec_(co)
except passthroughex:
raise
except:
raise Failure(self)
def file_input(self, nodelist):
doc = None # self.get_docstring(nodelist, symbol.file_input)
html_imp = ast.From('quixote.html', [('TemplateIO', '_q_TemplateIO'),
('htmltext', '_q_htmltext')])
vars_imp = ast.From("__builtin__", [("vars", "_q_vars")])
stmts = [ vars_imp, html_imp ]
for node in nodelist:
if node[0] != token.ENDMARKER and node[0] != token.NEWLINE:
self.com_append_stmt(stmts, node)
return ast.Module(doc, ast.Stmt(stmts))
def compile(src, filename, mode='exec', showTree=False, importlogix=True,
module=None):
global lineno
lineno = 0
global modulename
modulename = module
implogix = ast.Import([(logixModuleName, 'logix')])
prepend = importlogix and [implogix] or None
if len(src) == 0:
src = [None]
try:
if mode == "exec":
statements = block(src, False, prepend)
tree = ast.Module(None, statements)
gen = pycodegen.ModuleCodeGenerator
else:
assert len(src) == 1
stmt = src[0]
if mode == "single":
statements = block([stmt], False, prepend=prepend)
tree = ast.Module(None, statements)
gen = pycodegen.InteractiveCodeGenerator
elif mode == "eval":
statements = block([stmt], True, prepend)
tree = ast.Expression(statements)
gen = pycodegen.ExpressionCodeGenerator
else:
raise ValueError("compile() 3rd arg must be 'exec' or "
"'eval' or 'single'")
except CompileError, exc:
offset = None
raise SyntaxError(str(exc), (filename, lineno, offset, None))
def compileCodeObjects(filename, codeobjs):
if len(codeobjs) == 0:
stmts = []
else:
stmts = [ast.For(ast.AssName('[--codeobj--]', 'OP_ASSIGN'),
ast.Const(codeobjs),
ast.Stmt([ast.Exec(ast.Name('[--codeobj--]'),
None, None)]),
None),
ast.AssName('[--codeobj--]', 'OP_DELETE')]
module = ast.Module(None, ast.Stmt(stmts))
compiler.misc.set_filename(filename, module)
return pycodegen.ModuleCodeGenerator(module).getCode()
def transform(node, filename):
root = ast.Module(None, node, lineno=1)
nodes = [root]
while nodes:
node = nodes.pop()
node.filename = filename
if node.__class__ in (ast.Printnl, ast.Print):
node.dest = ast.Name('__context')
elif node.__class__ is ast.Const and isinstance(node.value, str):
try:
node.value.decode('ascii')
except UnicodeError:
node.value = node.value.decode('utf-8')
nodes.extend(node.getChildNodes())
return root
def run(self, frame):
expr = Interpretable(self.expr)
expr.eval(frame)
self.result = expr.result
self.explanation = '... = ' + expr.explanation
# fall-back-run the rest of the assignment
ass = ast.Assign(self.nodes, ast.Name('__exprinfo_expr'))
mod = ast.Module(None, ast.Stmt([ass]))
mod.filename = '<run>'
co = pycodegen.ModuleCodeGenerator(mod).getCode()
try:
frame.exec_(co, __exprinfo_expr=expr.result)
except passthroughex:
raise
except:
raise Failure(self)
def parse(self, code):
self.lexer.input(code)
result = self.parser.parse(lexer=self.lexer)
return ast.Module(None, result)
def parsefile(self, node):
doc = node.Documentation
body = self.transform(node)
if doc:
del body.nodes[0]
return ast.Module(doc, body)
