mirrors/cpython
1
0
Fork 0
mirror of https://github.com/python/cpython.git synced 2025-08-02 16:13:13 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 6

Whitespace normalization.

Browse source
This commit is contained in:
Tim Peters 2006-02-28 18:30:36 +00:00
parent 08533fdad6
commit 710ab3b5f8
9 changed files with 990 additions and 993 deletions
Download patch file Download diff file Expand all files Collapse all files

316
Demo/parser/unparse.py
View file

@ -1,158 +1,158 @@
"Usage: unparse.py <path to source file>" "Usage: unparse.py <path to source file>"
import sys import sys
class Unparser: class Unparser:
"""Methods in this class recursively traverse an AST and """Methods in this class recursively traverse an AST and
output source code for the abstract syntax; original formatting output source code for the abstract syntax; original formatting
is disregarged. """ is disregarged. """
def __init__(self, tree, file = sys.stdout): def __init__(self, tree, file = sys.stdout):
"""Unparser(tree, file=sys.stdout) -> None. """Unparser(tree, file=sys.stdout) -> None.
Print the source for tree to file.""" Print the source for tree to file."""
self.f = file self.f = file
self._indent = 0 self._indent = 0
self.dispatch(tree) self.dispatch(tree)
self.f.flush() self.f.flush()
def fill(self, text = ""): def fill(self, text = ""):
"Indent a piece of text, according to the current indentation level" "Indent a piece of text, according to the current indentation level"
self.f.write("\n"+" "*self._indent + text) self.f.write("\n"+" "*self._indent + text)
def write(self, text): def write(self, text):
"Append a piece of text to the current line." "Append a piece of text to the current line."
self.f.write(text) self.f.write(text)
def enter(self): def enter(self):
"Print ':', and increase the indentation." "Print ':', and increase the indentation."
self.write(":") self.write(":")
self._indent += 1 self._indent += 1
def leave(self): def leave(self):
"Decrease the indentation level." "Decrease the indentation level."
self._indent -= 1 self._indent -= 1
def dispatch(self, tree): def dispatch(self, tree):
"Dispatcher function, dispatching tree type T to method _T." "Dispatcher function, dispatching tree type T to method _T."
if isinstance(tree, list): if isinstance(tree, list):
for t in tree: for t in tree:
self.dispatch(t) self.dispatch(t)
return return
meth = getattr(self, "_"+tree.__class__.__name__) meth = getattr(self, "_"+tree.__class__.__name__)
meth(tree) meth(tree)
############### Unparsing methods ###################### ############### Unparsing methods ######################
# There should be one method per concrete grammar type # # There should be one method per concrete grammar type #
# Constructors should be grouped by sum type. Ideally, # # Constructors should be grouped by sum type. Ideally, #
# this would follow the order in the grammar, but # # this would follow the order in the grammar, but #
# currently doesn't. # # currently doesn't. #
######################################################## ########################################################
def _Module(self, tree): def _Module(self, tree):
for stmt in tree.body: for stmt in tree.body:
self.dispatch(stmt) self.dispatch(stmt)
# stmt # stmt
def _Expr(self, tree): def _Expr(self, tree):
self.fill() self.fill()
self.dispatch(tree.value) self.dispatch(tree.value)
def _Import(self, t): def _Import(self, t):
self.fill("import ") self.fill("import ")
first = True first = True
for a in t.names: for a in t.names:
if first: if first:
first = False first = False
else: else:
self.write(", ") self.write(", ")
self.write(a.name) self.write(a.name)
if a.asname: if a.asname:
self.write(" as "+a.asname) self.write(" as "+a.asname)
def _Assign(self, t): def _Assign(self, t):
self.fill() self.fill()
for target in t.targets: for target in t.targets:
self.dispatch(target) self.dispatch(target)
self.write(" = ") self.write(" = ")
self.dispatch(t.value) self.dispatch(t.value)
def _ClassDef(self, t): def _ClassDef(self, t):
self.write("\n") self.write("\n")
self.fill("class "+t.name) self.fill("class "+t.name)
if t.bases: if t.bases:
self.write("(") self.write("(")
for a in t.bases: for a in t.bases:
self.dispatch(a) self.dispatch(a)
self.write(", ") self.write(", ")
self.write(")") self.write(")")
self.enter() self.enter()
self.dispatch(t.body) self.dispatch(t.body)
self.leave() self.leave()
def _FunctionDef(self, t): def _FunctionDef(self, t):
self.write("\n") self.write("\n")
self.fill("def "+t.name + "(") self.fill("def "+t.name + "(")
self.dispatch(t.args) self.dispatch(t.args)
self.enter() self.enter()
self.dispatch(t.body) self.dispatch(t.body)
self.leave() self.leave()
def _If(self, t): def _If(self, t):
self.fill("if ") self.fill("if ")
self.dispatch(t.test) self.dispatch(t.test)
self.enter() self.enter()
# XXX elif? # XXX elif?
self.dispatch(t.body) self.dispatch(t.body)
self.leave() self.leave()
if t.orelse: if t.orelse:
self.fill("else") self.fill("else")
self.enter() self.enter()
self.dispatch(t.orelse) self.dispatch(t.orelse)
self.leave() self.leave()
# expr # expr
def _Str(self, tree): def _Str(self, tree):
self.write(repr(tree.s)) self.write(repr(tree.s))
def _Name(self, t): def _Name(self, t):
self.write(t.id) self.write(t.id)
def _List(self, t): def _List(self, t):
self.write("[") self.write("[")
for e in t.elts: for e in t.elts:
self.dispatch(e) self.dispatch(e)
self.write(", ") self.write(", ")
self.write("]") self.write("]")
unop = {"Invert":"~", "Not": "not", "UAdd":"+", "USub":"-"} unop = {"Invert":"~", "Not": "not", "UAdd":"+", "USub":"-"}
def _UnaryOp(self, t): def _UnaryOp(self, t):
self.write(self.unop[t.op.__class__.__name__]) self.write(self.unop[t.op.__class__.__name__])
self.write("(") self.write("(")
self.dispatch(t.operand) self.dispatch(t.operand)
self.write(")") self.write(")")
# others # others
def _arguments(self, t): def _arguments(self, t):
first = True first = True
# XXX t.defaults # XXX t.defaults
for a in t.args: for a in t.args:
if first:first = False if first:first = False
else: self.write(", ") else: self.write(", ")
self.dispatch(a) self.dispatch(a)
if t.vararg: if t.vararg:
if first:first = False if first:first = False
else: self.write(", ") else: self.write(", ")
self.write("*"+t.vararg) self.write("*"+t.vararg)
if t.kwarg: if t.kwarg:
if first:first = False if first:first = False
else: self.write(", ") else: self.write(", ")
self.write("**"+self.kwarg) self.write("**"+self.kwarg)
self.write(")") self.write(")")
def roundtrip(filename): def roundtrip(filename):
source = open(filename).read() source = open(filename).read()
tree = compile(source, filename, "exec", 0x400) tree = compile(source, filename, "exec", 0x400)
Unparser(tree) Unparser(tree)
if __name__=='__main__': if __name__=='__main__':
roundtrip(sys.argv[1]) roundtrip(sys.argv[1])

