Whitespace normalization.
This commit is contained in:
Tim Peters
parent
08533fdad6
commit
710ab3b5f8
|
|
@ -1,158 +1,158 @@
|
|||
"Usage: unparse.py <path to source file>"
|
||||
import sys
|
||||
|
||||
class Unparser:
|
||||
"""Methods in this class recursively traverse an AST and
|
||||
output source code for the abstract syntax; original formatting
|
||||
is disregarged. """
|
||||
|
||||
def __init__(self, tree, file = sys.stdout):
|
||||
"""Unparser(tree, file=sys.stdout) -> None.
|
||||
Print the source for tree to file."""
|
||||
self.f = file
|
||||
self._indent = 0
|
||||
self.dispatch(tree)
|
||||
self.f.flush()
|
||||
|
||||
def fill(self, text = ""):
|
||||
"Indent a piece of text, according to the current indentation level"
|
||||
self.f.write("\n"+" "*self._indent + text)
|
||||
|
||||
def write(self, text):
|
||||
"Append a piece of text to the current line."
|
||||
self.f.write(text)
|
||||
|
||||
def enter(self):
|
||||
"Print ':', and increase the indentation."
|
||||
self.write(":")
|
||||
self._indent += 1
|
||||
|
||||
def leave(self):
|
||||
"Decrease the indentation level."
|
||||
self._indent -= 1
|
||||
|
||||
def dispatch(self, tree):
|
||||
"Dispatcher function, dispatching tree type T to method _T."
|
||||
if isinstance(tree, list):
|
||||
for t in tree:
|
||||
self.dispatch(t)
|
||||
return
|
||||
meth = getattr(self, "_"+tree.__class__.__name__)
|
||||
meth(tree)
|
||||
|
||||
|
||||
############### Unparsing methods ######################
|
||||
# There should be one method per concrete grammar type #
|
||||
# Constructors should be grouped by sum type. Ideally, #
|
||||
# this would follow the order in the grammar, but #
|
||||
# currently doesn't. #
|
||||
########################################################
|
||||
|
||||
def _Module(self, tree):
|
||||
for stmt in tree.body:
|
||||
self.dispatch(stmt)
|
||||
|
||||
# stmt
|
||||
def _Expr(self, tree):
|
||||
self.fill()
|
||||
self.dispatch(tree.value)
|
||||
|
||||
def _Import(self, t):
|
||||
self.fill("import ")
|
||||
first = True
|
||||
for a in t.names:
|
||||
if first:
|
||||
first = False
|
||||
else:
|
||||
self.write(", ")
|
||||
self.write(a.name)
|
||||
if a.asname:
|
||||
self.write(" as "+a.asname)
|
||||
|
||||
def _Assign(self, t):
|
||||
self.fill()
|
||||
for target in t.targets:
|
||||
self.dispatch(target)
|
||||
self.write(" = ")
|
||||
self.dispatch(t.value)
|
||||
|
||||
def _ClassDef(self, t):
|
||||
self.write("\n")
|
||||
self.fill("class "+t.name)
|
||||
if t.bases:
|
||||
self.write("(")
|
||||
for a in t.bases:
|
||||
self.dispatch(a)
|
||||
self.write(", ")
|
||||
self.write(")")
|
||||
self.enter()
|
||||
self.dispatch(t.body)
|
||||
self.leave()
|
||||
|
||||
def _FunctionDef(self, t):
|
||||
self.write("\n")
|
||||
self.fill("def "+t.name + "(")
|
||||
self.dispatch(t.args)
|
||||
self.enter()
|
||||
self.dispatch(t.body)
|
||||
self.leave()
|
||||
|
||||
def _If(self, t):
|
||||
self.fill("if ")
|
||||
self.dispatch(t.test)
|
||||
self.enter()
|
||||
# XXX elif?
|
||||
self.dispatch(t.body)
|
||||
self.leave()
|
||||
if t.orelse:
|
||||
self.fill("else")
|
||||
self.enter()
|
||||
self.dispatch(t.orelse)
|
||||
self.leave()
|
||||
|
||||
# expr
|
||||
def _Str(self, tree):
|
||||
self.write(repr(tree.s))
|
||||
|
||||
def _Name(self, t):
|
||||
self.write(t.id)
|
||||
|
||||
def _List(self, t):
|
||||
self.write("[")
|
||||
for e in t.elts:
|
||||
self.dispatch(e)
|
||||
self.write(", ")
|
||||
self.write("]")
|
||||
|
||||
unop = {"Invert":"~", "Not": "not", "UAdd":"+", "USub":"-"}
|
||||
def _UnaryOp(self, t):
|
||||
self.write(self.unop[t.op.__class__.__name__])
|
||||
self.write("(")
|
||||
self.dispatch(t.operand)
|
||||
self.write(")")
|
||||
|
||||
# others
|
||||
def _arguments(self, t):
|
||||
first = True
|
||||
# XXX t.defaults
|
||||
for a in t.args:
|
||||
if first:first = False
|
||||
else: self.write(", ")
|
||||
self.dispatch(a)
|
||||
if t.vararg:
|
||||
if first:first = False
|
||||
else: self.write(", ")
|
||||
self.write("*"+t.vararg)
|
||||
if t.kwarg:
|
||||
if first:first = False
|
||||
else: self.write(", ")
|
||||
self.write("**"+self.kwarg)
|
||||
self.write(")")
|
||||
|
||||
def roundtrip(filename):
|
||||
source = open(filename).read()
|
||||
tree = compile(source, filename, "exec", 0x400)
|
||||
Unparser(tree)
|
||||
|
||||
if __name__=='__main__':
|
||||
roundtrip(sys.argv[1])
|
||||
"Usage: unparse.py <path to source file>"
|
||||
import sys
|
||||
|
||||
class Unparser:
|
||||
"""Methods in this class recursively traverse an AST and
|
||||
output source code for the abstract syntax; original formatting
|
||||
is disregarged. """
|
||||
|
||||
def __init__(self, tree, file = sys.stdout):
|
||||
"""Unparser(tree, file=sys.stdout) -> None.
|
||||
Print the source for tree to file."""
|
||||
self.f = file
|
||||
self._indent = 0
|
||||
self.dispatch(tree)
|
||||
self.f.flush()
|
||||
|
||||
def fill(self, text = ""):
|
||||
"Indent a piece of text, according to the current indentation level"
|
||||
self.f.write("\n"+" "*self._indent + text)
|
||||
|
||||
def write(self, text):
|
||||
"Append a piece of text to the current line."
|
||||
self.f.write(text)
|
||||
|
||||
def enter(self):
|
||||
"Print ':', and increase the indentation."
|
||||
self.write(":")
|
||||
self._indent += 1
|
||||
|
||||
def leave(self):
|
||||
"Decrease the indentation level."
|
||||
self._indent -= 1
|
||||
|
||||
def dispatch(self, tree):
|
||||
"Dispatcher function, dispatching tree type T to method _T."
|
||||
if isinstance(tree, list):
|
||||
for t in tree:
|
||||
self.dispatch(t)
|
||||
return
|
||||
meth = getattr(self, "_"+tree.__class__.__name__)
|
||||
meth(tree)
|
||||
|
||||
|
||||
############### Unparsing methods ######################
|
||||
# There should be one method per concrete grammar type #
|
||||
# Constructors should be grouped by sum type. Ideally, #
|
||||
# this would follow the order in the grammar, but #
|
||||
# currently doesn't. #
|
||||
########################################################
|
||||
|
||||
def _Module(self, tree):
|
||||
for stmt in tree.body:
|
||||
self.dispatch(stmt)
|
||||
|
||||
# stmt
|
||||
def _Expr(self, tree):
|
||||
self.fill()
|
||||
self.dispatch(tree.value)
|
||||
|
||||
def _Import(self, t):
|
||||
self.fill("import ")
|
||||
first = True
|
||||
for a in t.names:
|
||||
if first:
|
||||
first = False
|
||||
else:
|
||||
self.write(", ")
|
||||
self.write(a.name)
|
||||
if a.asname:
|
||||
self.write(" as "+a.asname)
|
||||
|
||||
def _Assign(self, t):
|
||||
self.fill()
|
||||
for target in t.targets:
|
||||
self.dispatch(target)
|
||||
self.write(" = ")
|
||||
self.dispatch(t.value)
|
||||
|
||||
def _ClassDef(self, t):
|
||||
self.write("\n")
|
||||
self.fill("class "+t.name)
|
||||
if t.bases:
|
||||
self.write("(")
|
||||
for a in t.bases:
|
||||
self.dispatch(a)
|
||||
self.write(", ")
|
||||
self.write(")")
|
||||
self.enter()
|
||||
self.dispatch(t.body)
|
||||
self.leave()
|
||||
|
||||
def _FunctionDef(self, t):
|
||||
self.write("\n")
|
||||
self.fill("def "+t.name + "(")
|
||||
self.dispatch(t.args)
|
||||
self.enter()
|
||||
self.dispatch(t.body)
|
||||
self.leave()
|
||||
|
||||
def _If(self, t):
|
||||
self.fill("if ")
|
||||
self.dispatch(t.test)
|
||||
self.enter()
|
||||
# XXX elif?
|
||||
self.dispatch(t.body)
|
||||
self.leave()
|
||||
if t.orelse:
|
||||
self.fill("else")
|
||||
self.enter()
|
||||
self.dispatch(t.orelse)
|
||||
self.leave()
|
||||
|
||||
# expr
|
||||
def _Str(self, tree):
|
||||
self.write(repr(tree.s))
|
||||
|
||||
def _Name(self, t):
|
||||
self.write(t.id)
|
||||
|
||||
def _List(self, t):
|
||||
self.write("[")
|
||||
for e in t.elts:
|
||||
self.dispatch(e)
|
||||
self.write(", ")
|
||||
self.write("]")
|
||||
|
||||
unop = {"Invert":"~", "Not": "not", "UAdd":"+", "USub":"-"}
|
||||
def _UnaryOp(self, t):
|
||||
self.write(self.unop[t.op.__class__.__name__])
|
||||
self.write("(")
|
||||
self.dispatch(t.operand)
|
||||
self.write(")")
|
||||
|
||||
# others
|
||||
def _arguments(self, t):
|
||||
first = True
|
||||
# XXX t.defaults
|
||||
for a in t.args:
|
||||
if first:first = False
|
||||
else: self.write(", ")
|
||||
self.dispatch(a)
|
||||
if t.vararg:
|
||||
if first:first = False
|
||||
else: self.write(", ")
|
||||
self.write("*"+t.vararg)
|
||||
if t.kwarg:
|
||||
if first:first = False
|
||||
else: self.write(", ")
|
||||
self.write("**"+self.kwarg)
|
||||
self.write(")")
|
||||
|
||||
def roundtrip(filename):
|
||||
source = open(filename).read()
|
||||
tree = compile(source, filename, "exec", 0x400)
|
||||
Unparser(tree)
|
||||
|
||||
if __name__=='__main__':
|
||||
roundtrip(sys.argv[1])
|
||||
|
|
|
|||
|
|
@ -553,7 +553,7 @@ class Function(Node):
|
|||
self.varargs = 1
|
||||
if flags & CO_VARKEYWORDS:
|
||||
self.kwargs = 1
|
||||
|
||||
|
||||
|
||||
|
||||
def getChildren(self):
|
||||
|
|
@ -584,7 +584,7 @@ class GenExpr(Node):
|
|||
self.lineno = lineno
|
||||
self.argnames = ['[outmost-iterable]']
|
||||
self.varargs = self.kwargs = None
|
||||
|
||||
|
||||
|
||||
|
||||
def getChildren(self):
|
||||
|
|
@ -763,7 +763,7 @@ class Lambda(Node):
|
|||
self.varargs = 1
|
||||
if flags & CO_VARKEYWORDS:
|
||||
self.kwargs = 1
|
||||
|
||||
|
||||
|
||||
|
||||
def getChildren(self):
|
||||
|
|
|
|||
|
|
@ -1,34 +1,33 @@
|
|||
class GeneratorContextManager(object):
|
||||
def __init__(self, gen):
|
||||
self.gen = gen
|
||||
|
||||
def __context__(self):
|
||||
return self
|
||||
|
||||
def __enter__(self):
|
||||
try:
|
||||
return self.gen.next()
|
||||
except StopIteration:
|
||||
raise RuntimeError("generator didn't yield")
|
||||
|
||||
def __exit__(self, type, value, traceback):
|
||||
if type is None:
|
||||
try:
|
||||
self.gen.next()
|
||||
except StopIteration:
|
||||
return
|
||||
else:
|
||||
raise RuntimeError("generator didn't stop")
|
||||
else:
|
||||
try:
|
||||
self.gen.throw(type, value, traceback)
|
||||
except (type, StopIteration):
|
||||
return
|
||||
else:
|
||||
raise RuntimeError("generator caught exception")
|
||||
|
||||
def contextmanager(func):
|
||||
def helper(*args, **kwds):
|
||||
return GeneratorContextManager(func(*args, **kwds))
|
||||
return helper
|
||||
|
||||
class GeneratorContextManager(object):
|
||||
def __init__(self, gen):
|
||||
self.gen = gen
|
||||
|
||||
def __context__(self):
|
||||
return self
|
||||
|
||||
def __enter__(self):
|
||||
try:
|
||||
return self.gen.next()
|
||||
except StopIteration:
|
||||
raise RuntimeError("generator didn't yield")
|
||||
|
||||
def __exit__(self, type, value, traceback):
|
||||
if type is None:
|
||||
try:
|
||||
self.gen.next()
|
||||
except StopIteration:
|
||||
return
|
||||
else:
|
||||
raise RuntimeError("generator didn't stop")
|
||||
else:
|
||||
try:
|
||||
self.gen.throw(type, value, traceback)
|
||||
except (type, StopIteration):
|
||||
return
|
||||
else:
|
||||
raise RuntimeError("generator caught exception")
|
||||
|
||||
def contextmanager(func):
|
||||
def helper(*args, **kwds):
|
||||
return GeneratorContextManager(func(*args, **kwds))
|
||||
return helper
|
||||
|
|
|
|||
|
|
@ -1,41 +1,40 @@
|
|||
import sys
|
||||
from collections import deque
|
||||
|
||||
|
||||
class nested(object):
|
||||
def __init__(self, *contexts):
|
||||
self.contexts = contexts
|
||||
self.entered = None
|
||||
|
||||
def __context__(self):
|
||||
return self
|
||||
|
||||
def __enter__(self):
|
||||
if self.entered is not None:
|
||||
raise RuntimeError("Context is not reentrant")
|
||||
self.entered = deque()
|
||||
vars = []
|
||||
try:
|
||||
for context in self.contexts:
|
||||
mgr = context.__context__()
|
||||
vars.append(mgr.__enter__())
|
||||
self.entered.appendleft(mgr)
|
||||
except:
|
||||
self.__exit__(*sys.exc_info())
|
||||
raise
|
||||
return vars
|
||||
|
||||
def __exit__(self, *exc_info):
|
||||
# Behave like nested with statements
|
||||
# first in, last out
|
||||
# New exceptions override old ones
|
||||
ex = exc_info
|
||||
for mgr in self.entered:
|
||||
try:
|
||||
mgr.__exit__(*ex)
|
||||
except:
|
||||
ex = sys.exc_info()
|
||||
self.entered = None
|
||||
if ex is not exc_info:
|
||||
raise ex[0], ex[1], ex[2]
|
||||
|
||||
import sys
|
||||
from collections import deque
|
||||
|
||||
|
||||
class nested(object):
|
||||
def __init__(self, *contexts):
|
||||
self.contexts = contexts
|
||||
self.entered = None
|
||||
|
||||
def __context__(self):
|
||||
return self
|
||||
|
||||
def __enter__(self):
|
||||
if self.entered is not None:
|
||||
raise RuntimeError("Context is not reentrant")
|
||||
self.entered = deque()
|
||||
vars = []
|
||||
try:
|
||||
for context in self.contexts:
|
||||
mgr = context.__context__()
|
||||
vars.append(mgr.__enter__())
|
||||
self.entered.appendleft(mgr)
|
||||
except:
|
||||
self.__exit__(*sys.exc_info())
|
||||
raise
|
||||
return vars
|
||||
|
||||
def __exit__(self, *exc_info):
|
||||
# Behave like nested with statements
|
||||
# first in, last out
|
||||
# New exceptions override old ones
|
||||
ex = exc_info
|
||||
for mgr in self.entered:
|
||||
try:
|
||||
mgr.__exit__(*ex)
|
||||
except:
|
||||
ex = sys.exc_info()
|
||||
self.entered = None
|
||||
if ex is not exc_info:
|
||||
raise ex[0], ex[1], ex[2]
|
||||
|
|
|
|||
|
|
@ -1,179 +1,178 @@
|
|||
import sys, itertools
|
||||
|
||||
def to_tuple(t):
|
||||
if t is None or isinstance(t, (basestring, int, long, complex)):
|
||||
return t
|
||||
elif isinstance(t, list):
|
||||
return [to_tuple(e) for e in t]
|
||||
result = [t.__class__.__name__]
|
||||
if t._fields is None:
|
||||
return tuple(result)
|
||||
for f in t._fields:
|
||||
result.append(to_tuple(getattr(t, f)))
|
||||
return tuple(result)
|
||||
|
||||
# These tests are compiled through "exec"
|
||||
# There should be atleast one test per statement
|
||||
exec_tests = [
|
||||
# FunctionDef
|
||||
"def f(): pass",
|
||||
# ClassDef
|
||||
"class C:pass",
|
||||
# Return
|
||||
"def f():return 1",
|
||||
# Delete
|
||||
"del v",
|
||||
# Assign
|
||||
"v = 1",
|
||||
# AugAssign
|
||||
"v += 1",
|
||||
# Print
|
||||
"print >>f, 1, ",
|
||||
# For
|
||||
"for v in v:pass",
|
||||
# While
|
||||
"while v:pass",
|
||||
# If
|
||||
"if v:pass",
|
||||
# Raise
|
||||
"raise Exception, 'string'",
|
||||
# TryExcept
|
||||
"try:\n pass\nexcept Exception:\n pass",
|
||||
# TryFinally
|
||||
"try:\n pass\nfinally:\n pass",
|
||||
# Assert
|
||||
"assert v",
|
||||
# Import
|
||||
"import sys",
|
||||
# ImportFrom
|
||||
"from sys import v",
|
||||
# Exec
|
||||
"exec 'v'",
|
||||
# Global
|
||||
"global v",
|
||||
# Expr
|
||||
"1",
|
||||
# Pass,
|
||||
"pass",
|
||||
# Break
|
||||
"break",
|
||||
# Continue
|
||||
"continue",
|
||||
]
|
||||
|
||||
# These are compiled through "single"
|
||||
# because of overlap with "eval", it just tests what
|
||||
# can't be tested with "eval"
|
||||
single_tests = [
|
||||
"1+2"
|
||||
]
|
||||
|
||||
# These are compiled through "eval"
|
||||
# It should test all expressions
|
||||
eval_tests = [
|
||||
# BoolOp
|
||||
"a and b",
|
||||
# BinOp
|
||||
"a + b",
|
||||
# UnaryOp
|
||||
"not v",
|
||||
# Lambda
|
||||
"lambda:None",
|
||||
# Dict
|
||||
"{ 1:2 }",
|
||||
# ListComp
|
||||
"[a for b in c if d]",
|
||||
# GeneratorExp
|
||||
"(a for b in c if d)",
|
||||
# Yield - yield expressions can't work outside a function
|
||||
#
|
||||
# Compare
|
||||
"1 < 2 < 3",
|
||||
# Call
|
||||
"f(1,2,c=3,*d,**e)",
|
||||
# Repr
|
||||
"`v`",
|
||||
# Num
|
||||
"10L",
|
||||
# Str
|
||||
"'string'",
|
||||
# Attribute
|
||||
"a.b",
|
||||
# Subscript
|
||||
"a[b:c]",
|
||||
# Name
|
||||
"v",
|
||||
# List
|
||||
"[1,2,3]",
|
||||
# Tuple
|
||||
"1,2,3"
|
||||
]
|
||||
|
||||
# TODO: expr_context, slice, boolop, operator, unaryop, cmpop, comprehension
|
||||
# excepthandler, arguments, keywords, alias
|
||||
|
||||
if __name__=='__main__' and sys.argv[1:] == ['-g']:
|
||||
for statements, kind in ((exec_tests, "exec"), (single_tests, "single"), (eval_tests, "eval")):
|
||||
print kind+"_results = ["
|
||||
for s in statements:
|
||||
print repr(to_tuple(compile(s, "?", kind, 0x400)))+","
|
||||
print "]"
|
||||
print "run_tests()"
|
||||
raise SystemExit
|
||||
|
||||
def run_tests():
|
||||
for input, output, kind in ((exec_tests, exec_results, "exec"),
|
||||
(single_tests, single_results, "single"),
|
||||
(eval_tests, eval_results, "eval")):
|
||||
for i, o in itertools.izip(input, output):
|
||||
assert to_tuple(compile(i, "?", kind, 0x400)) == o
|
||||
|
||||
#### EVERYTHING BELOW IS GENERATED #####
|
||||
exec_results = [
|
||||
('Module', [('FunctionDef', 'f', ('arguments', [], None, None, []), [('Pass',)], [])]),
|
||||
('Module', [('ClassDef', 'C', [], [('Pass',)])]),
|
||||
('Module', [('FunctionDef', 'f', ('arguments', [], None, None, []), [('Return', ('Num', 1))], [])]),
|
||||
('Module', [('Delete', [('Name', 'v', ('Del',))])]),
|
||||
('Module', [('Assign', [('Name', 'v', ('Store',))], ('Num', 1))]),
|
||||
('Module', [('AugAssign', ('Name', 'v', ('Load',)), ('Add',), ('Num', 1))]),
|
||||
('Module', [('Print', ('Name', 'f', ('Load',)), [('Num', 1)], False)]),
|
||||
('Module', [('For', ('Name', 'v', ('Store',)), ('Name', 'v', ('Load',)), [('Pass',)], [])]),
|
||||
('Module', [('While', ('Name', 'v', ('Load',)), [('Pass',)], [])]),
|
||||
('Module', [('If', ('Name', 'v', ('Load',)), [('Pass',)], [])]),
|
||||
('Module', [('Raise', ('Name', 'Exception', ('Load',)), ('Str', 'string'), None)]),
|
||||
('Module', [('TryExcept', [('Pass',)], [('excepthandler', ('Name', 'Exception', ('Load',)), None, [('Pass',)])], [])]),
|
||||
('Module', [('TryFinally', [('Pass',)], [('Pass',)])]),
|
||||
('Module', [('Assert', ('Name', 'v', ('Load',)), None)]),
|
||||
('Module', [('Import', [('alias', 'sys', None)])]),
|
||||
('Module', [('ImportFrom', 'sys', [('alias', 'v', None)], 0)]),
|
||||
('Module', [('Exec', ('Str', 'v'), None, None)]),
|
||||
('Module', [('Global', ['v'])]),
|
||||
('Module', [('Expr', ('Num', 1))]),
|
||||
('Module', [('Pass',)]),
|
||||
('Module', [('Break',)]),
|
||||
('Module', [('Continue',)]),
|
||||
]
|
||||
single_results = [
|
||||
('Interactive', [('Expr', ('BinOp', ('Num', 1), ('Add',), ('Num', 2)))]),
|
||||
]
|
||||
eval_results = [
|
||||
('Expression', ('BoolOp', ('And',), [('Name', 'a', ('Load',)), ('Name', 'b', ('Load',))])),
|
||||
('Expression', ('BinOp', ('Name', 'a', ('Load',)), ('Add',), ('Name', 'b', ('Load',)))),
|
||||
('Expression', ('UnaryOp', ('Not',), ('Name', 'v', ('Load',)))),
|
||||
('Expression', ('Lambda', ('arguments', [], None, None, []), ('Name', 'None', ('Load',)))),
|
||||
('Expression', ('Dict', [('Num', 1)], [('Num', 2)])),
|
||||
('Expression', ('ListComp', ('Name', 'a', ('Load',)), [('comprehension', ('Name', 'b', ('Store',)), ('Name', 'c', ('Load',)), [('Name', 'd', ('Load',))])])),
|
||||
('Expression', ('GeneratorExp', ('Name', 'a', ('Load',)), [('comprehension', ('Name', 'b', ('Store',)), ('Name', 'c', ('Load',)), [('Name', 'd', ('Load',))])])),
|
||||
('Expression', ('Compare', ('Num', 1), [('Lt',), ('Lt',)], [('Num', 2), ('Num', 3)])),
|
||||
('Expression', ('Call', ('Name', 'f', ('Load',)), [('Num', 1), ('Num', 2)], [('keyword', 'c', ('Num', 3))], ('Name', 'd', ('Load',)), ('Name', 'e', ('Load',)))),
|
||||
('Expression', ('Repr', ('Name', 'v', ('Load',)))),
|
||||
('Expression', ('Num', 10L)),
|
||||
('Expression', ('Str', 'string')),
|
||||
('Expression', ('Attribute', ('Name', 'a', ('Load',)), 'b', ('Load',))),
|
||||
('Expression', ('Subscript', ('Name', 'a', ('Load',)), ('Slice', ('Name', 'b', ('Load',)), ('Name', 'c', ('Load',)), None), ('Load',))),
|
||||
('Expression', ('Name', 'v', ('Load',))),
|
||||
('Expression', ('List', [('Num', 1), ('Num', 2), ('Num', 3)], ('Load',))),
|
||||
('Expression', ('Tuple', [('Num', 1), ('Num', 2), ('Num', 3)], ('Load',))),
|
||||
]
|
||||
run_tests()
|
||||
|
||||
import sys, itertools
|
||||
|
||||
def to_tuple(t):
|
||||
if t is None or isinstance(t, (basestring, int, long, complex)):
|
||||
return t
|
||||
elif isinstance(t, list):
|
||||
return [to_tuple(e) for e in t]
|
||||
result = [t.__class__.__name__]
|
||||
if t._fields is None:
|
||||
return tuple(result)
|
||||
for f in t._fields:
|
||||
result.append(to_tuple(getattr(t, f)))
|
||||
return tuple(result)
|
||||
|
||||
# These tests are compiled through "exec"
|
||||
# There should be atleast one test per statement
|
||||
exec_tests = [
|
||||
# FunctionDef
|
||||
"def f(): pass",
|
||||
# ClassDef
|
||||
"class C:pass",
|
||||
# Return
|
||||
"def f():return 1",
|
||||
# Delete
|
||||
"del v",
|
||||
# Assign
|
||||
"v = 1",
|
||||
# AugAssign
|
||||
"v += 1",
|
||||
# Print
|
||||
"print >>f, 1, ",
|
||||
# For
|
||||
"for v in v:pass",
|
||||
# While
|
||||
"while v:pass",
|
||||
# If
|
||||
"if v:pass",
|
||||
# Raise
|
||||
"raise Exception, 'string'",
|
||||
# TryExcept
|
||||
"try:\n pass\nexcept Exception:\n pass",
|
||||
# TryFinally
|
||||
"try:\n pass\nfinally:\n pass",
|
||||
# Assert
|
||||
"assert v",
|
||||
# Import
|
||||
"import sys",
|
||||
# ImportFrom
|
||||
"from sys import v",
|
||||
# Exec
|
||||
"exec 'v'",
|
||||
# Global
|
||||
"global v",
|
||||
# Expr
|
||||
"1",
|
||||
# Pass,
|
||||
"pass",
|
||||
# Break
|
||||
"break",
|
||||
# Continue
|
||||
"continue",
|
||||
]
|
||||
|
||||
# These are compiled through "single"
|
||||
# because of overlap with "eval", it just tests what
|
||||
# can't be tested with "eval"
|
||||
single_tests = [
|
||||
"1+2"
|
||||
]
|
||||
|
||||
# These are compiled through "eval"
|
||||
# It should test all expressions
|
||||
eval_tests = [
|
||||
# BoolOp
|
||||
"a and b",
|
||||
# BinOp
|
||||
"a + b",
|
||||
# UnaryOp
|
||||
"not v",
|
||||
# Lambda
|
||||
"lambda:None",
|
||||
# Dict
|
||||
"{ 1:2 }",
|
||||
# ListComp
|
||||
"[a for b in c if d]",
|
||||
# GeneratorExp
|
||||
"(a for b in c if d)",
|
||||
# Yield - yield expressions can't work outside a function
|
||||
#
|
||||
# Compare
|
||||
"1 < 2 < 3",
|
||||
# Call
|
||||
"f(1,2,c=3,*d,**e)",
|
||||
# Repr
|
||||
"`v`",
|
||||
# Num
|
||||
"10L",
|
||||
# Str
|
||||
"'string'",
|
||||
# Attribute
|
||||
"a.b",
|
||||
# Subscript
|
||||
"a[b:c]",
|
||||
# Name
|
||||
"v",
|
||||
# List
|
||||
"[1,2,3]",
|
||||
# Tuple
|
||||
"1,2,3"
|
||||
]
|
||||
|
||||
# TODO: expr_context, slice, boolop, operator, unaryop, cmpop, comprehension
|
||||
# excepthandler, arguments, keywords, alias
|
||||
|
||||
if __name__=='__main__' and sys.argv[1:] == ['-g']:
|
||||
for statements, kind in ((exec_tests, "exec"), (single_tests, "single"), (eval_tests, "eval")):
|
||||
print kind+"_results = ["
|
||||
for s in statements:
|
||||
print repr(to_tuple(compile(s, "?", kind, 0x400)))+","
|
||||
print "]"
|
||||
print "run_tests()"
|
||||
raise SystemExit
|
||||
|
||||
def run_tests():
|
||||
for input, output, kind in ((exec_tests, exec_results, "exec"),
|
||||
(single_tests, single_results, "single"),
|
||||
(eval_tests, eval_results, "eval")):
|
||||
for i, o in itertools.izip(input, output):
|
||||
assert to_tuple(compile(i, "?", kind, 0x400)) == o
|
||||
|
||||
#### EVERYTHING BELOW IS GENERATED #####
|
||||
exec_results = [
|
||||
('Module', [('FunctionDef', 'f', ('arguments', [], None, None, []), [('Pass',)], [])]),
|
||||
('Module', [('ClassDef', 'C', [], [('Pass',)])]),
|
||||
('Module', [('FunctionDef', 'f', ('arguments', [], None, None, []), [('Return', ('Num', 1))], [])]),
|
||||
('Module', [('Delete', [('Name', 'v', ('Del',))])]),
|
||||
('Module', [('Assign', [('Name', 'v', ('Store',))], ('Num', 1))]),
|
||||
('Module', [('AugAssign', ('Name', 'v', ('Load',)), ('Add',), ('Num', 1))]),
|
||||
('Module', [('Print', ('Name', 'f', ('Load',)), [('Num', 1)], False)]),
|
||||
('Module', [('For', ('Name', 'v', ('Store',)), ('Name', 'v', ('Load',)), [('Pass',)], [])]),
|
||||
('Module', [('While', ('Name', 'v', ('Load',)), [('Pass',)], [])]),
|
||||
('Module', [('If', ('Name', 'v', ('Load',)), [('Pass',)], [])]),
|
||||
('Module', [('Raise', ('Name', 'Exception', ('Load',)), ('Str', 'string'), None)]),
|
||||
('Module', [('TryExcept', [('Pass',)], [('excepthandler', ('Name', 'Exception', ('Load',)), None, [('Pass',)])], [])]),
|
||||
('Module', [('TryFinally', [('Pass',)], [('Pass',)])]),
|
||||
('Module', [('Assert', ('Name', 'v', ('Load',)), None)]),
|
||||
('Module', [('Import', [('alias', 'sys', None)])]),
|
||||
('Module', [('ImportFrom', 'sys', [('alias', 'v', None)], 0)]),
|
||||
('Module', [('Exec', ('Str', 'v'), None, None)]),
|
||||
('Module', [('Global', ['v'])]),
|
||||
('Module', [('Expr', ('Num', 1))]),
|
||||
('Module', [('Pass',)]),
|
||||
('Module', [('Break',)]),
|
||||
('Module', [('Continue',)]),
|
||||
]
|
||||
single_results = [
|
||||
('Interactive', [('Expr', ('BinOp', ('Num', 1), ('Add',), ('Num', 2)))]),
|
||||
]
|
||||
eval_results = [
|
||||
('Expression', ('BoolOp', ('And',), [('Name', 'a', ('Load',)), ('Name', 'b', ('Load',))])),
|
||||
('Expression', ('BinOp', ('Name', 'a', ('Load',)), ('Add',), ('Name', 'b', ('Load',)))),
|
||||
('Expression', ('UnaryOp', ('Not',), ('Name', 'v', ('Load',)))),
|
||||
('Expression', ('Lambda', ('arguments', [], None, None, []), ('Name', 'None', ('Load',)))),
|
||||
('Expression', ('Dict', [('Num', 1)], [('Num', 2)])),
|
||||
('Expression', ('ListComp', ('Name', 'a', ('Load',)), [('comprehension', ('Name', 'b', ('Store',)), ('Name', 'c', ('Load',)), [('Name', 'd', ('Load',))])])),
|
||||
('Expression', ('GeneratorExp', ('Name', 'a', ('Load',)), [('comprehension', ('Name', 'b', ('Store',)), ('Name', 'c', ('Load',)), [('Name', 'd', ('Load',))])])),
|
||||
('Expression', ('Compare', ('Num', 1), [('Lt',), ('Lt',)], [('Num', 2), ('Num', 3)])),
|
||||
('Expression', ('Call', ('Name', 'f', ('Load',)), [('Num', 1), ('Num', 2)], [('keyword', 'c', ('Num', 3))], ('Name', 'd', ('Load',)), ('Name', 'e', ('Load',)))),
|
||||
('Expression', ('Repr', ('Name', 'v', ('Load',)))),
|
||||
('Expression', ('Num', 10L)),
|
||||
('Expression', ('Str', 'string')),
|
||||
('Expression', ('Attribute', ('Name', 'a', ('Load',)), 'b', ('Load',))),
|
||||
('Expression', ('Subscript', ('Name', 'a', ('Load',)), ('Slice', ('Name', 'b', ('Load',)), ('Name', 'c', ('Load',)), None), ('Load',))),
|
||||
('Expression', ('Name', 'v', ('Load',))),
|
||||
('Expression', ('List', [('Num', 1), ('Num', 2), ('Num', 3)], ('Load',))),
|
||||
('Expression', ('Tuple', [('Num', 1), ('Num', 2), ('Num', 3)], ('Load',))),
|
||||
]
|
||||
run_tests()
|
||||
|
|
|
|||
|
|
@ -190,7 +190,7 @@ class ImportHooksTestCase(ImportHooksBaseTestCase):
|
|||
TestImporter.modules['reloadmodule'] = (False, reload_co)
|
||||
reload(reloadmodule)
|
||||
self.failUnless(hasattr(reloadmodule,'reloaded'))
|
||||
|
||||
|
||||
import hooktestpackage.oldabs
|
||||
self.assertEqual(hooktestpackage.oldabs.get_name(),
|
||||
"hooktestpackage.oldabs")
|
||||
|
|
@ -208,7 +208,7 @@ class ImportHooksTestCase(ImportHooksBaseTestCase):
|
|||
"hooktestpackage.futrel")
|
||||
self.assertEqual(hooktestpackage.futrel.sub,
|
||||
hooktestpackage.sub)
|
||||
|
||||
|
||||
import sub
|
||||
self.assertEqual(sub.get_name(), "sub")
|
||||
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load Diff
|
|
@ -38,7 +38,7 @@ class Id(Token):
|
|||
|
||||
def __str__(self):
|
||||
return self.value
|
||||
|
||||
|
||||
class String(Token):
|
||||
def __init__(self, value, lineno):
|
||||
self.type = 'String'
|
||||
|
|
@ -71,7 +71,7 @@ class ASDLScanner(spark.GenericScanner, object):
|
|||
# XXX doesn't distinguish upper vs. lower, which is
|
||||
# significant for ASDL.
|
||||
self.rv.append(Id(s, self.lineno))
|
||||
|
||||
|
||||
def t_string(self, s):
|
||||
r'"[^"]*"'
|
||||
self.rv.append(String(s, self.lineno))
|
||||
|
|
@ -123,7 +123,7 @@ class ASDLParser(spark.GenericParser, object):
|
|||
raise ASDLSyntaxError(module.lineno,
|
||||
msg="expected 'module', found %s" % module)
|
||||
return Module(name, definitions, version)
|
||||
|
||||
|
||||
def p_version(self, (version, V)):
|
||||
"version ::= Id String"
|
||||
if version.value != "version":
|
||||
|
|
|
|||
|
|
@ -354,7 +354,7 @@ class PyTypesDeclareVisitor(PickleVisitor):
|
|||
for f in prod.fields:
|
||||
self.emit('"%s",' % f.name, 1)
|
||||
self.emit("};", 0)
|
||||
|
||||
|
||||
def visitSum(self, sum, name):
|
||||
self.emit("PyTypeObject *%s_type;" % name, 0)
|
||||
if sum.attributes:
|
||||
|
|
@ -373,7 +373,7 @@ class PyTypesDeclareVisitor(PickleVisitor):
|
|||
self.emit("static PyObject* ast2obj_%s(%s);" % (name, ptype), 0)
|
||||
for t in sum.types:
|
||||
self.visitConstructor(t, name)
|
||||
|
||||
|
||||
def visitConstructor(self, cons, name):
|
||||
self.emit("PyTypeObject *%s_type;" % cons.name, 0)
|
||||
if cons.fields:
|
||||
|
|
@ -405,7 +405,7 @@ static PyTypeObject* make_type(char *type, PyTypeObject* base, char**fields, int
|
|||
}
|
||||
PyTuple_SET_ITEM(fnames, i, field);
|
||||
}
|
||||
result = PyObject_CallFunction((PyObject*)&PyType_Type, "s(O){sOss}",
|
||||
result = PyObject_CallFunction((PyObject*)&PyType_Type, "s(O){sOss}",
|
||||
type, base, "_fields", fnames, "__module__", "_ast");
|
||||
Py_DECREF(fnames);
|
||||
return (PyTypeObject*)result;
|
||||
|
|
@ -481,35 +481,35 @@ static PyObject* ast2obj_int(bool b)
|
|||
fields = name.value+"_fields"
|
||||
else:
|
||||
fields = "NULL"
|
||||
self.emit('%s_type = make_type("%s", AST_type, %s, %d);' %
|
||||
self.emit('%s_type = make_type("%s", AST_type, %s, %d);' %
|
||||
(name, name, fields, len(prod.fields)), 1)
|
||||
self.emit("if (!%s_type) return 0;" % name, 1)
|
||||
|
||||
|
||||
def visitSum(self, sum, name):
|
||||
self.emit('%s_type = make_type("%s", AST_type, NULL, 0);' % (name, name), 1)
|
||||
self.emit("if (!%s_type) return 0;" % name, 1)
|
||||
if sum.attributes:
|
||||
self.emit("if (!add_attributes(%s_type, %s_attributes, %d)) return 0;" %
|
||||
self.emit("if (!add_attributes(%s_type, %s_attributes, %d)) return 0;" %
|
||||
(name, name, len(sum.attributes)), 1)
|
||||
else:
|
||||
self.emit("if (!add_attributes(%s_type, NULL, 0)) return 0;" % name, 1)
|
||||
simple = is_simple(sum)
|
||||
for t in sum.types:
|
||||
self.visitConstructor(t, name, simple)
|
||||
|
||||
|
||||
def visitConstructor(self, cons, name, simple):
|
||||
if cons.fields:
|
||||
fields = cons.name.value+"_fields"
|
||||
else:
|
||||
fields = "NULL"
|
||||
self.emit('%s_type = make_type("%s", %s_type, %s, %d);' %
|
||||
self.emit('%s_type = make_type("%s", %s_type, %s, %d);' %
|
||||
(cons.name, cons.name, name, fields, len(cons.fields)), 1)
|
||||
self.emit("if (!%s_type) return 0;" % cons.name, 1)
|
||||
if simple:
|
||||
self.emit("%s_singleton = PyType_GenericNew(%s_type, NULL, NULL);" %
|
||||
(cons.name, cons.name), 1)
|
||||
self.emit("if (!%s_singleton) return 0;" % cons.name, 1)
|
||||
|
||||
|
||||
class ASTModuleVisitor(PickleVisitor):
|
||||
|
||||
def visitModule(self, mod):
|
||||
|
|
@ -533,15 +533,15 @@ class ASTModuleVisitor(PickleVisitor):
|
|||
|
||||
def visitProduct(self, prod, name):
|
||||
self.addObj(name)
|
||||
|
||||
|
||||
def visitSum(self, sum, name):
|
||||
self.addObj(name)
|
||||
for t in sum.types:
|
||||
self.visitConstructor(t, name)
|
||||
|
||||
|
||||
def visitConstructor(self, cons, name):
|
||||
self.addObj(cons.name)
|
||||
|
||||
|
||||
def addObj(self, name):
|
||||
self.emit('if(PyDict_SetItemString(d, "%s", (PyObject*)%s_type) < 0) return;' % (name, name), 1)
|
||||
|
||||
|
|
@ -609,7 +609,7 @@ class ObjVisitor(PickleVisitor):
|
|||
self.emit("if (!value) goto failed;", 1)
|
||||
self.emit('PyObject_SetAttrString(result, "%s", value);' % a.name, 1)
|
||||
self.func_end()
|
||||
|
||||
|
||||
def simpleSum(self, sum, name):
|
||||
self.emit("PyObject* ast2obj_%s(%s_ty o)" % (name, name), 0)
|
||||
self.emit("{", 0)
|
||||
|
|
|
|||
Loading…
Reference in New Issue