Set EOL style to native.
This commit is contained in:
Tim Peters
parent
85b1052efe
commit
400cbc3a44
|
|
@ -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])
|
||||
|
|
|
|||
|
|
@ -1,33 +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,40 +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,178 +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()
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load Diff
Loading…
Reference in New Issue