6
Lib/compiler/ast.py
View file

@ -553,7 +553,7 @@ class Function(Node):
self.varargs = 1 self.varargs = 1
if flags & CO_VARKEYWORDS: if flags & CO_VARKEYWORDS:
self.kwargs = 1 self.kwargs = 1
def getChildren(self): def getChildren(self):
@ -584,7 +584,7 @@ class GenExpr(Node):
self.lineno = lineno self.lineno = lineno
self.argnames = ['[outmost-iterable]'] self.argnames = ['[outmost-iterable]']
self.varargs = self.kwargs = None self.varargs = self.kwargs = None
def getChildren(self): def getChildren(self):
@ -763,7 +763,7 @@ class Lambda(Node):
self.varargs = 1 self.varargs = 1
if flags & CO_VARKEYWORDS: if flags & CO_VARKEYWORDS:
self.kwargs = 1 self.kwargs = 1
def getChildren(self): def getChildren(self):

67
Lib/test/contextmanager.py
View file

@ -1,34 +1,33 @@
class GeneratorContextManager(object): class GeneratorContextManager(object):
def __init__(self, gen): def __init__(self, gen):
self.gen = gen self.gen = gen
def __context__(self): def __context__(self):
return self return self
def __enter__(self): def __enter__(self):
try: try:
return self.gen.next() return self.gen.next()
except StopIteration: except StopIteration:
raise RuntimeError("generator didn't yield") raise RuntimeError("generator didn't yield")
def __exit__(self, type, value, traceback): def __exit__(self, type, value, traceback):
if type is None: if type is None:
try: try:
self.gen.next() self.gen.next()
except StopIteration: except StopIteration:
return return
else: else:
raise RuntimeError("generator didn't stop") raise RuntimeError("generator didn't stop")
else: else:
try: try:
self.gen.throw(type, value, traceback) self.gen.throw(type, value, traceback)
except (type, StopIteration): except (type, StopIteration):
return return
else: else:
raise RuntimeError("generator caught exception") raise RuntimeError("generator caught exception")
def contextmanager(func): def contextmanager(func):
def helper(*args, **kwds): def helper(*args, **kwds):
return GeneratorContextManager(func(*args, **kwds)) return GeneratorContextManager(func(*args, **kwds))
return helper return helper

