[pypy-commit] pypy ootype-rerased: Merge default.
ademan
noreply at buildbot.pypy.org
Mon Jul 25 02:15:04 CEST 2011
Author: Daniel Roberts <Ademan555 at gmail.com>
Branch: ootype-rerased
Changeset: r45955:7f3d2d819c7d
Date: 2011-07-24 16:57 -0700
http://bitbucket.org/pypy/pypy/changeset/7f3d2d819c7d/
Log: Merge default.
diff --git a/lib_pypy/pyrepl/unix_console.py b/lib_pypy/pyrepl/unix_console.py
--- a/lib_pypy/pyrepl/unix_console.py
+++ b/lib_pypy/pyrepl/unix_console.py
@@ -384,14 +384,18 @@
self.__maybe_write_code(self._smkx)
+ try:
self.old_sigwinch = signal.signal(
signal.SIGWINCH, self.__sigwinch)
+ except ValueError:
+ pass
def restore(self):
self.__maybe_write_code(self._rmkx)
self.flushoutput()
tcsetattr(self.input_fd, termios.TCSADRAIN, self.__svtermstate)
+ if hasattr(self, 'old_sigwinch'):
signal.signal(signal.SIGWINCH, self.old_sigwinch)
def __sigwinch(self, signum, frame):
diff --git a/pypy/interpreter/astcompiler/ast.py b/pypy/interpreter/astcompiler/ast.py
--- a/pypy/interpreter/astcompiler/ast.py
+++ b/pypy/interpreter/astcompiler/ast.py
@@ -2541,6 +2541,7 @@
class ASTVisitor(object):
def visit_sequence(self, seq):
+ if seq is not None:
for node in seq:
node.walkabout(self)
@@ -2673,33 +2674,25 @@
class GenericASTVisitor(ASTVisitor):
def visit_Module(self, node):
- if node.body:
self.visit_sequence(node.body)
def visit_Interactive(self, node):
- if node.body:
self.visit_sequence(node.body)
def visit_Expression(self, node):
node.body.walkabout(self)
def visit_Suite(self, node):
- if node.body:
self.visit_sequence(node.body)
def visit_FunctionDef(self, node):
node.args.walkabout(self)
- if node.body:
self.visit_sequence(node.body)
- if node.decorator_list:
self.visit_sequence(node.decorator_list)
def visit_ClassDef(self, node):
- if node.bases:
self.visit_sequence(node.bases)
- if node.body:
self.visit_sequence(node.body)
- if node.decorator_list:
self.visit_sequence(node.decorator_list)
def visit_Return(self, node):
@@ -2707,11 +2700,9 @@
node.value.walkabout(self)
def visit_Delete(self, node):
- if node.targets:
self.visit_sequence(node.targets)
def visit_Assign(self, node):
- if node.targets:
self.visit_sequence(node.targets)
node.value.walkabout(self)
@@ -2722,36 +2713,28 @@
def visit_Print(self, node):
if node.dest:
node.dest.walkabout(self)
- if node.values:
self.visit_sequence(node.values)
def visit_For(self, node):
node.target.walkabout(self)
node.iter.walkabout(self)
- if node.body:
self.visit_sequence(node.body)
- if node.orelse:
self.visit_sequence(node.orelse)
def visit_While(self, node):
node.test.walkabout(self)
- if node.body:
self.visit_sequence(node.body)
- if node.orelse:
self.visit_sequence(node.orelse)
def visit_If(self, node):
node.test.walkabout(self)
- if node.body:
self.visit_sequence(node.body)
- if node.orelse:
self.visit_sequence(node.orelse)
def visit_With(self, node):
node.context_expr.walkabout(self)
if node.optional_vars:
node.optional_vars.walkabout(self)
- if node.body:
self.visit_sequence(node.body)
def visit_Raise(self, node):
@@ -2763,17 +2746,12 @@
node.tback.walkabout(self)
def visit_TryExcept(self, node):
- if node.body:
self.visit_sequence(node.body)
- if node.handlers:
self.visit_sequence(node.handlers)
- if node.orelse:
self.visit_sequence(node.orelse)
def visit_TryFinally(self, node):
- if node.body:
self.visit_sequence(node.body)
- if node.finalbody:
self.visit_sequence(node.finalbody)
def visit_Assert(self, node):
@@ -2782,11 +2760,9 @@
node.msg.walkabout(self)
def visit_Import(self, node):
- if node.names:
self.visit_sequence(node.names)
def visit_ImportFrom(self, node):
- if node.names:
self.visit_sequence(node.names)
def visit_Exec(self, node):
@@ -2812,7 +2788,6 @@
pass
def visit_BoolOp(self, node):
- if node.values:
self.visit_sequence(node.values)
def visit_BinOp(self, node):
@@ -2832,34 +2807,27 @@
node.orelse.walkabout(self)
def visit_Dict(self, node):
- if node.keys:
self.visit_sequence(node.keys)
- if node.values:
self.visit_sequence(node.values)
def visit_Set(self, node):
- if node.elts:
self.visit_sequence(node.elts)
def visit_ListComp(self, node):
node.elt.walkabout(self)
- if node.generators:
self.visit_sequence(node.generators)
def visit_SetComp(self, node):
node.elt.walkabout(self)
- if node.generators:
self.visit_sequence(node.generators)
def visit_DictComp(self, node):
node.key.walkabout(self)
node.value.walkabout(self)
- if node.generators:
self.visit_sequence(node.generators)
def visit_GeneratorExp(self, node):
node.elt.walkabout(self)
- if node.generators:
self.visit_sequence(node.generators)
def visit_Yield(self, node):
@@ -2868,14 +2836,11 @@
def visit_Compare(self, node):
node.left.walkabout(self)
- if node.comparators:
self.visit_sequence(node.comparators)
def visit_Call(self, node):
node.func.walkabout(self)
- if node.args:
self.visit_sequence(node.args)
- if node.keywords:
self.visit_sequence(node.keywords)
if node.starargs:
node.starargs.walkabout(self)
@@ -2902,11 +2867,9 @@
pass
def visit_List(self, node):
- if node.elts:
self.visit_sequence(node.elts)
def visit_Tuple(self, node):
- if node.elts:
self.visit_sequence(node.elts)
def visit_Const(self, node):
@@ -2924,7 +2887,6 @@
node.step.walkabout(self)
def visit_ExtSlice(self, node):
- if node.dims:
self.visit_sequence(node.dims)
def visit_Index(self, node):
@@ -2933,7 +2895,6 @@
def visit_comprehension(self, node):
node.target.walkabout(self)
node.iter.walkabout(self)
- if node.ifs:
self.visit_sequence(node.ifs)
def visit_ExceptHandler(self, node):
@@ -2941,13 +2902,10 @@
node.type.walkabout(self)
if node.name:
node.name.walkabout(self)
- if node.body:
self.visit_sequence(node.body)
def visit_arguments(self, node):
- if node.args:
self.visit_sequence(node.args)
- if node.defaults:
self.visit_sequence(node.defaults)
def visit_keyword(self, node):
@@ -3069,6 +3027,7 @@
raise
w_self.setdictvalue(space, 'body', w_new_value)
return
+ w_self.deldictvalue(space, 'body')
w_self.initialization_state |= 1
_Expression_field_unroller = unrolling_iterable(['body'])
@@ -3157,6 +3116,7 @@
raise
w_self.setdictvalue(space, 'lineno', w_new_value)
return
+ w_self.deldictvalue(space, 'lineno')
w_self.initialization_state |= w_self._lineno_mask
def stmt_get_col_offset(space, w_self):
@@ -3178,6 +3138,7 @@
raise
w_self.setdictvalue(space, 'col_offset', w_new_value)
return
+ w_self.deldictvalue(space, 'col_offset')
w_self.initialization_state |= w_self._col_offset_mask
stmt.typedef = typedef.TypeDef("stmt",
@@ -3208,6 +3169,7 @@
raise
w_self.setdictvalue(space, 'name', w_new_value)
return
+ w_self.deldictvalue(space, 'name')
w_self.initialization_state |= 1
def FunctionDef_get_args(space, w_self):
@@ -3229,6 +3191,7 @@
raise
w_self.setdictvalue(space, 'args', w_new_value)
return
+ w_self.deldictvalue(space, 'args')
w_self.initialization_state |= 2
def FunctionDef_get_body(space, w_self):
@@ -3315,6 +3278,7 @@
raise
w_self.setdictvalue(space, 'name', w_new_value)
return
+ w_self.deldictvalue(space, 'name')
w_self.initialization_state |= 1
def ClassDef_get_bases(space, w_self):
@@ -3420,6 +3384,7 @@
raise
w_self.setdictvalue(space, 'value', w_new_value)
return
+ w_self.deldictvalue(space, 'value')
w_self.initialization_state |= 1
_Return_field_unroller = unrolling_iterable(['value'])
@@ -3526,6 +3491,7 @@
raise
w_self.setdictvalue(space, 'value', w_new_value)
return
+ w_self.deldictvalue(space, 'value')
w_self.initialization_state |= 2
_Assign_field_unroller = unrolling_iterable(['targets', 'value'])
@@ -3573,6 +3539,7 @@
raise
w_self.setdictvalue(space, 'target', w_new_value)
return
+ w_self.deldictvalue(space, 'target')
w_self.initialization_state |= 1
def AugAssign_get_op(space, w_self):
@@ -3590,13 +3557,13 @@
try:
obj = space.interp_w(operator, w_new_value)
w_self.op = obj.to_simple_int(space)
- # need to save the original object too
- w_self.setdictvalue(space, 'op', w_new_value)
except OperationError, e:
if not e.match(space, space.w_TypeError):
raise
w_self.setdictvalue(space, 'op', w_new_value)
return
+ # need to save the original object too
+ w_self.setdictvalue(space, 'op', w_new_value)
w_self.initialization_state |= 2
def AugAssign_get_value(space, w_self):
@@ -3618,6 +3585,7 @@
raise
w_self.setdictvalue(space, 'value', w_new_value)
return
+ w_self.deldictvalue(space, 'value')
w_self.initialization_state |= 4
_AugAssign_field_unroller = unrolling_iterable(['target', 'op', 'value'])
@@ -3665,6 +3633,7 @@
raise
w_self.setdictvalue(space, 'dest', w_new_value)
return
+ w_self.deldictvalue(space, 'dest')
w_self.initialization_state |= 1
def Print_get_values(space, w_self):
@@ -3704,6 +3673,7 @@
raise
w_self.setdictvalue(space, 'nl', w_new_value)
return
+ w_self.deldictvalue(space, 'nl')
w_self.initialization_state |= 4
_Print_field_unroller = unrolling_iterable(['dest', 'values', 'nl'])
@@ -3752,6 +3722,7 @@
raise
w_self.setdictvalue(space, 'target', w_new_value)
return
+ w_self.deldictvalue(space, 'target')
w_self.initialization_state |= 1
def For_get_iter(space, w_self):
@@ -3773,6 +3744,7 @@
raise
w_self.setdictvalue(space, 'iter', w_new_value)
return
+ w_self.deldictvalue(space, 'iter')
w_self.initialization_state |= 2
def For_get_body(space, w_self):
@@ -3859,6 +3831,7 @@
raise
w_self.setdictvalue(space, 'test', w_new_value)
return
+ w_self.deldictvalue(space, 'test')
w_self.initialization_state |= 1
def While_get_body(space, w_self):
@@ -3944,6 +3917,7 @@
raise
w_self.setdictvalue(space, 'test', w_new_value)
return
+ w_self.deldictvalue(space, 'test')
w_self.initialization_state |= 1
def If_get_body(space, w_self):
@@ -4029,6 +4003,7 @@
raise
w_self.setdictvalue(space, 'context_expr', w_new_value)
return
+ w_self.deldictvalue(space, 'context_expr')
w_self.initialization_state |= 1
def With_get_optional_vars(space, w_self):
@@ -4050,6 +4025,7 @@
raise
w_self.setdictvalue(space, 'optional_vars', w_new_value)
return
+ w_self.deldictvalue(space, 'optional_vars')
w_self.initialization_state |= 2
def With_get_body(space, w_self):
@@ -4116,6 +4092,7 @@
raise
w_self.setdictvalue(space, 'type', w_new_value)
return
+ w_self.deldictvalue(space, 'type')
w_self.initialization_state |= 1
def Raise_get_inst(space, w_self):
@@ -4137,6 +4114,7 @@
raise
w_self.setdictvalue(space, 'inst', w_new_value)
return
+ w_self.deldictvalue(space, 'inst')
w_self.initialization_state |= 2
def Raise_get_tback(space, w_self):
@@ -4158,6 +4136,7 @@
raise
w_self.setdictvalue(space, 'tback', w_new_value)
return
+ w_self.deldictvalue(space, 'tback')
w_self.initialization_state |= 4
_Raise_field_unroller = unrolling_iterable(['type', 'inst', 'tback'])
@@ -4351,6 +4330,7 @@
raise
w_self.setdictvalue(space, 'test', w_new_value)
return
+ w_self.deldictvalue(space, 'test')
w_self.initialization_state |= 1
def Assert_get_msg(space, w_self):
@@ -4372,6 +4352,7 @@
raise
w_self.setdictvalue(space, 'msg', w_new_value)
return
+ w_self.deldictvalue(space, 'msg')
w_self.initialization_state |= 2
_Assert_field_unroller = unrolling_iterable(['test', 'msg'])
@@ -4464,6 +4445,7 @@
raise
w_self.setdictvalue(space, 'module', w_new_value)
return
+ w_self.deldictvalue(space, 'module')
w_self.initialization_state |= 1
def ImportFrom_get_names(space, w_self):
@@ -4503,6 +4485,7 @@
raise
w_self.setdictvalue(space, 'level', w_new_value)
return
+ w_self.deldictvalue(space, 'level')
w_self.initialization_state |= 4
_ImportFrom_field_unroller = unrolling_iterable(['module', 'names', 'level'])
@@ -4551,6 +4534,7 @@
raise
w_self.setdictvalue(space, 'body', w_new_value)
return
+ w_self.deldictvalue(space, 'body')
w_self.initialization_state |= 1
def Exec_get_globals(space, w_self):
@@ -4572,6 +4556,7 @@
raise
w_self.setdictvalue(space, 'globals', w_new_value)
return
+ w_self.deldictvalue(space, 'globals')
w_self.initialization_state |= 2
def Exec_get_locals(space, w_self):
@@ -4593,6 +4578,7 @@
raise
w_self.setdictvalue(space, 'locals', w_new_value)
return
+ w_self.deldictvalue(space, 'locals')
w_self.initialization_state |= 4
_Exec_field_unroller = unrolling_iterable(['body', 'globals', 'locals'])
@@ -4683,6 +4669,7 @@
raise
w_self.setdictvalue(space, 'value', w_new_value)
return
+ w_self.deldictvalue(space, 'value')
w_self.initialization_state |= 1
_Expr_field_unroller = unrolling_iterable(['value'])
@@ -4779,6 +4766,7 @@
raise
w_self.setdictvalue(space, 'lineno', w_new_value)
return
+ w_self.deldictvalue(space, 'lineno')
w_self.initialization_state |= w_self._lineno_mask
def expr_get_col_offset(space, w_self):
@@ -4800,6 +4788,7 @@
raise
w_self.setdictvalue(space, 'col_offset', w_new_value)
return
+ w_self.deldictvalue(space, 'col_offset')
w_self.initialization_state |= w_self._col_offset_mask
expr.typedef = typedef.TypeDef("expr",
@@ -4826,13 +4815,13 @@
try:
obj = space.interp_w(boolop, w_new_value)
w_self.op = obj.to_simple_int(space)
- # need to save the original object too
- w_self.setdictvalue(space, 'op', w_new_value)
except OperationError, e:
if not e.match(space, space.w_TypeError):
raise
w_self.setdictvalue(space, 'op', w_new_value)
return
+ # need to save the original object too
+ w_self.setdictvalue(space, 'op', w_new_value)
w_self.initialization_state |= 1
def BoolOp_get_values(space, w_self):
@@ -4898,6 +4887,7 @@
raise
w_self.setdictvalue(space, 'left', w_new_value)
return
+ w_self.deldictvalue(space, 'left')
w_self.initialization_state |= 1
def BinOp_get_op(space, w_self):
@@ -4915,13 +4905,13 @@
try:
obj = space.interp_w(operator, w_new_value)
w_self.op = obj.to_simple_int(space)
- # need to save the original object too
- w_self.setdictvalue(space, 'op', w_new_value)
except OperationError, e:
if not e.match(space, space.w_TypeError):
raise
w_self.setdictvalue(space, 'op', w_new_value)
return
+ # need to save the original object too
+ w_self.setdictvalue(space, 'op', w_new_value)
w_self.initialization_state |= 2
def BinOp_get_right(space, w_self):
@@ -4943,6 +4933,7 @@
raise
w_self.setdictvalue(space, 'right', w_new_value)
return
+ w_self.deldictvalue(space, 'right')
w_self.initialization_state |= 4
_BinOp_field_unroller = unrolling_iterable(['left', 'op', 'right'])
@@ -4986,13 +4977,13 @@
try:
obj = space.interp_w(unaryop, w_new_value)
w_self.op = obj.to_simple_int(space)
- # need to save the original object too
- w_self.setdictvalue(space, 'op', w_new_value)
except OperationError, e:
if not e.match(space, space.w_TypeError):
raise
w_self.setdictvalue(space, 'op', w_new_value)
return
+ # need to save the original object too
+ w_self.setdictvalue(space, 'op', w_new_value)
w_self.initialization_state |= 1
def UnaryOp_get_operand(space, w_self):
@@ -5014,6 +5005,7 @@
raise
w_self.setdictvalue(space, 'operand', w_new_value)
return
+ w_self.deldictvalue(space, 'operand')
w_self.initialization_state |= 2
_UnaryOp_field_unroller = unrolling_iterable(['op', 'operand'])
@@ -5060,6 +5052,7 @@
raise
w_self.setdictvalue(space, 'args', w_new_value)
return
+ w_self.deldictvalue(space, 'args')
w_self.initialization_state |= 1
def Lambda_get_body(space, w_self):
@@ -5081,6 +5074,7 @@
raise
w_self.setdictvalue(space, 'body', w_new_value)
return
+ w_self.deldictvalue(space, 'body')
w_self.initialization_state |= 2
_Lambda_field_unroller = unrolling_iterable(['args', 'body'])
@@ -5127,6 +5121,7 @@
raise
w_self.setdictvalue(space, 'test', w_new_value)
return
+ w_self.deldictvalue(space, 'test')
w_self.initialization_state |= 1
def IfExp_get_body(space, w_self):
@@ -5148,6 +5143,7 @@
raise
w_self.setdictvalue(space, 'body', w_new_value)
return
+ w_self.deldictvalue(space, 'body')
w_self.initialization_state |= 2
def IfExp_get_orelse(space, w_self):
@@ -5169,6 +5165,7 @@
raise
w_self.setdictvalue(space, 'orelse', w_new_value)
return
+ w_self.deldictvalue(space, 'orelse')
w_self.initialization_state |= 4
_IfExp_field_unroller = unrolling_iterable(['test', 'body', 'orelse'])
@@ -5322,6 +5319,7 @@
raise
w_self.setdictvalue(space, 'elt', w_new_value)
return
+ w_self.deldictvalue(space, 'elt')
w_self.initialization_state |= 1
def ListComp_get_generators(space, w_self):
@@ -5387,6 +5385,7 @@
raise
w_self.setdictvalue(space, 'elt', w_new_value)
return
+ w_self.deldictvalue(space, 'elt')
w_self.initialization_state |= 1
def SetComp_get_generators(space, w_self):
@@ -5452,6 +5451,7 @@
raise
w_self.setdictvalue(space, 'key', w_new_value)
return
+ w_self.deldictvalue(space, 'key')
w_self.initialization_state |= 1
def DictComp_get_value(space, w_self):
@@ -5473,6 +5473,7 @@
raise
w_self.setdictvalue(space, 'value', w_new_value)
return
+ w_self.deldictvalue(space, 'value')
w_self.initialization_state |= 2
def DictComp_get_generators(space, w_self):
@@ -5539,6 +5540,7 @@
raise
w_self.setdictvalue(space, 'elt', w_new_value)
return
+ w_self.deldictvalue(space, 'elt')
w_self.initialization_state |= 1
def GeneratorExp_get_generators(space, w_self):
@@ -5604,6 +5606,7 @@
raise
w_self.setdictvalue(space, 'value', w_new_value)
return
+ w_self.deldictvalue(space, 'value')
w_self.initialization_state |= 1
_Yield_field_unroller = unrolling_iterable(['value'])
@@ -5649,6 +5652,7 @@
raise
w_self.setdictvalue(space, 'left', w_new_value)
return
+ w_self.deldictvalue(space, 'left')
w_self.initialization_state |= 1
def Compare_get_ops(space, w_self):
@@ -5734,6 +5738,7 @@
raise
w_self.setdictvalue(space, 'func', w_new_value)
return
+ w_self.deldictvalue(space, 'func')
w_self.initialization_state |= 1
def Call_get_args(space, w_self):
@@ -5791,6 +5796,7 @@
raise
w_self.setdictvalue(space, 'starargs', w_new_value)
return
+ w_self.deldictvalue(space, 'starargs')
w_self.initialization_state |= 8
def Call_get_kwargs(space, w_self):
@@ -5812,6 +5818,7 @@
raise
w_self.setdictvalue(space, 'kwargs', w_new_value)
return
+ w_self.deldictvalue(space, 'kwargs')
w_self.initialization_state |= 16
_Call_field_unroller = unrolling_iterable(['func', 'args', 'keywords', 'starargs', 'kwargs'])
@@ -5863,6 +5870,7 @@
raise
w_self.setdictvalue(space, 'value', w_new_value)
return
+ w_self.deldictvalue(space, 'value')
w_self.initialization_state |= 1
_Repr_field_unroller = unrolling_iterable(['value'])
@@ -5908,6 +5916,7 @@
raise
w_self.setdictvalue(space, 'n', w_new_value)
return
+ w_self.deldictvalue(space, 'n')
w_self.initialization_state |= 1
_Num_field_unroller = unrolling_iterable(['n'])
@@ -5953,6 +5962,7 @@
raise
w_self.setdictvalue(space, 's', w_new_value)
return
+ w_self.deldictvalue(space, 's')
w_self.initialization_state |= 1
_Str_field_unroller = unrolling_iterable(['s'])
@@ -5998,6 +6008,7 @@
raise
w_self.setdictvalue(space, 'value', w_new_value)
return
+ w_self.deldictvalue(space, 'value')
w_self.initialization_state |= 1
def Attribute_get_attr(space, w_self):
@@ -6019,6 +6030,7 @@
raise
w_self.setdictvalue(space, 'attr', w_new_value)
return
+ w_self.deldictvalue(space, 'attr')
w_self.initialization_state |= 2
def Attribute_get_ctx(space, w_self):
@@ -6036,13 +6048,13 @@
try:
obj = space.interp_w(expr_context, w_new_value)
w_self.ctx = obj.to_simple_int(space)
- # need to save the original object too
- w_self.setdictvalue(space, 'ctx', w_new_value)
except OperationError, e:
if not e.match(space, space.w_TypeError):
raise
w_self.setdictvalue(space, 'ctx', w_new_value)
return
+ # need to save the original object too
+ w_self.setdictvalue(space, 'ctx', w_new_value)
w_self.initialization_state |= 4
_Attribute_field_unroller = unrolling_iterable(['value', 'attr', 'ctx'])
@@ -6090,6 +6102,7 @@
raise
w_self.setdictvalue(space, 'value', w_new_value)
return
+ w_self.deldictvalue(space, 'value')
w_self.initialization_state |= 1
def Subscript_get_slice(space, w_self):
@@ -6111,6 +6124,7 @@
raise
w_self.setdictvalue(space, 'slice', w_new_value)
return
+ w_self.deldictvalue(space, 'slice')
w_self.initialization_state |= 2
def Subscript_get_ctx(space, w_self):
@@ -6128,13 +6142,13 @@
try:
obj = space.interp_w(expr_context, w_new_value)
w_self.ctx = obj.to_simple_int(space)
- # need to save the original object too
- w_self.setdictvalue(space, 'ctx', w_new_value)
except OperationError, e:
if not e.match(space, space.w_TypeError):
raise
w_self.setdictvalue(space, 'ctx', w_new_value)
return
+ # need to save the original object too
+ w_self.setdictvalue(space, 'ctx', w_new_value)
w_self.initialization_state |= 4
_Subscript_field_unroller = unrolling_iterable(['value', 'slice', 'ctx'])
@@ -6182,6 +6196,7 @@
raise
w_self.setdictvalue(space, 'id', w_new_value)
return
+ w_self.deldictvalue(space, 'id')
w_self.initialization_state |= 1
def Name_get_ctx(space, w_self):
@@ -6199,13 +6214,13 @@
try:
obj = space.interp_w(expr_context, w_new_value)
w_self.ctx = obj.to_simple_int(space)
- # need to save the original object too
- w_self.setdictvalue(space, 'ctx', w_new_value)
except OperationError, e:
if not e.match(space, space.w_TypeError):
raise
w_self.setdictvalue(space, 'ctx', w_new_value)
return
+ # need to save the original object too
+ w_self.setdictvalue(space, 'ctx', w_new_value)
w_self.initialization_state |= 2
_Name_field_unroller = unrolling_iterable(['id', 'ctx'])
@@ -6266,13 +6281,13 @@
try:
obj = space.interp_w(expr_context, w_new_value)
w_self.ctx = obj.to_simple_int(space)
- # need to save the original object too
- w_self.setdictvalue(space, 'ctx', w_new_value)
except OperationError, e:
if not e.match(space, space.w_TypeError):
raise
w_self.setdictvalue(space, 'ctx', w_new_value)
return
+ # need to save the original object too
+ w_self.setdictvalue(space, 'ctx', w_new_value)
w_self.initialization_state |= 2
_List_field_unroller = unrolling_iterable(['elts', 'ctx'])
@@ -6334,13 +6349,13 @@
try:
obj = space.interp_w(expr_context, w_new_value)
w_self.ctx = obj.to_simple_int(space)
- # need to save the original object too
- w_self.setdictvalue(space, 'ctx', w_new_value)
except OperationError, e:
if not e.match(space, space.w_TypeError):
raise
w_self.setdictvalue(space, 'ctx', w_new_value)
return
+ # need to save the original object too
+ w_self.setdictvalue(space, 'ctx', w_new_value)
w_self.initialization_state |= 2
_Tuple_field_unroller = unrolling_iterable(['elts', 'ctx'])
@@ -6388,6 +6403,7 @@
raise
w_self.setdictvalue(space, 'value', w_new_value)
return
+ w_self.deldictvalue(space, 'value')
w_self.initialization_state |= 1
_Const_field_unroller = unrolling_iterable(['value'])
@@ -6506,6 +6522,7 @@
raise
w_self.setdictvalue(space, 'lower', w_new_value)
return
+ w_self.deldictvalue(space, 'lower')
w_self.initialization_state |= 1
def Slice_get_upper(space, w_self):
@@ -6527,6 +6544,7 @@
raise
w_self.setdictvalue(space, 'upper', w_new_value)
return
+ w_self.deldictvalue(space, 'upper')
w_self.initialization_state |= 2
def Slice_get_step(space, w_self):
@@ -6548,6 +6566,7 @@
raise
w_self.setdictvalue(space, 'step', w_new_value)
return
+ w_self.deldictvalue(space, 'step')
w_self.initialization_state |= 4
_Slice_field_unroller = unrolling_iterable(['lower', 'upper', 'step'])
@@ -6638,6 +6657,7 @@
raise
w_self.setdictvalue(space, 'value', w_new_value)
return
+ w_self.deldictvalue(space, 'value')
w_self.initialization_state |= 1
_Index_field_unroller = unrolling_iterable(['value'])
@@ -6907,6 +6927,7 @@
raise
w_self.setdictvalue(space, 'target', w_new_value)
return
+ w_self.deldictvalue(space, 'target')
w_self.initialization_state |= 1
def comprehension_get_iter(space, w_self):
@@ -6928,6 +6949,7 @@
raise
w_self.setdictvalue(space, 'iter', w_new_value)
return
+ w_self.deldictvalue(space, 'iter')
w_self.initialization_state |= 2
def comprehension_get_ifs(space, w_self):
@@ -6994,6 +7016,7 @@
raise
w_self.setdictvalue(space, 'lineno', w_new_value)
return
+ w_self.deldictvalue(space, 'lineno')
w_self.initialization_state |= w_self._lineno_mask
def excepthandler_get_col_offset(space, w_self):
@@ -7015,6 +7038,7 @@
raise
w_self.setdictvalue(space, 'col_offset', w_new_value)
return
+ w_self.deldictvalue(space, 'col_offset')
w_self.initialization_state |= w_self._col_offset_mask
excepthandler.typedef = typedef.TypeDef("excepthandler",
@@ -7045,6 +7069,7 @@
raise
w_self.setdictvalue(space, 'type', w_new_value)
return
+ w_self.deldictvalue(space, 'type')
w_self.initialization_state |= 1
def ExceptHandler_get_name(space, w_self):
@@ -7066,6 +7091,7 @@
raise
w_self.setdictvalue(space, 'name', w_new_value)
return
+ w_self.deldictvalue(space, 'name')
w_self.initialization_state |= 2
def ExceptHandler_get_body(space, w_self):
@@ -7153,6 +7179,7 @@
raise
w_self.setdictvalue(space, 'vararg', w_new_value)
return
+ w_self.deldictvalue(space, 'vararg')
w_self.initialization_state |= 2
def arguments_get_kwarg(space, w_self):
@@ -7177,6 +7204,7 @@
raise
w_self.setdictvalue(space, 'kwarg', w_new_value)
return
+ w_self.deldictvalue(space, 'kwarg')
w_self.initialization_state |= 4
def arguments_get_defaults(space, w_self):
@@ -7245,6 +7273,7 @@
raise
w_self.setdictvalue(space, 'arg', w_new_value)
return
+ w_self.deldictvalue(space, 'arg')
w_self.initialization_state |= 1
def keyword_get_value(space, w_self):
@@ -7266,6 +7295,7 @@
raise
w_self.setdictvalue(space, 'value', w_new_value)
return
+ w_self.deldictvalue(space, 'value')
w_self.initialization_state |= 2
_keyword_field_unroller = unrolling_iterable(['arg', 'value'])
@@ -7312,6 +7342,7 @@
raise
w_self.setdictvalue(space, 'name', w_new_value)
return
+ w_self.deldictvalue(space, 'name')
w_self.initialization_state |= 1
def alias_get_asname(space, w_self):
@@ -7336,6 +7367,7 @@
raise
w_self.setdictvalue(space, 'asname', w_new_value)
return
+ w_self.deldictvalue(space, 'asname')
w_self.initialization_state |= 2
_alias_field_unroller = unrolling_iterable(['name', 'asname'])
diff --git a/pypy/interpreter/astcompiler/codegen.py b/pypy/interpreter/astcompiler/codegen.py
--- a/pypy/interpreter/astcompiler/codegen.py
+++ b/pypy/interpreter/astcompiler/codegen.py
@@ -295,15 +295,11 @@
def visit_FunctionDef(self, func):
self.update_position(func.lineno, True)
# Load decorators first, but apply them after the function is created.
- if func.decorator_list:
self.visit_sequence(func.decorator_list)
args = func.args
assert isinstance(args, ast.arguments)
- if args.defaults:
self.visit_sequence(args.defaults)
- num_defaults = len(args.defaults)
- else:
- num_defaults = 0
+ num_defaults = len(args.defaults) if args.defaults is not None else 0
code = self.sub_scope(FunctionCodeGenerator, func.name, func,
func.lineno)
self._make_function(code, num_defaults)
@@ -317,24 +313,17 @@
self.update_position(lam.lineno)
args = lam.args
assert isinstance(args, ast.arguments)
- if args.defaults:
self.visit_sequence(args.defaults)
- default_count = len(args.defaults)
- else:
- default_count = 0
+ default_count = len(args.defaults) if args.defaults is not None else 0
code = self.sub_scope(LambdaCodeGenerator, "<lambda>", lam, lam.lineno)
self._make_function(code, default_count)
def visit_ClassDef(self, cls):
self.update_position(cls.lineno, True)
- if cls.decorator_list:
self.visit_sequence(cls.decorator_list)
self.load_const(self.space.wrap(cls.name))
- if cls.bases:
- bases_count = len(cls.bases)
self.visit_sequence(cls.bases)
- else:
- bases_count = 0
+ bases_count = len(cls.bases) if cls.bases is not None else 0
self.emit_op_arg(ops.BUILD_TUPLE, bases_count)
code = self.sub_scope(ClassCodeGenerator, cls.name, cls, cls.lineno)
self._make_function(code, 0)
@@ -446,7 +435,6 @@
end = self.new_block()
test_constant = if_.test.as_constant_truth(self.space)
if test_constant == optimize.CONST_FALSE:
- if if_.orelse:
self.visit_sequence(if_.orelse)
elif test_constant == optimize.CONST_TRUE:
self.visit_sequence(if_.body)
@@ -515,7 +503,6 @@
self.use_next_block(cleanup)
self.emit_op(ops.POP_BLOCK)
self.pop_frame_block(F_BLOCK_LOOP, start)
- if fr.orelse:
self.visit_sequence(fr.orelse)
self.use_next_block(end)
@@ -523,7 +510,6 @@
self.update_position(wh.lineno, True)
test_constant = wh.test.as_constant_truth(self.space)
if test_constant == optimize.CONST_FALSE:
- if wh.orelse:
self.visit_sequence(wh.orelse)
else:
end = self.new_block()
@@ -544,7 +530,6 @@
self.use_next_block(anchor)
self.emit_op(ops.POP_BLOCK)
self.pop_frame_block(F_BLOCK_LOOP, loop)
- if wh.orelse:
self.visit_sequence(wh.orelse)
self.use_next_block(end)
@@ -581,7 +566,6 @@
self.use_next_block(next_except)
self.emit_op(ops.END_FINALLY)
self.use_next_block(otherwise)
- if te.orelse:
self.visit_sequence(te.orelse)
self.use_next_block(end)
@@ -893,26 +877,18 @@
def visit_Tuple(self, tup):
self.update_position(tup.lineno)
- if tup.elts:
- elt_count = len(tup.elts)
- else:
- elt_count = 0
+ elt_count = len(tup.elts) if tup.elts is not None else 0
if tup.ctx == ast.Store:
self.emit_op_arg(ops.UNPACK_SEQUENCE, elt_count)
- if elt_count:
self.visit_sequence(tup.elts)
if tup.ctx == ast.Load:
self.emit_op_arg(ops.BUILD_TUPLE, elt_count)
def visit_List(self, l):
self.update_position(l.lineno)
- if l.elts:
- elt_count = len(l.elts)
- else:
- elt_count = 0
+ elt_count = len(l.elts) if l.elts is not None else 0
if l.ctx == ast.Store:
self.emit_op_arg(ops.UNPACK_SEQUENCE, elt_count)
- if elt_count:
self.visit_sequence(l.elts)
if l.ctx == ast.Load:
self.emit_op_arg(ops.BUILD_LIST, elt_count)
@@ -944,10 +920,8 @@
if self._optimize_method_call(call):
return
call.func.walkabout(self)
- arg = 0
+ arg = len(call.args) if call.args is not None else 0
call_type = 0
- if call.args:
- arg = len(call.args)
self.visit_sequence(call.args)
if call.keywords:
self.visit_sequence(call.keywords)
@@ -984,16 +958,10 @@
assert isinstance(attr_lookup, ast.Attribute)
attr_lookup.value.walkabout(self)
self.emit_op_name(ops.LOOKUP_METHOD, self.names, attr_lookup.attr)
- if call.args:
self.visit_sequence(call.args)
- arg_count = len(call.args)
- else:
- arg_count = 0
- if call.keywords:
+ arg_count = len(call.args) if call.args is not None else 0
self.visit_sequence(call.keywords)
- kwarg_count = len(call.keywords)
- else:
- kwarg_count = 0
+ kwarg_count = len(call.keywords) if call.keywords is not None else 0
self.emit_op_arg(ops.CALL_METHOD, (kwarg_count << 8) | arg_count)
return True
@@ -1251,7 +1219,10 @@
def _compile(self, func):
assert isinstance(func, ast.FunctionDef)
# If there's a docstring, store it as the first constant.
+ if func.body:
doc_expr = self.possible_docstring(func.body[0])
+ else:
+ doc_expr = None
if doc_expr is not None:
self.add_const(doc_expr.s)
start = 1
@@ -1263,6 +1234,7 @@
if args.args:
self._handle_nested_args(args.args)
self.argcount = len(args.args)
+ if func.body:
for i in range(start, len(func.body)):
func.body[i].walkabout(self)
diff --git a/pypy/interpreter/astcompiler/symtable.py b/pypy/interpreter/astcompiler/symtable.py
--- a/pypy/interpreter/astcompiler/symtable.py
+++ b/pypy/interpreter/astcompiler/symtable.py
@@ -356,9 +356,7 @@
# Function defaults and decorators happen in the outer scope.
args = func.args
assert isinstance(args, ast.arguments)
- if args.defaults:
self.visit_sequence(args.defaults)
- if func.decorator_list:
self.visit_sequence(func.decorator_list)
new_scope = FunctionScope(func.name, func.lineno, func.col_offset)
self.push_scope(new_scope, func)
@@ -372,9 +370,7 @@
def visit_ClassDef(self, clsdef):
self.note_symbol(clsdef.name, SYM_ASSIGNED)
- if clsdef.bases:
self.visit_sequence(clsdef.bases)
- if clsdef.decorator_list:
self.visit_sequence(clsdef.decorator_list)
self.push_scope(ClassScope(clsdef), clsdef)
self.visit_sequence(clsdef.body)
@@ -431,7 +427,6 @@
def visit_Lambda(self, lamb):
args = lamb.args
assert isinstance(args, ast.arguments)
- if args.defaults:
self.visit_sequence(args.defaults)
new_scope = FunctionScope("lambda", lamb.lineno, lamb.col_offset)
self.push_scope(new_scope, lamb)
@@ -447,7 +442,6 @@
self.push_scope(new_scope, node)
self.implicit_arg(0)
outer.target.walkabout(self)
- if outer.ifs:
self.visit_sequence(outer.ifs)
self.visit_sequence(comps[1:])
for item in list(consider):
diff --git a/pypy/interpreter/astcompiler/tools/asdl_py.py b/pypy/interpreter/astcompiler/tools/asdl_py.py
--- a/pypy/interpreter/astcompiler/tools/asdl_py.py
+++ b/pypy/interpreter/astcompiler/tools/asdl_py.py
@@ -221,8 +221,9 @@
self.emit("class ASTVisitor(object):")
self.emit("")
self.emit("def visit_sequence(self, seq):", 1)
- self.emit("for node in seq:", 2)
- self.emit("node.walkabout(self)", 3)
+ self.emit("if seq is not None:", 2)
+ self.emit("for node in seq:", 3)
+ self.emit("node.walkabout(self)", 4)
self.emit("")
self.emit("def default_visitor(self, node):", 1)
self.emit("raise NodeVisitorNotImplemented", 2)
@@ -280,15 +281,13 @@
def visitField(self, field):
if field.type.value not in asdl.builtin_types and \
field.type.value not in self.data.simple_types:
- if field.seq or field.opt:
+ level = 2
+ template = "node.%s.walkabout(self)"
+ if field.seq:
+ template = "self.visit_sequence(node.%s)"
+ elif field.opt:
self.emit("if node.%s:" % (field.name,), 2)
level = 3
- else:
- level = 2
- if field.seq:
- template = "self.visit_sequence(node.%s)"
- else:
- template = "node.%s.walkabout(self)"
self.emit(template % (field.name,), level)
return True
return False
@@ -446,6 +445,7 @@
if field.seq:
self.emit("w_self.w_%s = w_new_value" % (field.name,), 1)
else:
+ save_original_object = False
self.emit("try:", 1)
if field.type.value not in asdl.builtin_types:
# These are always other AST nodes.
@@ -454,9 +454,7 @@
(field.type,), 2)
self.emit("w_self.%s = obj.to_simple_int(space)" %
(field.name,), 2)
- self.emit("# need to save the original object too", 2)
- self.emit("w_self.setdictvalue(space, '%s', w_new_value)"
- % (field.name,), 2)
+ save_original_object = True
else:
config = (field.name, field.type, repr(field.opt))
self.emit("w_self.%s = space.interp_w(%s, w_new_value, %s)" %
@@ -480,6 +478,12 @@
self.emit(" w_self.setdictvalue(space, '%s', w_new_value)"
% (field.name,), 1)
self.emit(" return", 1)
+ if save_original_object:
+ self.emit("# need to save the original object too", 1)
+ self.emit("w_self.setdictvalue(space, '%s', w_new_value)"
+ % (field.name,), 1)
+ else:
+ self.emit("w_self.deldictvalue(space, '%s')" %(field.name,), 1)
self.emit("w_self.initialization_state |= %s" % (flag,), 1)
self.emit("")
diff --git a/pypy/interpreter/baseobjspace.py b/pypy/interpreter/baseobjspace.py
--- a/pypy/interpreter/baseobjspace.py
+++ b/pypy/interpreter/baseobjspace.py
@@ -44,11 +44,11 @@
return True
return False
- def deldictvalue(self, space, w_name):
+ def deldictvalue(self, space, attr):
w_dict = self.getdict(space)
if w_dict is not None:
try:
- space.delitem(w_dict, w_name)
+ space.delitem(w_dict, space.wrap(attr))
return True
except OperationError, ex:
if not ex.match(space, space.w_KeyError):
diff --git a/pypy/interpreter/error.py b/pypy/interpreter/error.py
--- a/pypy/interpreter/error.py
+++ b/pypy/interpreter/error.py
@@ -189,7 +189,7 @@
if space.is_w(w_value, space.w_None):
# raise Type: we assume we have to instantiate Type
w_value = space.call_function(w_type)
- w_type = space.exception_getclass(w_value)
+ w_type = self._exception_getclass(space, w_value)
else:
w_valuetype = space.exception_getclass(w_value)
if space.exception_issubclass_w(w_valuetype, w_type):
@@ -204,18 +204,12 @@
else:
# raise Type, X: assume X is the constructor argument
w_value = space.call_function(w_type, w_value)
- w_type = space.exception_getclass(w_value)
+ w_type = self._exception_getclass(space, w_value)
else:
# the only case left here is (inst, None), from a 'raise inst'.
w_inst = w_type
- w_instclass = space.exception_getclass(w_inst)
- if not space.exception_is_valid_class_w(w_instclass):
- instclassname = w_instclass.getname(space)
- msg = ("exceptions must be old-style classes or derived "
- "from BaseException, not %s")
- raise operationerrfmt(space.w_TypeError, msg, instclassname)
-
+ w_instclass = self._exception_getclass(space, w_inst)
if not space.is_w(w_value, space.w_None):
raise OperationError(space.w_TypeError,
space.wrap("instance exception may not "
@@ -226,6 +220,15 @@
self.w_type = w_type
self._w_value = w_value
+ def _exception_getclass(self, space, w_inst):
+ w_type = space.exception_getclass(w_inst)
+ if not space.exception_is_valid_class_w(w_type):
+ typename = w_type.getname(space)
+ msg = ("exceptions must be old-style classes or derived "
+ "from BaseException, not %s")
+ raise operationerrfmt(space.w_TypeError, msg, typename)
+ return w_type
+
def write_unraisable(self, space, where, w_object=None):
if w_object is None:
objrepr = ''
diff --git a/pypy/interpreter/pyopcode.py b/pypy/interpreter/pyopcode.py
--- a/pypy/interpreter/pyopcode.py
+++ b/pypy/interpreter/pyopcode.py
@@ -905,16 +905,15 @@
def SETUP_WITH(self, offsettoend, next_instr):
w_manager = self.peekvalue()
+ w_enter = self.space.lookup(w_manager, "__enter__")
w_descr = self.space.lookup(w_manager, "__exit__")
- if w_descr is None:
- raise OperationError(self.space.w_AttributeError,
- self.space.wrap("__exit__"))
+ if w_enter is None or w_descr is None:
+ typename = self.space.type(w_manager).getname(self.space)
+ raise operationerrfmt(self.space.w_AttributeError,
+ "'%s' object is not a context manager"
+ " (no __enter__/__exit__ method)", typename)
w_exit = self.space.get(w_descr, w_manager)
self.settopvalue(w_exit)
- w_enter = self.space.lookup(w_manager, "__enter__")
- if w_enter is None:
- raise OperationError(self.space.w_AttributeError,
- self.space.wrap("__enter__"))
w_result = self.space.get_and_call_function(w_enter, w_manager)
block = WithBlock(self, next_instr + offsettoend)
self.append_block(block)
diff --git a/pypy/interpreter/test/test_raise.py b/pypy/interpreter/test/test_raise.py
--- a/pypy/interpreter/test/test_raise.py
+++ b/pypy/interpreter/test/test_raise.py
@@ -274,3 +274,9 @@
pass
except A:
pass
+
+ def test_new_returns_bad_instance(self):
+ class MyException(Exception):
+ def __new__(cls, *args):
+ return object()
+ raises(TypeError, "raise MyException")
diff --git a/pypy/jit/metainterp/pyjitpl.py b/pypy/jit/metainterp/pyjitpl.py
--- a/pypy/jit/metainterp/pyjitpl.py
+++ b/pypy/jit/metainterp/pyjitpl.py
@@ -56,6 +56,8 @@
# for resume.py operation
self.parent_resumedata_snapshot = None
self.parent_resumedata_frame_info_list = None
+ # counter for unrolling inlined loops
+ self.unroll_iterations = 1
@specialize.arg(3)
def copy_constants(self, registers, constants, ConstClass):
@@ -931,6 +933,10 @@
# 'redboxes' back into the registers where it comes from.
put_back_list_of_boxes3(self, jcposition, redboxes)
else:
+ if jitdriver_sd.warmstate.should_unroll_one_iteration(greenboxes):
+ if self.unroll_iterations > 0:
+ self.unroll_iterations -= 1
+ return
# warning! careful here. We have to return from the current
# frame containing the jit_merge_point, and then use
# do_recursive_call() to follow the recursive call. This is
@@ -1162,12 +1168,10 @@
metainterp.jitdriver_sd.greenfield_info is not None):
virtualizable_boxes = metainterp.virtualizable_boxes
saved_pc = self.pc
- try:
if resumepc >= 0:
self.pc = resumepc
resume.capture_resumedata(metainterp.framestack, virtualizable_boxes,
metainterp.virtualref_boxes, resumedescr)
- finally:
self.pc = saved_pc
def implement_guard_value(self, orgpc, box):
diff --git a/pypy/jit/metainterp/test/test_ajit.py b/pypy/jit/metainterp/test/test_ajit.py
--- a/pypy/jit/metainterp/test/test_ajit.py
+++ b/pypy/jit/metainterp/test/test_ajit.py
@@ -508,6 +508,32 @@
assert res == 84 - 61 - 62
self.check_history(call=1) # because the trace starts immediately
+ def test_unroll_one_loop_iteration(self):
+ def unroll(code):
+ return code == 0
+ myjitdriver = JitDriver(greens = ['code'],
+ reds = ['loops', 'inner_loops', 's'],
+ should_unroll_one_iteration=unroll)
+
+ def f(code, loops, inner_loops):
+ s = 0
+ while loops > 0:
+ myjitdriver.jit_merge_point(code=code, loops=loops,
+ inner_loops=inner_loops, s=s)
+ if code == 1:
+ s += f(0, inner_loops, 0)
+ loops -= 1
+ s += 1
+ return s
+
+ res = self.meta_interp(f, [1, 4, 1], enable_opts="", inline=True)
+ assert res == f(1, 4, 1)
+ self.check_history(call_assembler=0)
+
+ res = self.meta_interp(f, [1, 4, 2], enable_opts="", inline=True)
+ assert res == f(1, 4, 2)
+ self.check_history(call_assembler=1)
+
def test_format(self):
def f(n):
return len("<%d>" % n)
diff --git a/pypy/jit/metainterp/warmspot.py b/pypy/jit/metainterp/warmspot.py
--- a/pypy/jit/metainterp/warmspot.py
+++ b/pypy/jit/metainterp/warmspot.py
@@ -468,6 +468,9 @@
onlygreens=False)
jd._can_never_inline_ptr = self._make_hook_graph(jd,
annhelper, jd.jitdriver.can_never_inline, annmodel.s_Bool)
+ jd._should_unroll_one_iteration_ptr = self._make_hook_graph(jd,
+ annhelper, jd.jitdriver.should_unroll_one_iteration,
+ annmodel.s_Bool)
annhelper.finish()
def _make_hook_graph(self, jitdriver_sd, annhelper, func,
diff --git a/pypy/jit/metainterp/warmstate.py b/pypy/jit/metainterp/warmstate.py
--- a/pypy/jit/metainterp/warmstate.py
+++ b/pypy/jit/metainterp/warmstate.py
@@ -572,6 +572,19 @@
return can_inline_greenargs(*greenargs)
self.can_inline_greenargs = can_inline_greenargs
self.can_inline_callable = can_inline_callable
+
+ if jd._should_unroll_one_iteration_ptr is None:
+ def should_unroll_one_iteration(greenkey):
+ return False
+ else:
+ rtyper = self.warmrunnerdesc.rtyper
+ inline_ptr = jd._should_unroll_one_iteration_ptr
+ def should_unroll_one_iteration(greenkey):
+ greenargs = unwrap_greenkey(greenkey)
+ fn = support.maybe_on_top_of_llinterp(rtyper, inline_ptr)
+ return fn(*greenargs)
+ self.should_unroll_one_iteration = should_unroll_one_iteration
+
if hasattr(jd.jitdriver, 'on_compile'):
def on_compile(logger, token, operations, type, greenkey):
greenargs = unwrap_greenkey(greenkey)
diff --git a/pypy/module/__builtin__/interp_classobj.py b/pypy/module/__builtin__/interp_classobj.py
--- a/pypy/module/__builtin__/interp_classobj.py
+++ b/pypy/module/__builtin__/interp_classobj.py
@@ -418,7 +418,7 @@
if w_meth is not None:
space.call_function(w_meth, w_name)
else:
- if not self.deldictvalue(space, w_name):
+ if not self.deldictvalue(space, name):
raise operationerrfmt(
space.w_AttributeError,
"%s instance has no attribute '%s'",
diff --git a/pypy/module/_ast/test/test_ast.py b/pypy/module/_ast/test/test_ast.py
--- a/pypy/module/_ast/test/test_ast.py
+++ b/pypy/module/_ast/test/test_ast.py
@@ -250,3 +250,38 @@
assert x.left == n1
assert x.op == addop
assert x.right == n3
+
+ def test_functiondef(self):
+ import _ast as ast
+ fAst = ast.FunctionDef(
+ name="foo",
+ args=ast.arguments(
+ args=[], vararg=None, kwarg=None, defaults=[],
+ kwonlyargs=[], kw_defaults=[]),
+ body=[], decorator_list=[], lineno=5, col_offset=0)
+ exprAst = ast.Interactive(body=[fAst])
+ compiled = compile(exprAst, "<foo>", "single")
+ #
+ d = {}
+ eval(compiled, d, d)
+ assert type(d['foo']) is type(lambda: 42)
+ assert d['foo']() is None
+
+ def test_missing_name(self):
+ import _ast as ast
+ n = ast.FunctionDef(name=None)
+ n.name = "foo"
+ n.name = "foo"
+ n.name = "foo"
+ assert n.name == "foo"
+
+ def test_issue793(self):
+ import _ast as ast
+ body = ast.Module([
+ ast.TryExcept([ast.Pass(lineno=2, col_offset=4)],
+ [ast.ExceptHandler(ast.Name('Exception', ast.Load(),
+ lineno=3, col_offset=0),
+ None, [], lineno=4, col_offset=0)],
+ [], lineno=1, col_offset=0)
+ ])
+ exec compile(body, '<string>', 'exec')
diff --git a/pypy/module/itertools/interp_itertools.py b/pypy/module/itertools/interp_itertools.py
--- a/pypy/module/itertools/interp_itertools.py
+++ b/pypy/module/itertools/interp_itertools.py
@@ -379,16 +379,23 @@
self.start = -1
else: # all following calls
consume = self.step
+ if consume > 1:
+ self._ignore_items(consume-1)
if self.stop >= 0:
if self.stop < consume:
+ self.stop = 0 # reset the state so that a following next_w()
+ self.step = 1 # has no effect any more
raise OperationError(self.space.w_StopIteration,
self.space.w_None)
self.stop -= consume
+ return self.space.next(self.iterable)
+
+ def _ignore_items(self, num):
while True:
- w_obj = self.space.next(self.iterable)
- consume -= 1
- if consume <= 0:
- return w_obj
+ self.space.next(self.iterable)
+ num -= 1
+ if num <= 0:
+ break
def W_ISlice___new__(space, w_subtype, w_iterable, w_startstop, args_w):
r = space.allocate_instance(W_ISlice, w_subtype)
diff --git a/pypy/module/itertools/test/test_itertools.py b/pypy/module/itertools/test/test_itertools.py
--- a/pypy/module/itertools/test/test_itertools.py
+++ b/pypy/module/itertools/test/test_itertools.py
@@ -227,6 +227,45 @@
assert list(itertools.islice(xrange(10), None,None)) == range(10)
assert list(itertools.islice(xrange(10), None,None,None)) == range(10)
+ def test_islice_dropitems_exact(self):
+ import itertools
+
+ it = iter("abcdefghij")
+ itertools.islice(it, 2, 2) # doesn't eagerly drop anything
+ assert it.next() == "a"
+ itertools.islice(it, 3, 8, 2) # doesn't eagerly drop anything
+ assert it.next() == "b"
+ assert it.next() == "c"
+
+ it = iter("abcdefghij")
+ x = next(itertools.islice(it, 2, 3), None) # drops 2 items
+ assert x == "c"
+ assert it.next() == "d"
+
+ it = iter("abcdefghij")
+ x = next(itertools.islice(it, 3, 8, 2), None) # drops 3 items
+ assert x == "d"
+ assert it.next() == "e"
+
+ it = iter("abcdefghij")
+ x = next(itertools.islice(it, None, 8), None) # drops 0 items
+ assert x == "a"
+ assert it.next() == "b"
+
+ it = iter("abcdefghij")
+ x = next(itertools.islice(it, 3, 2), None) # drops 3 items
+ assert x is None
+ assert it.next() == "d"
+
+ it = iter("abcdefghij")
+ islc = itertools.islice(it, 3, 7, 2)
+ assert islc.next() == "d" # drops 0, 1, 2, returns item #3
+ assert it.next() == "e"
+ assert islc.next() == "g" # drops the 4th and return item #5
+ assert it.next() == "h"
+ raises(StopIteration, islc.next) # drops the 6th and raise
+ assert it.next() == "j"
+
def test_islice_overflow(self):
import itertools
import sys
diff --git a/pypy/module/pypyjit/interp_jit.py b/pypy/module/pypyjit/interp_jit.py
--- a/pypy/module/pypyjit/interp_jit.py
+++ b/pypy/module/pypyjit/interp_jit.py
@@ -44,9 +44,11 @@
ec.w_tracefunc is None)
def can_never_inline(next_instr, is_being_profiled, bytecode):
+ return False
+
+def should_unroll_one_iteration(next_instr, is_being_profiled, bytecode):
return (bytecode.co_flags & CO_GENERATOR) != 0
-
def wrap_oplist(space, logops, operations):
list_w = []
for op in operations:
@@ -110,7 +112,9 @@
get_jitcell_at = get_jitcell_at,
set_jitcell_at = set_jitcell_at,
confirm_enter_jit = confirm_enter_jit,
- can_never_inline = can_never_inline)
+ can_never_inline = can_never_inline,
+ should_unroll_one_iteration =
+ should_unroll_one_iteration)
class __extend__(PyFrame):
diff --git a/pypy/module/pypyjit/test_pypy_c/test_generators.py b/pypy/module/pypyjit/test_pypy_c/test_generators.py
new file mode 100644
--- /dev/null
+++ b/pypy/module/pypyjit/test_pypy_c/test_generators.py
@@ -0,0 +1,25 @@
+from pypy.module.pypyjit.test_pypy_c.test_00_model import BaseTestPyPyC
+
+
+class TestGenerators(BaseTestPyPyC):
+ def test_simple_generator(self):
+ def main(n):
+ def f():
+ for i in range(10000):
+ yield i
+
+ def g():
+ for i in f(): # ID: generator
+ pass
+
+ g()
+
+ log = self.run(main, [500])
+ loop, = log.loops_by_filename(self.filepath)
+ assert loop.match_by_id("generator", """
+ i16 = force_token()
+ p45 = new_with_vtable(ConstClass(W_IntObject))
+ setfield_gc(p45, i29, descr=<SignedFieldDescr .*>)
+ setarrayitem_gc(p8, 0, p45, descr=<GcPtrArrayDescr>)
+ jump(..., descr=...)
+ """)
diff --git a/pypy/objspace/descroperation.py b/pypy/objspace/descroperation.py
--- a/pypy/objspace/descroperation.py
+++ b/pypy/objspace/descroperation.py
@@ -96,7 +96,7 @@
if space.is_data_descr(w_descr):
space.delete(w_descr, w_obj)
return
- if w_obj.deldictvalue(space, w_name):
+ if w_obj.deldictvalue(space, name):
return
raiseattrerror(space, w_obj, name, w_descr)
diff --git a/pypy/objspace/std/dictproxyobject.py b/pypy/objspace/std/dictproxyobject.py
--- a/pypy/objspace/std/dictproxyobject.py
+++ b/pypy/objspace/std/dictproxyobject.py
@@ -61,7 +61,8 @@
space = self.space
w_key_type = space.type(w_key)
if space.is_w(w_key_type, space.w_str):
- if not self.unerase(w_dict.dstorage).deldictvalue(space, w_key):
+ key = self.space.str_w(w_key)
+ if not self.unerase(w_dict.dstorage).deldictvalue(space, key):
raise KeyError
else:
raise KeyError
diff --git a/pypy/objspace/std/mapdict.py b/pypy/objspace/std/mapdict.py
--- a/pypy/objspace/std/mapdict.py
+++ b/pypy/objspace/std/mapdict.py
@@ -369,8 +369,7 @@
def setdictvalue(self, space, attrname, w_value):
return self._get_mapdict_map().write(self, (attrname, DICT), w_value)
- def deldictvalue(self, space, w_name):
- attrname = space.str_w(w_name)
+ def deldictvalue(self, space, attrname):
new_obj = self._get_mapdict_map().delete(self, (attrname, DICT))
if new_obj is None:
return False
@@ -647,7 +646,8 @@
w_key_type = space.type(w_key)
w_obj = self.unerase(w_dict.dstorage)
if space.is_w(w_key_type, space.w_str):
- flag = w_obj.deldictvalue(space, w_key)
+ key = self.space.str_w(w_key)
+ flag = w_obj.deldictvalue(space, key)
if not flag:
raise KeyError
elif _never_equal_to_string(space, w_key_type):
diff --git a/pypy/objspace/std/proxyobject.py b/pypy/objspace/std/proxyobject.py
--- a/pypy/objspace/std/proxyobject.py
+++ b/pypy/objspace/std/proxyobject.py
@@ -52,10 +52,10 @@
raise
return False
- def deldictvalue(self, space, w_attr):
+ def deldictvalue(self, space, attr):
try:
space.call_function(self.w_controller, space.wrap('__delattr__'),
- w_attr)
+ space.wrap(attr))
return True
except OperationError, e:
if not e.match(space, space.w_AttributeError):
diff --git a/pypy/objspace/std/typeobject.py b/pypy/objspace/std/typeobject.py
--- a/pypy/objspace/std/typeobject.py
+++ b/pypy/objspace/std/typeobject.py
@@ -313,10 +313,9 @@
w_self.dict_w[name] = w_value
return True
- def deldictvalue(w_self, space, w_key):
+ def deldictvalue(w_self, space, key):
if w_self.lazyloaders:
w_self._freeze_() # force un-lazification
- key = space.str_w(w_key)
if (not space.config.objspace.std.mutable_builtintypes
and not w_self.is_heaptype()):
msg = "can't delete attributes on type object '%s'"
diff --git a/pypy/objspace/std/typetype.py b/pypy/objspace/std/typetype.py
--- a/pypy/objspace/std/typetype.py
+++ b/pypy/objspace/std/typetype.py
@@ -226,7 +226,7 @@
def descr_del___abstractmethods__(space, w_type):
w_type = _check(space, w_type)
- if not w_type.deldictvalue(space, space.wrap("__abstractmethods__")):
+ if not w_type.deldictvalue(space, "__abstractmethods__"):
raise OperationError(space.w_AttributeError,
space.wrap("__abstractmethods__"))
w_type.set_abstract(False)
diff --git a/pypy/rlib/jit.py b/pypy/rlib/jit.py
--- a/pypy/rlib/jit.py
+++ b/pypy/rlib/jit.py
@@ -315,7 +315,7 @@
def __init__(self, greens=None, reds=None, virtualizables=None,
get_jitcell_at=None, set_jitcell_at=None,
get_printable_location=None, confirm_enter_jit=None,
- can_never_inline=None):
+ can_never_inline=None, should_unroll_one_iteration=None):
if greens is not None:
self.greens = greens
if reds is not None:
@@ -334,6 +334,7 @@
self.get_printable_location = get_printable_location
self.confirm_enter_jit = confirm_enter_jit
self.can_never_inline = can_never_inline
+ self.should_unroll_one_iteration = should_unroll_one_iteration
def _freeze_(self):
return True
diff --git a/pypy/rlib/rbigint.py b/pypy/rlib/rbigint.py
--- a/pypy/rlib/rbigint.py
+++ b/pypy/rlib/rbigint.py
@@ -40,7 +40,7 @@
# In that case, do 5 bits at a time. The potential drawback is that
# a table of 2**5 intermediate results is computed.
-FIVEARY_CUTOFF = 8
+## FIVEARY_CUTOFF = 8 disabled for now
def _mask_digit(x):
@@ -456,7 +456,7 @@
# python adaptation: moved macros REDUCE(X) and MULT(X, Y, result)
# into helper function result = _help_mult(x, y, c)
- if b.numdigits() <= FIVEARY_CUTOFF:
+ if 1: ## b.numdigits() <= FIVEARY_CUTOFF:
# Left-to-right binary exponentiation (HAC Algorithm 14.79)
# http://www.cacr.math.uwaterloo.ca/hac/about/chap14.pdf
i = b.numdigits() - 1
@@ -469,26 +469,30 @@
z = _help_mult(z, a, c)
j >>= 1
i -= 1
- else:
- # Left-to-right 5-ary exponentiation (HAC Algorithm 14.82)
- # This is only useful in the case where c != None.
- # z still holds 1L
- table = [z] * 32
- table[0] = z
- for i in range(1, 32):
- table[i] = _help_mult(table[i-1], a, c)
- i = b.numdigits() - 1
- while i >= 0:
- bi = b.digit(i)
- j = SHIFT - 5
- while j >= 0:
- index = (bi >> j) & 0x1f
- for k in range(5):
- z = _help_mult(z, z, c)
- if index:
- z = _help_mult(z, table[index], c)
- j -= 5
- i -= 1
+## else:
+## This code is disabled for now, because it assumes that
+## SHIFT is a multiple of 5. It could be fixed but it looks
+## like it's more troubles than benefits...
+##
+## # Left-to-right 5-ary exponentiation (HAC Algorithm 14.82)
+## # This is only useful in the case where c != None.
+## # z still holds 1L
+## table = [z] * 32
+## table[0] = z
+## for i in range(1, 32):
+## table[i] = _help_mult(table[i-1], a, c)
+## i = b.numdigits() - 1
+## while i >= 0:
+## bi = b.digit(i)
+## j = SHIFT - 5
+## while j >= 0:
+## index = (bi >> j) & 0x1f
+## for k in range(5):
+## z = _help_mult(z, z, c)
+## if index:
+## z = _help_mult(z, table[index], c)
+## j -= 5
+## i -= 1
if negativeOutput and z.sign != 0:
z = z.sub(c)
diff --git a/pypy/rlib/test/test_rbigint.py b/pypy/rlib/test/test_rbigint.py
--- a/pypy/rlib/test/test_rbigint.py
+++ b/pypy/rlib/test/test_rbigint.py
@@ -373,6 +373,13 @@
print '--->', v
assert v.tolong() == pow(x, y, z)
+ def test_pow_lll_bug(self):
+ two = rbigint.fromint(2)
+ t = rbigint.fromlong(2655689964083835493447941032762343136647965588635159615997220691002017799304)
+ for n, expected in [(37, 9), (1291, 931), (67889, 39464)]:
+ v = two.pow(t, rbigint.fromint(n))
+ assert v.toint() == expected
+
def test_pow_lln(self):
x = 10L
y = 2L
diff --git a/pypy/rpython/lltypesystem/rdict.py b/pypy/rpython/lltypesystem/rdict.py
--- a/pypy/rpython/lltypesystem/rdict.py
+++ b/pypy/rpython/lltypesystem/rdict.py
@@ -501,9 +501,6 @@
ENTRY = ENTRIES.OF
entry = d.entries[i]
if ENTRIES.must_clear_key:
- key = entry.key # careful about destructor side effects:
- # keep key alive until entry.value has also
- # been zeroed (if it must be)
entry.key = lltype.nullptr(ENTRY.key.TO)
if ENTRIES.must_clear_value:
entry.value = lltype.nullptr(ENTRY.value.TO)
diff --git a/pypy/rpython/memory/gc/minimark.py b/pypy/rpython/memory/gc/minimark.py
--- a/pypy/rpython/memory/gc/minimark.py
+++ b/pypy/rpython/memory/gc/minimark.py
@@ -256,12 +256,15 @@
# (may) contain a pointer to a young object. Populated by
# the write barrier: when we clear GCFLAG_TRACK_YOUNG_PTRS, we
# add it to this list.
- self.objects_pointing_to_young = self.AddressStack()
+ # Note that young array objects may (by temporary "mistake") be added
+ # to this list, but will be removed again at the start of the next
+ # minor collection.
+ self.old_objects_pointing_to_young = self.AddressStack()
#
- # Similar to 'objects_pointing_to_young', but lists objects
+ # Similar to 'old_objects_pointing_to_young', but lists objects
# that have the GCFLAG_CARDS_SET bit. For large arrays. Note
# that it is possible for an object to be listed both in here
- # and in 'objects_pointing_to_young', in which case we
+ # and in 'old_objects_pointing_to_young', in which case we
# should just clear the cards and trace it fully, as usual.
# Note also that young array objects are never listed here.
self.old_objects_with_cards_set = self.AddressStack()
@@ -979,12 +982,12 @@
# If it seems that what we are writing is a pointer to a young obj
# (as checked with appears_to_be_young()), then we need
# to remove the flag GCFLAG_TRACK_YOUNG_PTRS and add the object
- # to the list 'objects_pointing_to_young'. We know that
+ # to the list 'old_objects_pointing_to_young'. We know that
# 'addr_struct' cannot be in the nursery, because nursery objects
# never have the flag GCFLAG_TRACK_YOUNG_PTRS to start with.
objhdr = self.header(addr_struct)
if self.appears_to_be_young(newvalue):
- self.objects_pointing_to_young.append(addr_struct)
+ self.old_objects_pointing_to_young.append(addr_struct)
objhdr.tid &= ~GCFLAG_TRACK_YOUNG_PTRS
#
# Second part: if 'addr_struct' is actually a prebuilt GC
@@ -1019,7 +1022,7 @@
"young array with no card but GCFLAG_TRACK_YOUNG_PTRS")
#
# no cards, use default logic. Mostly copied from above.
- self.objects_pointing_to_young.append(addr_array)
+ self.old_objects_pointing_to_young.append(addr_array)
objhdr.tid &= ~GCFLAG_TRACK_YOUNG_PTRS
if objhdr.tid & GCFLAG_NO_HEAP_PTRS:
objhdr.tid &= ~GCFLAG_NO_HEAP_PTRS
@@ -1100,7 +1103,7 @@
"young array with no card but GCFLAG_TRACK_YOUNG_PTRS")
#
if self.appears_to_be_young(newvalue):
- self.objects_pointing_to_young.append(addr_array)
+ self.old_objects_pointing_to_young.append(addr_array)
objhdr.tid &= ~GCFLAG_TRACK_YOUNG_PTRS
remember_young_pointer_from_array3._dont_inline_ = True
@@ -1120,7 +1123,7 @@
"""
objhdr = self.header(addr_struct)
if objhdr.tid & GCFLAG_TRACK_YOUNG_PTRS:
- self.objects_pointing_to_young.append(addr_struct)
+ self.old_objects_pointing_to_young.append(addr_struct)
objhdr.tid &= ~GCFLAG_TRACK_YOUNG_PTRS
#
if objhdr.tid & GCFLAG_NO_HEAP_PTRS:
@@ -1164,7 +1167,7 @@
#
if source_hdr.tid & GCFLAG_TRACK_YOUNG_PTRS == 0:
# there might be in source a pointer to a young object
- self.objects_pointing_to_young.append(dest_addr)
+ self.old_objects_pointing_to_young.append(dest_addr)
dest_hdr.tid &= ~GCFLAG_TRACK_YOUNG_PTRS
#
if dest_hdr.tid & GCFLAG_NO_HEAP_PTRS:
@@ -1202,13 +1205,18 @@
#
debug_start("gc-minor")
#
+ # Before everything else, remove from 'old_objects_pointing_to_young'
+ # the young arrays.
+ if self.young_rawmalloced_objects:
+ self.remove_young_arrays_from_old_objects_pointing_to_young()
+ #
# First, find the roots that point to young objects. All nursery
# objects found are copied out of the nursery, and the occasional
# young raw-malloced object is flagged with GCFLAG_VISITED.
# Note that during this step, we ignore references to further
# young objects; only objects directly referenced by roots
# are copied out or flagged. They are also added to the list
- # 'objects_pointing_to_young'.
+ # 'old_objects_pointing_to_young'.
self.collect_roots_in_nursery()
#
while True:
@@ -1217,11 +1225,11 @@
if self.card_page_indices > 0:
self.collect_cardrefs_to_nursery()
#
- # Now trace objects from 'objects_pointing_to_young'.
+ # Now trace objects from 'old_objects_pointing_to_young'.
# All nursery objects they reference are copied out of the
- # nursery, and again added to 'objects_pointing_to_young'.
- # All young raw-malloced object found is flagged GCFLAG_VISITED.
- # We proceed until 'objects_pointing_to_young' is empty.
+ # nursery, and again added to 'old_objects_pointing_to_young'.
+ # All young raw-malloced object found are flagged GCFLAG_VISITED.
+ # We proceed until 'old_objects_pointing_to_young' is empty.
self.collect_oldrefs_to_nursery()
#
# We have to loop back if collect_oldrefs_to_nursery caused
@@ -1262,7 +1270,7 @@
# we don't need to trace prebuilt GcStructs during a minor collect:
# if a prebuilt GcStruct contains a pointer to a young object,
# then the write_barrier must have ensured that the prebuilt
- # GcStruct is in the list self.objects_pointing_to_young.
+ # GcStruct is in the list self.old_objects_pointing_to_young.
self.root_walker.walk_roots(
MiniMarkGC._trace_drag_out1, # stack roots
MiniMarkGC._trace_drag_out1, # static in prebuilt non-gc
@@ -1287,7 +1295,7 @@
p = llarena.getfakearenaaddress(obj - size_gc_header)
#
# If the object doesn't have GCFLAG_TRACK_YOUNG_PTRS, then it
- # means that it is in 'objects_pointing_to_young' and
+ # means that it is in 'old_objects_pointing_to_young' and
# will be fully traced by collect_oldrefs_to_nursery() just
# afterwards.
if self.header(obj).tid & GCFLAG_TRACK_YOUNG_PTRS == 0:
@@ -1326,22 +1334,17 @@
def collect_oldrefs_to_nursery(self):
- # Follow the objects_pointing_to_young list and move the
+ # Follow the old_objects_pointing_to_young list and move the
# young objects they point to out of the nursery.
- oldlist = self.objects_pointing_to_young
+ oldlist = self.old_objects_pointing_to_young
while oldlist.non_empty():
obj = oldlist.pop()
#
- # Check (somehow) that the flags are correct: we must not have
- # GCFLAG_TRACK_YOUNG_PTRS so far. But in a rare case, it's
- # possible that the same obj is appended twice to the list
- # (see _trace_drag_out, GCFLAG_VISITED case). Filter it out
- # here.
- if self.header(obj).tid & GCFLAG_TRACK_YOUNG_PTRS != 0:
- ll_assert(self.header(obj).tid & GCFLAG_VISITED != 0,
- "objects_pointing_to_young contains obj with "
- "GCFLAG_TRACK_YOUNG_PTRS and not GCFLAG_VISITED")
- continue
+ # Check that the flags are correct: we must not have
+ # GCFLAG_TRACK_YOUNG_PTRS so far.
+ ll_assert(self.header(obj).tid & GCFLAG_TRACK_YOUNG_PTRS == 0,
+ "old_objects_pointing_to_young contains obj with "
+ "GCFLAG_TRACK_YOUNG_PTRS")
#
# Add the flag GCFLAG_TRACK_YOUNG_PTRS. All live objects should
# have this flag set after a nursery collection.
@@ -1349,7 +1352,7 @@
#
# Trace the 'obj' to replace pointers to nursery with pointers
# outside the nursery, possibly forcing nursery objects out
- # and adding them to 'objects_pointing_to_young' as well.
+ # and adding them to 'old_objects_pointing_to_young' as well.
self.trace_and_drag_out_of_nursery(obj)
def trace_and_drag_out_of_nursery(self, obj):
@@ -1432,11 +1435,11 @@
# Change the original pointer to this object.
root.address[0] = newobj
#
- # Add the newobj to the list 'objects_pointing_to_young',
+ # Add the newobj to the list 'old_objects_pointing_to_young',
# because it can contain further pointers to other young objects.
# We will fix such references to point to the copy of the young
- # objects when we walk 'objects_pointing_to_young'.
- self.objects_pointing_to_young.append(newobj)
+ # objects when we walk 'old_objects_pointing_to_young'.
+ self.old_objects_pointing_to_young.append(newobj)
def _visit_young_rawmalloced_object(self, obj):
# 'obj' points to a young, raw-malloced object.
@@ -1451,33 +1454,20 @@
return
hdr.tid |= GCFLAG_VISITED
#
- # we just made 'obj' old, so we need to add it to the correct
- # lists. (Note that another point of view on the longish
- # comments below is that we are not changing any flags in 'hdr',
- # but just restoring invariants: the object may be missing from
- # these lists as long as it is a young array, but not when it
- # grows old.)
- anywhere = False
+ # we just made 'obj' old, so we need to add it to the correct lists
+ added_somewhere = False
#
if hdr.tid & GCFLAG_TRACK_YOUNG_PTRS == 0:
- # common case: GCFLAG_TRACK_YOUNG_PTRS is not set, so
- # the object may contain young pointers anywhere
- self.objects_pointing_to_young.append(obj)
- anywhere = True
+ self.old_objects_pointing_to_young.append(obj)
+ added_somewhere = True
#
if hdr.tid & GCFLAG_HAS_CARDS != 0:
- # large array case: the object contains card marks
- # that tell us where young pointers are, and it must
- # be added to 'old_objects_with_cards_set'. Note that
- # we must add it even if we also added it just above to
- # 'objects_pointing_to_young', because the object header
- # needs to be cleaned up.
ll_assert(hdr.tid & GCFLAG_CARDS_SET != 0,
"young array: GCFLAG_HAS_CARDS without GCFLAG_CARDS_SET")
self.old_objects_with_cards_set.append(obj)
- anywhere = True
+ added_somewhere = True
#
- ll_assert(anywhere, "wrong flag combination on young array")
+ ll_assert(added_somewhere, "wrong flag combination on young array")
def _malloc_out_of_nursery(self, totalsize):
@@ -1517,6 +1507,18 @@
# and survives. Otherwise, it dies.
self.free_rawmalloced_object_if_unvisited(obj)
+ def remove_young_arrays_from_old_objects_pointing_to_young(self):
+ old = self.old_objects_pointing_to_young
+ new = self.AddressStack()
+ while old.non_empty():
+ obj = old.pop()
+ if not self.young_rawmalloced_objects.contains(obj):
+ new.append(obj)
+ # an extra copy, to avoid assignments to
+ # 'self.old_objects_pointing_to_young'
+ while new.non_empty():
+ old.append(new.pop())
+ new.delete()
# ----------
# Full collection
More information about the pypy-commit
mailing list