def parse_python(space, source, mode):
info = pyparse.CompileInfo("<string>", mode)
parser = pyparse.PythonParser(space)
try:
tree = parser.parse_source(source, info)
except error.IndentationError, e:
raise OperationError(space.w_IndentationError, e.wrap_info(space))
def bench(title):
a = time.clock()
info = pyparse.CompileInfo("<string>", "exec")
parser = pyparse.PythonParser(fakespace)
tree = parser._parse(s, info)
b = time.clock()
print title, (b - a)
def validate_node(space, tree):
assert tree.type >= 256
type = tree.type - 256
parser = pyparse.PythonParser(space)
if type >= len(parser.grammar.dfas):
raise parse_error(space, "Unrecognized node type %d." % type)
dfa = parser.grammar.dfas[type]
# Run the DFA for this nonterminal
arcs, is_accepting = dfa.states[0]
for pos in range(tree.num_children()):
ch = tree.get_child(pos)
for i, next_state in arcs:
label = parser.grammar.labels[i]
if label == ch.type:
# The child is acceptable; validate it recursively
if ch.type >= 256:
validate_node(space, ch)
# Update the state, and move on to the next child.
arcs, is_accepting = dfa.states[next_state]
break
else:
raise parse_error(space, "Illegal node")
if not is_accepting:
raise parse_error(space,
"Illegal number of children for %d node" % tree.type)
def parse_python(space, source, mode):
info = pyparse.CompileInfo("<string>", mode)
parser = pyparse.PythonParser(space)
try:
tree = parser.parse_source(source, info)
except error.IndentationError as e:
raise OperationError(space.w_IndentationError, e.wrap_info(space))
except error.SyntaxError as e:
raise OperationError(space.w_SyntaxError, e.wrap_info(space))
return W_STType(tree, mode, recursive_parser=parser)
def generate_function_code(expr, space):
p = pyparse.PythonParser(space)
info = pyparse.CompileInfo("<test>", 'exec')
cst = p.parse_source(expr, info)
ast = astbuilder.ast_from_node(space, cst, info)
function_ast = optimize.optimize_ast(space, ast.body[0], info)
function_ast = ast.body[0]
symbols = symtable.SymtableBuilder(space, ast, info)
generator = codegen.FunctionCodeGenerator(space, 'function', function_ast,
1, symbols, info)
blocks = generator.first_block.post_order()
generator._resolve_block_targets(blocks)
return generator, blocks
def setup_class(self):
self.parser = pyparse.PythonParser(self.space)
def __init__(self, space, override_version=None):
PyCodeCompiler.__init__(self, space)
self.future_flags = future.futureFlags_3_7
self.parser = pyparse.PythonParser(space, self.future_flags)
self.additional_rules = {}
self.compiler_flags = self.future_flags.allowed_flags
def compile_with_astcompiler(expr, mode, space):
p = pyparse.PythonParser(space)
info = pyparse.CompileInfo("<test>", mode)
cst = p.parse_source(expr, info)
ast = astbuilder.ast_from_node(space, cst, info)
return codegen.compile_ast(space, ast, info)
def setup_class(cls):
cls.parser = pyparse.PythonParser(cls.space)
def tuple2st(space, w_sequence):
# Convert the tree to the internal form before checking it
tree = build_node_tree(space, w_sequence)
parser = pyparse.PythonParser(space)
validate_node(space, tree, parser)
return W_STType(tree, 'eval')
# <codecell>
from pypy.interpreter.pyparser import pyparse
from pypy.interpreter.astcompiler import ast
from pypy.interpreter.astcompiler.astbuilder import ast_from_node
from pypy.tool.pytest.objspace import TinyObjSpace
from .codecommon import normalize_name, assert_tree
from .ogm import OG
# <codecell>
# Source code to tree (AST)
space = TinyObjSpace()
pyparser = pyparse.PythonParser(space)
compile_info = pyparse.CompileInfo("<filename>", "exec")
def source_to_tree(source):
parsetree = pyparser.parse_source(source, compile_info)
tree = ast_from_node(space, parsetree, compile_info)
return tree
# <codecell>
# Find nodes that define new names
def make_def_finders():
# Class Definition
def ClassDef(node, links):
yield node.name
def setup_class(self):
self.parser = pyparse.PythonParser(None)