81
Lib/test/nested.py
View file

@ -1,41 +1,40 @@
import sys import sys
from collections import deque from collections import deque
class nested(object): class nested(object):
def __init__(self, *contexts): def __init__(self, *contexts):
self.contexts = contexts self.contexts = contexts
self.entered = None self.entered = None
def __context__(self): def __context__(self):
return self return self
def __enter__(self): def __enter__(self):
if self.entered is not None: if self.entered is not None:
raise RuntimeError("Context is not reentrant") raise RuntimeError("Context is not reentrant")
self.entered = deque() self.entered = deque()
vars = [] vars = []
try: try:
for context in self.contexts: for context in self.contexts:
mgr = context.__context__() mgr = context.__context__()
vars.append(mgr.__enter__()) vars.append(mgr.__enter__())
self.entered.appendleft(mgr) self.entered.appendleft(mgr)
except: except:
self.__exit__(*sys.exc_info()) self.__exit__(*sys.exc_info())
raise raise
return vars return vars
def __exit__(self, *exc_info): def __exit__(self, *exc_info):
# Behave like nested with statements # Behave like nested with statements
# first in, last out # first in, last out
# New exceptions override old ones # New exceptions override old ones
ex = exc_info ex = exc_info
for mgr in self.entered: for mgr in self.entered:
try: try:
mgr.__exit__(*ex) mgr.__exit__(*ex)
except: except:
ex = sys.exc_info() ex = sys.exc_info()
self.entered = None self.entered = None
if ex is not exc_info: if ex is not exc_info:
raise ex[0], ex[1], ex[2] raise ex[0], ex[1], ex[2]

357
Lib/test/test_ast.py
View file

