[pypy-svn] r21146 - pypy/dist/pypy/interpreter/astcompiler
adim at codespeak.net
adim at codespeak.net
Tue Dec 13 22:14:15 CET 2005
Author: adim
Date: Tue Dec 13 22:14:14 2005
New Revision: 21146
Modified:
pypy/dist/pypy/interpreter/astcompiler/ast.py
pypy/dist/pypy/interpreter/astcompiler/ast.txt
pypy/dist/pypy/interpreter/astcompiler/astgen.py
Log:
export __new__ methods to be able to create AST nodes at applevel.
Thanks a lot to Armin who helped me to find out why PyPy refused
to compile.
Modified: pypy/dist/pypy/interpreter/astcompiler/ast.py
==============================================================================
--- pypy/dist/pypy/interpreter/astcompiler/ast.py (original)
+++ pypy/dist/pypy/interpreter/astcompiler/ast.py Tue Dec 13 22:14:14 2005
@@ -5,7 +5,7 @@
"""
from consts import CO_VARARGS, CO_VARKEYWORDS, OP_ASSIGN
from pypy.interpreter.baseobjspace import Wrappable
-from pypy.interpreter.typedef import TypeDef, GetSetProperty
+from pypy.interpreter.typedef import TypeDef, GetSetProperty, interp_attrproperty
from pypy.interpreter.gateway import interp2app, W_Root, ObjSpace
from pypy.interpreter.argument import Arguments
from pypy.interpreter.error import OperationError
@@ -69,10 +69,18 @@
args = Arguments(space, [ w_self ])
return space.call_args( w_callable, args )
+def descr_Node_new(space, w_subtype, lineno=-1):
+ node = space.allocate_instance(Node, w_subtype)
+ node.lineno = lineno
+ return space.wrap(node)
+
Node.typedef = TypeDef('ASTNode',
+ __new__ = interp2app(descr_Node_new, unwrap_spec=[ObjSpace, W_Root, int]),
#__repr__ = interp2app(descr_node_repr, unwrap_spec=['self', ObjSpace] ),
getChildNodes = interp2app(Node.descr_getChildNodes, unwrap_spec=[ 'self', ObjSpace ] ),
accept = interp2app(descr_node_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ lineno = interp_attrproperty('lineno', cls=Node),
+ filename = interp_attrproperty('filename', cls=Node),
)
@@ -119,13 +127,19 @@
return visitor.visitAbstractFunction(self)
+def descr_AbstractFunction_new(space, w_subtype, lineno=-1):
+ self = space.allocate_instance(AbstractFunction, w_subtype)
+ self.lineno = lineno
+ return space.wrap(self)
+
def descr_AbstractFunction_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitAbstractFunction'))
args = Arguments(space, [ w_self ])
return space.call_args(w_callable, args)
AbstractFunction.typedef = TypeDef('AbstractFunction', Node.typedef,
- accept=interp2app(descr_AbstractFunction_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ __new__ = interp2app(descr_AbstractFunction_new, unwrap_spec=[ObjSpace, W_Root, int]),
+ accept=interp2app(descr_AbstractFunction_accept, unwrap_spec=[ObjSpace, W_Root, W_Root] ),
)
class AbstractTest(Node):
@@ -146,13 +160,19 @@
return visitor.visitAbstractTest(self)
+def descr_AbstractTest_new(space, w_subtype, lineno=-1):
+ self = space.allocate_instance(AbstractTest, w_subtype)
+ self.lineno = lineno
+ return space.wrap(self)
+
def descr_AbstractTest_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitAbstractTest'))
args = Arguments(space, [ w_self ])
return space.call_args(w_callable, args)
AbstractTest.typedef = TypeDef('AbstractTest', Node.typedef,
- accept=interp2app(descr_AbstractTest_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ __new__ = interp2app(descr_AbstractTest_new, unwrap_spec=[ObjSpace, W_Root, int]),
+ accept=interp2app(descr_AbstractTest_accept, unwrap_spec=[ObjSpace, W_Root, W_Root] ),
)
class BinaryOp(Node):
@@ -173,13 +193,19 @@
return visitor.visitBinaryOp(self)
+def descr_BinaryOp_new(space, w_subtype, lineno=-1):
+ self = space.allocate_instance(BinaryOp, w_subtype)
+ self.lineno = lineno
+ return space.wrap(self)
+
def descr_BinaryOp_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitBinaryOp'))
args = Arguments(space, [ w_self ])
return space.call_args(w_callable, args)
BinaryOp.typedef = TypeDef('BinaryOp', Node.typedef,
- accept=interp2app(descr_BinaryOp_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ __new__ = interp2app(descr_BinaryOp_new, unwrap_spec=[ObjSpace, W_Root, int]),
+ accept=interp2app(descr_BinaryOp_accept, unwrap_spec=[ObjSpace, W_Root, W_Root] ),
)
class Add(BinaryOp):
@@ -204,17 +230,20 @@
def fget_left( space, self):
return space.wrap(self.left)
def fset_left( space, self, w_arg):
- obj = space.interpclass_w( w_arg )
- if not isinstance( obj, Node):
- raise OperationError(space.w_TypeError,space.wrap('Need a Node instance'))
- self.left = obj
+ self.left = space.interp_w(Node, w_arg, can_be_None=False)
def fget_right( space, self):
return space.wrap(self.right)
def fset_right( space, self, w_arg):
- obj = space.interpclass_w( w_arg )
- if not isinstance( obj, Node):
- raise OperationError(space.w_TypeError,space.wrap('Need a Node instance'))
- self.right = obj
+ self.right = space.interp_w(Node, w_arg, can_be_None=False)
+
+def descr_Add_new(space, w_subtype, w_left, w_right, lineno=-1):
+ self = space.allocate_instance(Add, w_subtype)
+ left = space.interp_w(Node, w_left, can_be_None=False)
+ self.left = left
+ right = space.interp_w(Node, w_right, can_be_None=False)
+ self.right = right
+ self.lineno = lineno
+ return space.wrap(self)
def descr_Add_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitAdd'))
@@ -222,7 +251,8 @@
return space.call_args(w_callable, args)
Add.typedef = TypeDef('Add', BinaryOp.typedef,
- accept=interp2app(descr_Add_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ __new__ = interp2app(descr_Add_new, unwrap_spec=[ObjSpace, W_Root, W_Root, W_Root, int]),
+ accept=interp2app(descr_Add_accept, unwrap_spec=[ObjSpace, W_Root, W_Root] ),
left=GetSetProperty(Add.fget_left, Add.fset_left ),
right=GetSetProperty(Add.fget_right, Add.fset_right ),
)
@@ -251,8 +281,15 @@
return space.newlist( [space.wrap(itm) for itm in self.nodes] )
def fset_nodes( space, self, w_arg):
del self.nodes[:]
- for w_itm in space.unpackiterable( w_arg ):
- self.nodes.append( space.interpclass_w( w_arg ) )
+ for w_itm in space.unpackiterable(w_arg):
+ self.nodes.append( space.interp_w(Node, w_arg))
+
+def descr_And_new(space, w_subtype, w_nodes, lineno=-1):
+ self = space.allocate_instance(And, w_subtype)
+ nodes = [space.interp_w(Node, w_node) for w_node in space.unpackiterable(w_nodes)]
+ self.nodes = nodes
+ self.lineno = lineno
+ return space.wrap(self)
def descr_And_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitAnd'))
@@ -260,7 +297,8 @@
return space.call_args(w_callable, args)
And.typedef = TypeDef('And', AbstractTest.typedef,
- accept=interp2app(descr_And_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ __new__ = interp2app(descr_And_new, unwrap_spec=[ObjSpace, W_Root, W_Root, int]),
+ accept=interp2app(descr_And_accept, unwrap_spec=[ObjSpace, W_Root, W_Root] ),
nodes=GetSetProperty(And.fget_nodes, And.fset_nodes ),
)
@@ -287,10 +325,7 @@
def fget_expr( space, self):
return space.wrap(self.expr)
def fset_expr( space, self, w_arg):
- obj = space.interpclass_w( w_arg )
- if not isinstance( obj, Node):
- raise OperationError(space.w_TypeError,space.wrap('Need a Node instance'))
- self.expr = obj
+ self.expr = space.interp_w(Node, w_arg, can_be_None=False)
def fget_attrname( space, self):
return space.wrap(self.attrname)
def fset_attrname( space, self, w_arg):
@@ -300,13 +335,25 @@
def fset_flags( space, self, w_arg):
self.flags = space.int_w(w_arg)
+def descr_AssAttr_new(space, w_subtype, w_expr, w_attrname, w_flags, lineno=-1):
+ self = space.allocate_instance(AssAttr, w_subtype)
+ expr = space.interp_w(Node, w_expr, can_be_None=False)
+ self.expr = expr
+ attrname = space.str_w(w_attrname)
+ self.attrname = attrname
+ flags = space.int_w(w_flags)
+ self.flags = flags
+ self.lineno = lineno
+ return space.wrap(self)
+
def descr_AssAttr_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitAssAttr'))
args = Arguments(space, [ w_self ])
return space.call_args(w_callable, args)
AssAttr.typedef = TypeDef('AssAttr', Node.typedef,
- accept=interp2app(descr_AssAttr_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ __new__ = interp2app(descr_AssAttr_new, unwrap_spec=[ObjSpace, W_Root, W_Root, W_Root, W_Root, int]),
+ accept=interp2app(descr_AssAttr_accept, unwrap_spec=[ObjSpace, W_Root, W_Root] ),
expr=GetSetProperty(AssAttr.fget_expr, AssAttr.fset_expr ),
attrname=GetSetProperty(AssAttr.fget_attrname, AssAttr.fset_attrname ),
flags=GetSetProperty(AssAttr.fget_flags, AssAttr.fset_flags ),
@@ -330,13 +377,19 @@
return visitor.visitAssSeq(self)
+def descr_AssSeq_new(space, w_subtype, lineno=-1):
+ self = space.allocate_instance(AssSeq, w_subtype)
+ self.lineno = lineno
+ return space.wrap(self)
+
def descr_AssSeq_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitAssSeq'))
args = Arguments(space, [ w_self ])
return space.call_args(w_callable, args)
AssSeq.typedef = TypeDef('AssSeq', Node.typedef,
- accept=interp2app(descr_AssSeq_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ __new__ = interp2app(descr_AssSeq_new, unwrap_spec=[ObjSpace, W_Root, int]),
+ accept=interp2app(descr_AssSeq_accept, unwrap_spec=[ObjSpace, W_Root, W_Root] ),
)
class AssList(AssSeq):
@@ -363,8 +416,15 @@
return space.newlist( [space.wrap(itm) for itm in self.nodes] )
def fset_nodes( space, self, w_arg):
del self.nodes[:]
- for w_itm in space.unpackiterable( w_arg ):
- self.nodes.append( space.interpclass_w( w_arg ) )
+ for w_itm in space.unpackiterable(w_arg):
+ self.nodes.append( space.interp_w(Node, w_arg))
+
+def descr_AssList_new(space, w_subtype, w_nodes, lineno=-1):
+ self = space.allocate_instance(AssList, w_subtype)
+ nodes = [space.interp_w(Node, w_node) for w_node in space.unpackiterable(w_nodes)]
+ self.nodes = nodes
+ self.lineno = lineno
+ return space.wrap(self)
def descr_AssList_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitAssList'))
@@ -372,7 +432,8 @@
return space.call_args(w_callable, args)
AssList.typedef = TypeDef('AssList', AssSeq.typedef,
- accept=interp2app(descr_AssList_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ __new__ = interp2app(descr_AssList_new, unwrap_spec=[ObjSpace, W_Root, W_Root, int]),
+ accept=interp2app(descr_AssList_accept, unwrap_spec=[ObjSpace, W_Root, W_Root] ),
nodes=GetSetProperty(AssList.fget_nodes, AssList.fset_nodes ),
)
@@ -404,13 +465,23 @@
def fset_flags( space, self, w_arg):
self.flags = space.int_w(w_arg)
+def descr_AssName_new(space, w_subtype, w_name, w_flags, lineno=-1):
+ self = space.allocate_instance(AssName, w_subtype)
+ name = space.str_w(w_name)
+ self.name = name
+ flags = space.int_w(w_flags)
+ self.flags = flags
+ self.lineno = lineno
+ return space.wrap(self)
+
def descr_AssName_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitAssName'))
args = Arguments(space, [ w_self ])
return space.call_args(w_callable, args)
AssName.typedef = TypeDef('AssName', Node.typedef,
- accept=interp2app(descr_AssName_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ __new__ = interp2app(descr_AssName_new, unwrap_spec=[ObjSpace, W_Root, W_Root, W_Root, int]),
+ accept=interp2app(descr_AssName_accept, unwrap_spec=[ObjSpace, W_Root, W_Root] ),
name=GetSetProperty(AssName.fget_name, AssName.fset_name ),
flags=GetSetProperty(AssName.fget_flags, AssName.fset_flags ),
)
@@ -453,8 +524,15 @@
return space.newlist( [space.wrap(itm) for itm in self.nodes] )
def fset_nodes( space, self, w_arg):
del self.nodes[:]
- for w_itm in space.unpackiterable( w_arg ):
- self.nodes.append( space.interpclass_w( w_arg ) )
+ for w_itm in space.unpackiterable(w_arg):
+ self.nodes.append( space.interp_w(Node, w_arg))
+
+def descr_AssTuple_new(space, w_subtype, w_nodes, lineno=-1):
+ self = space.allocate_instance(AssTuple, w_subtype)
+ nodes = [space.interp_w(Node, w_node) for w_node in space.unpackiterable(w_nodes)]
+ self.nodes = nodes
+ self.lineno = lineno
+ return space.wrap(self)
def descr_AssTuple_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitAssTuple'))
@@ -462,7 +540,8 @@
return space.call_args(w_callable, args)
AssTuple.typedef = TypeDef('AssTuple', AssSeq.typedef,
- accept=interp2app(descr_AssTuple_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ __new__ = interp2app(descr_AssTuple_new, unwrap_spec=[ObjSpace, W_Root, W_Root, int]),
+ accept=interp2app(descr_AssTuple_accept, unwrap_spec=[ObjSpace, W_Root, W_Root] ),
nodes=GetSetProperty(AssTuple.fget_nodes, AssTuple.fset_nodes ),
)
@@ -495,23 +574,23 @@
def fget_test( space, self):
return space.wrap(self.test)
def fset_test( space, self, w_arg):
- obj = space.interpclass_w( w_arg )
- if not isinstance( obj, Node):
- raise OperationError(space.w_TypeError,space.wrap('Need a Node instance'))
- self.test = obj
+ self.test = space.interp_w(Node, w_arg, can_be_None=False)
def fget_fail( space, self):
if self.fail is None:
return space.w_None
else:
return space.wrap(self.fail)
def fset_fail( space, self, w_arg):
- if space.is_w( w_arg, space.w_None ):
- self.fail = None
- else:
- obj = space.interpclass_w( w_arg )
- if not isinstance( obj, Node):
- raise OperationError(space.w_TypeError,space.wrap('Need a Node instance'))
- self.fail = obj
+ self.fail = space.interp_w(Node, w_arg, can_be_None=True)
+
+def descr_Assert_new(space, w_subtype, w_test, w_fail, lineno=-1):
+ self = space.allocate_instance(Assert, w_subtype)
+ test = space.interp_w(Node, w_test, can_be_None=False)
+ self.test = test
+ fail = space.interp_w(Node, w_fail, can_be_None=True)
+ self.fail = fail
+ self.lineno = lineno
+ return space.wrap(self)
def descr_Assert_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitAssert'))
@@ -519,7 +598,8 @@
return space.call_args(w_callable, args)
Assert.typedef = TypeDef('Assert', Node.typedef,
- accept=interp2app(descr_Assert_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ __new__ = interp2app(descr_Assert_new, unwrap_spec=[ObjSpace, W_Root, W_Root, W_Root, int]),
+ accept=interp2app(descr_Assert_accept, unwrap_spec=[ObjSpace, W_Root, W_Root] ),
test=GetSetProperty(Assert.fget_test, Assert.fset_test ),
fail=GetSetProperty(Assert.fget_fail, Assert.fset_fail ),
)
@@ -553,15 +633,21 @@
return space.newlist( [space.wrap(itm) for itm in self.nodes] )
def fset_nodes( space, self, w_arg):
del self.nodes[:]
- for w_itm in space.unpackiterable( w_arg ):
- self.nodes.append( space.interpclass_w( w_arg ) )
+ for w_itm in space.unpackiterable(w_arg):
+ self.nodes.append( space.interp_w(Node, w_arg))
def fget_expr( space, self):
return space.wrap(self.expr)
def fset_expr( space, self, w_arg):
- obj = space.interpclass_w( w_arg )
- if not isinstance( obj, Node):
- raise OperationError(space.w_TypeError,space.wrap('Need a Node instance'))
- self.expr = obj
+ self.expr = space.interp_w(Node, w_arg, can_be_None=False)
+
+def descr_Assign_new(space, w_subtype, w_nodes, w_expr, lineno=-1):
+ self = space.allocate_instance(Assign, w_subtype)
+ nodes = [space.interp_w(Node, w_node) for w_node in space.unpackiterable(w_nodes)]
+ self.nodes = nodes
+ expr = space.interp_w(Node, w_expr, can_be_None=False)
+ self.expr = expr
+ self.lineno = lineno
+ return space.wrap(self)
def descr_Assign_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitAssign'))
@@ -569,7 +655,8 @@
return space.call_args(w_callable, args)
Assign.typedef = TypeDef('Assign', Node.typedef,
- accept=interp2app(descr_Assign_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ __new__ = interp2app(descr_Assign_new, unwrap_spec=[ObjSpace, W_Root, W_Root, W_Root, int]),
+ accept=interp2app(descr_Assign_accept, unwrap_spec=[ObjSpace, W_Root, W_Root] ),
nodes=GetSetProperty(Assign.fget_nodes, Assign.fset_nodes ),
expr=GetSetProperty(Assign.fget_expr, Assign.fset_expr ),
)
@@ -597,10 +684,7 @@
def fget_node( space, self):
return space.wrap(self.node)
def fset_node( space, self, w_arg):
- obj = space.interpclass_w( w_arg )
- if not isinstance( obj, Node):
- raise OperationError(space.w_TypeError,space.wrap('Need a Node instance'))
- self.node = obj
+ self.node = space.interp_w(Node, w_arg, can_be_None=False)
def fget_op( space, self):
return space.wrap(self.op)
def fset_op( space, self, w_arg):
@@ -608,10 +692,18 @@
def fget_expr( space, self):
return space.wrap(self.expr)
def fset_expr( space, self, w_arg):
- obj = space.interpclass_w( w_arg )
- if not isinstance( obj, Node):
- raise OperationError(space.w_TypeError,space.wrap('Need a Node instance'))
- self.expr = obj
+ self.expr = space.interp_w(Node, w_arg, can_be_None=False)
+
+def descr_AugAssign_new(space, w_subtype, w_node, w_op, w_expr, lineno=-1):
+ self = space.allocate_instance(AugAssign, w_subtype)
+ node = space.interp_w(Node, w_node, can_be_None=False)
+ self.node = node
+ op = space.str_w(w_op)
+ self.op = op
+ expr = space.interp_w(Node, w_expr, can_be_None=False)
+ self.expr = expr
+ self.lineno = lineno
+ return space.wrap(self)
def descr_AugAssign_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitAugAssign'))
@@ -619,7 +711,8 @@
return space.call_args(w_callable, args)
AugAssign.typedef = TypeDef('AugAssign', Node.typedef,
- accept=interp2app(descr_AugAssign_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ __new__ = interp2app(descr_AugAssign_new, unwrap_spec=[ObjSpace, W_Root, W_Root, W_Root, W_Root, int]),
+ accept=interp2app(descr_AugAssign_accept, unwrap_spec=[ObjSpace, W_Root, W_Root] ),
node=GetSetProperty(AugAssign.fget_node, AugAssign.fset_node ),
op=GetSetProperty(AugAssign.fget_op, AugAssign.fset_op ),
expr=GetSetProperty(AugAssign.fget_expr, AugAssign.fset_expr ),
@@ -643,13 +736,19 @@
return visitor.visitUnaryOp(self)
+def descr_UnaryOp_new(space, w_subtype, lineno=-1):
+ self = space.allocate_instance(UnaryOp, w_subtype)
+ self.lineno = lineno
+ return space.wrap(self)
+
def descr_UnaryOp_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitUnaryOp'))
args = Arguments(space, [ w_self ])
return space.call_args(w_callable, args)
UnaryOp.typedef = TypeDef('UnaryOp', Node.typedef,
- accept=interp2app(descr_UnaryOp_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ __new__ = interp2app(descr_UnaryOp_new, unwrap_spec=[ObjSpace, W_Root, int]),
+ accept=interp2app(descr_UnaryOp_accept, unwrap_spec=[ObjSpace, W_Root, W_Root] ),
)
class Backquote(UnaryOp):
@@ -673,10 +772,14 @@
def fget_expr( space, self):
return space.wrap(self.expr)
def fset_expr( space, self, w_arg):
- obj = space.interpclass_w( w_arg )
- if not isinstance( obj, Node):
- raise OperationError(space.w_TypeError,space.wrap('Need a Node instance'))
- self.expr = obj
+ self.expr = space.interp_w(Node, w_arg, can_be_None=False)
+
+def descr_Backquote_new(space, w_subtype, w_expr, lineno=-1):
+ self = space.allocate_instance(Backquote, w_subtype)
+ expr = space.interp_w(Node, w_expr, can_be_None=False)
+ self.expr = expr
+ self.lineno = lineno
+ return space.wrap(self)
def descr_Backquote_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitBackquote'))
@@ -684,7 +787,8 @@
return space.call_args(w_callable, args)
Backquote.typedef = TypeDef('Backquote', UnaryOp.typedef,
- accept=interp2app(descr_Backquote_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ __new__ = interp2app(descr_Backquote_new, unwrap_spec=[ObjSpace, W_Root, W_Root, int]),
+ accept=interp2app(descr_Backquote_accept, unwrap_spec=[ObjSpace, W_Root, W_Root] ),
expr=GetSetProperty(Backquote.fget_expr, Backquote.fset_expr ),
)
@@ -706,13 +810,19 @@
return visitor.visitBitOp(self)
+def descr_BitOp_new(space, w_subtype, lineno=-1):
+ self = space.allocate_instance(BitOp, w_subtype)
+ self.lineno = lineno
+ return space.wrap(self)
+
def descr_BitOp_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitBitOp'))
args = Arguments(space, [ w_self ])
return space.call_args(w_callable, args)
BitOp.typedef = TypeDef('BitOp', Node.typedef,
- accept=interp2app(descr_BitOp_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ __new__ = interp2app(descr_BitOp_new, unwrap_spec=[ObjSpace, W_Root, int]),
+ accept=interp2app(descr_BitOp_accept, unwrap_spec=[ObjSpace, W_Root, W_Root] ),
)
class Bitand(BitOp):
@@ -739,8 +849,15 @@
return space.newlist( [space.wrap(itm) for itm in self.nodes] )
def fset_nodes( space, self, w_arg):
del self.nodes[:]
- for w_itm in space.unpackiterable( w_arg ):
- self.nodes.append( space.interpclass_w( w_arg ) )
+ for w_itm in space.unpackiterable(w_arg):
+ self.nodes.append( space.interp_w(Node, w_arg))
+
+def descr_Bitand_new(space, w_subtype, w_nodes, lineno=-1):
+ self = space.allocate_instance(Bitand, w_subtype)
+ nodes = [space.interp_w(Node, w_node) for w_node in space.unpackiterable(w_nodes)]
+ self.nodes = nodes
+ self.lineno = lineno
+ return space.wrap(self)
def descr_Bitand_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitBitand'))
@@ -748,7 +865,8 @@
return space.call_args(w_callable, args)
Bitand.typedef = TypeDef('Bitand', BitOp.typedef,
- accept=interp2app(descr_Bitand_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ __new__ = interp2app(descr_Bitand_new, unwrap_spec=[ObjSpace, W_Root, W_Root, int]),
+ accept=interp2app(descr_Bitand_accept, unwrap_spec=[ObjSpace, W_Root, W_Root] ),
nodes=GetSetProperty(Bitand.fget_nodes, Bitand.fset_nodes ),
)
@@ -776,8 +894,15 @@
return space.newlist( [space.wrap(itm) for itm in self.nodes] )
def fset_nodes( space, self, w_arg):
del self.nodes[:]
- for w_itm in space.unpackiterable( w_arg ):
- self.nodes.append( space.interpclass_w( w_arg ) )
+ for w_itm in space.unpackiterable(w_arg):
+ self.nodes.append( space.interp_w(Node, w_arg))
+
+def descr_Bitor_new(space, w_subtype, w_nodes, lineno=-1):
+ self = space.allocate_instance(Bitor, w_subtype)
+ nodes = [space.interp_w(Node, w_node) for w_node in space.unpackiterable(w_nodes)]
+ self.nodes = nodes
+ self.lineno = lineno
+ return space.wrap(self)
def descr_Bitor_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitBitor'))
@@ -785,7 +910,8 @@
return space.call_args(w_callable, args)
Bitor.typedef = TypeDef('Bitor', BitOp.typedef,
- accept=interp2app(descr_Bitor_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ __new__ = interp2app(descr_Bitor_new, unwrap_spec=[ObjSpace, W_Root, W_Root, int]),
+ accept=interp2app(descr_Bitor_accept, unwrap_spec=[ObjSpace, W_Root, W_Root] ),
nodes=GetSetProperty(Bitor.fget_nodes, Bitor.fset_nodes ),
)
@@ -813,8 +939,15 @@
return space.newlist( [space.wrap(itm) for itm in self.nodes] )
def fset_nodes( space, self, w_arg):
del self.nodes[:]
- for w_itm in space.unpackiterable( w_arg ):
- self.nodes.append( space.interpclass_w( w_arg ) )
+ for w_itm in space.unpackiterable(w_arg):
+ self.nodes.append( space.interp_w(Node, w_arg))
+
+def descr_Bitxor_new(space, w_subtype, w_nodes, lineno=-1):
+ self = space.allocate_instance(Bitxor, w_subtype)
+ nodes = [space.interp_w(Node, w_node) for w_node in space.unpackiterable(w_nodes)]
+ self.nodes = nodes
+ self.lineno = lineno
+ return space.wrap(self)
def descr_Bitxor_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitBitxor'))
@@ -822,7 +955,8 @@
return space.call_args(w_callable, args)
Bitxor.typedef = TypeDef('Bitxor', BitOp.typedef,
- accept=interp2app(descr_Bitxor_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ __new__ = interp2app(descr_Bitxor_new, unwrap_spec=[ObjSpace, W_Root, W_Root, int]),
+ accept=interp2app(descr_Bitxor_accept, unwrap_spec=[ObjSpace, W_Root, W_Root] ),
nodes=GetSetProperty(Bitxor.fget_nodes, Bitxor.fset_nodes ),
)
@@ -844,13 +978,19 @@
return visitor.visitBreak(self)
+def descr_Break_new(space, w_subtype, lineno=-1):
+ self = space.allocate_instance(Break, w_subtype)
+ self.lineno = lineno
+ return space.wrap(self)
+
def descr_Break_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitBreak'))
args = Arguments(space, [ w_self ])
return space.call_args(w_callable, args)
Break.typedef = TypeDef('Break', Node.typedef,
- accept=interp2app(descr_Break_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ __new__ = interp2app(descr_Break_new, unwrap_spec=[ObjSpace, W_Root, int]),
+ accept=interp2app(descr_Break_accept, unwrap_spec=[ObjSpace, W_Root, W_Root] ),
)
class CallFunc(Node):
@@ -889,42 +1029,40 @@
def fget_node( space, self):
return space.wrap(self.node)
def fset_node( space, self, w_arg):
- obj = space.interpclass_w( w_arg )
- if not isinstance( obj, Node):
- raise OperationError(space.w_TypeError,space.wrap('Need a Node instance'))
- self.node = obj
+ self.node = space.interp_w(Node, w_arg, can_be_None=False)
def fget_args( space, self):
return space.newlist( [space.wrap(itm) for itm in self.args] )
def fset_args( space, self, w_arg):
del self.args[:]
- for w_itm in space.unpackiterable( w_arg ):
- self.args.append( space.interpclass_w( w_arg ) )
+ for w_itm in space.unpackiterable(w_arg):
+ self.args.append( space.interp_w(Node, w_arg))
def fget_star_args( space, self):
if self.star_args is None:
return space.w_None
else:
return space.wrap(self.star_args)
def fset_star_args( space, self, w_arg):
- if space.is_w( w_arg, space.w_None ):
- self.star_args = None
- else:
- obj = space.interpclass_w( w_arg )
- if not isinstance( obj, Node):
- raise OperationError(space.w_TypeError,space.wrap('Need a Node instance'))
- self.star_args = obj
+ self.star_args = space.interp_w(Node, w_arg, can_be_None=True)
def fget_dstar_args( space, self):
if self.dstar_args is None:
return space.w_None
else:
return space.wrap(self.dstar_args)
def fset_dstar_args( space, self, w_arg):
- if space.is_w( w_arg, space.w_None ):
- self.dstar_args = None
- else:
- obj = space.interpclass_w( w_arg )
- if not isinstance( obj, Node):
- raise OperationError(space.w_TypeError,space.wrap('Need a Node instance'))
- self.dstar_args = obj
+ self.dstar_args = space.interp_w(Node, w_arg, can_be_None=True)
+
+def descr_CallFunc_new(space, w_subtype, w_node, w_args, w_star_args, w_dstar_args, lineno=-1):
+ self = space.allocate_instance(CallFunc, w_subtype)
+ node = space.interp_w(Node, w_node, can_be_None=False)
+ self.node = node
+ args = [space.interp_w(Node, w_node) for w_node in space.unpackiterable(w_args)]
+ self.args = args
+ star_args = space.interp_w(Node, w_star_args, can_be_None=True)
+ self.star_args = star_args
+ dstar_args = space.interp_w(Node, w_dstar_args, can_be_None=True)
+ self.dstar_args = dstar_args
+ self.lineno = lineno
+ return space.wrap(self)
def descr_CallFunc_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitCallFunc'))
@@ -932,7 +1070,8 @@
return space.call_args(w_callable, args)
CallFunc.typedef = TypeDef('CallFunc', Node.typedef,
- accept=interp2app(descr_CallFunc_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ __new__ = interp2app(descr_CallFunc_new, unwrap_spec=[ObjSpace, W_Root, W_Root, W_Root, W_Root, W_Root, int]),
+ accept=interp2app(descr_CallFunc_accept, unwrap_spec=[ObjSpace, W_Root, W_Root] ),
node=GetSetProperty(CallFunc.fget_node, CallFunc.fset_node ),
args=GetSetProperty(CallFunc.fget_args, CallFunc.fset_args ),
star_args=GetSetProperty(CallFunc.fget_star_args, CallFunc.fset_star_args ),
@@ -976,8 +1115,8 @@
return space.newlist( [space.wrap(itm) for itm in self.bases] )
def fset_bases( space, self, w_arg):
del self.bases[:]
- for w_itm in space.unpackiterable( w_arg ):
- self.bases.append( space.interpclass_w( w_arg ) )
+ for w_itm in space.unpackiterable(w_arg):
+ self.bases.append( space.interp_w(Node, w_arg))
def fget_w_doc( space, self):
return self.w_doc
def fset_w_doc( space, self, w_arg):
@@ -985,10 +1124,21 @@
def fget_code( space, self):
return space.wrap(self.code)
def fset_code( space, self, w_arg):
- obj = space.interpclass_w( w_arg )
- if not isinstance( obj, Node):
- raise OperationError(space.w_TypeError,space.wrap('Need a Node instance'))
- self.code = obj
+ self.code = space.interp_w(Node, w_arg, can_be_None=False)
+
+def descr_Class_new(space, w_subtype, w_name, w_bases, w_w_doc, w_code, lineno=-1):
+ self = space.allocate_instance(Class, w_subtype)
+ name = space.str_w(w_name)
+ self.name = name
+ bases = [space.interp_w(Node, w_node) for w_node in space.unpackiterable(w_bases)]
+ self.bases = bases
+ # This dummy assingment is auto-generated, astgen.py should be fixed to avoid that
+ w_doc = w_w_doc
+ self.w_doc = w_doc
+ code = space.interp_w(Node, w_code, can_be_None=False)
+ self.code = code
+ self.lineno = lineno
+ return space.wrap(self)
def descr_Class_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitClass'))
@@ -996,7 +1146,8 @@
return space.call_args(w_callable, args)
Class.typedef = TypeDef('Class', Node.typedef,
- accept=interp2app(descr_Class_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ __new__ = interp2app(descr_Class_new, unwrap_spec=[ObjSpace, W_Root, W_Root, W_Root, W_Root, W_Root, int]),
+ accept=interp2app(descr_Class_accept, unwrap_spec=[ObjSpace, W_Root, W_Root] ),
name=GetSetProperty(Class.fget_name, Class.fset_name ),
bases=GetSetProperty(Class.fget_bases, Class.fset_bases ),
w_doc=GetSetProperty(Class.fget_w_doc, Class.fset_w_doc ),
@@ -1031,9 +1182,7 @@
w_opname = space.getitem( w_obj, space.wrap(0) )
w_node = space.getitem( w_obj, space.wrap(1) )
ops = space.str_w(w_opname)
- node = space.interpclass_w( w_node )
- if not isinstance(node, Node):
- raise OperationError(space.w_TypeError, space.wrap("ops must be a list of (name,node)"))
+ node = space.interp_w(Node, w_node)
self.ops.append( (ops,node) )
@@ -1053,10 +1202,23 @@
def fget_expr( space, self):
return space.wrap(self.expr)
def fset_expr( space, self, w_arg):
- obj = space.interpclass_w( w_arg )
- if not isinstance( obj, Node):
- raise OperationError(space.w_TypeError,space.wrap('Need a Node instance'))
- self.expr = obj
+ self.expr = space.interp_w(Node, w_arg, can_be_None=False)
+
+def descr_Compare_new(space, w_subtype, w_expr, w_ops, lineno=-1):
+ self = space.allocate_instance(Compare, w_subtype)
+ self.expr = space.interp_w(Node, w_expr)
+ ops = []
+ for w_tuple in space.unpackiterable(w_ops):
+ w_opname = space.getitem(w_tuple, space.wrap(0))
+ w_node = space.getitem(w_tuple, space.wrap(1))
+ opname = space.str_w(w_opname)
+ node = space.interp_w(Node, w_node)
+ ops.append((opname, node))
+ self.ops = ops
+ self.lineno = lineno
+ return space.wrap(self)
+
+
def descr_Compare_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitCompare'))
@@ -1064,7 +1226,8 @@
return space.call_args(w_callable, args)
Compare.typedef = TypeDef('Compare', Node.typedef,
- accept=interp2app(descr_Compare_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ __new__ = interp2app(descr_Compare_new, unwrap_spec=[ObjSpace, W_Root, W_Root, W_Root, int]),
+ accept=interp2app(descr_Compare_accept, unwrap_spec=[ObjSpace, W_Root, W_Root] ),
expr=GetSetProperty(Compare.fget_expr, Compare.fset_expr ),
ops=GetSetProperty(Compare.fget_ops, Compare.fset_ops ),
)
@@ -1092,13 +1255,22 @@
def fset_value( space, self, w_arg):
self.value = w_arg
+def descr_Const_new(space, w_subtype, w_value, lineno=-1):
+ self = space.allocate_instance(Const, w_subtype)
+ # This dummy assingment is auto-generated, astgen.py should be fixed to avoid that
+ value = w_value
+ self.value = value
+ self.lineno = lineno
+ return space.wrap(self)
+
def descr_Const_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitConst'))
args = Arguments(space, [ w_self ])
return space.call_args(w_callable, args)
Const.typedef = TypeDef('Const', Node.typedef,
- accept=interp2app(descr_Const_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ __new__ = interp2app(descr_Const_new, unwrap_spec=[ObjSpace, W_Root, W_Root, int]),
+ accept=interp2app(descr_Const_accept, unwrap_spec=[ObjSpace, W_Root, W_Root] ),
value=GetSetProperty(Const.fget_value, Const.fset_value ),
)
@@ -1120,13 +1292,19 @@
return visitor.visitContinue(self)
+def descr_Continue_new(space, w_subtype, lineno=-1):
+ self = space.allocate_instance(Continue, w_subtype)
+ self.lineno = lineno
+ return space.wrap(self)
+
def descr_Continue_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitContinue'))
args = Arguments(space, [ w_self ])
return space.call_args(w_callable, args)
Continue.typedef = TypeDef('Continue', Node.typedef,
- accept=interp2app(descr_Continue_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ __new__ = interp2app(descr_Continue_new, unwrap_spec=[ObjSpace, W_Root, int]),
+ accept=interp2app(descr_Continue_accept, unwrap_spec=[ObjSpace, W_Root, W_Root] ),
)
class Decorators(Node):
@@ -1153,8 +1331,15 @@
return space.newlist( [space.wrap(itm) for itm in self.nodes] )
def fset_nodes( space, self, w_arg):
del self.nodes[:]
- for w_itm in space.unpackiterable( w_arg ):
- self.nodes.append( space.interpclass_w( w_arg ) )
+ for w_itm in space.unpackiterable(w_arg):
+ self.nodes.append( space.interp_w(Node, w_arg))
+
+def descr_Decorators_new(space, w_subtype, w_nodes, lineno=-1):
+ self = space.allocate_instance(Decorators, w_subtype)
+ nodes = [space.interp_w(Node, w_node) for w_node in space.unpackiterable(w_nodes)]
+ self.nodes = nodes
+ self.lineno = lineno
+ return space.wrap(self)
def descr_Decorators_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitDecorators'))
@@ -1162,7 +1347,8 @@
return space.call_args(w_callable, args)
Decorators.typedef = TypeDef('Decorators', Node.typedef,
- accept=interp2app(descr_Decorators_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ __new__ = interp2app(descr_Decorators_new, unwrap_spec=[ObjSpace, W_Root, W_Root, int]),
+ accept=interp2app(descr_Decorators_accept, unwrap_spec=[ObjSpace, W_Root, W_Root] ),
nodes=GetSetProperty(Decorators.fget_nodes, Decorators.fset_nodes ),
)
@@ -1189,14 +1375,13 @@
for w_tup in space.unpackiterable( w_arg ):
w_key = space.getitem( w_tup, space.wrap(0) )
w_value = space.getitem( w_tup, space.wrap(1) )
- key = space.interpclass_w( w_key )
- value = space.interpclass_w( w_value )
- if not isinstance( key, Node ) or not isinstance( value, Node ):
- raise OperationError(space.w_TypeError, space.wrap("Need a list of (key node, value node)"))
+ key = space.interp_w(Node, w_key)
+ value = space.interp_w(Node, w_value)
self.items.append( (key,value) )
+
- def fget_items( space, self ):
+ def fget_items(space, self):
return space.newlist( [ space.newtuple( [ space.wrap(key), space.wrap(value) ] )
for key, value in self.items ] )
@@ -1208,13 +1393,30 @@
return visitor.visitDict(self)
+def descr_Dict_new(space, w_subtype, w_items, lineno=-1):
+ self = space.allocate_instance(Dict, w_subtype)
+ items = []
+ for w_tuple in space.unpackiterable(w_items):
+ w_key = space.getitem(w_tuple, space.wrap(0))
+ w_value = space.getitem(w_tuple, space.wrap(1))
+ key = space.interp_w(Node, w_key)
+ value = space.interp_w(Node, w_value)
+ items.append((key, value))
+ self.items = items
+ self.lineno = lineno
+ return space.wrap(self)
+
+
+
+
def descr_Dict_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitDict'))
args = Arguments(space, [ w_self ])
return space.call_args(w_callable, args)
Dict.typedef = TypeDef('Dict', Node.typedef,
- accept=interp2app(descr_Dict_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ __new__ = interp2app(descr_Dict_new, unwrap_spec=[ObjSpace, W_Root, W_Root, int]),
+ accept=interp2app(descr_Dict_accept, unwrap_spec=[ObjSpace, W_Root, W_Root] ),
items=GetSetProperty(Dict.fget_items, Dict.fset_items ),
)
@@ -1239,10 +1441,14 @@
def fget_expr( space, self):
return space.wrap(self.expr)
def fset_expr( space, self, w_arg):
- obj = space.interpclass_w( w_arg )
- if not isinstance( obj, Node):
- raise OperationError(space.w_TypeError,space.wrap('Need a Node instance'))
- self.expr = obj
+ self.expr = space.interp_w(Node, w_arg, can_be_None=False)
+
+def descr_Discard_new(space, w_subtype, w_expr, lineno=-1):
+ self = space.allocate_instance(Discard, w_subtype)
+ expr = space.interp_w(Node, w_expr, can_be_None=False)
+ self.expr = expr
+ self.lineno = lineno
+ return space.wrap(self)
def descr_Discard_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitDiscard'))
@@ -1250,7 +1456,8 @@
return space.call_args(w_callable, args)
Discard.typedef = TypeDef('Discard', Node.typedef,
- accept=interp2app(descr_Discard_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ __new__ = interp2app(descr_Discard_new, unwrap_spec=[ObjSpace, W_Root, W_Root, int]),
+ accept=interp2app(descr_Discard_accept, unwrap_spec=[ObjSpace, W_Root, W_Root] ),
expr=GetSetProperty(Discard.fget_expr, Discard.fset_expr ),
)
@@ -1276,17 +1483,20 @@
def fget_left( space, self):
return space.wrap(self.left)
def fset_left( space, self, w_arg):
- obj = space.interpclass_w( w_arg )
- if not isinstance( obj, Node):
- raise OperationError(space.w_TypeError,space.wrap('Need a Node instance'))
- self.left = obj
+ self.left = space.interp_w(Node, w_arg, can_be_None=False)
def fget_right( space, self):
return space.wrap(self.right)
def fset_right( space, self, w_arg):
- obj = space.interpclass_w( w_arg )
- if not isinstance( obj, Node):
- raise OperationError(space.w_TypeError,space.wrap('Need a Node instance'))
- self.right = obj
+ self.right = space.interp_w(Node, w_arg, can_be_None=False)
+
+def descr_Div_new(space, w_subtype, w_left, w_right, lineno=-1):
+ self = space.allocate_instance(Div, w_subtype)
+ left = space.interp_w(Node, w_left, can_be_None=False)
+ self.left = left
+ right = space.interp_w(Node, w_right, can_be_None=False)
+ self.right = right
+ self.lineno = lineno
+ return space.wrap(self)
def descr_Div_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitDiv'))
@@ -1294,7 +1504,8 @@
return space.call_args(w_callable, args)
Div.typedef = TypeDef('Div', BinaryOp.typedef,
- accept=interp2app(descr_Div_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ __new__ = interp2app(descr_Div_new, unwrap_spec=[ObjSpace, W_Root, W_Root, W_Root, int]),
+ accept=interp2app(descr_Div_accept, unwrap_spec=[ObjSpace, W_Root, W_Root] ),
left=GetSetProperty(Div.fget_left, Div.fset_left ),
right=GetSetProperty(Div.fget_right, Div.fset_right ),
)
@@ -1317,13 +1528,19 @@
return visitor.visitEllipsis(self)
+def descr_Ellipsis_new(space, w_subtype, lineno=-1):
+ self = space.allocate_instance(Ellipsis, w_subtype)
+ self.lineno = lineno
+ return space.wrap(self)
+
def descr_Ellipsis_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitEllipsis'))
args = Arguments(space, [ w_self ])
return space.call_args(w_callable, args)
Ellipsis.typedef = TypeDef('Ellipsis', Node.typedef,
- accept=interp2app(descr_Ellipsis_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ __new__ = interp2app(descr_Ellipsis_new, unwrap_spec=[ObjSpace, W_Root, int]),
+ accept=interp2app(descr_Ellipsis_accept, unwrap_spec=[ObjSpace, W_Root, W_Root] ),
)
class Exec(Node):
@@ -1359,36 +1576,32 @@
def fget_expr( space, self):
return space.wrap(self.expr)
def fset_expr( space, self, w_arg):
- obj = space.interpclass_w( w_arg )
- if not isinstance( obj, Node):
- raise OperationError(space.w_TypeError,space.wrap('Need a Node instance'))
- self.expr = obj
+ self.expr = space.interp_w(Node, w_arg, can_be_None=False)
def fget_locals( space, self):
if self.locals is None:
return space.w_None
else:
return space.wrap(self.locals)
def fset_locals( space, self, w_arg):
- if space.is_w( w_arg, space.w_None ):
- self.locals = None
- else:
- obj = space.interpclass_w( w_arg )
- if not isinstance( obj, Node):
- raise OperationError(space.w_TypeError,space.wrap('Need a Node instance'))
- self.locals = obj
+ self.locals = space.interp_w(Node, w_arg, can_be_None=True)
def fget_globals( space, self):
if self.globals is None:
return space.w_None
else:
return space.wrap(self.globals)
def fset_globals( space, self, w_arg):
- if space.is_w( w_arg, space.w_None ):
- self.globals = None
- else:
- obj = space.interpclass_w( w_arg )
- if not isinstance( obj, Node):
- raise OperationError(space.w_TypeError,space.wrap('Need a Node instance'))
- self.globals = obj
+ self.globals = space.interp_w(Node, w_arg, can_be_None=True)
+
+def descr_Exec_new(space, w_subtype, w_expr, w_locals, w_globals, lineno=-1):
+ self = space.allocate_instance(Exec, w_subtype)
+ expr = space.interp_w(Node, w_expr, can_be_None=False)
+ self.expr = expr
+ locals = space.interp_w(Node, w_locals, can_be_None=True)
+ self.locals = locals
+ globals = space.interp_w(Node, w_globals, can_be_None=True)
+ self.globals = globals
+ self.lineno = lineno
+ return space.wrap(self)
def descr_Exec_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitExec'))
@@ -1396,7 +1609,8 @@
return space.call_args(w_callable, args)
Exec.typedef = TypeDef('Exec', Node.typedef,
- accept=interp2app(descr_Exec_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ __new__ = interp2app(descr_Exec_new, unwrap_spec=[ObjSpace, W_Root, W_Root, W_Root, W_Root, int]),
+ accept=interp2app(descr_Exec_accept, unwrap_spec=[ObjSpace, W_Root, W_Root] ),
expr=GetSetProperty(Exec.fget_expr, Exec.fset_expr ),
locals=GetSetProperty(Exec.fget_locals, Exec.fset_locals ),
globals=GetSetProperty(Exec.fget_globals, Exec.fset_globals ),
@@ -1424,17 +1638,20 @@
def fget_left( space, self):
return space.wrap(self.left)
def fset_left( space, self, w_arg):
- obj = space.interpclass_w( w_arg )
- if not isinstance( obj, Node):
- raise OperationError(space.w_TypeError,space.wrap('Need a Node instance'))
- self.left = obj
+ self.left = space.interp_w(Node, w_arg, can_be_None=False)
def fget_right( space, self):
return space.wrap(self.right)
def fset_right( space, self, w_arg):
- obj = space.interpclass_w( w_arg )
- if not isinstance( obj, Node):
- raise OperationError(space.w_TypeError,space.wrap('Need a Node instance'))
- self.right = obj
+ self.right = space.interp_w(Node, w_arg, can_be_None=False)
+
+def descr_FloorDiv_new(space, w_subtype, w_left, w_right, lineno=-1):
+ self = space.allocate_instance(FloorDiv, w_subtype)
+ left = space.interp_w(Node, w_left, can_be_None=False)
+ self.left = left
+ right = space.interp_w(Node, w_right, can_be_None=False)
+ self.right = right
+ self.lineno = lineno
+ return space.wrap(self)
def descr_FloorDiv_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitFloorDiv'))
@@ -1442,7 +1659,8 @@
return space.call_args(w_callable, args)
FloorDiv.typedef = TypeDef('FloorDiv', BinaryOp.typedef,
- accept=interp2app(descr_FloorDiv_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ __new__ = interp2app(descr_FloorDiv_new, unwrap_spec=[ObjSpace, W_Root, W_Root, W_Root, int]),
+ accept=interp2app(descr_FloorDiv_accept, unwrap_spec=[ObjSpace, W_Root, W_Root] ),
left=GetSetProperty(FloorDiv.fget_left, FloorDiv.fset_left ),
right=GetSetProperty(FloorDiv.fget_right, FloorDiv.fset_right ),
)
@@ -1482,37 +1700,35 @@
def fget_assign( space, self):
return space.wrap(self.assign)
def fset_assign( space, self, w_arg):
- obj = space.interpclass_w( w_arg )
- if not isinstance( obj, Node):
- raise OperationError(space.w_TypeError,space.wrap('Need a Node instance'))
- self.assign = obj
+ self.assign = space.interp_w(Node, w_arg, can_be_None=False)
def fget_list( space, self):
return space.wrap(self.list)
def fset_list( space, self, w_arg):
- obj = space.interpclass_w( w_arg )
- if not isinstance( obj, Node):
- raise OperationError(space.w_TypeError,space.wrap('Need a Node instance'))
- self.list = obj
+ self.list = space.interp_w(Node, w_arg, can_be_None=False)
def fget_body( space, self):
return space.wrap(self.body)
def fset_body( space, self, w_arg):
- obj = space.interpclass_w( w_arg )
- if not isinstance( obj, Node):
- raise OperationError(space.w_TypeError,space.wrap('Need a Node instance'))
- self.body = obj
+ self.body = space.interp_w(Node, w_arg, can_be_None=False)
def fget_else_( space, self):
if self.else_ is None:
return space.w_None
else:
return space.wrap(self.else_)
def fset_else_( space, self, w_arg):
- if space.is_w( w_arg, space.w_None ):
- self.else_ = None
- else:
- obj = space.interpclass_w( w_arg )
- if not isinstance( obj, Node):
- raise OperationError(space.w_TypeError,space.wrap('Need a Node instance'))
- self.else_ = obj
+ self.else_ = space.interp_w(Node, w_arg, can_be_None=True)
+
+def descr_For_new(space, w_subtype, w_assign, w_list, w_body, w_else_, lineno=-1):
+ self = space.allocate_instance(For, w_subtype)
+ assign = space.interp_w(Node, w_assign, can_be_None=False)
+ self.assign = assign
+ list = space.interp_w(Node, w_list, can_be_None=False)
+ self.list = list
+ body = space.interp_w(Node, w_body, can_be_None=False)
+ self.body = body
+ else_ = space.interp_w(Node, w_else_, can_be_None=True)
+ self.else_ = else_
+ self.lineno = lineno
+ return space.wrap(self)
def descr_For_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitFor'))
@@ -1520,7 +1736,8 @@
return space.call_args(w_callable, args)
For.typedef = TypeDef('For', Node.typedef,
- accept=interp2app(descr_For_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ __new__ = interp2app(descr_For_new, unwrap_spec=[ObjSpace, W_Root, W_Root, W_Root, W_Root, W_Root, int]),
+ accept=interp2app(descr_For_accept, unwrap_spec=[ObjSpace, W_Root, W_Root] ),
assign=GetSetProperty(For.fget_assign, For.fset_assign ),
list=GetSetProperty(For.fget_list, For.fset_list ),
body=GetSetProperty(For.fget_body, For.fset_body ),
@@ -1568,13 +1785,33 @@
def fset_modname( space, self, w_arg):
self.modname = space.str_w(w_arg)
+def descr_From_new(space, w_subtype, w_modname, w_names, lineno=-1):
+ self = space.allocate_instance(From, w_subtype)
+ modname = space.str_w(w_modname)
+ self.modname = modname
+ names = []
+ for w_tuple in space.unpackiterable(w_names):
+ w_name = space.getitem(w_tuple, space.wrap(0))
+ w_as_name = space.getitem(w_tuple, space.wrap(1))
+ name = space.str_w(w_name)
+ as_name = None
+ if not space.is_w(w_as_name, space.w_None):
+ as_name = space.str_w(w_as_name)
+ names.append((name, as_name))
+ self.names = names
+ self.lineno = lineno
+ return space.wrap(self)
+
+
+
def descr_From_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitFrom'))
args = Arguments(space, [ w_self ])
return space.call_args(w_callable, args)
From.typedef = TypeDef('From', Node.typedef,
- accept=interp2app(descr_From_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ __new__ = interp2app(descr_From_new, unwrap_spec=[ObjSpace, W_Root, W_Root, W_Root, int]),
+ accept=interp2app(descr_From_accept, unwrap_spec=[ObjSpace, W_Root, W_Root] ),
modname=GetSetProperty(From.fget_modname, From.fset_modname ),
names=GetSetProperty(From.fget_names, From.fset_names ),
)
@@ -1630,13 +1867,7 @@
else:
return space.wrap(self.decorators)
def fset_decorators( space, self, w_arg):
- if space.is_w( w_arg, space.w_None ):
- self.decorators = None
- else:
- obj = space.interpclass_w( w_arg )
- if not isinstance( obj, Node):
- raise OperationError(space.w_TypeError,space.wrap('Need a Node instance'))
- self.decorators = obj
+ self.decorators = space.interp_w(Node, w_arg, can_be_None=True)
def fget_name( space, self):
return space.wrap(self.name)
def fset_name( space, self, w_arg):
@@ -1645,14 +1876,14 @@
return space.newlist( [space.wrap(itm) for itm in self.argnames] )
def fset_argnames( space, self, w_arg):
del self.argnames[:]
- for w_itm in space.unpackiterable( w_arg ):
- self.argnames.append( space.interpclass_w( w_arg ) )
+ for w_itm in space.unpackiterable(w_arg):
+ self.argnames.append( space.interp_w(Node, w_arg))
def fget_defaults( space, self):
return space.newlist( [space.wrap(itm) for itm in self.defaults] )
def fset_defaults( space, self, w_arg):
del self.defaults[:]
- for w_itm in space.unpackiterable( w_arg ):
- self.defaults.append( space.interpclass_w( w_arg ) )
+ for w_itm in space.unpackiterable(w_arg):
+ self.defaults.append( space.interp_w(Node, w_arg))
def fget_flags( space, self):
return space.wrap(self.flags)
def fset_flags( space, self, w_arg):
@@ -1664,10 +1895,27 @@
def fget_code( space, self):
return space.wrap(self.code)
def fset_code( space, self, w_arg):
- obj = space.interpclass_w( w_arg )
- if not isinstance( obj, Node):
- raise OperationError(space.w_TypeError,space.wrap('Need a Node instance'))
- self.code = obj
+ self.code = space.interp_w(Node, w_arg, can_be_None=False)
+
+def descr_Function_new(space, w_subtype, w_decorators, w_name, w_argnames, w_defaults, w_flags, w_w_doc, w_code, lineno=-1):
+ self = space.allocate_instance(Function, w_subtype)
+ decorators = space.interp_w(Node, w_decorators, can_be_None=True)
+ self.decorators = decorators
+ name = space.str_w(w_name)
+ self.name = name
+ argnames = [space.interp_w(Node, w_node) for w_node in space.unpackiterable(w_argnames)]
+ self.argnames = argnames
+ defaults = [space.interp_w(Node, w_node) for w_node in space.unpackiterable(w_defaults)]
+ self.defaults = defaults
+ flags = space.int_w(w_flags)
+ self.flags = flags
+ # This dummy assingment is auto-generated, astgen.py should be fixed to avoid that
+ w_doc = w_w_doc
+ self.w_doc = w_doc
+ code = space.interp_w(Node, w_code, can_be_None=False)
+ self.code = code
+ self.lineno = lineno
+ return space.wrap(self)
def descr_Function_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitFunction'))
@@ -1675,7 +1923,8 @@
return space.call_args(w_callable, args)
Function.typedef = TypeDef('Function', AbstractFunction.typedef,
- accept=interp2app(descr_Function_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ __new__ = interp2app(descr_Function_new, unwrap_spec=[ObjSpace, W_Root, W_Root, W_Root, W_Root, W_Root, W_Root, W_Root, W_Root, int]),
+ accept=interp2app(descr_Function_accept, unwrap_spec=[ObjSpace, W_Root, W_Root] ),
decorators=GetSetProperty(Function.fget_decorators, Function.fset_decorators ),
name=GetSetProperty(Function.fget_name, Function.fset_name ),
argnames=GetSetProperty(Function.fget_argnames, Function.fset_argnames ),
@@ -1710,10 +1959,14 @@
def fget_code( space, self):
return space.wrap(self.code)
def fset_code( space, self, w_arg):
- obj = space.interpclass_w( w_arg )
- if not isinstance( obj, Node):
- raise OperationError(space.w_TypeError,space.wrap('Need a Node instance'))
- self.code = obj
+ self.code = space.interp_w(Node, w_arg, can_be_None=False)
+
+def descr_GenExpr_new(space, w_subtype, w_code, lineno=-1):
+ self = space.allocate_instance(GenExpr, w_subtype)
+ code = space.interp_w(Node, w_code, can_be_None=False)
+ self.code = code
+ self.lineno = lineno
+ return space.wrap(self)
def descr_GenExpr_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitGenExpr'))
@@ -1721,7 +1974,8 @@
return space.call_args(w_callable, args)
GenExpr.typedef = TypeDef('GenExpr', AbstractFunction.typedef,
- accept=interp2app(descr_GenExpr_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ __new__ = interp2app(descr_GenExpr_new, unwrap_spec=[ObjSpace, W_Root, W_Root, int]),
+ accept=interp2app(descr_GenExpr_accept, unwrap_spec=[ObjSpace, W_Root, W_Root] ),
code=GetSetProperty(GenExpr.fget_code, GenExpr.fset_code ),
)
@@ -1759,23 +2013,28 @@
def fget_assign( space, self):
return space.wrap(self.assign)
def fset_assign( space, self, w_arg):
- obj = space.interpclass_w( w_arg )
- if not isinstance( obj, Node):
- raise OperationError(space.w_TypeError,space.wrap('Need a Node instance'))
- self.assign = obj
+ self.assign = space.interp_w(Node, w_arg, can_be_None=False)
def fget_iter( space, self):
return space.wrap(self.iter)
def fset_iter( space, self, w_arg):
- obj = space.interpclass_w( w_arg )
- if not isinstance( obj, Node):
- raise OperationError(space.w_TypeError,space.wrap('Need a Node instance'))
- self.iter = obj
+ self.iter = space.interp_w(Node, w_arg, can_be_None=False)
def fget_ifs( space, self):
return space.newlist( [space.wrap(itm) for itm in self.ifs] )
def fset_ifs( space, self, w_arg):
del self.ifs[:]
- for w_itm in space.unpackiterable( w_arg ):
- self.ifs.append( space.interpclass_w( w_arg ) )
+ for w_itm in space.unpackiterable(w_arg):
+ self.ifs.append( space.interp_w(Node, w_arg))
+
+def descr_GenExprFor_new(space, w_subtype, w_assign, w_iter, w_ifs, lineno=-1):
+ self = space.allocate_instance(GenExprFor, w_subtype)
+ assign = space.interp_w(Node, w_assign, can_be_None=False)
+ self.assign = assign
+ iter = space.interp_w(Node, w_iter, can_be_None=False)
+ self.iter = iter
+ ifs = [space.interp_w(Node, w_node) for w_node in space.unpackiterable(w_ifs)]
+ self.ifs = ifs
+ self.lineno = lineno
+ return space.wrap(self)
def descr_GenExprFor_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitGenExprFor'))
@@ -1783,7 +2042,8 @@
return space.call_args(w_callable, args)
GenExprFor.typedef = TypeDef('GenExprFor', Node.typedef,
- accept=interp2app(descr_GenExprFor_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ __new__ = interp2app(descr_GenExprFor_new, unwrap_spec=[ObjSpace, W_Root, W_Root, W_Root, W_Root, int]),
+ accept=interp2app(descr_GenExprFor_accept, unwrap_spec=[ObjSpace, W_Root, W_Root] ),
assign=GetSetProperty(GenExprFor.fget_assign, GenExprFor.fset_assign ),
iter=GetSetProperty(GenExprFor.fget_iter, GenExprFor.fset_iter ),
ifs=GetSetProperty(GenExprFor.fget_ifs, GenExprFor.fset_ifs ),
@@ -1810,10 +2070,14 @@
def fget_test( space, self):
return space.wrap(self.test)
def fset_test( space, self, w_arg):
- obj = space.interpclass_w( w_arg )
- if not isinstance( obj, Node):
- raise OperationError(space.w_TypeError,space.wrap('Need a Node instance'))
- self.test = obj
+ self.test = space.interp_w(Node, w_arg, can_be_None=False)
+
+def descr_GenExprIf_new(space, w_subtype, w_test, lineno=-1):
+ self = space.allocate_instance(GenExprIf, w_subtype)
+ test = space.interp_w(Node, w_test, can_be_None=False)
+ self.test = test
+ self.lineno = lineno
+ return space.wrap(self)
def descr_GenExprIf_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitGenExprIf'))
@@ -1821,7 +2085,8 @@
return space.call_args(w_callable, args)
GenExprIf.typedef = TypeDef('GenExprIf', Node.typedef,
- accept=interp2app(descr_GenExprIf_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ __new__ = interp2app(descr_GenExprIf_new, unwrap_spec=[ObjSpace, W_Root, W_Root, int]),
+ accept=interp2app(descr_GenExprIf_accept, unwrap_spec=[ObjSpace, W_Root, W_Root] ),
test=GetSetProperty(GenExprIf.fget_test, GenExprIf.fset_test ),
)
@@ -1853,16 +2118,22 @@
def fget_expr( space, self):
return space.wrap(self.expr)
def fset_expr( space, self, w_arg):
- obj = space.interpclass_w( w_arg )
- if not isinstance( obj, Node):
- raise OperationError(space.w_TypeError,space.wrap('Need a Node instance'))
- self.expr = obj
+ self.expr = space.interp_w(Node, w_arg, can_be_None=False)
def fget_quals( space, self):
return space.newlist( [space.wrap(itm) for itm in self.quals] )
def fset_quals( space, self, w_arg):
del self.quals[:]
- for w_itm in space.unpackiterable( w_arg ):
- self.quals.append( space.interpclass_w( w_arg ) )
+ for w_itm in space.unpackiterable(w_arg):
+ self.quals.append( space.interp_w(Node, w_arg))
+
+def descr_GenExprInner_new(space, w_subtype, w_expr, w_quals, lineno=-1):
+ self = space.allocate_instance(GenExprInner, w_subtype)
+ expr = space.interp_w(Node, w_expr, can_be_None=False)
+ self.expr = expr
+ quals = [space.interp_w(Node, w_node) for w_node in space.unpackiterable(w_quals)]
+ self.quals = quals
+ self.lineno = lineno
+ return space.wrap(self)
def descr_GenExprInner_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitGenExprInner'))
@@ -1870,7 +2141,8 @@
return space.call_args(w_callable, args)
GenExprInner.typedef = TypeDef('GenExprInner', Node.typedef,
- accept=interp2app(descr_GenExprInner_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ __new__ = interp2app(descr_GenExprInner_new, unwrap_spec=[ObjSpace, W_Root, W_Root, W_Root, int]),
+ accept=interp2app(descr_GenExprInner_accept, unwrap_spec=[ObjSpace, W_Root, W_Root] ),
expr=GetSetProperty(GenExprInner.fget_expr, GenExprInner.fset_expr ),
quals=GetSetProperty(GenExprInner.fget_quals, GenExprInner.fset_quals ),
)
@@ -1897,22 +2169,29 @@
def fget_expr( space, self):
return space.wrap(self.expr)
def fset_expr( space, self, w_arg):
- obj = space.interpclass_w( w_arg )
- if not isinstance( obj, Node):
- raise OperationError(space.w_TypeError,space.wrap('Need a Node instance'))
- self.expr = obj
+ self.expr = space.interp_w(Node, w_arg, can_be_None=False)
def fget_attrname( space, self):
return space.wrap(self.attrname)
def fset_attrname( space, self, w_arg):
self.attrname = space.str_w(w_arg)
+def descr_Getattr_new(space, w_subtype, w_expr, w_attrname, lineno=-1):
+ self = space.allocate_instance(Getattr, w_subtype)
+ expr = space.interp_w(Node, w_expr, can_be_None=False)
+ self.expr = expr
+ attrname = space.str_w(w_attrname)
+ self.attrname = attrname
+ self.lineno = lineno
+ return space.wrap(self)
+
def descr_Getattr_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitGetattr'))
args = Arguments(space, [ w_self ])
return space.call_args(w_callable, args)
Getattr.typedef = TypeDef('Getattr', Node.typedef,
- accept=interp2app(descr_Getattr_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ __new__ = interp2app(descr_Getattr_new, unwrap_spec=[ObjSpace, W_Root, W_Root, W_Root, int]),
+ accept=interp2app(descr_Getattr_accept, unwrap_spec=[ObjSpace, W_Root, W_Root] ),
expr=GetSetProperty(Getattr.fget_expr, Getattr.fset_expr ),
attrname=GetSetProperty(Getattr.fget_attrname, Getattr.fset_attrname ),
)
@@ -1942,13 +2221,21 @@
for itm in space.unpackiterable(w_arg):
self.names.append( space.str_w(itm) )
+def descr_Global_new(space, w_subtype, w_names, lineno=-1):
+ self = space.allocate_instance(Global, w_subtype)
+ names = [space.str_w(w_str) for w_str in space.unpackiterable(w_names)]
+ self.names = names
+ self.lineno = lineno
+ return space.wrap(self)
+
def descr_Global_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitGlobal'))
args = Arguments(space, [ w_self ])
return space.call_args(w_callable, args)
Global.typedef = TypeDef('Global', Node.typedef,
- accept=interp2app(descr_Global_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ __new__ = interp2app(descr_Global_new, unwrap_spec=[ObjSpace, W_Root, W_Root, int]),
+ accept=interp2app(descr_Global_accept, unwrap_spec=[ObjSpace, W_Root, W_Root] ),
names=GetSetProperty(Global.fget_names, Global.fset_names ),
)
@@ -1981,14 +2268,11 @@
for w_tup in space.unpackiterable( w_arg ):
w_test = space.getitem( w_tup, space.wrap(0) )
w_suite = space.getitem( w_tup, space.wrap(1) )
- test = space.interpclass_w( w_test )
- suite = space.interpclass_w( w_suite )
- if not isinstance( test, Node ) or not isinstance( suite, Node ):
- raise OperationError(space.w_TypeError, space.wrap("Need a list of (test,suite) nodes") )
+ test = space.interp_w(Node, w_test)
+ suite = space.interp_w(Node, w_suite)
self.tests.append( (test,suite) )
-
def fget_tests( space, self ):
return space.newlist( [ space.newtuple( [ space.wrap(test),
@@ -2008,13 +2292,24 @@
else:
return space.wrap(self.else_)
def fset_else_( space, self, w_arg):
- if space.is_w( w_arg, space.w_None ):
- self.else_ = None
- else:
- obj = space.interpclass_w( w_arg )
- if not isinstance( obj, Node):
- raise OperationError(space.w_TypeError,space.wrap('Need a Node instance'))
- self.else_ = obj
+ self.else_ = space.interp_w(Node, w_arg, can_be_None=True)
+
+def descr_If_new(space, w_subtype, w_tests, w_else_, lineno=-1):
+ self = space.allocate_instance(If, w_subtype)
+ tests = []
+ for w_tuple in space.unpackiterable(w_tests):
+ w_test = space.getitem(w_tuple, space.wrap(0))
+ w_suite = space.getitem(w_tuple, space.wrap(1))
+ test = space.interp_w(Node, w_test)
+ suite = space.interp_w(Node, w_suite)
+ tests.append((test, suite))
+ self.tests = tests
+ self.else_ = space.interp_w(Node, w_else_, can_be_None=True)
+ self.lineno = lineno
+ return space.wrap(self)
+
+
+
def descr_If_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitIf'))
@@ -2022,7 +2317,8 @@
return space.call_args(w_callable, args)
If.typedef = TypeDef('If', Node.typedef,
- accept=interp2app(descr_If_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ __new__ = interp2app(descr_If_new, unwrap_spec=[ObjSpace, W_Root, W_Root, W_Root, int]),
+ accept=interp2app(descr_If_accept, unwrap_spec=[ObjSpace, W_Root, W_Root] ),
tests=GetSetProperty(If.fget_tests, If.fset_tests ),
else_=GetSetProperty(If.fget_else_, If.fset_else_ ),
)
@@ -2063,13 +2359,31 @@
return visitor.visitImport(self)
+def descr_Import_new(space, w_subtype, w_names, lineno=-1):
+ self = space.allocate_instance(Import, w_subtype)
+ names = []
+ for w_tuple in space.unpackiterable(w_names):
+ w_name = space.getitem(w_tuple, space.wrap(0))
+ w_as_name = space.getitem(w_tuple, space.wrap(1))
+ name = space.str_w(w_name)
+ as_name = None
+ if not space.is_w(w_as_name, space.w_None):
+ as_name = space.str_w(w_as_name)
+ names.append((name, as_name))
+ self.names = names
+ self.lineno = lineno
+ return space.wrap(self)
+
+
+
def descr_Import_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitImport'))
args = Arguments(space, [ w_self ])
return space.call_args(w_callable, args)
Import.typedef = TypeDef('Import', Node.typedef,
- accept=interp2app(descr_Import_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ __new__ = interp2app(descr_Import_new, unwrap_spec=[ObjSpace, W_Root, W_Root, int]),
+ accept=interp2app(descr_Import_accept, unwrap_spec=[ObjSpace, W_Root, W_Root] ),
names=GetSetProperty(Import.fget_names, Import.fset_names ),
)
@@ -2094,10 +2408,14 @@
def fget_expr( space, self):
return space.wrap(self.expr)
def fset_expr( space, self, w_arg):
- obj = space.interpclass_w( w_arg )
- if not isinstance( obj, Node):
- raise OperationError(space.w_TypeError,space.wrap('Need a Node instance'))
- self.expr = obj
+ self.expr = space.interp_w(Node, w_arg, can_be_None=False)
+
+def descr_Invert_new(space, w_subtype, w_expr, lineno=-1):
+ self = space.allocate_instance(Invert, w_subtype)
+ expr = space.interp_w(Node, w_expr, can_be_None=False)
+ self.expr = expr
+ self.lineno = lineno
+ return space.wrap(self)
def descr_Invert_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitInvert'))
@@ -2105,7 +2423,8 @@
return space.call_args(w_callable, args)
Invert.typedef = TypeDef('Invert', UnaryOp.typedef,
- accept=interp2app(descr_Invert_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ __new__ = interp2app(descr_Invert_new, unwrap_spec=[ObjSpace, W_Root, W_Root, int]),
+ accept=interp2app(descr_Invert_accept, unwrap_spec=[ObjSpace, W_Root, W_Root] ),
expr=GetSetProperty(Invert.fget_expr, Invert.fset_expr ),
)
@@ -2135,10 +2454,16 @@
def fget_expr( space, self):
return space.wrap(self.expr)
def fset_expr( space, self, w_arg):
- obj = space.interpclass_w( w_arg )
- if not isinstance( obj, Node):
- raise OperationError(space.w_TypeError,space.wrap('Need a Node instance'))
- self.expr = obj
+ self.expr = space.interp_w(Node, w_arg, can_be_None=False)
+
+def descr_Keyword_new(space, w_subtype, w_name, w_expr, lineno=-1):
+ self = space.allocate_instance(Keyword, w_subtype)
+ name = space.str_w(w_name)
+ self.name = name
+ expr = space.interp_w(Node, w_expr, can_be_None=False)
+ self.expr = expr
+ self.lineno = lineno
+ return space.wrap(self)
def descr_Keyword_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitKeyword'))
@@ -2146,7 +2471,8 @@
return space.call_args(w_callable, args)
Keyword.typedef = TypeDef('Keyword', Node.typedef,
- accept=interp2app(descr_Keyword_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ __new__ = interp2app(descr_Keyword_new, unwrap_spec=[ObjSpace, W_Root, W_Root, W_Root, int]),
+ accept=interp2app(descr_Keyword_accept, unwrap_spec=[ObjSpace, W_Root, W_Root] ),
name=GetSetProperty(Keyword.fget_name, Keyword.fset_name ),
expr=GetSetProperty(Keyword.fget_expr, Keyword.fset_expr ),
)
@@ -2192,14 +2518,14 @@
return space.newlist( [space.wrap(itm) for itm in self.argnames] )
def fset_argnames( space, self, w_arg):
del self.argnames[:]
- for w_itm in space.unpackiterable( w_arg ):
- self.argnames.append( space.interpclass_w( w_arg ) )
+ for w_itm in space.unpackiterable(w_arg):
+ self.argnames.append( space.interp_w(Node, w_arg))
def fget_defaults( space, self):
return space.newlist( [space.wrap(itm) for itm in self.defaults] )
def fset_defaults( space, self, w_arg):
del self.defaults[:]
- for w_itm in space.unpackiterable( w_arg ):
- self.defaults.append( space.interpclass_w( w_arg ) )
+ for w_itm in space.unpackiterable(w_arg):
+ self.defaults.append( space.interp_w(Node, w_arg))
def fget_flags( space, self):
return space.wrap(self.flags)
def fset_flags( space, self, w_arg):
@@ -2207,10 +2533,20 @@
def fget_code( space, self):
return space.wrap(self.code)
def fset_code( space, self, w_arg):
- obj = space.interpclass_w( w_arg )
- if not isinstance( obj, Node):
- raise OperationError(space.w_TypeError,space.wrap('Need a Node instance'))
- self.code = obj
+ self.code = space.interp_w(Node, w_arg, can_be_None=False)
+
+def descr_Lambda_new(space, w_subtype, w_argnames, w_defaults, w_flags, w_code, lineno=-1):
+ self = space.allocate_instance(Lambda, w_subtype)
+ argnames = [space.interp_w(Node, w_node) for w_node in space.unpackiterable(w_argnames)]
+ self.argnames = argnames
+ defaults = [space.interp_w(Node, w_node) for w_node in space.unpackiterable(w_defaults)]
+ self.defaults = defaults
+ flags = space.int_w(w_flags)
+ self.flags = flags
+ code = space.interp_w(Node, w_code, can_be_None=False)
+ self.code = code
+ self.lineno = lineno
+ return space.wrap(self)
def descr_Lambda_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitLambda'))
@@ -2218,7 +2554,8 @@
return space.call_args(w_callable, args)
Lambda.typedef = TypeDef('Lambda', AbstractFunction.typedef,
- accept=interp2app(descr_Lambda_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ __new__ = interp2app(descr_Lambda_new, unwrap_spec=[ObjSpace, W_Root, W_Root, W_Root, W_Root, W_Root, int]),
+ accept=interp2app(descr_Lambda_accept, unwrap_spec=[ObjSpace, W_Root, W_Root] ),
argnames=GetSetProperty(Lambda.fget_argnames, Lambda.fset_argnames ),
defaults=GetSetProperty(Lambda.fget_defaults, Lambda.fset_defaults ),
flags=GetSetProperty(Lambda.fget_flags, Lambda.fset_flags ),
@@ -2247,17 +2584,20 @@
def fget_left( space, self):
return space.wrap(self.left)
def fset_left( space, self, w_arg):
- obj = space.interpclass_w( w_arg )
- if not isinstance( obj, Node):
- raise OperationError(space.w_TypeError,space.wrap('Need a Node instance'))
- self.left = obj
+ self.left = space.interp_w(Node, w_arg, can_be_None=False)
def fget_right( space, self):
return space.wrap(self.right)
def fset_right( space, self, w_arg):
- obj = space.interpclass_w( w_arg )
- if not isinstance( obj, Node):
- raise OperationError(space.w_TypeError,space.wrap('Need a Node instance'))
- self.right = obj
+ self.right = space.interp_w(Node, w_arg, can_be_None=False)
+
+def descr_LeftShift_new(space, w_subtype, w_left, w_right, lineno=-1):
+ self = space.allocate_instance(LeftShift, w_subtype)
+ left = space.interp_w(Node, w_left, can_be_None=False)
+ self.left = left
+ right = space.interp_w(Node, w_right, can_be_None=False)
+ self.right = right
+ self.lineno = lineno
+ return space.wrap(self)
def descr_LeftShift_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitLeftShift'))
@@ -2265,7 +2605,8 @@
return space.call_args(w_callable, args)
LeftShift.typedef = TypeDef('LeftShift', BinaryOp.typedef,
- accept=interp2app(descr_LeftShift_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ __new__ = interp2app(descr_LeftShift_new, unwrap_spec=[ObjSpace, W_Root, W_Root, W_Root, int]),
+ accept=interp2app(descr_LeftShift_accept, unwrap_spec=[ObjSpace, W_Root, W_Root] ),
left=GetSetProperty(LeftShift.fget_left, LeftShift.fset_left ),
right=GetSetProperty(LeftShift.fget_right, LeftShift.fset_right ),
)
@@ -2294,8 +2635,15 @@
return space.newlist( [space.wrap(itm) for itm in self.nodes] )
def fset_nodes( space, self, w_arg):
del self.nodes[:]
- for w_itm in space.unpackiterable( w_arg ):
- self.nodes.append( space.interpclass_w( w_arg ) )
+ for w_itm in space.unpackiterable(w_arg):
+ self.nodes.append( space.interp_w(Node, w_arg))
+
+def descr_List_new(space, w_subtype, w_nodes, lineno=-1):
+ self = space.allocate_instance(List, w_subtype)
+ nodes = [space.interp_w(Node, w_node) for w_node in space.unpackiterable(w_nodes)]
+ self.nodes = nodes
+ self.lineno = lineno
+ return space.wrap(self)
def descr_List_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitList'))
@@ -2303,7 +2651,8 @@
return space.call_args(w_callable, args)
List.typedef = TypeDef('List', Node.typedef,
- accept=interp2app(descr_List_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ __new__ = interp2app(descr_List_new, unwrap_spec=[ObjSpace, W_Root, W_Root, int]),
+ accept=interp2app(descr_List_accept, unwrap_spec=[ObjSpace, W_Root, W_Root] ),
nodes=GetSetProperty(List.fget_nodes, List.fset_nodes ),
)
@@ -2335,16 +2684,22 @@
def fget_expr( space, self):
return space.wrap(self.expr)
def fset_expr( space, self, w_arg):
- obj = space.interpclass_w( w_arg )
- if not isinstance( obj, Node):
- raise OperationError(space.w_TypeError,space.wrap('Need a Node instance'))
- self.expr = obj
+ self.expr = space.interp_w(Node, w_arg, can_be_None=False)
def fget_quals( space, self):
return space.newlist( [space.wrap(itm) for itm in self.quals] )
def fset_quals( space, self, w_arg):
del self.quals[:]
- for w_itm in space.unpackiterable( w_arg ):
- self.quals.append( space.interpclass_w( w_arg ) )
+ for w_itm in space.unpackiterable(w_arg):
+ self.quals.append( space.interp_w(Node, w_arg))
+
+def descr_ListComp_new(space, w_subtype, w_expr, w_quals, lineno=-1):
+ self = space.allocate_instance(ListComp, w_subtype)
+ expr = space.interp_w(Node, w_expr, can_be_None=False)
+ self.expr = expr
+ quals = [space.interp_w(Node, w_node) for w_node in space.unpackiterable(w_quals)]
+ self.quals = quals
+ self.lineno = lineno
+ return space.wrap(self)
def descr_ListComp_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitListComp'))
@@ -2352,7 +2707,8 @@
return space.call_args(w_callable, args)
ListComp.typedef = TypeDef('ListComp', Node.typedef,
- accept=interp2app(descr_ListComp_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ __new__ = interp2app(descr_ListComp_new, unwrap_spec=[ObjSpace, W_Root, W_Root, W_Root, int]),
+ accept=interp2app(descr_ListComp_accept, unwrap_spec=[ObjSpace, W_Root, W_Root] ),
expr=GetSetProperty(ListComp.fget_expr, ListComp.fset_expr ),
quals=GetSetProperty(ListComp.fget_quals, ListComp.fset_quals ),
)
@@ -2388,23 +2744,28 @@
def fget_assign( space, self):
return space.wrap(self.assign)
def fset_assign( space, self, w_arg):
- obj = space.interpclass_w( w_arg )
- if not isinstance( obj, Node):
- raise OperationError(space.w_TypeError,space.wrap('Need a Node instance'))
- self.assign = obj
+ self.assign = space.interp_w(Node, w_arg, can_be_None=False)
def fget_list( space, self):
return space.wrap(self.list)
def fset_list( space, self, w_arg):
- obj = space.interpclass_w( w_arg )
- if not isinstance( obj, Node):
- raise OperationError(space.w_TypeError,space.wrap('Need a Node instance'))
- self.list = obj
+ self.list = space.interp_w(Node, w_arg, can_be_None=False)
def fget_ifs( space, self):
return space.newlist( [space.wrap(itm) for itm in self.ifs] )
def fset_ifs( space, self, w_arg):
del self.ifs[:]
- for w_itm in space.unpackiterable( w_arg ):
- self.ifs.append( space.interpclass_w( w_arg ) )
+ for w_itm in space.unpackiterable(w_arg):
+ self.ifs.append( space.interp_w(Node, w_arg))
+
+def descr_ListCompFor_new(space, w_subtype, w_assign, w_list, w_ifs, lineno=-1):
+ self = space.allocate_instance(ListCompFor, w_subtype)
+ assign = space.interp_w(Node, w_assign, can_be_None=False)
+ self.assign = assign
+ list = space.interp_w(Node, w_list, can_be_None=False)
+ self.list = list
+ ifs = [space.interp_w(Node, w_node) for w_node in space.unpackiterable(w_ifs)]
+ self.ifs = ifs
+ self.lineno = lineno
+ return space.wrap(self)
def descr_ListCompFor_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitListCompFor'))
@@ -2412,7 +2773,8 @@
return space.call_args(w_callable, args)
ListCompFor.typedef = TypeDef('ListCompFor', Node.typedef,
- accept=interp2app(descr_ListCompFor_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ __new__ = interp2app(descr_ListCompFor_new, unwrap_spec=[ObjSpace, W_Root, W_Root, W_Root, W_Root, int]),
+ accept=interp2app(descr_ListCompFor_accept, unwrap_spec=[ObjSpace, W_Root, W_Root] ),
assign=GetSetProperty(ListCompFor.fget_assign, ListCompFor.fset_assign ),
list=GetSetProperty(ListCompFor.fget_list, ListCompFor.fset_list ),
ifs=GetSetProperty(ListCompFor.fget_ifs, ListCompFor.fset_ifs ),
@@ -2439,10 +2801,14 @@
def fget_test( space, self):
return space.wrap(self.test)
def fset_test( space, self, w_arg):
- obj = space.interpclass_w( w_arg )
- if not isinstance( obj, Node):
- raise OperationError(space.w_TypeError,space.wrap('Need a Node instance'))
- self.test = obj
+ self.test = space.interp_w(Node, w_arg, can_be_None=False)
+
+def descr_ListCompIf_new(space, w_subtype, w_test, lineno=-1):
+ self = space.allocate_instance(ListCompIf, w_subtype)
+ test = space.interp_w(Node, w_test, can_be_None=False)
+ self.test = test
+ self.lineno = lineno
+ return space.wrap(self)
def descr_ListCompIf_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitListCompIf'))
@@ -2450,7 +2816,8 @@
return space.call_args(w_callable, args)
ListCompIf.typedef = TypeDef('ListCompIf', Node.typedef,
- accept=interp2app(descr_ListCompIf_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ __new__ = interp2app(descr_ListCompIf_new, unwrap_spec=[ObjSpace, W_Root, W_Root, int]),
+ accept=interp2app(descr_ListCompIf_accept, unwrap_spec=[ObjSpace, W_Root, W_Root] ),
test=GetSetProperty(ListCompIf.fget_test, ListCompIf.fset_test ),
)
@@ -2476,17 +2843,20 @@
def fget_left( space, self):
return space.wrap(self.left)
def fset_left( space, self, w_arg):
- obj = space.interpclass_w( w_arg )
- if not isinstance( obj, Node):
- raise OperationError(space.w_TypeError,space.wrap('Need a Node instance'))
- self.left = obj
+ self.left = space.interp_w(Node, w_arg, can_be_None=False)
def fget_right( space, self):
return space.wrap(self.right)
def fset_right( space, self, w_arg):
- obj = space.interpclass_w( w_arg )
- if not isinstance( obj, Node):
- raise OperationError(space.w_TypeError,space.wrap('Need a Node instance'))
- self.right = obj
+ self.right = space.interp_w(Node, w_arg, can_be_None=False)
+
+def descr_Mod_new(space, w_subtype, w_left, w_right, lineno=-1):
+ self = space.allocate_instance(Mod, w_subtype)
+ left = space.interp_w(Node, w_left, can_be_None=False)
+ self.left = left
+ right = space.interp_w(Node, w_right, can_be_None=False)
+ self.right = right
+ self.lineno = lineno
+ return space.wrap(self)
def descr_Mod_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitMod'))
@@ -2494,7 +2864,8 @@
return space.call_args(w_callable, args)
Mod.typedef = TypeDef('Mod', BinaryOp.typedef,
- accept=interp2app(descr_Mod_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ __new__ = interp2app(descr_Mod_new, unwrap_spec=[ObjSpace, W_Root, W_Root, W_Root, int]),
+ accept=interp2app(descr_Mod_accept, unwrap_spec=[ObjSpace, W_Root, W_Root] ),
left=GetSetProperty(Mod.fget_left, Mod.fset_left ),
right=GetSetProperty(Mod.fget_right, Mod.fset_right ),
)
@@ -2525,10 +2896,17 @@
def fget_node( space, self):
return space.wrap(self.node)
def fset_node( space, self, w_arg):
- obj = space.interpclass_w( w_arg )
- if not isinstance( obj, Node):
- raise OperationError(space.w_TypeError,space.wrap('Need a Node instance'))
- self.node = obj
+ self.node = space.interp_w(Node, w_arg, can_be_None=False)
+
+def descr_Module_new(space, w_subtype, w_w_doc, w_node, lineno=-1):
+ self = space.allocate_instance(Module, w_subtype)
+ # This dummy assingment is auto-generated, astgen.py should be fixed to avoid that
+ w_doc = w_w_doc
+ self.w_doc = w_doc
+ node = space.interp_w(Node, w_node, can_be_None=False)
+ self.node = node
+ self.lineno = lineno
+ return space.wrap(self)
def descr_Module_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitModule'))
@@ -2536,7 +2914,8 @@
return space.call_args(w_callable, args)
Module.typedef = TypeDef('Module', Node.typedef,
- accept=interp2app(descr_Module_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ __new__ = interp2app(descr_Module_new, unwrap_spec=[ObjSpace, W_Root, W_Root, W_Root, int]),
+ accept=interp2app(descr_Module_accept, unwrap_spec=[ObjSpace, W_Root, W_Root] ),
w_doc=GetSetProperty(Module.fget_w_doc, Module.fset_w_doc ),
node=GetSetProperty(Module.fget_node, Module.fset_node ),
)
@@ -2563,17 +2942,20 @@
def fget_left( space, self):
return space.wrap(self.left)
def fset_left( space, self, w_arg):
- obj = space.interpclass_w( w_arg )
- if not isinstance( obj, Node):
- raise OperationError(space.w_TypeError,space.wrap('Need a Node instance'))
- self.left = obj
+ self.left = space.interp_w(Node, w_arg, can_be_None=False)
def fget_right( space, self):
return space.wrap(self.right)
def fset_right( space, self, w_arg):
- obj = space.interpclass_w( w_arg )
- if not isinstance( obj, Node):
- raise OperationError(space.w_TypeError,space.wrap('Need a Node instance'))
- self.right = obj
+ self.right = space.interp_w(Node, w_arg, can_be_None=False)
+
+def descr_Mul_new(space, w_subtype, w_left, w_right, lineno=-1):
+ self = space.allocate_instance(Mul, w_subtype)
+ left = space.interp_w(Node, w_left, can_be_None=False)
+ self.left = left
+ right = space.interp_w(Node, w_right, can_be_None=False)
+ self.right = right
+ self.lineno = lineno
+ return space.wrap(self)
def descr_Mul_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitMul'))
@@ -2581,7 +2963,8 @@
return space.call_args(w_callable, args)
Mul.typedef = TypeDef('Mul', BinaryOp.typedef,
- accept=interp2app(descr_Mul_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ __new__ = interp2app(descr_Mul_new, unwrap_spec=[ObjSpace, W_Root, W_Root, W_Root, int]),
+ accept=interp2app(descr_Mul_accept, unwrap_spec=[ObjSpace, W_Root, W_Root] ),
left=GetSetProperty(Mul.fget_left, Mul.fset_left ),
right=GetSetProperty(Mul.fget_right, Mul.fset_right ),
)
@@ -2609,13 +2992,21 @@
def fset_varname( space, self, w_arg):
self.varname = space.str_w(w_arg)
+def descr_Name_new(space, w_subtype, w_varname, lineno=-1):
+ self = space.allocate_instance(Name, w_subtype)
+ varname = space.str_w(w_varname)
+ self.varname = varname
+ self.lineno = lineno
+ return space.wrap(self)
+
def descr_Name_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitName'))
args = Arguments(space, [ w_self ])
return space.call_args(w_callable, args)
Name.typedef = TypeDef('Name', Node.typedef,
- accept=interp2app(descr_Name_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ __new__ = interp2app(descr_Name_new, unwrap_spec=[ObjSpace, W_Root, W_Root, int]),
+ accept=interp2app(descr_Name_accept, unwrap_spec=[ObjSpace, W_Root, W_Root] ),
varname=GetSetProperty(Name.fget_varname, Name.fset_varname ),
)
@@ -2637,13 +3028,19 @@
return visitor.visitNoneConst(self)
+def descr_NoneConst_new(space, w_subtype, lineno=-1):
+ self = space.allocate_instance(NoneConst, w_subtype)
+ self.lineno = lineno
+ return space.wrap(self)
+
def descr_NoneConst_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitNoneConst'))
args = Arguments(space, [ w_self ])
return space.call_args(w_callable, args)
NoneConst.typedef = TypeDef('NoneConst', Node.typedef,
- accept=interp2app(descr_NoneConst_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ __new__ = interp2app(descr_NoneConst_new, unwrap_spec=[ObjSpace, W_Root, int]),
+ accept=interp2app(descr_NoneConst_accept, unwrap_spec=[ObjSpace, W_Root, W_Root] ),
)
class Not(UnaryOp):
@@ -2667,10 +3064,14 @@
def fget_expr( space, self):
return space.wrap(self.expr)
def fset_expr( space, self, w_arg):
- obj = space.interpclass_w( w_arg )
- if not isinstance( obj, Node):
- raise OperationError(space.w_TypeError,space.wrap('Need a Node instance'))
- self.expr = obj
+ self.expr = space.interp_w(Node, w_arg, can_be_None=False)
+
+def descr_Not_new(space, w_subtype, w_expr, lineno=-1):
+ self = space.allocate_instance(Not, w_subtype)
+ expr = space.interp_w(Node, w_expr, can_be_None=False)
+ self.expr = expr
+ self.lineno = lineno
+ return space.wrap(self)
def descr_Not_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitNot'))
@@ -2678,7 +3079,8 @@
return space.call_args(w_callable, args)
Not.typedef = TypeDef('Not', UnaryOp.typedef,
- accept=interp2app(descr_Not_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ __new__ = interp2app(descr_Not_new, unwrap_spec=[ObjSpace, W_Root, W_Root, int]),
+ accept=interp2app(descr_Not_accept, unwrap_spec=[ObjSpace, W_Root, W_Root] ),
expr=GetSetProperty(Not.fget_expr, Not.fset_expr ),
)
@@ -2706,8 +3108,15 @@
return space.newlist( [space.wrap(itm) for itm in self.nodes] )
def fset_nodes( space, self, w_arg):
del self.nodes[:]
- for w_itm in space.unpackiterable( w_arg ):
- self.nodes.append( space.interpclass_w( w_arg ) )
+ for w_itm in space.unpackiterable(w_arg):
+ self.nodes.append( space.interp_w(Node, w_arg))
+
+def descr_Or_new(space, w_subtype, w_nodes, lineno=-1):
+ self = space.allocate_instance(Or, w_subtype)
+ nodes = [space.interp_w(Node, w_node) for w_node in space.unpackiterable(w_nodes)]
+ self.nodes = nodes
+ self.lineno = lineno
+ return space.wrap(self)
def descr_Or_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitOr'))
@@ -2715,7 +3124,8 @@
return space.call_args(w_callable, args)
Or.typedef = TypeDef('Or', AbstractTest.typedef,
- accept=interp2app(descr_Or_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ __new__ = interp2app(descr_Or_new, unwrap_spec=[ObjSpace, W_Root, W_Root, int]),
+ accept=interp2app(descr_Or_accept, unwrap_spec=[ObjSpace, W_Root, W_Root] ),
nodes=GetSetProperty(Or.fget_nodes, Or.fset_nodes ),
)
@@ -2737,13 +3147,19 @@
return visitor.visitPass(self)
+def descr_Pass_new(space, w_subtype, lineno=-1):
+ self = space.allocate_instance(Pass, w_subtype)
+ self.lineno = lineno
+ return space.wrap(self)
+
def descr_Pass_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitPass'))
args = Arguments(space, [ w_self ])
return space.call_args(w_callable, args)
Pass.typedef = TypeDef('Pass', Node.typedef,
- accept=interp2app(descr_Pass_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ __new__ = interp2app(descr_Pass_new, unwrap_spec=[ObjSpace, W_Root, int]),
+ accept=interp2app(descr_Pass_accept, unwrap_spec=[ObjSpace, W_Root, W_Root] ),
)
class Power(BinaryOp):
@@ -2768,17 +3184,20 @@
def fget_left( space, self):
return space.wrap(self.left)
def fset_left( space, self, w_arg):
- obj = space.interpclass_w( w_arg )
- if not isinstance( obj, Node):
- raise OperationError(space.w_TypeError,space.wrap('Need a Node instance'))
- self.left = obj
+ self.left = space.interp_w(Node, w_arg, can_be_None=False)
def fget_right( space, self):
return space.wrap(self.right)
def fset_right( space, self, w_arg):
- obj = space.interpclass_w( w_arg )
- if not isinstance( obj, Node):
- raise OperationError(space.w_TypeError,space.wrap('Need a Node instance'))
- self.right = obj
+ self.right = space.interp_w(Node, w_arg, can_be_None=False)
+
+def descr_Power_new(space, w_subtype, w_left, w_right, lineno=-1):
+ self = space.allocate_instance(Power, w_subtype)
+ left = space.interp_w(Node, w_left, can_be_None=False)
+ self.left = left
+ right = space.interp_w(Node, w_right, can_be_None=False)
+ self.right = right
+ self.lineno = lineno
+ return space.wrap(self)
def descr_Power_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitPower'))
@@ -2786,7 +3205,8 @@
return space.call_args(w_callable, args)
Power.typedef = TypeDef('Power', BinaryOp.typedef,
- accept=interp2app(descr_Power_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ __new__ = interp2app(descr_Power_new, unwrap_spec=[ObjSpace, W_Root, W_Root, W_Root, int]),
+ accept=interp2app(descr_Power_accept, unwrap_spec=[ObjSpace, W_Root, W_Root] ),
left=GetSetProperty(Power.fget_left, Power.fset_left ),
right=GetSetProperty(Power.fget_right, Power.fset_right ),
)
@@ -2821,21 +3241,24 @@
return space.newlist( [space.wrap(itm) for itm in self.nodes] )
def fset_nodes( space, self, w_arg):
del self.nodes[:]
- for w_itm in space.unpackiterable( w_arg ):
- self.nodes.append( space.interpclass_w( w_arg ) )
+ for w_itm in space.unpackiterable(w_arg):
+ self.nodes.append( space.interp_w(Node, w_arg))
def fget_dest( space, self):
if self.dest is None:
return space.w_None
else:
return space.wrap(self.dest)
def fset_dest( space, self, w_arg):
- if space.is_w( w_arg, space.w_None ):
- self.dest = None
- else:
- obj = space.interpclass_w( w_arg )
- if not isinstance( obj, Node):
- raise OperationError(space.w_TypeError,space.wrap('Need a Node instance'))
- self.dest = obj
+ self.dest = space.interp_w(Node, w_arg, can_be_None=True)
+
+def descr_Print_new(space, w_subtype, w_nodes, w_dest, lineno=-1):
+ self = space.allocate_instance(Print, w_subtype)
+ nodes = [space.interp_w(Node, w_node) for w_node in space.unpackiterable(w_nodes)]
+ self.nodes = nodes
+ dest = space.interp_w(Node, w_dest, can_be_None=True)
+ self.dest = dest
+ self.lineno = lineno
+ return space.wrap(self)
def descr_Print_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitPrint'))
@@ -2843,7 +3266,8 @@
return space.call_args(w_callable, args)
Print.typedef = TypeDef('Print', Node.typedef,
- accept=interp2app(descr_Print_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ __new__ = interp2app(descr_Print_new, unwrap_spec=[ObjSpace, W_Root, W_Root, W_Root, int]),
+ accept=interp2app(descr_Print_accept, unwrap_spec=[ObjSpace, W_Root, W_Root] ),
nodes=GetSetProperty(Print.fget_nodes, Print.fset_nodes ),
dest=GetSetProperty(Print.fget_dest, Print.fset_dest ),
)
@@ -2878,21 +3302,24 @@
return space.newlist( [space.wrap(itm) for itm in self.nodes] )
def fset_nodes( space, self, w_arg):
del self.nodes[:]
- for w_itm in space.unpackiterable( w_arg ):
- self.nodes.append( space.interpclass_w( w_arg ) )
+ for w_itm in space.unpackiterable(w_arg):
+ self.nodes.append( space.interp_w(Node, w_arg))
def fget_dest( space, self):
if self.dest is None:
return space.w_None
else:
return space.wrap(self.dest)
def fset_dest( space, self, w_arg):
- if space.is_w( w_arg, space.w_None ):
- self.dest = None
- else:
- obj = space.interpclass_w( w_arg )
- if not isinstance( obj, Node):
- raise OperationError(space.w_TypeError,space.wrap('Need a Node instance'))
- self.dest = obj
+ self.dest = space.interp_w(Node, w_arg, can_be_None=True)
+
+def descr_Printnl_new(space, w_subtype, w_nodes, w_dest, lineno=-1):
+ self = space.allocate_instance(Printnl, w_subtype)
+ nodes = [space.interp_w(Node, w_node) for w_node in space.unpackiterable(w_nodes)]
+ self.nodes = nodes
+ dest = space.interp_w(Node, w_dest, can_be_None=True)
+ self.dest = dest
+ self.lineno = lineno
+ return space.wrap(self)
def descr_Printnl_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitPrintnl'))
@@ -2900,7 +3327,8 @@
return space.call_args(w_callable, args)
Printnl.typedef = TypeDef('Printnl', Node.typedef,
- accept=interp2app(descr_Printnl_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ __new__ = interp2app(descr_Printnl_new, unwrap_spec=[ObjSpace, W_Root, W_Root, W_Root, int]),
+ accept=interp2app(descr_Printnl_accept, unwrap_spec=[ObjSpace, W_Root, W_Root] ),
nodes=GetSetProperty(Printnl.fget_nodes, Printnl.fset_nodes ),
dest=GetSetProperty(Printnl.fget_dest, Printnl.fset_dest ),
)
@@ -2942,39 +3370,32 @@
else:
return space.wrap(self.expr1)
def fset_expr1( space, self, w_arg):
- if space.is_w( w_arg, space.w_None ):
- self.expr1 = None
- else:
- obj = space.interpclass_w( w_arg )
- if not isinstance( obj, Node):
- raise OperationError(space.w_TypeError,space.wrap('Need a Node instance'))
- self.expr1 = obj
+ self.expr1 = space.interp_w(Node, w_arg, can_be_None=True)
def fget_expr2( space, self):
if self.expr2 is None:
return space.w_None
else:
return space.wrap(self.expr2)
def fset_expr2( space, self, w_arg):
- if space.is_w( w_arg, space.w_None ):
- self.expr2 = None
- else:
- obj = space.interpclass_w( w_arg )
- if not isinstance( obj, Node):
- raise OperationError(space.w_TypeError,space.wrap('Need a Node instance'))
- self.expr2 = obj
+ self.expr2 = space.interp_w(Node, w_arg, can_be_None=True)
def fget_expr3( space, self):
if self.expr3 is None:
return space.w_None
else:
return space.wrap(self.expr3)
def fset_expr3( space, self, w_arg):
- if space.is_w( w_arg, space.w_None ):
- self.expr3 = None
- else:
- obj = space.interpclass_w( w_arg )
- if not isinstance( obj, Node):
- raise OperationError(space.w_TypeError,space.wrap('Need a Node instance'))
- self.expr3 = obj
+ self.expr3 = space.interp_w(Node, w_arg, can_be_None=True)
+
+def descr_Raise_new(space, w_subtype, w_expr1, w_expr2, w_expr3, lineno=-1):
+ self = space.allocate_instance(Raise, w_subtype)
+ expr1 = space.interp_w(Node, w_expr1, can_be_None=True)
+ self.expr1 = expr1
+ expr2 = space.interp_w(Node, w_expr2, can_be_None=True)
+ self.expr2 = expr2
+ expr3 = space.interp_w(Node, w_expr3, can_be_None=True)
+ self.expr3 = expr3
+ self.lineno = lineno
+ return space.wrap(self)
def descr_Raise_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitRaise'))
@@ -2982,7 +3403,8 @@
return space.call_args(w_callable, args)
Raise.typedef = TypeDef('Raise', Node.typedef,
- accept=interp2app(descr_Raise_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ __new__ = interp2app(descr_Raise_new, unwrap_spec=[ObjSpace, W_Root, W_Root, W_Root, W_Root, int]),
+ accept=interp2app(descr_Raise_accept, unwrap_spec=[ObjSpace, W_Root, W_Root] ),
expr1=GetSetProperty(Raise.fget_expr1, Raise.fset_expr1 ),
expr2=GetSetProperty(Raise.fget_expr2, Raise.fset_expr2 ),
expr3=GetSetProperty(Raise.fget_expr3, Raise.fset_expr3 ),
@@ -3015,13 +3437,14 @@
else:
return space.wrap(self.value)
def fset_value( space, self, w_arg):
- if space.is_w( w_arg, space.w_None ):
- self.value = None
- else:
- obj = space.interpclass_w( w_arg )
- if not isinstance( obj, Node):
- raise OperationError(space.w_TypeError,space.wrap('Need a Node instance'))
- self.value = obj
+ self.value = space.interp_w(Node, w_arg, can_be_None=True)
+
+def descr_Return_new(space, w_subtype, w_value, lineno=-1):
+ self = space.allocate_instance(Return, w_subtype)
+ value = space.interp_w(Node, w_value, can_be_None=True)
+ self.value = value
+ self.lineno = lineno
+ return space.wrap(self)
def descr_Return_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitReturn'))
@@ -3029,7 +3452,8 @@
return space.call_args(w_callable, args)
Return.typedef = TypeDef('Return', Node.typedef,
- accept=interp2app(descr_Return_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ __new__ = interp2app(descr_Return_new, unwrap_spec=[ObjSpace, W_Root, W_Root, int]),
+ accept=interp2app(descr_Return_accept, unwrap_spec=[ObjSpace, W_Root, W_Root] ),
value=GetSetProperty(Return.fget_value, Return.fset_value ),
)
@@ -3055,17 +3479,20 @@
def fget_left( space, self):
return space.wrap(self.left)
def fset_left( space, self, w_arg):
- obj = space.interpclass_w( w_arg )
- if not isinstance( obj, Node):
- raise OperationError(space.w_TypeError,space.wrap('Need a Node instance'))
- self.left = obj
+ self.left = space.interp_w(Node, w_arg, can_be_None=False)
def fget_right( space, self):
return space.wrap(self.right)
def fset_right( space, self, w_arg):
- obj = space.interpclass_w( w_arg )
- if not isinstance( obj, Node):
- raise OperationError(space.w_TypeError,space.wrap('Need a Node instance'))
- self.right = obj
+ self.right = space.interp_w(Node, w_arg, can_be_None=False)
+
+def descr_RightShift_new(space, w_subtype, w_left, w_right, lineno=-1):
+ self = space.allocate_instance(RightShift, w_subtype)
+ left = space.interp_w(Node, w_left, can_be_None=False)
+ self.left = left
+ right = space.interp_w(Node, w_right, can_be_None=False)
+ self.right = right
+ self.lineno = lineno
+ return space.wrap(self)
def descr_RightShift_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitRightShift'))
@@ -3073,7 +3500,8 @@
return space.call_args(w_callable, args)
RightShift.typedef = TypeDef('RightShift', BinaryOp.typedef,
- accept=interp2app(descr_RightShift_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ __new__ = interp2app(descr_RightShift_new, unwrap_spec=[ObjSpace, W_Root, W_Root, W_Root, int]),
+ accept=interp2app(descr_RightShift_accept, unwrap_spec=[ObjSpace, W_Root, W_Root] ),
left=GetSetProperty(RightShift.fget_left, RightShift.fset_left ),
right=GetSetProperty(RightShift.fget_right, RightShift.fset_right ),
)
@@ -3113,10 +3541,7 @@
def fget_expr( space, self):
return space.wrap(self.expr)
def fset_expr( space, self, w_arg):
- obj = space.interpclass_w( w_arg )
- if not isinstance( obj, Node):
- raise OperationError(space.w_TypeError,space.wrap('Need a Node instance'))
- self.expr = obj
+ self.expr = space.interp_w(Node, w_arg, can_be_None=False)
def fget_flags( space, self):
return space.wrap(self.flags)
def fset_flags( space, self, w_arg):
@@ -3127,26 +3552,27 @@
else:
return space.wrap(self.lower)
def fset_lower( space, self, w_arg):
- if space.is_w( w_arg, space.w_None ):
- self.lower = None
- else:
- obj = space.interpclass_w( w_arg )
- if not isinstance( obj, Node):
- raise OperationError(space.w_TypeError,space.wrap('Need a Node instance'))
- self.lower = obj
+ self.lower = space.interp_w(Node, w_arg, can_be_None=True)
def fget_upper( space, self):
if self.upper is None:
return space.w_None
else:
return space.wrap(self.upper)
def fset_upper( space, self, w_arg):
- if space.is_w( w_arg, space.w_None ):
- self.upper = None
- else:
- obj = space.interpclass_w( w_arg )
- if not isinstance( obj, Node):
- raise OperationError(space.w_TypeError,space.wrap('Need a Node instance'))
- self.upper = obj
+ self.upper = space.interp_w(Node, w_arg, can_be_None=True)
+
+def descr_Slice_new(space, w_subtype, w_expr, w_flags, w_lower, w_upper, lineno=-1):
+ self = space.allocate_instance(Slice, w_subtype)
+ expr = space.interp_w(Node, w_expr, can_be_None=False)
+ self.expr = expr
+ flags = space.int_w(w_flags)
+ self.flags = flags
+ lower = space.interp_w(Node, w_lower, can_be_None=True)
+ self.lower = lower
+ upper = space.interp_w(Node, w_upper, can_be_None=True)
+ self.upper = upper
+ self.lineno = lineno
+ return space.wrap(self)
def descr_Slice_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitSlice'))
@@ -3154,7 +3580,8 @@
return space.call_args(w_callable, args)
Slice.typedef = TypeDef('Slice', Node.typedef,
- accept=interp2app(descr_Slice_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ __new__ = interp2app(descr_Slice_new, unwrap_spec=[ObjSpace, W_Root, W_Root, W_Root, W_Root, W_Root, int]),
+ accept=interp2app(descr_Slice_accept, unwrap_spec=[ObjSpace, W_Root, W_Root] ),
expr=GetSetProperty(Slice.fget_expr, Slice.fset_expr ),
flags=GetSetProperty(Slice.fget_flags, Slice.fset_flags ),
lower=GetSetProperty(Slice.fget_lower, Slice.fset_lower ),
@@ -3185,8 +3612,15 @@
return space.newlist( [space.wrap(itm) for itm in self.nodes] )
def fset_nodes( space, self, w_arg):
del self.nodes[:]
- for w_itm in space.unpackiterable( w_arg ):
- self.nodes.append( space.interpclass_w( w_arg ) )
+ for w_itm in space.unpackiterable(w_arg):
+ self.nodes.append( space.interp_w(Node, w_arg))
+
+def descr_Sliceobj_new(space, w_subtype, w_nodes, lineno=-1):
+ self = space.allocate_instance(Sliceobj, w_subtype)
+ nodes = [space.interp_w(Node, w_node) for w_node in space.unpackiterable(w_nodes)]
+ self.nodes = nodes
+ self.lineno = lineno
+ return space.wrap(self)
def descr_Sliceobj_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitSliceobj'))
@@ -3194,7 +3628,8 @@
return space.call_args(w_callable, args)
Sliceobj.typedef = TypeDef('Sliceobj', Node.typedef,
- accept=interp2app(descr_Sliceobj_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ __new__ = interp2app(descr_Sliceobj_new, unwrap_spec=[ObjSpace, W_Root, W_Root, int]),
+ accept=interp2app(descr_Sliceobj_accept, unwrap_spec=[ObjSpace, W_Root, W_Root] ),
nodes=GetSetProperty(Sliceobj.fget_nodes, Sliceobj.fset_nodes ),
)
@@ -3222,8 +3657,15 @@
return space.newlist( [space.wrap(itm) for itm in self.nodes] )
def fset_nodes( space, self, w_arg):
del self.nodes[:]
- for w_itm in space.unpackiterable( w_arg ):
- self.nodes.append( space.interpclass_w( w_arg ) )
+ for w_itm in space.unpackiterable(w_arg):
+ self.nodes.append( space.interp_w(Node, w_arg))
+
+def descr_Stmt_new(space, w_subtype, w_nodes, lineno=-1):
+ self = space.allocate_instance(Stmt, w_subtype)
+ nodes = [space.interp_w(Node, w_node) for w_node in space.unpackiterable(w_nodes)]
+ self.nodes = nodes
+ self.lineno = lineno
+ return space.wrap(self)
def descr_Stmt_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitStmt'))
@@ -3231,7 +3673,8 @@
return space.call_args(w_callable, args)
Stmt.typedef = TypeDef('Stmt', Node.typedef,
- accept=interp2app(descr_Stmt_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ __new__ = interp2app(descr_Stmt_new, unwrap_spec=[ObjSpace, W_Root, W_Root, int]),
+ accept=interp2app(descr_Stmt_accept, unwrap_spec=[ObjSpace, W_Root, W_Root] ),
nodes=GetSetProperty(Stmt.fget_nodes, Stmt.fset_nodes ),
)
@@ -3257,17 +3700,20 @@
def fget_left( space, self):
return space.wrap(self.left)
def fset_left( space, self, w_arg):
- obj = space.interpclass_w( w_arg )
- if not isinstance( obj, Node):
- raise OperationError(space.w_TypeError,space.wrap('Need a Node instance'))
- self.left = obj
+ self.left = space.interp_w(Node, w_arg, can_be_None=False)
def fget_right( space, self):
return space.wrap(self.right)
def fset_right( space, self, w_arg):
- obj = space.interpclass_w( w_arg )
- if not isinstance( obj, Node):
- raise OperationError(space.w_TypeError,space.wrap('Need a Node instance'))
- self.right = obj
+ self.right = space.interp_w(Node, w_arg, can_be_None=False)
+
+def descr_Sub_new(space, w_subtype, w_left, w_right, lineno=-1):
+ self = space.allocate_instance(Sub, w_subtype)
+ left = space.interp_w(Node, w_left, can_be_None=False)
+ self.left = left
+ right = space.interp_w(Node, w_right, can_be_None=False)
+ self.right = right
+ self.lineno = lineno
+ return space.wrap(self)
def descr_Sub_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitSub'))
@@ -3275,7 +3721,8 @@
return space.call_args(w_callable, args)
Sub.typedef = TypeDef('Sub', BinaryOp.typedef,
- accept=interp2app(descr_Sub_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ __new__ = interp2app(descr_Sub_new, unwrap_spec=[ObjSpace, W_Root, W_Root, W_Root, int]),
+ accept=interp2app(descr_Sub_accept, unwrap_spec=[ObjSpace, W_Root, W_Root] ),
left=GetSetProperty(Sub.fget_left, Sub.fset_left ),
right=GetSetProperty(Sub.fget_right, Sub.fset_right ),
)
@@ -3310,10 +3757,7 @@
def fget_expr( space, self):
return space.wrap(self.expr)
def fset_expr( space, self, w_arg):
- obj = space.interpclass_w( w_arg )
- if not isinstance( obj, Node):
- raise OperationError(space.w_TypeError,space.wrap('Need a Node instance'))
- self.expr = obj
+ self.expr = space.interp_w(Node, w_arg, can_be_None=False)
def fget_flags( space, self):
return space.wrap(self.flags)
def fset_flags( space, self, w_arg):
@@ -3322,8 +3766,19 @@
return space.newlist( [space.wrap(itm) for itm in self.subs] )
def fset_subs( space, self, w_arg):
del self.subs[:]
- for w_itm in space.unpackiterable( w_arg ):
- self.subs.append( space.interpclass_w( w_arg ) )
+ for w_itm in space.unpackiterable(w_arg):
+ self.subs.append( space.interp_w(Node, w_arg))
+
+def descr_Subscript_new(space, w_subtype, w_expr, w_flags, w_subs, lineno=-1):
+ self = space.allocate_instance(Subscript, w_subtype)
+ expr = space.interp_w(Node, w_expr, can_be_None=False)
+ self.expr = expr
+ flags = space.int_w(w_flags)
+ self.flags = flags
+ subs = [space.interp_w(Node, w_node) for w_node in space.unpackiterable(w_subs)]
+ self.subs = subs
+ self.lineno = lineno
+ return space.wrap(self)
def descr_Subscript_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitSubscript'))
@@ -3331,7 +3786,8 @@
return space.call_args(w_callable, args)
Subscript.typedef = TypeDef('Subscript', Node.typedef,
- accept=interp2app(descr_Subscript_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ __new__ = interp2app(descr_Subscript_new, unwrap_spec=[ObjSpace, W_Root, W_Root, W_Root, W_Root, int]),
+ accept=interp2app(descr_Subscript_accept, unwrap_spec=[ObjSpace, W_Root, W_Root] ),
expr=GetSetProperty(Subscript.fget_expr, Subscript.fset_expr ),
flags=GetSetProperty(Subscript.fget_flags, Subscript.fset_flags ),
subs=GetSetProperty(Subscript.fget_subs, Subscript.fset_subs ),
@@ -3381,11 +3837,9 @@
w_expr1 = space.getitem( w_tup, space.wrap(0) )
w_expr2 = space.getitem( w_tup, space.wrap(1) )
w_body = space.getitem( w_tup, space.wrap(2) )
- expr1 = space.interpclass_w( w_expr1 )
- expr2 = space.interpclass_w( w_expr2 )
- body = space.interpclass_w( w_body )
- if not isinstance( expr1, Node ) or not isinstance( expr2, Node ) or not isinstance( body, Node ):
- raise OperationError(space.w_TypeError, space.wrap("Need a list of (expr1,expr2,body) nodes") )
+ expr1 = space.interp_w(Node, w_expr1, can_be_None=True)
+ expr2 = space.interp_w(Node, w_expr2, can_be_None=True)
+ body = space.interp_w(Node, w_body, can_be_None=False)
self.handlers.append( (expr1,expr2,body) )
@@ -3398,23 +3852,33 @@
def fget_body( space, self):
return space.wrap(self.body)
def fset_body( space, self, w_arg):
- obj = space.interpclass_w( w_arg )
- if not isinstance( obj, Node):
- raise OperationError(space.w_TypeError,space.wrap('Need a Node instance'))
- self.body = obj
+ self.body = space.interp_w(Node, w_arg, can_be_None=False)
def fget_else_( space, self):
if self.else_ is None:
return space.w_None
else:
return space.wrap(self.else_)
def fset_else_( space, self, w_arg):
- if space.is_w( w_arg, space.w_None ):
- self.else_ = None
- else:
- obj = space.interpclass_w( w_arg )
- if not isinstance( obj, Node):
- raise OperationError(space.w_TypeError,space.wrap('Need a Node instance'))
- self.else_ = obj
+ self.else_ = space.interp_w(Node, w_arg, can_be_None=True)
+
+def descr_TryExcept_new(space, w_subtype, w_body, w_handlers, w_else_, lineno=-1):
+ self = space.allocate_instance(TryExcept, w_subtype)
+ self.body = space.interp_w(Node, w_body)
+ handlers = []
+ for w_tuple in space.unpackiterable( w_handlers ):
+ w_expr1 = space.getitem( w_tuple, space.wrap(0) )
+ w_expr2 = space.getitem( w_tuple, space.wrap(1) )
+ w_body = space.getitem( w_tuple, space.wrap(2) )
+ expr1 = space.interp_w(Node, w_expr1, can_be_None=True)
+ expr2 = space.interp_w(Node, w_expr2, can_be_None=True)
+ body = space.interp_w(Node, w_body, can_be_None=False)
+ handlers.append((expr1, expr2, body))
+ self.handlers = handlers
+ self.else_ = space.interp_w(Node, w_else_, can_be_None=True)
+ self.lineno = lineno
+ return space.wrap(self)
+
+
def descr_TryExcept_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitTryExcept'))
@@ -3422,7 +3886,8 @@
return space.call_args(w_callable, args)
TryExcept.typedef = TypeDef('TryExcept', Node.typedef,
- accept=interp2app(descr_TryExcept_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ __new__ = interp2app(descr_TryExcept_new, unwrap_spec=[ObjSpace, W_Root, W_Root, W_Root, W_Root, int]),
+ accept=interp2app(descr_TryExcept_accept, unwrap_spec=[ObjSpace, W_Root, W_Root] ),
body=GetSetProperty(TryExcept.fget_body, TryExcept.fset_body ),
handlers=GetSetProperty(TryExcept.fget_handlers, TryExcept.fset_handlers ),
else_=GetSetProperty(TryExcept.fget_else_, TryExcept.fset_else_ ),
@@ -3450,17 +3915,20 @@
def fget_body( space, self):
return space.wrap(self.body)
def fset_body( space, self, w_arg):
- obj = space.interpclass_w( w_arg )
- if not isinstance( obj, Node):
- raise OperationError(space.w_TypeError,space.wrap('Need a Node instance'))
- self.body = obj
+ self.body = space.interp_w(Node, w_arg, can_be_None=False)
def fget_final( space, self):
return space.wrap(self.final)
def fset_final( space, self, w_arg):
- obj = space.interpclass_w( w_arg )
- if not isinstance( obj, Node):
- raise OperationError(space.w_TypeError,space.wrap('Need a Node instance'))
- self.final = obj
+ self.final = space.interp_w(Node, w_arg, can_be_None=False)
+
+def descr_TryFinally_new(space, w_subtype, w_body, w_final, lineno=-1):
+ self = space.allocate_instance(TryFinally, w_subtype)
+ body = space.interp_w(Node, w_body, can_be_None=False)
+ self.body = body
+ final = space.interp_w(Node, w_final, can_be_None=False)
+ self.final = final
+ self.lineno = lineno
+ return space.wrap(self)
def descr_TryFinally_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitTryFinally'))
@@ -3468,7 +3936,8 @@
return space.call_args(w_callable, args)
TryFinally.typedef = TypeDef('TryFinally', Node.typedef,
- accept=interp2app(descr_TryFinally_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ __new__ = interp2app(descr_TryFinally_new, unwrap_spec=[ObjSpace, W_Root, W_Root, W_Root, int]),
+ accept=interp2app(descr_TryFinally_accept, unwrap_spec=[ObjSpace, W_Root, W_Root] ),
body=GetSetProperty(TryFinally.fget_body, TryFinally.fset_body ),
final=GetSetProperty(TryFinally.fget_final, TryFinally.fset_final ),
)
@@ -3497,8 +3966,15 @@
return space.newlist( [space.wrap(itm) for itm in self.nodes] )
def fset_nodes( space, self, w_arg):
del self.nodes[:]
- for w_itm in space.unpackiterable( w_arg ):
- self.nodes.append( space.interpclass_w( w_arg ) )
+ for w_itm in space.unpackiterable(w_arg):
+ self.nodes.append( space.interp_w(Node, w_arg))
+
+def descr_Tuple_new(space, w_subtype, w_nodes, lineno=-1):
+ self = space.allocate_instance(Tuple, w_subtype)
+ nodes = [space.interp_w(Node, w_node) for w_node in space.unpackiterable(w_nodes)]
+ self.nodes = nodes
+ self.lineno = lineno
+ return space.wrap(self)
def descr_Tuple_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitTuple'))
@@ -3506,7 +3982,8 @@
return space.call_args(w_callable, args)
Tuple.typedef = TypeDef('Tuple', Node.typedef,
- accept=interp2app(descr_Tuple_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ __new__ = interp2app(descr_Tuple_new, unwrap_spec=[ObjSpace, W_Root, W_Root, int]),
+ accept=interp2app(descr_Tuple_accept, unwrap_spec=[ObjSpace, W_Root, W_Root] ),
nodes=GetSetProperty(Tuple.fget_nodes, Tuple.fset_nodes ),
)
@@ -3531,10 +4008,14 @@
def fget_expr( space, self):
return space.wrap(self.expr)
def fset_expr( space, self, w_arg):
- obj = space.interpclass_w( w_arg )
- if not isinstance( obj, Node):
- raise OperationError(space.w_TypeError,space.wrap('Need a Node instance'))
- self.expr = obj
+ self.expr = space.interp_w(Node, w_arg, can_be_None=False)
+
+def descr_UnaryAdd_new(space, w_subtype, w_expr, lineno=-1):
+ self = space.allocate_instance(UnaryAdd, w_subtype)
+ expr = space.interp_w(Node, w_expr, can_be_None=False)
+ self.expr = expr
+ self.lineno = lineno
+ return space.wrap(self)
def descr_UnaryAdd_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitUnaryAdd'))
@@ -3542,7 +4023,8 @@
return space.call_args(w_callable, args)
UnaryAdd.typedef = TypeDef('UnaryAdd', UnaryOp.typedef,
- accept=interp2app(descr_UnaryAdd_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ __new__ = interp2app(descr_UnaryAdd_new, unwrap_spec=[ObjSpace, W_Root, W_Root, int]),
+ accept=interp2app(descr_UnaryAdd_accept, unwrap_spec=[ObjSpace, W_Root, W_Root] ),
expr=GetSetProperty(UnaryAdd.fget_expr, UnaryAdd.fset_expr ),
)
@@ -3567,10 +4049,14 @@
def fget_expr( space, self):
return space.wrap(self.expr)
def fset_expr( space, self, w_arg):
- obj = space.interpclass_w( w_arg )
- if not isinstance( obj, Node):
- raise OperationError(space.w_TypeError,space.wrap('Need a Node instance'))
- self.expr = obj
+ self.expr = space.interp_w(Node, w_arg, can_be_None=False)
+
+def descr_UnarySub_new(space, w_subtype, w_expr, lineno=-1):
+ self = space.allocate_instance(UnarySub, w_subtype)
+ expr = space.interp_w(Node, w_expr, can_be_None=False)
+ self.expr = expr
+ self.lineno = lineno
+ return space.wrap(self)
def descr_UnarySub_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitUnarySub'))
@@ -3578,7 +4064,8 @@
return space.call_args(w_callable, args)
UnarySub.typedef = TypeDef('UnarySub', UnaryOp.typedef,
- accept=interp2app(descr_UnarySub_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ __new__ = interp2app(descr_UnarySub_new, unwrap_spec=[ObjSpace, W_Root, W_Root, int]),
+ accept=interp2app(descr_UnarySub_accept, unwrap_spec=[ObjSpace, W_Root, W_Root] ),
expr=GetSetProperty(UnarySub.fget_expr, UnarySub.fset_expr ),
)
@@ -3614,30 +4101,29 @@
def fget_test( space, self):
return space.wrap(self.test)
def fset_test( space, self, w_arg):
- obj = space.interpclass_w( w_arg )
- if not isinstance( obj, Node):
- raise OperationError(space.w_TypeError,space.wrap('Need a Node instance'))
- self.test = obj
+ self.test = space.interp_w(Node, w_arg, can_be_None=False)
def fget_body( space, self):
return space.wrap(self.body)
def fset_body( space, self, w_arg):
- obj = space.interpclass_w( w_arg )
- if not isinstance( obj, Node):
- raise OperationError(space.w_TypeError,space.wrap('Need a Node instance'))
- self.body = obj
+ self.body = space.interp_w(Node, w_arg, can_be_None=False)
def fget_else_( space, self):
if self.else_ is None:
return space.w_None
else:
return space.wrap(self.else_)
def fset_else_( space, self, w_arg):
- if space.is_w( w_arg, space.w_None ):
- self.else_ = None
- else:
- obj = space.interpclass_w( w_arg )
- if not isinstance( obj, Node):
- raise OperationError(space.w_TypeError,space.wrap('Need a Node instance'))
- self.else_ = obj
+ self.else_ = space.interp_w(Node, w_arg, can_be_None=True)
+
+def descr_While_new(space, w_subtype, w_test, w_body, w_else_, lineno=-1):
+ self = space.allocate_instance(While, w_subtype)
+ test = space.interp_w(Node, w_test, can_be_None=False)
+ self.test = test
+ body = space.interp_w(Node, w_body, can_be_None=False)
+ self.body = body
+ else_ = space.interp_w(Node, w_else_, can_be_None=True)
+ self.else_ = else_
+ self.lineno = lineno
+ return space.wrap(self)
def descr_While_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitWhile'))
@@ -3645,7 +4131,8 @@
return space.call_args(w_callable, args)
While.typedef = TypeDef('While', Node.typedef,
- accept=interp2app(descr_While_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ __new__ = interp2app(descr_While_new, unwrap_spec=[ObjSpace, W_Root, W_Root, W_Root, W_Root, int]),
+ accept=interp2app(descr_While_accept, unwrap_spec=[ObjSpace, W_Root, W_Root] ),
test=GetSetProperty(While.fget_test, While.fset_test ),
body=GetSetProperty(While.fget_body, While.fset_body ),
else_=GetSetProperty(While.fget_else_, While.fset_else_ ),
@@ -3672,10 +4159,14 @@
def fget_value( space, self):
return space.wrap(self.value)
def fset_value( space, self, w_arg):
- obj = space.interpclass_w( w_arg )
- if not isinstance( obj, Node):
- raise OperationError(space.w_TypeError,space.wrap('Need a Node instance'))
- self.value = obj
+ self.value = space.interp_w(Node, w_arg, can_be_None=False)
+
+def descr_Yield_new(space, w_subtype, w_value, lineno=-1):
+ self = space.allocate_instance(Yield, w_subtype)
+ value = space.interp_w(Node, w_value, can_be_None=False)
+ self.value = value
+ self.lineno = lineno
+ return space.wrap(self)
def descr_Yield_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitYield'))
@@ -3683,7 +4174,8 @@
return space.call_args(w_callable, args)
Yield.typedef = TypeDef('Yield', Node.typedef,
- accept=interp2app(descr_Yield_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ __new__ = interp2app(descr_Yield_new, unwrap_spec=[ObjSpace, W_Root, W_Root, int]),
+ accept=interp2app(descr_Yield_accept, unwrap_spec=[ObjSpace, W_Root, W_Root] ),
value=GetSetProperty(Yield.fget_value, Yield.fset_value ),
)
@@ -3861,7 +4353,9 @@
return self.default( node )
+nodeclasses = []
for name, obj in globals().items():
if isinstance(obj, type) and issubclass(obj, Node):
nodes[name.lower()] = obj
+ nodeclasses.append(name)
Modified: pypy/dist/pypy/interpreter/astcompiler/ast.txt
==============================================================================
--- pypy/dist/pypy/interpreter/astcompiler/ast.txt (original)
+++ pypy/dist/pypy/interpreter/astcompiler/ast.txt Tue Dec 13 22:14:14 2005
@@ -171,12 +171,10 @@
w_opname = space.getitem( w_obj, space.wrap(0) )
w_node = space.getitem( w_obj, space.wrap(1) )
ops = space.str_w(w_opname)
- node = space.interpclass_w( w_node )
- if not isinstance(node, Node):
- raise OperationError(space.w_TypeError, space.wrap("ops must be a list of (name,node)"))
+ node = space.interp_w(Node, w_node)
self.ops.append( (ops,node) )
-Dict.fget_items( space, self ):
+Dict.fget_items(space, self):
return space.newlist( [ space.newtuple( [ space.wrap(key), space.wrap(value) ] )
for key, value in self.items ] )
@@ -185,28 +183,10 @@
for w_tup in space.unpackiterable( w_arg ):
w_key = space.getitem( w_tup, space.wrap(0) )
w_value = space.getitem( w_tup, space.wrap(1) )
- key = space.interpclass_w( w_key )
- value = space.interpclass_w( w_value )
- if not isinstance( key, Node ) or not isinstance( value, Node ):
- raise OperationError(space.w_TypeError, space.wrap("Need a list of (key node, value node)"))
+ key = space.interp_w(Node, w_key)
+ value = space.interp_w(Node, w_value)
self.items.append( (key,value) )
-flatten_nodes(TryExcept.handlers):
- # handlers is a list of triplets (expr1, expr2, body)
- for expr1, expr2, body in self.handlers:
- if expr1 is not None:
- nodelist.append(expr1)
- if expr2 is not None:
- nodelist.append(expr2)
- if body is not None:
- nodelist.append(body)
-
-flatten_nodes(If.tests):
- # tests is a list of couples (node (test), node (suite))
- for test, suite in self.tests:
- nodelist.append(test)
- nodelist.append(suite)
-
If.fget_tests( space, self ):
return space.newlist( [ space.newtuple( [ space.wrap(test),
@@ -218,14 +198,11 @@
for w_tup in space.unpackiterable( w_arg ):
w_test = space.getitem( w_tup, space.wrap(0) )
w_suite = space.getitem( w_tup, space.wrap(1) )
- test = space.interpclass_w( w_test )
- suite = space.interpclass_w( w_suite )
- if not isinstance( test, Node ) or not isinstance( suite, Node ):
- raise OperationError(space.w_TypeError, space.wrap("Need a list of (test,suite) nodes") )
+ test = space.interp_w(Node, w_test)
+ suite = space.interp_w(Node, w_suite)
self.tests.append( (test,suite) )
-
TryExcept.fget_handlers( space, self ):
return space.newlist( [ space.newtuple( [ space.wrap(expr1),
space.wrap(expr2),
@@ -238,11 +215,9 @@
w_expr1 = space.getitem( w_tup, space.wrap(0) )
w_expr2 = space.getitem( w_tup, space.wrap(1) )
w_body = space.getitem( w_tup, space.wrap(2) )
- expr1 = space.interpclass_w( w_expr1 )
- expr2 = space.interpclass_w( w_expr2 )
- body = space.interpclass_w( w_body )
- if not isinstance( expr1, Node ) or not isinstance( expr2, Node ) or not isinstance( body, Node ):
- raise OperationError(space.w_TypeError, space.wrap("Need a list of (expr1,expr2,body) nodes") )
+ expr1 = space.interp_w(Node, w_expr1, can_be_None=True)
+ expr2 = space.interp_w(Node, w_expr2, can_be_None=True)
+ body = space.interp_w(Node, w_body, can_be_None=False)
self.handlers.append( (expr1,expr2,body) )
Import.fget_names( space, self ):
@@ -275,3 +250,95 @@
as_name = space.str_w( w_as_name )
self.names.append( (name, as_name) )
+def descr_From_new(space, w_subtype, w_modname, w_names, lineno=-1):
+ self = space.allocate_instance(From, w_subtype)
+ modname = space.str_w(w_modname)
+ self.modname = modname
+ names = []
+ for w_tuple in space.unpackiterable(w_names):
+ w_name = space.getitem(w_tuple, space.wrap(0))
+ w_as_name = space.getitem(w_tuple, space.wrap(1))
+ name = space.str_w(w_name)
+ as_name = None
+ if not space.is_w(w_as_name, space.w_None):
+ as_name = space.str_w(w_as_name)
+ names.append((name, as_name))
+ self.names = names
+ self.lineno = lineno
+ return space.wrap(self)
+
+def descr_Import_new(space, w_subtype, w_names, lineno=-1):
+ self = space.allocate_instance(Import, w_subtype)
+ names = []
+ for w_tuple in space.unpackiterable(w_names):
+ w_name = space.getitem(w_tuple, space.wrap(0))
+ w_as_name = space.getitem(w_tuple, space.wrap(1))
+ name = space.str_w(w_name)
+ as_name = None
+ if not space.is_w(w_as_name, space.w_None):
+ as_name = space.str_w(w_as_name)
+ names.append((name, as_name))
+ self.names = names
+ self.lineno = lineno
+ return space.wrap(self)
+
+def descr_Compare_new(space, w_subtype, w_expr, w_ops, lineno=-1):
+ self = space.allocate_instance(Compare, w_subtype)
+ self.expr = space.interp_w(Node, w_expr)
+ ops = []
+ for w_tuple in space.unpackiterable(w_ops):
+ w_opname = space.getitem(w_tuple, space.wrap(0))
+ w_node = space.getitem(w_tuple, space.wrap(1))
+ opname = space.str_w(w_opname)
+ node = space.interp_w(Node, w_node)
+ ops.append((opname, node))
+ self.ops = ops
+ self.lineno = lineno
+ return space.wrap(self)
+
+def descr_Dict_new(space, w_subtype, w_items, lineno=-1):
+ self = space.allocate_instance(Dict, w_subtype)
+ items = []
+ for w_tuple in space.unpackiterable(w_items):
+ w_key = space.getitem(w_tuple, space.wrap(0))
+ w_value = space.getitem(w_tuple, space.wrap(1))
+ key = space.interp_w(Node, w_key)
+ value = space.interp_w(Node, w_value)
+ items.append((key, value))
+ self.items = items
+ self.lineno = lineno
+ return space.wrap(self)
+
+
+def descr_If_new(space, w_subtype, w_tests, w_else_, lineno=-1):
+ self = space.allocate_instance(If, w_subtype)
+ tests = []
+ for w_tuple in space.unpackiterable(w_tests):
+ w_test = space.getitem(w_tuple, space.wrap(0))
+ w_suite = space.getitem(w_tuple, space.wrap(1))
+ test = space.interp_w(Node, w_test)
+ suite = space.interp_w(Node, w_suite)
+ tests.append((test, suite))
+ self.tests = tests
+ self.else_ = space.interp_w(Node, w_else_, can_be_None=True)
+ self.lineno = lineno
+ return space.wrap(self)
+
+
+def descr_TryExcept_new(space, w_subtype, w_body, w_handlers, w_else_, lineno=-1):
+ self = space.allocate_instance(TryExcept, w_subtype)
+ self.body = space.interp_w(Node, w_body)
+ handlers = []
+ for w_tuple in space.unpackiterable( w_handlers ):
+ w_expr1 = space.getitem( w_tuple, space.wrap(0) )
+ w_expr2 = space.getitem( w_tuple, space.wrap(1) )
+ w_body = space.getitem( w_tuple, space.wrap(2) )
+ expr1 = space.interp_w(Node, w_expr1, can_be_None=True)
+ expr2 = space.interp_w(Node, w_expr2, can_be_None=True)
+ body = space.interp_w(Node, w_body, can_be_None=False)
+ handlers.append((expr1, expr2, body))
+ self.handlers = handlers
+ self.else_ = space.interp_w(Node, w_else_, can_be_None=True)
+ self.lineno = lineno
+ return space.wrap(self)
+
Modified: pypy/dist/pypy/interpreter/astcompiler/astgen.py
==============================================================================
--- pypy/dist/pypy/interpreter/astcompiler/astgen.py (original)
+++ pypy/dist/pypy/interpreter/astcompiler/astgen.py Tue Dec 13 22:14:14 2005
@@ -45,6 +45,7 @@
self.argprops = self.get_argprops()
self.nargs = len(self.argnames)
self.init = []
+ self.applevel_new = []
self.flatten_nodes = {}
self.additional_methods = {}
self.parent = parent
@@ -117,6 +118,13 @@
return d
+ def get_initargs(self):
+ if self.parent.args and self.args:
+ args = self.parent.args +","+ self.args
+ else:
+ args = self.parent.args or self.args
+ return args
+
def gen_source(self):
buf = StringIO()
print >> buf, "class %s(%s):" % (self.name, self.parent.name)
@@ -133,21 +141,20 @@
print >> buf
self._gen_attrs(buf)
print >> buf
+ self._gen_new(buf)
+ print >> buf
self._gen_typedef(buf)
buf.seek(0, 0)
return buf.read()
def _gen_init(self, buf):
- if self.parent.args and self.args:
- args = self.parent.args +","+ self.args
- else:
- args = self.parent.args or self.args
- if args:
- print >> buf, " def __init__(self, %s, lineno=-1):" % args
+ initargs = self.get_initargs()
+ if initargs:
+ print >> buf, " def __init__(self, %s, lineno=-1):" % initargs
else:
print >> buf, " def __init__(self, lineno=-1):"
if self.parent.args:
- print >> buf, " %s.__init__(self, %s, lineno)" % self.parent.args
+ print >> buf, " %s.__init__(self, %s, lineno)" % (self.parent.name, self.parent.args)
else:
print >> buf, " Node.__init__(self, lineno)"
if self.argnames:
@@ -158,6 +165,47 @@
if self.init:
print >> buf, "".join([" " + line for line in self.init])
+ def _gen_new(self, buf):
+ if self.applevel_new:
+ print >> buf, ''.join(self.applevel_new)
+ return
+ args = self.get_initargs()
+ argprops = self.argprops
+ if args:
+ w_args = ['w_%s' % strip_default(arg.strip())
+ for arg in args.split(',') if arg]
+ print >> buf, "def descr_%s_new(space, w_subtype, %s, lineno=-1):" % (self.name, ', '.join(w_args))
+ else:
+ w_args = []
+ print >> buf, "def descr_%s_new(space, w_subtype, lineno=-1):" % (self.name,)
+ print >> buf, " self = space.allocate_instance(%s, w_subtype)" % (self.name,)
+ # w_args = ['w_%s' % strip_default(arg.strip()) for arg in self.args.split(',') if arg]
+ for w_arg in w_args:
+ argname = w_arg[2:]
+ prop = argprops[argname]
+ if prop == P_NONE:
+ print >> buf, " %s = space.interp_w(Node, %s, can_be_None=True)" % (argname, w_arg)
+ elif prop == P_NODE:
+ print >> buf, " %s = space.interp_w(Node, %s, can_be_None=False)" % (argname, w_arg)
+ elif prop == P_NESTED:
+ print >> buf, " %s = [space.interp_w(Node, w_node) for w_node in space.unpackiterable(%s)]" % (argname, w_arg)
+ elif prop == P_STR:
+ print >> buf, " %s = space.str_w(%s)" % (argname, w_arg)
+ elif prop == P_INT:
+ print >> buf, " %s = space.int_w(%s)" % (argname, w_arg)
+ elif prop == P_STR_LIST:
+ print >> buf, " %s = [space.str_w(w_str) for w_str in space.unpackiterable(%s)]" % (argname, w_arg)
+ elif prop == P_INT_LIST:
+ print >> buf, " %s = [space.int_w(w_int) for w_int in space.unpackiterable(%s)]" % (argname, w_arg)
+ elif prop == P_WRAPPED:
+ print >> buf, " # This dummy assingment is auto-generated, astgen.py should be fixed to avoid that"
+ print >> buf, " %s = %s" % (argname, w_arg)
+ else:
+ raise ValueError("Don't know how to handle property '%s'" % prop)
+ print >> buf, " self.%s = %s" % (argname, argname)
+ print >> buf, " self.lineno = lineno"
+ print >> buf, " return space.wrap(self)"
+
def _gen_getChildren(self, buf):
print >> buf, " def getChildren(self):"
print >> buf, ' "NOT_RPYTHON"'
@@ -266,37 +314,28 @@
def _gen_fset_func(self, buf, attr, prop ):
# FSET
print >> buf, " def fset_%s( space, self, w_arg):" % attr
- if prop[attr]==P_WRAPPED:
+ if prop[attr] == P_WRAPPED:
print >> buf, " self.%s = w_arg" % attr
- elif prop[attr]==P_INT:
+ elif prop[attr] == P_INT:
print >> buf, " self.%s = space.int_w(w_arg)" % attr
- elif prop[attr]==P_STR:
+ elif prop[attr] == P_STR:
print >> buf, " self.%s = space.str_w(w_arg)" % attr
- elif prop[attr]==P_INT_LIST:
+ elif prop[attr] == P_INT_LIST:
print >> buf, " del self.%s[:]" % attr
print >> buf, " for itm in space.unpackiterable(w_arg):"
print >> buf, " self.%s.append( space.int_w(itm) )" % attr
- elif prop[attr]==P_STR_LIST:
+ elif prop[attr] == P_STR_LIST:
print >> buf, " del self.%s[:]" % attr
print >> buf, " for itm in space.unpackiterable(w_arg):"
print >> buf, " self.%s.append( space.str_w(itm) )" % attr
- elif prop[attr]==P_NESTED:
+ elif prop[attr] == P_NESTED:
print >> buf, " del self.%s[:]" % attr
- print >> buf, " for w_itm in space.unpackiterable( w_arg ):"
- print >> buf, " self.%s.append( space.interpclass_w( w_arg ) )" % attr
- elif prop[attr]==P_NONE:
- print >> buf, " if space.is_w( w_arg, space.w_None ):"
- print >> buf, " self.%s = None" % attr
- print >> buf, " else:"
- print >> buf, " obj = space.interpclass_w( w_arg )"
- print >> buf, " if not isinstance( obj, Node):"
- print >> buf, " raise OperationError(space.w_TypeError,space.wrap('Need a Node instance'))"
- print >> buf, " self.%s = obj" % attr
+ print >> buf, " for w_itm in space.unpackiterable(w_arg):"
+ print >> buf, " self.%s.append( space.interp_w(Node, w_arg))" % attr
+ elif prop[attr] == P_NONE:
+ print >> buf, " self.%s = space.interp_w(Node, w_arg, can_be_None=True)" % attr
else: # P_NODE
- print >> buf, " obj = space.interpclass_w( w_arg )"
- print >> buf, " if not isinstance( obj, Node):"
- print >> buf, " raise OperationError(space.w_TypeError,space.wrap('Need a Node instance'))"
- print >> buf, " self.%s = obj" % attr
+ print >> buf, " self.%s = space.interp_w(Node, w_arg, can_be_None=False)" % attr
def _gen_attrs(self, buf):
prop = self.argprops
@@ -307,16 +346,22 @@
if "fset_%s" % attr not in self.additional_methods:
self._gen_fset_func( buf, attr, prop )
-
def _gen_typedef(self, buf):
+ initargs = [strip_default(arg.strip())
+ for arg in self.get_initargs().split(',') if arg]
+ if initargs:
+ new_unwrap_spec = ['ObjSpace', 'W_Root'] + ['W_Root'] * len(initargs) + ['int']
+ else:
+ new_unwrap_spec = ['ObjSpace', 'W_Root', 'int']
parent_type = "%s.typedef" % self.parent.name
print >> buf, "def descr_%s_accept( space, w_self, w_visitor):" %self.name
print >> buf, " w_callable = space.getattr(w_visitor, space.wrap('visit%s'))" % self.name
print >> buf, " args = Arguments(space, [ w_self ])"
print >> buf, " return space.call_args(w_callable, args)"
print >> buf, ""
- print >> buf, "%s.typedef = TypeDef('%s', %s, " % (self.name,self.name,parent_type)
- print >> buf, " accept=interp2app(descr_%s_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] )," % self.name
+ print >> buf, "%s.typedef = TypeDef('%s', %s, " % (self.name, self.name, parent_type)
+ print >> buf, " __new__ = interp2app(descr_%s_new, unwrap_spec=[%s])," % (self.name, ', '.join(new_unwrap_spec))
+ print >> buf, " accept=interp2app(descr_%s_accept, unwrap_spec=[ObjSpace, W_Root, W_Root] )," % self.name
for attr in self.argnames:
print >> buf, " %s=GetSetProperty(%s.fget_%s, %s.fset_%s )," % (attr,self.name,attr,self.name,attr)
print >> buf, " )"
@@ -356,7 +401,7 @@
rx_init = re.compile('init\((.*)\):')
rx_flatten_nodes = re.compile('flatten_nodes\((.*)\.(.*)\):')
rx_additional_methods = re.compile('(\\w+)\.(\w+)\((.*?)\):')
-
+rx_descr_news_methods = re.compile('def\s+descr_(\\w+)_new\((.*?)\):')
def parse_spec(file):
classes = {}
cur = None
@@ -414,6 +459,14 @@
cur.additional_methods[_cur_] = [' def %s(%s):\n' % (methname, params)]
continue
+ mo = rx_descr_news_methods.match(line)
+ if mo:
+ kind = 'applevel_new'
+ name = mo.group(1)
+ cur = classes[name]
+ cur.applevel_new = [mo.group(0) + '\n']
+ continue
+
if kind == 'init':
# some code for the __init__ method
cur.init.append(line)
@@ -424,6 +477,8 @@
cur.flatten_nodes[_cur_].append(line)
elif kind == 'additional_method':
cur.additional_methods[_cur_].append(' '*4 + line)
+ elif kind == 'applevel_new':
+ cur.applevel_new.append(line)
for node in classes.values():
node.setup_parent(classes)
@@ -492,7 +547,7 @@
"""
from consts import CO_VARARGS, CO_VARKEYWORDS, OP_ASSIGN
from pypy.interpreter.baseobjspace import Wrappable
-from pypy.interpreter.typedef import TypeDef, GetSetProperty
+from pypy.interpreter.typedef import TypeDef, GetSetProperty, interp_attrproperty
from pypy.interpreter.gateway import interp2app, W_Root, ObjSpace
from pypy.interpreter.argument import Arguments
from pypy.interpreter.error import OperationError
@@ -556,10 +611,18 @@
args = Arguments(space, [ w_self ])
return space.call_args( w_callable, args )
+def descr_Node_new(space, w_subtype, lineno=-1):
+ node = space.allocate_instance(Node, w_subtype)
+ node.lineno = lineno
+ return space.wrap(node)
+
Node.typedef = TypeDef('ASTNode',
+ __new__ = interp2app(descr_Node_new, unwrap_spec=[ObjSpace, W_Root, int]),
#__repr__ = interp2app(descr_node_repr, unwrap_spec=['self', ObjSpace] ),
getChildNodes = interp2app(Node.descr_getChildNodes, unwrap_spec=[ 'self', ObjSpace ] ),
accept = interp2app(descr_node_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ lineno = interp_attrproperty('lineno', cls=Node),
+ filename = interp_attrproperty('filename', cls=Node),
)
@@ -589,9 +652,11 @@
'''
epilogue = '''
+nodeclasses = []
for name, obj in globals().items():
if isinstance(obj, type) and issubclass(obj, Node):
nodes[name.lower()] = obj
+ nodeclasses.append(name)
'''
if __name__ == "__main__":
More information about the Pypy-commit
mailing list