mirrors/cpython
1
0
Fork 0
mirror of https://github.com/python/cpython.git synced 2025-07-23 11:15:24 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 11

Set EOL style to native.

Browse source
This commit is contained in:
Tim Peters 2006-02-28 18:44:41 +00:00
parent 85b1052efe
commit 400cbc3a44
5 changed files with 969 additions and 969 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])

66
Lib/test/contextmanager.py
View file

@ -1,33 +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

80
Lib/test/nested.py
View file

@ -1,40 +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]

356
Lib/test/test_ast.py
View file

@ -1,178 +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()

1120
Lib/test/test_with.py
View file

File diff suppressed because it is too large Load diff