@ -1,179 +1,178 @@
import sys, itertools import sys, itertools
def to_tuple(t): def to_tuple(t):
if t is None or isinstance(t, (basestring, int, long, complex)): if t is None or isinstance(t, (basestring, int, long, complex)):
return t return t
elif isinstance(t, list): elif isinstance(t, list):
return [to_tuple(e) for e in t] return [to_tuple(e) for e in t]
result = [t.__class__.__name__] result = [t.__class__.__name__]
if t._fields is None: if t._fields is None:
return tuple(result) return tuple(result)
for f in t._fields: for f in t._fields:
result.append(to_tuple(getattr(t, f))) result.append(to_tuple(getattr(t, f)))
return tuple(result) return tuple(result)
# These tests are compiled through "exec" # These tests are compiled through "exec"
# There should be atleast one test per statement # There should be atleast one test per statement
exec_tests = [ exec_tests = [
# FunctionDef # FunctionDef
"def f(): pass", "def f(): pass",
# ClassDef # ClassDef
"class C:pass", "class C:pass",
# Return # Return
"def f():return 1", "def f():return 1",
# Delete # Delete
"del v", "del v",
# Assign # Assign
"v = 1", "v = 1",
# AugAssign # AugAssign
"v += 1", "v += 1",
# Print # Print
"print >>f, 1, ", "print >>f, 1, ",
# For # For
"for v in v:pass", "for v in v:pass",
# While # While
"while v:pass", "while v:pass",
# If # If
"if v:pass", "if v:pass",
# Raise # Raise
"raise Exception, 'string'", "raise Exception, 'string'",
# TryExcept # TryExcept
"try:\n pass\nexcept Exception:\n pass", "try:\n pass\nexcept Exception:\n pass",
# TryFinally # TryFinally
"try:\n pass\nfinally:\n pass", "try:\n pass\nfinally:\n pass",
# Assert # Assert
"assert v", "assert v",
# Import # Import
"import sys", "import sys",
# ImportFrom # ImportFrom
"from sys import v", "from sys import v",
# Exec # Exec
"exec 'v'", "exec 'v'",
# Global # Global
"global v", "global v",
# Expr # Expr
"1", "1",
# Pass, # Pass,
"pass", "pass",
# Break # Break
"break", "break",
# Continue # Continue
"continue", "continue",
] ]
# These are compiled through "single" # These are compiled through "single"
# because of overlap with "eval", it just tests what # because of overlap with "eval", it just tests what
# can't be tested with "eval" # can't be tested with "eval"
single_tests = [ single_tests = [
"1+2" "1+2"
] ]
# These are compiled through "eval" # These are compiled through "eval"
# It should test all expressions # It should test all expressions
eval_tests = [ eval_tests = [
# BoolOp # BoolOp
"a and b", "a and b",
# BinOp # BinOp
"a + b", "a + b",
# UnaryOp # UnaryOp
"not v", "not v",
# Lambda # Lambda
"lambda:None", "lambda:None",
# Dict # Dict
"{ 1:2 }", "{ 1:2 }",
# ListComp # ListComp
"[a for b in c if d]", "[a for b in c if d]",
# GeneratorExp # GeneratorExp
"(a for b in c if d)", "(a for b in c if d)",
# Yield - yield expressions can't work outside a function # Yield - yield expressions can't work outside a function
# #
# Compare # Compare
"1 < 2 < 3", "1 < 2 < 3",
# Call # Call
"f(1,2,c=3,*d,**e)", "f(1,2,c=3,*d,**e)",
# Repr # Repr
"`v`", "`v`",
# Num # Num
"10L", "10L",
# Str # Str
"'string'", "'string'",
# Attribute # Attribute
"a.b", "a.b",
# Subscript # Subscript
"a[b:c]", "a[b:c]",
# Name # Name
"v", "v",
# List # List
"[1,2,3]", "[1,2,3]",
# Tuple # Tuple
"1,2,3" "1,2,3"
] ]
# TODO: expr_context, slice, boolop, operator, unaryop, cmpop, comprehension # TODO: expr_context, slice, boolop, operator, unaryop, cmpop, comprehension
# excepthandler, arguments, keywords, alias # excepthandler, arguments, keywords, alias
if __name__=='__main__' and sys.argv[1:] == ['-g']: if __name__=='__main__' and sys.argv[1:] == ['-g']:
for statements, kind in ((exec_tests, "exec"), (single_tests, "single"), (eval_tests, "eval")): for statements, kind in ((exec_tests, "exec"), (single_tests, "single"), (eval_tests, "eval")):
print kind+"_results = [" print kind+"_results = ["
for s in statements: for s in statements:
print repr(to_tuple(compile(s, "?", kind, 0x400)))+"," print repr(to_tuple(compile(s, "?", kind, 0x400)))+","
print "]" print "]"
print "run_tests()" print "run_tests()"
raise SystemExit raise SystemExit
def run_tests(): def run_tests():
for input, output, kind in ((exec_tests, exec_results, "exec"), for input, output, kind in ((exec_tests, exec_results, "exec"),
(single_tests, single_results, "single"), (single_tests, single_results, "single"),
(eval_tests, eval_results, "eval")): (eval_tests, eval_results, "eval")):
for i, o in itertools.izip(input, output): for i, o in itertools.izip(input, output):
assert to_tuple(compile(i, "?", kind, 0x400)) == o assert to_tuple(compile(i, "?", kind, 0x400)) == o
#### EVERYTHING BELOW IS GENERATED ##### #### EVERYTHING BELOW IS GENERATED #####
exec_results = [ exec_results = [
('Module', [('FunctionDef', 'f', ('arguments', [], None, None, []), [('Pass',)], [])]), ('Module', [('FunctionDef', 'f', ('arguments', [], None, None, []), [('Pass',)], [])]),
('Module', [('ClassDef', 'C', [], [('Pass',)])]), ('Module', [('ClassDef', 'C', [], [('Pass',)])]),
('Module', [('FunctionDef', 'f', ('arguments', [], None, None, []), [('Return', ('Num', 1))], [])]), ('Module', [('FunctionDef', 'f', ('arguments', [], None, None, []), [('Return', ('Num', 1))], [])]),
('Module', [('Delete', [('Name', 'v', ('Del',))])]), ('Module', [('Delete', [('Name', 'v', ('Del',))])]),
('Module', [('Assign', [('Name', 'v', ('Store',))], ('Num', 1))]), ('Module', [('Assign', [('Name', 'v', ('Store',))], ('Num', 1))]),
('Module', [('AugAssign', ('Name', 'v', ('Load',)), ('Add',), ('Num', 1))]), ('Module', [('AugAssign', ('Name', 'v', ('Load',)), ('Add',), ('Num', 1))]),
('Module', [('Print', ('Name', 'f', ('Load',)), [('Num', 1)], False)]), ('Module', [('Print', ('Name', 'f', ('Load',)), [('Num', 1)], False)]),
('Module', [('For', ('Name', 'v', ('Store',)), ('Name', 'v', ('Load',)), [('Pass',)], [])]), ('Module', [('For', ('Name', 'v', ('Store',)), ('Name', 'v', ('Load',)), [('Pass',)], [])]),
('Module', [('While', ('Name', 'v', ('Load',)), [('Pass',)], [])]), ('Module', [('While', ('Name', 'v', ('Load',)), [('Pass',)], [])]),
('Module', [('If', ('Name', 'v', ('Load',)), [('Pass',)], [])]), ('Module', [('If', ('Name', 'v', ('Load',)), [('Pass',)], [])]),
('Module', [('Raise', ('Name', 'Exception', ('Load',)), ('Str', 'string'), None)]), ('Module', [('Raise', ('Name', 'Exception', ('Load',)), ('Str', 'string'), None)]),
('Module', [('TryExcept', [('Pass',)], [('excepthandler', ('Name', 'Exception', ('Load',)), None, [('Pass',)])], [])]), ('Module', [('TryExcept', [('Pass',)], [('excepthandler', ('Name', 'Exception', ('Load',)), None, [('Pass',)])], [])]),
('Module', [('TryFinally', [('Pass',)], [('Pass',)])]), ('Module', [('TryFinally', [('Pass',)], [('Pass',)])]),
('Module', [('Assert', ('Name', 'v', ('Load',)), None)]), ('Module', [('Assert', ('Name', 'v', ('Load',)), None)]),
('Module', [('Import', [('alias', 'sys', None)])]), ('Module', [('Import', [('alias', 'sys', None)])]),
('Module', [('ImportFrom', 'sys', [('alias', 'v', None)], 0)]), ('Module', [('ImportFrom', 'sys', [('alias', 'v', None)], 0)]),
('Module', [('Exec', ('Str', 'v'), None, None)]), ('Module', [('Exec', ('Str', 'v'), None, None)]),
('Module', [('Global', ['v'])]), ('Module', [('Global', ['v'])]),
('Module', [('Expr', ('Num', 1))]), ('Module', [('Expr', ('Num', 1))]),
('Module', [('Pass',)]), ('Module', [('Pass',)]),
('Module', [('Break',)]), ('Module', [('Break',)]),
('Module', [('Continue',)]), ('Module', [('Continue',)]),
] ]
single_results = [ single_results = [
('Interactive', [('Expr', ('BinOp', ('Num', 1), ('Add',), ('Num', 2)))]), ('Interactive', [('Expr', ('BinOp', ('Num', 1), ('Add',), ('Num', 2)))]),
] ]
eval_results = [ eval_results = [
('Expression', ('BoolOp', ('And',), [('Name', 'a', ('Load',)), ('Name', 'b', ('Load',))])), ('Expression', ('BoolOp', ('And',), [('Name', 'a', ('Load',)), ('Name', 'b', ('Load',))])),
('Expression', ('BinOp', ('Name', 'a', ('Load',)), ('Add',), ('Name', 'b', ('Load',)))), ('Expression', ('BinOp', ('Name', 'a', ('Load',)), ('Add',), ('Name', 'b', ('Load',)))),
('Expression', ('UnaryOp', ('Not',), ('Name', 'v', ('Load',)))), ('Expression', ('UnaryOp', ('Not',), ('Name', 'v', ('Load',)))),
('Expression', ('Lambda', ('arguments', [], None, None, []), ('Name', 'None', ('Load',)))), ('Expression', ('Lambda', ('arguments', [], None, None, []), ('Name', 'None', ('Load',)))),
('Expression', ('Dict', [('Num', 1)], [('Num', 2)])), ('Expression', ('Dict', [('Num', 1)], [('Num', 2)])),
('Expression', ('ListComp', ('Name', 'a', ('Load',)), [('comprehension', ('Name', 'b', ('Store',)), ('Name', 'c', ('Load',)), [('Name', 'd', ('Load',))])])), ('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', ('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', ('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', ('Call', ('Name', 'f', ('Load',)), [('Num', 1), ('Num', 2)], [('keyword', 'c', ('Num', 3))], ('Name', 'd', ('Load',)), ('Name', 'e', ('Load',)))),
('Expression', ('Repr', ('Name', 'v', ('Load',)))), ('Expression', ('Repr', ('Name', 'v', ('Load',)))),
('Expression', ('Num', 10L)), ('Expression', ('Num', 10L)),
('Expression', ('Str', 'string')), ('Expression', ('Str', 'string')),
('Expression', ('Attribute', ('Name', 'a', ('Load',)), 'b', ('Load',))), ('Expression', ('Attribute', ('Name', 'a', ('Load',)), 'b', ('Load',))),
('Expression', ('Subscript', ('Name', 'a', ('Load',)), ('Slice', ('Name', 'b', ('Load',)), ('Name', 'c', ('Load',)), None), ('Load',))), ('Expression', ('Subscript', ('Name', 'a', ('Load',)), ('Slice', ('Name', 'b', ('Load',)), ('Name', 'c', ('Load',)), None), ('Load',))),
('Expression', ('Name', 'v', ('Load',))), ('Expression', ('Name', 'v', ('Load',))),
('Expression', ('List', [('Num', 1), ('Num', 2), ('Num', 3)], ('Load',))), ('Expression', ('List', [('Num', 1), ('Num', 2), ('Num', 3)], ('Load',))),
('Expression', ('Tuple', [('Num', 1), ('Num', 2), ('Num', 3)], ('Load',))), ('Expression', ('Tuple', [('Num', 1), ('Num', 2), ('Num', 3)], ('Load',))),
] ]
run_tests() run_tests()

4
Lib/test/test_importhooks.py
View file

@ -190,7 +190,7 @@ class ImportHooksTestCase(ImportHooksBaseTestCase):
TestImporter.modules['reloadmodule'] = (False, reload_co) TestImporter.modules['reloadmodule'] = (False, reload_co)
reload(reloadmodule) reload(reloadmodule)
self.failUnless(hasattr(reloadmodule,'reloaded')) self.failUnless(hasattr(reloadmodule,'reloaded'))
import hooktestpackage.oldabs import hooktestpackage.oldabs
self.assertEqual(hooktestpackage.oldabs.get_name(), self.assertEqual(hooktestpackage.oldabs.get_name(),
"hooktestpackage.oldabs") "hooktestpackage.oldabs")
@ -208,7 +208,7 @@ class ImportHooksTestCase(ImportHooksBaseTestCase):
"hooktestpackage.futrel") "hooktestpackage.futrel")
self.assertEqual(hooktestpackage.futrel.sub, self.assertEqual(hooktestpackage.futrel.sub,
hooktestpackage.sub) hooktestpackage.sub)
import sub import sub
self.assertEqual(sub.get_name(), "sub") self.assertEqual(sub.get_name(), "sub")

