traverseda
/
cpython
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

* Remove PRINT_ITEM(_TO), PRINT_NEWLINE(_TO) opcodes. 

* Fix some docstrings and one Print -> print.
* Fix test_{class,code,descrtut,dis,extcall,parser,popen,pkg,subprocess,syntax,traceback}.
  These were the ones that generated code with a print statement.
  In most remaining failing tests there's an issue with the soft space.
This commit is contained in:
Georg Brandl 2007-02-09 21:28:07 +00:00
parent 08c47ba0df
commit 88fc6646d1
31 changed files with 159 additions and 553 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
Doc/lib/libdis.tex
View File

@ -353,27 +353,6 @@ removed from the stack and printed. In non-interactive mode, an
expression statement is terminated with \code{POP_STACK}.
\end{opcodedesc}
\begin{opcodedesc}{PRINT_ITEM}{}
Prints TOS to the file-like object bound to \code{sys.stdout}. There
is one such instruction for each item in the \keyword{print} statement.
\end{opcodedesc}
\begin{opcodedesc}{PRINT_ITEM_TO}{}
Like \code{PRINT_ITEM}, but prints the item second from TOS to the
file-like object at TOS. This is used by the extended print statement.
\end{opcodedesc}
\begin{opcodedesc}{PRINT_NEWLINE}{}
Prints a new line on \code{sys.stdout}. This is generated as the
last operation of a \keyword{print} statement, unless the statement
ends with a comma.
\end{opcodedesc}
\begin{opcodedesc}{PRINT_NEWLINE_TO}{}
Like \code{PRINT_NEWLINE}, but prints the new line on the file-like
object on the TOS. This is used by the extended print statement.
\end{opcodedesc}
\begin{opcodedesc}{BREAK_LOOP}{}
Terminates a loop due to a \keyword{break} statement.
\end{opcodedesc}

55
Doc/ref/ref6.tex
View File

@ -12,7 +12,6 @@ by semicolons. The syntax for simple statements is:
\productioncont{| \token{augmented_assignment_stmt}}
\productioncont{| \token{pass_stmt}}
\productioncont{| \token{del_stmt}}
\productioncont{| \token{print_stmt}}
\productioncont{| \token{return_stmt}}
\productioncont{| \token{yield_stmt}}
\productioncont{| \token{raise_stmt}}
@ -370,60 +369,6 @@ right type (but even this is determined by the sliced object).
\indexii{attribute}{deletion}
\section{The \keyword{print} statement \label{print}}
\stindex{print}
\begin{productionlist}
\production{print_stmt}
{"print" ( \optional{\token{expression} ("," \token{expression})* \optional{","}}}
\productioncont{| ">>" \token{expression}
\optional{("," \token{expression})+ \optional{","}} )}
\end{productionlist}
\keyword{print} evaluates each expression in turn and writes the
resulting object to standard output (see below). If an object is not
a string, it is first converted to a string using the rules for string
conversions. The (resulting or original) string is then written. A
space is written before each object is (converted and) written, unless
the output system believes it is positioned at the beginning of a
line. This is the case (1) when no characters have yet been written
to standard output, (2) when the last character written to standard
output is \character{\e n}, or (3) when the last write operation on
standard output was not a \keyword{print} statement. (In some cases
it may be functional to write an empty string to standard output for
this reason.) \note{Objects which act like file objects but which are
not the built-in file objects often do not properly emulate this
aspect of the file object's behavior, so it is best not to rely on
this.}
\index{output}
\indexii{writing}{values}
A \character{\e n} character is written at the end, unless the
\keyword{print} statement ends with a comma. This is the only action
if the statement contains just the keyword \keyword{print}.
\indexii{trailing}{comma}
\indexii{newline}{suppression}
Standard output is defined as the file object named \code{stdout}
in the built-in module \module{sys}. If no such object exists, or if
it does not have a \method{write()} method, a \exception{RuntimeError}
exception is raised.
\indexii{standard}{output}
\refbimodindex{sys}
\withsubitem{(in module sys)}{\ttindex{stdout}}
\exindex{RuntimeError}
\keyword{print} also has an extended\index{extended print statement}
form, defined by the second portion of the syntax described above.
This form is sometimes referred to as ``\keyword{print} chevron.''
In this form, the first expression after the \code{>>} must
evaluate to a ``file-like'' object, specifically an object that has a
\method{write()} method as described above. With this extended form,
the subsequent expressions are printed to this file object. If the
first expression evaluates to \code{None}, then \code{sys.stdout} is
used as the file for output.
\section{The \keyword{return} statement \label{return}}
\stindex{return}

20
Include/Python-ast.h
View File