1120
Lib/test/test_with.py
View file

File diff suppressed because it is too large Load diff

6
Parser/asdl.py
View file

@ -38,7 +38,7 @@ class Id(Token):
def __str__(self): def __str__(self):
return self.value return self.value
class String(Token): class String(Token):
def __init__(self, value, lineno): def __init__(self, value, lineno):
self.type = 'String' self.type = 'String'
@ -71,7 +71,7 @@ class ASDLScanner(spark.GenericScanner, object):
# XXX doesn't distinguish upper vs. lower, which is # XXX doesn't distinguish upper vs. lower, which is
# significant for ASDL. # significant for ASDL.
self.rv.append(Id(s, self.lineno)) self.rv.append(Id(s, self.lineno))
def t_string(self, s): def t_string(self, s):
r'"[^"]*"' r'"[^"]*"'
self.rv.append(String(s, self.lineno)) self.rv.append(String(s, self.lineno))
@ -123,7 +123,7 @@ class ASDLParser(spark.GenericParser, object):
raise ASDLSyntaxError(module.lineno, raise ASDLSyntaxError(module.lineno,
msg="expected 'module', found %s" % module) msg="expected 'module', found %s" % module)
return Module(name, definitions, version) return Module(name, definitions, version)
def p_version(self, (version, V)): def p_version(self, (version, V)):
"version ::= Id String" "version ::= Id String"
if version.value != "version": if version.value != "version":