@ -62,12 +62,11 @@ struct _mod {
};
enum _stmt_kind {FunctionDef_kind=1, ClassDef_kind=2, Return_kind=3,
Delete_kind=4, Assign_kind=5, AugAssign_kind=6, Print_kind=7,
For_kind=8, While_kind=9, If_kind=10, With_kind=11,
Raise_kind=12, TryExcept_kind=13, TryFinally_kind=14,
Assert_kind=15, Import_kind=16, ImportFrom_kind=17,
Global_kind=18, Expr_kind=19, Pass_kind=20, Break_kind=21,
Continue_kind=22};
Delete_kind=4, Assign_kind=5, AugAssign_kind=6, For_kind=7,
While_kind=8, If_kind=9, With_kind=10, Raise_kind=11,
TryExcept_kind=12, TryFinally_kind=13, Assert_kind=14,
Import_kind=15, ImportFrom_kind=16, Global_kind=17,
Expr_kind=18, Pass_kind=19, Break_kind=20, Continue_kind=21};
struct _stmt {
enum _stmt_kind kind;
union {
@ -104,12 +103,6 @@ struct _stmt {
expr_ty value;
} AugAssign;
struct {
expr_ty dest;
asdl_seq *values;
bool nl;
} Print;
struct {
expr_ty target;
expr_ty iter;
@ -392,9 +385,6 @@ stmt_ty _Py_Assign(asdl_seq * targets, expr_ty value, int lineno, int
#define AugAssign(a0, a1, a2, a3, a4, a5) _Py_AugAssign(a0, a1, a2, a3, a4, a5)
stmt_ty _Py_AugAssign(expr_ty target, operator_ty op, expr_ty value, int
lineno, int col_offset, PyArena *arena);
#define Print(a0, a1, a2, a3, a4, a5) _Py_Print(a0, a1, a2, a3, a4, a5)
stmt_ty _Py_Print(expr_ty dest, asdl_seq * values, bool nl, int lineno, int
col_offset, PyArena *arena);
#define For(a0, a1, a2, a3, a4, a5, a6) _Py_For(a0, a1, a2, a3, a4, a5, a6)
stmt_ty _Py_For(expr_ty target, expr_ty iter, asdl_seq * body, asdl_seq *
orelse, int lineno, int col_offset, PyArena *arena);

5
Include/opcode.h
View File

@ -61,10 +61,7 @@ extern "C" {
#define GET_ITER 68
#define PRINT_EXPR 70
#define PRINT_ITEM 71
#define PRINT_NEWLINE 72
#define PRINT_ITEM_TO 73
#define PRINT_NEWLINE_TO 74
#define INPLACE_LSHIFT 75
#define INPLACE_RSHIFT 76
#define INPLACE_AND 77

44
Lib/compiler/ast.py
View File

@ -998,50 +998,6 @@ class Power(Node):
def __repr__(self):
return "Power((%s, %s))" % (repr(self.left), repr(self.right))
class Print(Node):
def __init__(self, nodes, dest, lineno=None):
self.nodes = nodes
self.dest = dest
self.lineno = lineno
def getChildren(self):
children = []
children.extend(flatten(self.nodes))
children.append(self.dest)
return tuple(children)
def getChildNodes(self):
nodelist = []
nodelist.extend(flatten_nodes(self.nodes))
if self.dest is not None:
nodelist.append(self.dest)
return tuple(nodelist)
def __repr__(self):
return "Print(%s, %s)" % (repr(self.nodes), repr(self.dest))
class Printnl(Node):
def __init__(self, nodes, dest, lineno=None):
self.nodes = nodes
self.dest = dest
self.lineno = lineno
def getChildren(self):
children = []
children.extend(flatten(self.nodes))
children.append(self.dest)
return tuple(children)
def getChildNodes(self):
nodelist = []
nodelist.extend(flatten_nodes(self.nodes))
if self.dest is not None:
nodelist.append(self.dest)
return tuple(nodelist)
def __repr__(self):
return "Printnl(%s, %s)" % (repr(self.nodes), repr(self.dest))
class Raise(Node):
def __init__(self, expr1, expr2, expr3, lineno=None):
self.expr1 = expr1

3
Lib/compiler/pyassem.py
View File

@ -783,8 +783,7 @@ class StackDepthTracker:
'DELETE_SLICE+3': -3,
'STORE_SUBSCR': -3,
'DELETE_SUBSCR': -2,
# PRINT_EXPR?
'PRINT_ITEM': -1,
'PRINT_EXPR': -1,
'RETURN_VALUE': -1,
'YIELD_VALUE': -1,
'BUILD_CLASS': -2,

23
Lib/compiler/pycodegen.py
View File

@ -1130,29 +1130,6 @@ class CodeGenerator:
opcode = callfunc_opcode_info[have_star, have_dstar]
self.emit(opcode, kw << 8 | pos)
def visitPrint(self, node, newline=0):
self.set_lineno(node)
if node.dest:
self.visit(node.dest)
for child in node.nodes:
if node.dest:
self.emit('DUP_TOP')
self.visit(child)
if node.dest:
self.emit('ROT_TWO')
self.emit('PRINT_ITEM_TO')
else:
self.emit('PRINT_ITEM')
if node.dest and not newline:
self.emit('POP_TOP')
def visitPrintnl(self, node):
self.visitPrint(node, newline=1)
if node.dest:
self.emit('PRINT_NEWLINE_TO')
else:
self.emit('PRINT_NEWLINE')
def visitReturn(self, node):
self.set_lineno(node)
self.visit(node.value)

21
Lib/compiler/transformer.py
View File

@ -387,26 +387,6 @@ class Transformer:
return AugAssign(lval, op[1], exprNode, lineno=op[2])
raise WalkerError, "can't get here"
def print_stmt(self, nodelist):
# print ([ test (',' test)* [','] ] | '>>' test [ (',' test)+ [','] ])
items = []
if len(nodelist) == 1:
start = 1
dest = None
elif nodelist[1][0] == token.RIGHTSHIFT:
assert len(nodelist) == 3 \
or nodelist[3][0] == token.COMMA
dest = self.com_node(nodelist[2])
start = 4
else:
dest = None
start = 1
for i in range(start, len(nodelist), 2):
items.append(self.com_node(nodelist[i]))
if nodelist[-1][0] == token.COMMA:
return Print(items, dest, lineno=nodelist[0][2])
return Printnl(items, dest, lineno=nodelist[0][2])
def del_stmt(self, nodelist):
return self.com_assign(nodelist[1], OP_DELETE)
@ -1480,7 +1460,6 @@ _legal_node_types = [
symbol.simple_stmt,
symbol.compound_stmt,
symbol.expr_stmt,
symbol.print_stmt,
symbol.del_stmt,
symbol.pass_stmt,
symbol.break_stmt,

5
Lib/opcode.py
View File

@ -100,10 +100,7 @@ def_op('INPLACE_POWER', 67)
def_op('GET_ITER', 68)
def_op('PRINT_EXPR', 70)
def_op('PRINT_ITEM', 71)
def_op('PRINT_NEWLINE', 72)
def_op('PRINT_ITEM_TO', 73)
def_op('PRINT_NEWLINE_TO', 74)
def_op('INPLACE_LSHIFT', 75)
def_op('INPLACE_RSHIFT', 76)
def_op('INPLACE_AND', 77)

135
Lib/symbol.py
View File

@ -30,74 +30,73 @@ simple_stmt = 272
small_stmt = 273
expr_stmt = 274
augassign = 275
print_stmt = 276
del_stmt = 277
pass_stmt = 278
flow_stmt = 279
break_stmt = 280
continue_stmt = 281
return_stmt = 282
yield_stmt = 283
raise_stmt = 284
import_stmt = 285
import_name = 286
import_from = 287
import_as_name = 288
dotted_as_name = 289
import_as_names = 290
dotted_as_names = 291
dotted_name = 292
global_stmt = 293
assert_stmt = 294
compound_stmt = 295
if_stmt = 296
while_stmt = 297
for_stmt = 298
try_stmt = 299
with_stmt = 300
with_var = 301
except_clause = 302
suite = 303
testlist_safe = 304
old_test = 305
old_lambdef = 306
test = 307
or_test = 308
and_test = 309
not_test = 310
comparison = 311
comp_op = 312
expr = 313
xor_expr = 314
and_expr = 315
shift_expr = 316
arith_expr = 317
term = 318
factor = 319
power = 320
atom = 321
listmaker = 322
testlist_gexp = 323
lambdef = 324
trailer = 325
subscriptlist = 326
subscript = 327
sliceop = 328
exprlist = 329
testlist = 330
dictsetmaker = 331
classdef = 332
arglist = 333
argument = 334
list_iter = 335
list_for = 336
list_if = 337
gen_iter = 338
gen_for = 339
gen_if = 340
testlist1 = 341
encoding_decl = 342
yield_expr = 343
del_stmt = 276
pass_stmt = 277
flow_stmt = 278
break_stmt = 279
continue_stmt = 280
return_stmt = 281
yield_stmt = 282
raise_stmt = 283
import_stmt = 284
import_name = 285
import_from = 286
import_as_name = 287
dotted_as_name = 288
import_as_names = 289
dotted_as_names = 290
dotted_name = 291
global_stmt = 292
assert_stmt = 293
compound_stmt = 294
if_stmt = 295
while_stmt = 296
for_stmt = 297
try_stmt = 298
with_stmt = 299
with_var = 300
except_clause = 301
suite = 302
testlist_safe = 303
old_test = 304
old_lambdef = 305
test = 306
or_test = 307
and_test = 308
not_test = 309
comparison = 310
comp_op = 311
expr = 312
xor_expr = 313
and_expr = 314
shift_expr = 315
arith_expr = 316
term = 317
factor = 318
power = 319
atom = 320
listmaker = 321
testlist_gexp = 322
lambdef = 323
trailer = 324
subscriptlist = 325
subscript = 326
sliceop = 327
exprlist = 328
testlist = 329
dictsetmaker = 330
classdef = 331
arglist = 332
argument = 333
list_iter = 334
list_for = 335
list_if = 336
gen_iter = 337
gen_for = 338
gen_if = 339
testlist1 = 340
encoding_decl = 341
yield_expr = 342
#--end constants--
sym_name = {}

3
Lib/test/test_ast.py
View File

@ -30,8 +30,6 @@ exec_tests = [
"v = 1",
# AugAssign
"v += 1",
# Print
"print >>f, 1, ",
# For
"for v in v:pass",
# While
@ -157,7 +155,6 @@ exec_results = [
('Module', [('Delete', (1, 0), [('Name', (1, 4), 'v', ('Del',))])]),
('Module', [('Assign', (1, 0), [('Name', (1, 0), 'v', ('Store',))], ('Num', (1, 4), 1))]),
('Module', [('AugAssign', (1, 0), ('Name', (1, 0), 'v', ('Store',)), ('Add',), ('Num', (1, 5), 1))]),
('Module', [('Print', (1, 0), ('Name', (1, 8), 'f', ('Load',)), [('Num', (1, 11), 1)], False)]),
('Module', [('For', (1, 0), ('Name', (1, 4), 'v', ('Store',)), ('Name', (1, 9), 'v', ('Load',)), [('Pass', (1, 11))], [])]),
('Module', [('While', (1, 0), ('Name', (1, 6), 'v', ('Load',)), [('Pass', (1, 8))], [])]),
('Module', [('If', (1, 0), ('Name', (1, 3), 'v', ('Load',)), [('Pass', (1, 5))], [])]),

2
Lib/test/test_class.py
View File

@ -127,7 +127,7 @@ class AllTests:
method_template = """\
def __%(method)s__(self, *args):
print "__%(method)s__:", args
print("__%(method)s__:", args)
"""
d = {}

2
Lib/test/test_code.py
View File

@ -58,7 +58,7 @@ consts: ('None',)
name: attrs
argcount: 1
kwonlyargcount: 0
names: ('attr1', 'attr2', 'attr3')
names: ('print', 'attr1', 'attr2', 'attr3')
varnames: ('obj',)
cellvars: ()
freevars: ()

25
Lib/test/test_descrtut.py
View File

@ -36,28 +36,28 @@ test_1 = """
Here's the new type at work:
>>> print(defaultdict) # show our type
>>> print(defaultdict) # show our type
<class 'test.test_descrtut.defaultdict'>
>>> print(type(defaultdict)) # its metatype
>>> print(type(defaultdict)) # its metatype
<type 'type'>
>>> a = defaultdict(default=0.0) # create an instance
>>> print(a) # show the instance
>>> print(a) # show the instance
{}
>>> print(type(a)) # show its type
>>> print(type(a)) # show its type
<class 'test.test_descrtut.defaultdict'>
>>> print(a.__class__) # show its class
>>> print(a.__class__) # show its class
<class 'test.test_descrtut.defaultdict'>
>>> print(type(a) is a.__class__) # its type is its class
>>> print(type(a) is a.__class__) # its type is its class
True
>>> a[1] = 3.25 # modify the instance
>>> print(a) # show the new value
>>> print(a) # show the new value
{1: 3.25}
>>> print(a[1]) # show the new item
>>> print(a[1]) # show the new item
3.25
>>> print(a[0]) # a non-existant item
>>> print(a[0]) # a non-existant item
0.0
>>> a.merge({1:100, 2:200}) # use a dict method
>>> print(sortdict(a)) # show the result
>>> print(sortdict(a)) # show the result
{1: 3.25, 2: 200}
>>>
@ -67,10 +67,11 @@ statement or the built-in function eval():
>>> print(sorted(a.keys()))
[1, 2]
>>> exec("x = 3; print x", a)
>>> a['print'] = print # need the print function here
>>> exec("x = 3; print(x)", a)
3
>>> print(sorted(a.keys(), key=lambda x: (str(type(x)), x)))
[1, 2, '__builtins__', 'x']
[1, 2, '__builtins__', 'print', 'x']
>>> print(a['x'])
3
>>>

11
Lib/test/test_dis.py
View File

@ -12,12 +12,13 @@ def _f(a):
return 1
dis_f = """\
%-4d 0 LOAD_FAST 0 (a)
3 PRINT_ITEM
4 PRINT_NEWLINE
%-4d 0 LOAD_GLOBAL 0 (print)
3 LOAD_FAST 0 (a)
6 CALL_FUNCTION 1
9 POP_TOP
%-4d 5 LOAD_CONST 1 (1)
8 RETURN_VALUE
%-4d 10 LOAD_CONST 1 (1)
13 RETURN_VALUE
"""%(_f.func_code.co_firstlineno + 1,
_f.func_code.co_firstlineno + 2)

4
Lib/test/test_extcall.py
View File

@ -260,8 +260,8 @@ for args in ['', 'a', 'ab']:
lambda x: '%s="%s"' % (x, x), defargs)
if vararg: arglist.append('*' + vararg)
if kwarg: arglist.append('**' + kwarg)
decl = (('def %s(%s): print "ok %s", a, b, d, e, v, ' +
'type(k) is type ("") and k or sortdict(k)')
decl = (('def %s(%s): print("ok %s", a, b, d, e, v, ' +
'type(k) is type ("") and k or sortdict(k))')
% (name, ', '.join(arglist), name))
exec(decl)
func = eval(name)

31
Lib/test/test_parser.py
View File

@ -85,14 +85,6 @@ class RoundtripLegalSyntaxTestCase(unittest.TestCase):
self.check_expr("(x for x in range(10))")
self.check_expr("foo(x for x in range(10))")
def test_print(self):
self.check_suite("print")
self.check_suite("print 1")
self.check_suite("print 1,")
self.check_suite("print >>fp")
self.check_suite("print >>fp, 1")
self.check_suite("print >>fp, 1,")
def test_simple_expression(self):
# expr_stmt
self.check_suite("a")
@ -359,29 +351,6 @@ class IllegalSyntaxTestCase(unittest.TestCase):
(0, ''))))
self.check_bad_tree(tree, "def f():\n return 1\n yield 1")
def test_print_chevron_comma(self):
# Illegal input: print >>fp,
tree = \
(257,
(264,
(265,
(266,
(268,
(1, 'print'),
(35, '>>'),
(290,
(291,
(292,
(293,
(295,
(296,
(297,
(298, (299, (300, (301, (302, (303, (1, 'fp')))))))))))))),
(12, ','))),
(4, ''))),
(0, ''))
self.check_bad_tree(tree, "print >>fp,")
def test_a_comma_comma_c(self):
# Illegal input: a,,c
tree = \

80
Lib/test/test_pkg.py
View File

@ -81,122 +81,122 @@ tests = [
("t2", [
("t2", None),
("t2 __init__"+os.extsep+"py", "'doc for t2'; print __name__, 'loading'"),
("t2 __init__"+os.extsep+"py", "'doc for t2'; print(__name__, 'loading')"),
("t2 sub", None),
("t2 sub __init__"+os.extsep+"py", ""),
("t2 sub subsub", None),
("t2 sub subsub __init__"+os.extsep+"py", "print __name__, 'loading'; spam = 1"),
("t2 sub subsub __init__"+os.extsep+"py", "print(__name__, 'loading'); spam = 1"),
],
"""
import t2
print t2.__doc__
print(t2.__doc__)
import t2.sub
import t2.sub.subsub
print t2.__name__, t2.sub.__name__, t2.sub.subsub.__name__
print(t2.__name__, t2.sub.__name__, t2.sub.subsub.__name__)
import t2
from t2 import *
print dir()
print(dir())
from t2 import sub
from t2.sub import subsub
from t2.sub.subsub import spam
print sub.__name__, subsub.__name__
print sub.subsub.__name__
print dir()
print(sub.__name__, subsub.__name__)
print(sub.subsub.__name__)
print(dir())
import t2.sub
import t2.sub.subsub
print t2.__name__, t2.sub.__name__, t2.sub.subsub.__name__
print(t2.__name__, t2.sub.__name__, t2.sub.subsub.__name__)
from t2 import *
print dir()
print(dir())
"""),
("t3", [
("t3", None),
("t3 __init__"+os.extsep+"py", "print __name__, 'loading'"),
("t3 __init__"+os.extsep+"py", "print(__name__, 'loading')"),
("t3 sub", None),
("t3 sub __init__"+os.extsep+"py", ""),
("t3 sub subsub", None),
("t3 sub subsub __init__"+os.extsep+"py", "print __name__, 'loading'; spam = 1"),
("t3 sub subsub __init__"+os.extsep+"py", "print(__name__, 'loading'); spam = 1"),
],
"""
import t3.sub.subsub
print t3.__name__, t3.sub.__name__, t3.sub.subsub.__name__
print(t3.__name__, t3.sub.__name__, t3.sub.subsub.__name__)
reload(t3)
reload(t3.sub)
reload(t3.sub.subsub)
"""),
("t4", [
("t4"+os.extsep+"py", "print 'THIS SHOULD NOT BE PRINTED (t4"+os.extsep+"py)'"),
("t4"+os.extsep+"py", "print('THIS SHOULD NOT BE PRINTED (t4"+os.extsep+"py)')"),
("t4", None),
("t4 __init__"+os.extsep+"py", "print __name__, 'loading'"),
("t4 sub"+os.extsep+"py", "print 'THIS SHOULD NOT BE PRINTED (sub"+os.extsep+"py)'"),
("t4 __init__"+os.extsep+"py", "print(__name__, 'loading')"),
("t4 sub"+os.extsep+"py", "print('THIS SHOULD NOT BE PRINTED (sub"+os.extsep+"py)')"),
("t4 sub", None),
("t4 sub __init__"+os.extsep+"py", ""),
("t4 sub subsub"+os.extsep+"py", "print 'THIS SHOULD NOT BE PRINTED (subsub"+os.extsep+"py)'"),
("t4 sub subsub"+os.extsep+"py", "print('THIS SHOULD NOT BE PRINTED (subsub"+os.extsep+"py)')"),
("t4 sub subsub", None),
("t4 sub subsub __init__"+os.extsep+"py", "print __name__, 'loading'; spam = 1"),
("t4 sub subsub __init__"+os.extsep+"py", "print(__name__, 'loading'); spam = 1"),
],
"""
from t4.sub.subsub import *
print "t4.sub.subsub.spam =", spam
print("t4.sub.subsub.spam =", spam)
"""),
("t5", [
("t5", None),
("t5 __init__"+os.extsep+"py", "import t5.foo"),
("t5 string"+os.extsep+"py", "print __name__, 'loading'; spam = 1"),
("t5 string"+os.extsep+"py", "print(__name__, 'loading'); spam = 1"),
("t5 foo"+os.extsep+"py",
"print __name__, 'loading'; from . import string; print string.spam"),
"print(__name__, 'loading'); from . import string; print(string.spam)"),
],
"""
import t5
from t5 import *
print dir()
print(dir())
import t5
print fixdir(dir(t5))
print fixdir(dir(t5.foo))
print fixdir(dir(t5.string))
print(fixdir(dir(t5)))
print(fixdir(dir(t5.foo)))
print(fixdir(dir(t5.string)))
"""),
("t6", [
("t6", None),
("t6 __init__"+os.extsep+"py", "__all__ = ['spam', 'ham', 'eggs']"),
("t6 spam"+os.extsep+"py", "print __name__, 'loading'"),
("t6 ham"+os.extsep+"py", "print __name__, 'loading'"),
("t6 eggs"+os.extsep+"py", "print __name__, 'loading'"),
("t6 spam"+os.extsep+"py", "print(__name__, 'loading')"),
("t6 ham"+os.extsep+"py", "print(__name__, 'loading')"),
("t6 eggs"+os.extsep+"py", "print(__name__, 'loading')"),
],
"""
import t6
print fixdir(dir(t6))
print(fixdir(dir(t6)))
from t6 import *
print fixdir(dir(t6))
print dir()
print(fixdir(dir(t6)))
print(dir())
"""),
("t7", [
("t7"+os.extsep+"py", "print 'Importing t7"+os.extsep+"py'"),
("t7"+os.extsep+"py", "print('Importing t7"+os.extsep+"py')"),
("t7", None),
("t7 __init__"+os.extsep+"py", "print __name__, 'loading'"),
("t7 sub"+os.extsep+"py", "print 'THIS SHOULD NOT BE PRINTED (sub"+os.extsep+"py)'"),
("t7 __init__"+os.extsep+"py", "print(__name__, 'loading')"),
("t7 sub"+os.extsep+"py", "print('THIS SHOULD NOT BE PRINTED (sub"+os.extsep+"py)')"),
("t7 sub", None),
("t7 sub __init__"+os.extsep+"py", ""),
("t7 sub subsub"+os.extsep+"py", "print 'THIS SHOULD NOT BE PRINTED (subsub"+os.extsep+"py)'"),
("t7 sub subsub"+os.extsep+"py", "print('THIS SHOULD NOT BE PRINTED (subsub"+os.extsep+"py)')"),
("t7 sub subsub", None),
("t7 sub subsub __init__"+os.extsep+"py", "print __name__, 'loading'; spam = 1"),
("t7 sub subsub __init__"+os.extsep+"py", "print(__name__, 'loading'); spam = 1"),
],
"""
t7, sub, subsub = None, None, None
import t7 as tas
print fixdir(dir(tas))
print(fixdir(dir(tas)))
verify(not t7)
from t7 import sub as subpar
print fixdir(dir(subpar))
print(fixdir(dir(subpar)))
verify(not t7 and not sub)
from t7.sub import subsub as subsubsub
print fixdir(dir(subsubsub))
print(fixdir(dir(subsubsub)))
verify(not t7 and not sub and not subsub)
from t7.sub.subsub import spam as ham
print "t7.sub.subsub.spam =", ham
print("t7.sub.subsub.spam =", ham)
verify(not t7 and not sub and not subsub)
"""),

2
Lib/test/test_popen.py
View File

@ -19,7 +19,7 @@ if ' ' in python:
class PopenTest(unittest.TestCase):
def _do_test_commandline(self, cmdline, expected):
cmd = '%s -c "import sys;print sys.argv" %s' % (python, cmdline)
cmd = '%s -c "import sys; print(sys.argv)" %s' % (python, cmdline)
data = os.popen(cmd).read()
got = eval(data)[1:] # strip off argv[0]
self.assertEqual(got, expected)

8
Lib/test/test_subprocess.py
View File

@ -84,7 +84,7 @@ class ProcessTestCase(unittest.TestCase):
def test_stdin_none(self):
# .stdin is None when not redirected
p = subprocess.Popen([sys.executable, "-c", 'print "banana"'],
p = subprocess.Popen([sys.executable, "-c", 'print("banana")'],
stdout=subprocess.PIPE, stderr=subprocess.PIPE)
p.wait()
self.assertEqual(p.stdin, None)
@ -92,16 +92,16 @@ class ProcessTestCase(unittest.TestCase):
def test_stdout_none(self):
# .stdout is None when not redirected
p = subprocess.Popen([sys.executable, "-c",
'print " this bit of output is from a '
'print(" this bit of output is from a '
'test of stdout in a different '
'process ..."'],
'process ...")'],
stdin=subprocess.PIPE, stderr=subprocess.PIPE)
p.wait()
self.assertEqual(p.stdout, None)
def test_stderr_none(self):
# .stderr is None when not redirected
p = subprocess.Popen([sys.executable, "-c", 'print "banana"'],
p = subprocess.Popen([sys.executable, "-c", 'print("banana")'],
stdin=subprocess.PIPE, stdout=subprocess.PIPE)
p.wait()
self.assertEqual(p.stderr, None)

2
Lib/test/test_syntax.py
View File

@ -423,7 +423,7 @@ class SyntaxTestCase(unittest.TestCase):
source = re.sub('(?m)^ *:', '', """\
:def foo(x):
: def bar():
: print x
: print(x)
: del x
:""")
self._check_error(source, "nested scope")

20
Lib/test/test_tokenize.py
View File

@ -43,9 +43,9 @@ regenerate the original program text from the tokens.
There are some standard formatting practices that are easy to get right.
>>> roundtrip("if x == 1:\\n"
... " print x\\n")
... " print(x)\\n")
if x == 1:
print x
print(x)
Some people use different formatting conventions, which makes
untokenize a little trickier. Note that this test involves trailing
@ -53,29 +53,29 @@ whitespace after the colon. Note that we use hex escapes to make the
two trailing blanks apparent in the expected output.
>>> roundtrip("if x == 1 : \\n"
... " print x\\n")
... " print(x)\\n")
if x == 1 :\x20\x20
print x
print(x)
Comments need to go in the right place.
>>> roundtrip("if x == 1:\\n"
... " # A comment by itself.\\n"
... " print x # Comment here, too.\\n"
... " print(x) # Comment here, too.\\n"
... " # Another comment.\\n"
... "after_if = True\\n")
if x == 1:
# A comment by itself.
print x # Comment here, too.
print(x) # Comment here, too.
# Another comment.
after_if = True
>>> roundtrip("if (x # The comments need to go in the right place\\n"
... " == 1):\\n"
... " print 'x == 1'\\n")
... " print('x == 1')\\n")
if (x # The comments need to go in the right place
== 1):
print 'x == 1'
print('x == 1')
"""
@ -130,9 +130,9 @@ def decistmt(s):
"""Substitute Decimals for floats in a string of statements.
>>> from decimal import Decimal
>>> s = 'print +21.3e-5*-.1234/81.7'
>>> s = 'print(+21.3e-5*-.1234/81.7)'
>>> decistmt(s)
"print +Decimal ('21.3e-5')*-Decimal ('.1234')/Decimal ('81.7')"
"print (+Decimal ('21.3e-5')*-Decimal ('.1234')/Decimal ('81.7'))"
The format of the exponent is inherited from the platform C library.
Known cases are "e-007" (Windows) and "e-07" (not Windows). Since

6
Lib/test/test_traceback.py
View File

@ -25,7 +25,7 @@ class TracebackCases(unittest.TestCase):
import test.badsyntax_nocaret
def syntax_error_bad_indentation(self):
compile("def spam():\n print 1\n print 2", "?", "exec")
compile("def spam():\n print(1)\n print(2)", "?", "exec")
def test_caret(self):
err = self.get_exception_format(self.syntax_error_with_caret,
@ -48,9 +48,9 @@ class TracebackCases(unittest.TestCase):
err = self.get_exception_format(self.syntax_error_bad_indentation,
IndentationError)
self.assert_(len(err) == 4)
self.assert_(err[1].strip() == "print 2")
self.assert_(err[1].strip() == "print(2)")
self.assert_("^" in err[2])
self.assert_(err[1].find("2") == err[2].find("^"))
self.assert_(err[1].find(")") == err[2].find("^"))
def test_bug737473(self):
import sys, os, tempfile, time

3
Parser/Python.asdl
View File

@ -18,9 +18,6 @@ module Python version "$Revision$"
| Assign(expr* targets, expr value)
| AugAssign(expr target, operator op, expr value)
-- not sure if bool is allowed, can always use int
| Print(expr? dest, expr* values, bool nl)
-- use 'orelse' because else is a keyword in target languages
| For(expr target, expr iter, stmt* body, stmt* orelse)
| While(expr test, stmt* body, stmt* orelse)

47
Python/Python-ast.c
View File

@ -61,12 +61,6 @@ static char *AugAssign_fields[]={
"op",
"value",
};
static PyTypeObject *Print_type;
static char *Print_fields[]={
"dest",
"values",
"nl",
};
static PyTypeObject *For_type;
static char *For_fields[]={
"target",
@ -480,8 +474,6 @@ static int init_types(void)
if (!Assign_type) return 0;
AugAssign_type = make_type("AugAssign", stmt_type, AugAssign_fields, 3);
if (!AugAssign_type) return 0;
Print_type = make_type("Print", stmt_type, Print_fields, 3);
if (!Print_type) return 0;
For_type = make_type("For", stmt_type, For_fields, 4);
if (!For_type) return 0;
While_type = make_type("While", stmt_type, While_fields, 3);
@ -948,25 +940,6 @@ AugAssign(expr_ty target, operator_ty op, expr_ty value, int lineno, int
return p;
}
stmt_ty
Print(expr_ty dest, asdl_seq * values, bool nl, int lineno, int col_offset,
PyArena *arena)
{
stmt_ty p;
p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
if (!p) {
PyErr_NoMemory();
return NULL;
}
p->kind = Print_kind;
p->v.Print.dest = dest;
p->v.Print.values = values;
p->v.Print.nl = nl;
p->lineno = lineno;
p->col_offset = col_offset;
return p;
}
stmt_ty
For(expr_ty target, expr_ty iter, asdl_seq * body, asdl_seq * orelse, int
lineno, int col_offset, PyArena *arena)
@ -2118,25 +2091,6 @@ ast2obj_stmt(void* _o)
goto failed;
Py_DECREF(value);
break;
case Print_kind:
result = PyType_GenericNew(Print_type, NULL, NULL);
if (!result) goto failed;
value = ast2obj_expr(o->v.Print.dest);
if (!value) goto failed;
if (PyObject_SetAttrString(result, "dest", value) == -1)
goto failed;
Py_DECREF(value);
value = ast2obj_list(o->v.Print.values, ast2obj_expr);
if (!value) goto failed;
if (PyObject_SetAttrString(result, "values", value) == -1)
goto failed;
Py_DECREF(value);
value = ast2obj_bool(o->v.Print.nl);
if (!value) goto failed;
if (PyObject_SetAttrString(result, "nl", value) == -1)
goto failed;
Py_DECREF(value);
break;
case For_kind:
result = PyType_GenericNew(For_type, NULL, NULL);
if (!result) goto failed;
@ -3149,7 +3103,6 @@ init_ast(void)
return;
if (PyDict_SetItemString(d, "AugAssign", (PyObject*)AugAssign_type) <
0) return;
if (PyDict_SetItemString(d, "Print", (PyObject*)Print_type) < 0) return;
if (PyDict_SetItemString(d, "For", (PyObject*)For_type) < 0) return;
if (PyDict_SetItemString(d, "While", (PyObject*)While_type) < 0) return;
if (PyDict_SetItemString(d, "If", (PyObject*)If_type) < 0) return;

2
Python/bltinmodule.c
View File

@ -1398,7 +1398,7 @@ builtin_print(PyObject *self, PyObject *args, PyObject *kwds)
if (dummy_args == NULL)
return NULL;
if (!PyArg_ParseTupleAndKeywords(dummy_args, kwds, "|OOO:Print",
if (!PyArg_ParseTupleAndKeywords(dummy_args, kwds, "|OOO:print",
kwlist, &sep, &end, &file))
return NULL;
if (file == NULL || file == Py_None)

76
Python/ceval.c
View File

@ -524,7 +524,6 @@ PyEval_EvalFrameEx(PyFrameObject *f, int throwflag)
register PyObject *w;
register PyObject *u;
register PyObject *t;
register PyObject *stream = NULL; /* for PRINT opcodes */
register PyObject **fastlocals, **freevars;
PyObject *retval = NULL; /* Return value */
PyThreadState *tstate = PyThreadState_GET();
@ -1508,81 +1507,6 @@ PyEval_EvalFrameEx(PyFrameObject *f, int throwflag)
Py_XDECREF(x);
break;
case PRINT_ITEM_TO:
w = stream = POP();
/* fall through to PRINT_ITEM */
case PRINT_ITEM:
v = POP();
if (stream == NULL || stream == Py_None) {
w = PySys_GetObject("stdout");
if (w == NULL) {
PyErr_SetString(PyExc_RuntimeError,
"lost sys.stdout");
err = -1;
}
}
/* PyFile_SoftSpace() can exececute arbitrary code
if sys.stdout is an instance with a __getattr__.
If __getattr__ raises an exception, w will
be freed, so we need to prevent that temporarily. */
Py_XINCREF(w);
if (w != NULL && PyFile_SoftSpace(w, 0))
err = PyFile_WriteString(" ", w);
if (err == 0)
err = PyFile_WriteObject(v, w, Py_PRINT_RAW);
if (err == 0) {
/* XXX move into writeobject() ? */
if (PyString_Check(v)) {
char *s = PyString_AS_STRING(v);
Py_ssize_t len = PyString_GET_SIZE(v);
if (len == 0 ||
!isspace(Py_CHARMASK(s[len-1])) ||
s[len-1] == ' ')
PyFile_SoftSpace(w, 1);
}
#ifdef Py_USING_UNICODE
else if (PyUnicode_Check(v)) {
Py_UNICODE *s = PyUnicode_AS_UNICODE(v);
Py_ssize_t len = PyUnicode_GET_SIZE(v);
if (len == 0 ||
!Py_UNICODE_ISSPACE(s[len-1]) ||
s[len-1] == ' ')
PyFile_SoftSpace(w, 1);
}
#endif
else
PyFile_SoftSpace(w, 1);
}
Py_XDECREF(w);
Py_DECREF(v);
Py_XDECREF(stream);
stream = NULL;
if (err == 0)
continue;
break;
case PRINT_NEWLINE_TO:
w = stream = POP();
/* fall through to PRINT_NEWLINE */
case PRINT_NEWLINE:
if (stream == NULL || stream == Py_None) {
w = PySys_GetObject("stdout");
if (w == NULL)
PyErr_SetString(PyExc_RuntimeError,
"lost sys.stdout");
}
if (w != NULL) {
err = PyFile_WriteString("\n", w);
if (err == 0)
PyFile_SoftSpace(w, 0);
}
Py_XDECREF(stream);
stream = NULL;
break;
#ifdef CASE_TOO_BIG
default: switch (opcode) {
#endif

47
Python/compile.c
View File

@ -734,14 +734,6 @@ opcode_stack_effect(int opcode, int oparg)
case PRINT_EXPR:
return -1;
case PRINT_ITEM:
return -1;
case PRINT_NEWLINE:
return 0;
case PRINT_ITEM_TO:
return -2;
case PRINT_NEWLINE_TO:
return -1;
case INPLACE_LSHIFT:
case INPLACE_RSHIFT:
case INPLACE_AND:
@ -1625,43 +1617,6 @@ compiler_lambda(struct compiler *c, expr_ty e)
return 1;
}
static int
compiler_print(struct compiler *c, stmt_ty s)
{
int i, n;
bool dest;
assert(s->kind == Print_kind);
n = asdl_seq_LEN(s->v.Print.values);
dest = false;
if (s->v.Print.dest) {
VISIT(c, expr, s->v.Print.dest);
dest = true;
}
for (i = 0; i < n; i++) {
expr_ty e = (expr_ty)asdl_seq_GET(s->v.Print.values, i);
if (dest) {
ADDOP(c, DUP_TOP);
VISIT(c, expr, e);
ADDOP(c, ROT_TWO);
ADDOP(c, PRINT_ITEM_TO);
}
else {
VISIT(c, expr, e);
ADDOP(c, PRINT_ITEM);
}
}
if (s->v.Print.nl) {
if (dest)
ADDOP(c, PRINT_NEWLINE_TO)
else
ADDOP(c, PRINT_NEWLINE)
}
else if (dest)
ADDOP(c, POP_TOP);
return 1;
}
static int
compiler_if(struct compiler *c, stmt_ty s)
{
@ -2236,8 +2191,6 @@ compiler_visit_stmt(struct compiler *c, stmt_ty s)
break;
case AugAssign_kind:
return compiler_augassign(c, s);
case Print_kind:
return compiler_print(c, s);
case For_kind:
return compiler_for(c, s);
case While_kind:

5
Python/symtable.c
View File

@ -990,11 +990,6 @@ symtable_visit_stmt(struct symtable *st, stmt_ty s)
VISIT(st, expr, s->v.AugAssign.target);
VISIT(st, expr, s->v.AugAssign.value);
break;
case Print_kind:
if (s->v.Print.dest)
VISIT(st, expr, s->v.Print.dest);
VISIT_SEQ(st, expr, s->v.Print.values);
break;
case For_kind:
VISIT(st, expr, s->v.For.target);
VISIT(st, expr, s->v.For.iter);

2
Python/sysmodule.c
View File

@ -904,7 +904,7 @@ exitfunc -- if sys.exitfunc exists, this routine is called when Python exits\n\
Assigning to sys.exitfunc is deprecated; use the atexit module instead.\n\
\n\
stdin -- standard input file object; used by raw_input() and input()\n\
stdout -- standard output file object; used by the print statement\n\
stdout -- standard output file object; used by print()\n\
stderr -- standard error object; used for error messages\n\
By assigning other file objects (or objects that behave like files)\n\
to these, it is possible to redirect all of the interpreter's I/O.\n\

2
Tools/compiler/ast.txt
View File

@ -34,8 +34,6 @@ TryExcept: body, handlers!, else_&
Return: value
Yield: value
Const: value*
Print: nodes!, dest&
Printnl: nodes!, dest&
Discard: expr
AugAssign: node, op*, expr
Assign: nodes!, expr