26
Parser/asdl_c.py
View file

@ -354,7 +354,7 @@ class PyTypesDeclareVisitor(PickleVisitor):
for f in prod.fields: for f in prod.fields:
self.emit('"%s",' % f.name, 1) self.emit('"%s",' % f.name, 1)
self.emit("};", 0) self.emit("};", 0)
def visitSum(self, sum, name): def visitSum(self, sum, name):
self.emit("PyTypeObject *%s_type;" % name, 0) self.emit("PyTypeObject *%s_type;" % name, 0)
if sum.attributes: if sum.attributes:
@ -373,7 +373,7 @@ class PyTypesDeclareVisitor(PickleVisitor):
self.emit("static PyObject* ast2obj_%s(%s);" % (name, ptype), 0) self.emit("static PyObject* ast2obj_%s(%s);" % (name, ptype), 0)
for t in sum.types: for t in sum.types:
self.visitConstructor(t, name) self.visitConstructor(t, name)
def visitConstructor(self, cons, name): def visitConstructor(self, cons, name):
self.emit("PyTypeObject *%s_type;" % cons.name, 0) self.emit("PyTypeObject *%s_type;" % cons.name, 0)
if cons.fields: if cons.fields:
@ -405,7 +405,7 @@ static PyTypeObject* make_type(char *type, PyTypeObject* base, char**fields, int
} }
PyTuple_SET_ITEM(fnames, i, field); 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"); type, base, "_fields", fnames, "__module__", "_ast");
Py_DECREF(fnames); Py_DECREF(fnames);
return (PyTypeObject*)result; return (PyTypeObject*)result;
@ -481,35 +481,35 @@ static PyObject* ast2obj_int(bool b)
fields = name.value+"_fields" fields = name.value+"_fields"
else: else:
fields = "NULL" 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) (name, name, fields, len(prod.fields)), 1)
self.emit("if (!%s_type) return 0;" % name, 1) self.emit("if (!%s_type) return 0;" % name, 1)
def visitSum(self, sum, name): def visitSum(self, sum, name):
self.emit('%s_type = make_type("%s", AST_type, NULL, 0);' % (name, name), 1) self.emit('%s_type = make_type("%s", AST_type, NULL, 0);' % (name, name), 1)
self.emit("if (!%s_type) return 0;" % name, 1) self.emit("if (!%s_type) return 0;" % name, 1)
if sum.attributes: 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) (name, name, len(sum.attributes)), 1)
else: else:
self.emit("if (!add_attributes(%s_type, NULL, 0)) return 0;" % name, 1) self.emit("if (!add_attributes(%s_type, NULL, 0)) return 0;" % name, 1)
simple = is_simple(sum) simple = is_simple(sum)
for t in sum.types: for t in sum.types:
self.visitConstructor(t, name, simple) self.visitConstructor(t, name, simple)
def visitConstructor(self, cons, name, simple): def visitConstructor(self, cons, name, simple):
if cons.fields: if cons.fields:
fields = cons.name.value+"_fields" fields = cons.name.value+"_fields"
else: else:
fields = "NULL" 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) (cons.name, cons.name, name, fields, len(cons.fields)), 1)
self.emit("if (!%s_type) return 0;" % cons.name, 1) self.emit("if (!%s_type) return 0;" % cons.name, 1)
if simple: if simple:
self.emit("%s_singleton = PyType_GenericNew(%s_type, NULL, NULL);" % self.emit("%s_singleton = PyType_GenericNew(%s_type, NULL, NULL);" %
(cons.name, cons.name), 1) (cons.name, cons.name), 1)
self.emit("if (!%s_singleton) return 0;" % cons.name, 1) self.emit("if (!%s_singleton) return 0;" % cons.name, 1)
class ASTModuleVisitor(PickleVisitor): class ASTModuleVisitor(PickleVisitor):
def visitModule(self, mod): def visitModule(self, mod):
@ -533,15 +533,15 @@ class ASTModuleVisitor(PickleVisitor):
def visitProduct(self, prod, name): def visitProduct(self, prod, name):
self.addObj(name) self.addObj(name)
def visitSum(self, sum, name): def visitSum(self, sum, name):
self.addObj(name) self.addObj(name)
for t in sum.types: for t in sum.types:
self.visitConstructor(t, name) self.visitConstructor(t, name)
def visitConstructor(self, cons, name): def visitConstructor(self, cons, name):
self.addObj(cons.name) self.addObj(cons.name)
def addObj(self, name): def addObj(self, name):
self.emit('if(PyDict_SetItemString(d, "%s", (PyObject*)%s_type) < 0) return;' % (name, name), 1) 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("if (!value) goto failed;", 1)
self.emit('PyObject_SetAttrString(result, "%s", value);' % a.name, 1) self.emit('PyObject_SetAttrString(result, "%s", value);' % a.name, 1)
self.func_end() self.func_end()
def simpleSum(self, sum, name): def simpleSum(self, sum, name):
self.emit("PyObject* ast2obj_%s(%s_ty o)" % (name, name), 0) self.emit("PyObject* ast2obj_%s(%s_ty o)" % (name, name), 0)
self.emit("{", 0) self.emit("{", 0)