[pypy-svn] r20903 - in pypy/dist/pypy: interpreter/astcompiler interpreter/pyparser interpreter/pyparser/test interpreter/stablecompiler module/recparser
ludal at codespeak.net
ludal at codespeak.net
Thu Dec 8 18:25:36 CET 2005
Author: ludal
Date: Thu Dec 8 18:25:31 2005
New Revision: 20903
Modified:
pypy/dist/pypy/interpreter/astcompiler/ast.py
pypy/dist/pypy/interpreter/astcompiler/ast.txt
pypy/dist/pypy/interpreter/astcompiler/astgen.py
pypy/dist/pypy/interpreter/astcompiler/consts.py
pypy/dist/pypy/interpreter/astcompiler/pycodegen.py
pypy/dist/pypy/interpreter/astcompiler/symbols.py
pypy/dist/pypy/interpreter/pyparser/astbuilder.py
pypy/dist/pypy/interpreter/pyparser/grammar.py
pypy/dist/pypy/interpreter/pyparser/pythonparse.py
pypy/dist/pypy/interpreter/pyparser/test/test_astbuilder.py
pypy/dist/pypy/interpreter/pyparser/test/test_samples.py
pypy/dist/pypy/interpreter/stablecompiler/consts.py
pypy/dist/pypy/interpreter/stablecompiler/pycodegen.py
pypy/dist/pypy/module/recparser/__init__.py
Log:
(adim,ludal)
allow the AST tree to be exported to application level
also export the grammar rules
all attributes of all AST nodes are made available
can install a callback with parser.install_compiler_hook
which allows modification of AST just before compilation
Modified: pypy/dist/pypy/interpreter/astcompiler/ast.py
==============================================================================
--- pypy/dist/pypy/interpreter/astcompiler/ast.py (original)
+++ pypy/dist/pypy/interpreter/astcompiler/ast.py Thu Dec 8 18:25:31 2005
@@ -5,9 +5,10 @@
"""
from consts import CO_VARARGS, CO_VARKEYWORDS, OP_ASSIGN
from pypy.interpreter.baseobjspace import Wrappable
-from pypy.interpreter.typedef import TypeDef
+from pypy.interpreter.typedef import TypeDef, GetSetProperty
from pypy.interpreter.gateway import interp2app, W_Root, ObjSpace
from pypy.interpreter.argument import Arguments
+from pypy.interpreter.error import OperationError
def flatten(list):
l = []
@@ -117,13 +118,15 @@
def accept(self, visitor):
return visitor.visitAbstractFunction(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 ] ))
+ accept=interp2app(descr_AbstractFunction_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ )
class AbstractTest(Node):
def __init__(self, lineno=-1):
@@ -142,13 +145,15 @@
def accept(self, visitor):
return visitor.visitAbstractTest(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 ] ))
+ accept=interp2app(descr_AbstractTest_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ )
class BinaryOp(Node):
def __init__(self, lineno=-1):
@@ -167,16 +172,18 @@
def accept(self, visitor):
return visitor.visitBinaryOp(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 ] ))
+ accept=interp2app(descr_BinaryOp_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ )
class Add(BinaryOp):
- def __init__(self, (left, right), lineno=-1):
+ def __init__(self, left, right, lineno=-1):
Node.__init__(self, lineno)
self.left = left
self.right = right
@@ -189,18 +196,36 @@
return [self.left, self.right]
def __repr__(self):
- return "Add((%s, %s))" % (self.left.__repr__(), self.right.__repr__())
+ return "Add(%s, %s)" % (self.left.__repr__(), self.right.__repr__())
def accept(self, visitor):
return visitor.visitAdd(self)
+ 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
+ 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
+
def descr_Add_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitAdd'))
args = Arguments(space, [ w_self ])
return space.call_args(w_callable, args)
-Add.typedef = TypeDef('Add', Node.typedef,
- accept=interp2app(descr_Add_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ))
+Add.typedef = TypeDef('Add', BinaryOp.typedef,
+ 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 ),
+ )
class And(AbstractTest):
def __init__(self, nodes, lineno=-1):
@@ -222,13 +247,22 @@
def accept(self, visitor):
return visitor.visitAnd(self)
+ def fget_nodes( space, self):
+ 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 ) )
+
def descr_And_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitAnd'))
args = Arguments(space, [ w_self ])
return space.call_args(w_callable, args)
-And.typedef = TypeDef('And', Node.typedef,
- accept=interp2app(descr_And_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ))
+And.typedef = TypeDef('And', AbstractTest.typedef,
+ accept=interp2app(descr_And_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ nodes=GetSetProperty(And.fget_nodes, And.fset_nodes ),
+ )
class AssAttr(Node):
def __init__(self, expr, attrname, flags, lineno=-1):
@@ -250,13 +284,33 @@
def accept(self, visitor):
return visitor.visitAssAttr(self)
+ 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
+ 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 fget_flags( space, self):
+ return space.wrap(self.flags)
+ def fset_flags( space, self, w_arg):
+ self.flags = space.int_w(w_arg)
+
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 ] ))
+ 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 ),
+ )
class AssSeq(Node):
def __init__(self, lineno=-1):
@@ -275,13 +329,15 @@
def accept(self, visitor):
return visitor.visitAssSeq(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 ] ))
+ accept=interp2app(descr_AssSeq_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ )
class AssList(AssSeq):
def __init__(self, nodes, lineno=-1):
@@ -303,13 +359,22 @@
def accept(self, visitor):
return visitor.visitAssList(self)
+ def fget_nodes( space, self):
+ 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 ) )
+
def descr_AssList_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitAssList'))
args = Arguments(space, [ w_self ])
return space.call_args(w_callable, args)
-AssList.typedef = TypeDef('AssList', Node.typedef,
- accept=interp2app(descr_AssList_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ))
+AssList.typedef = TypeDef('AssList', AssSeq.typedef,
+ accept=interp2app(descr_AssList_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ nodes=GetSetProperty(AssList.fget_nodes, AssList.fset_nodes ),
+ )
class AssName(Node):
def __init__(self, name, flags, lineno=-1):
@@ -330,13 +395,25 @@
def accept(self, visitor):
return visitor.visitAssName(self)
+ def fget_name( space, self):
+ return space.wrap(self.name)
+ def fset_name( space, self, w_arg):
+ self.name = space.str_w(w_arg)
+ def fget_flags( space, self):
+ return space.wrap(self.flags)
+ def fset_flags( space, self, w_arg):
+ self.flags = space.int_w(w_arg)
+
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 ] ))
+ 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 ),
+ )
class AssTuple(AssSeq):
def __init__(self, nodes, lineno=-1):
@@ -364,6 +441,7 @@
else:
assert False, "should only have AssName and AssTuple as children"
return argnames
+
def __repr__(self):
return "AssTuple(%s)" % (self.nodes.__repr__(),)
@@ -371,13 +449,22 @@
def accept(self, visitor):
return visitor.visitAssTuple(self)
+ def fget_nodes( space, self):
+ 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 ) )
+
def descr_AssTuple_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitAssTuple'))
args = Arguments(space, [ w_self ])
return space.call_args(w_callable, args)
-AssTuple.typedef = TypeDef('AssTuple', Node.typedef,
- accept=interp2app(descr_AssTuple_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ))
+AssTuple.typedef = TypeDef('AssTuple', AssSeq.typedef,
+ accept=interp2app(descr_AssTuple_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ nodes=GetSetProperty(AssTuple.fget_nodes, AssTuple.fset_nodes ),
+ )
class Assert(Node):
def __init__(self, test, fail, lineno=-1):
@@ -405,13 +492,37 @@
def accept(self, visitor):
return visitor.visitAssert(self)
+ 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
+ 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
+
def descr_Assert_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitAssert'))
args = Arguments(space, [ w_self ])
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 ] ))
+ 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 ),
+ )
class Assign(Node):
def __init__(self, nodes, expr, lineno=-1):
@@ -438,13 +549,30 @@
def accept(self, visitor):
return visitor.visitAssign(self)
+ def fget_nodes( space, self):
+ 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 ) )
+ 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
+
def descr_Assign_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitAssign'))
args = Arguments(space, [ w_self ])
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 ] ))
+ 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 ),
+ )
class AugAssign(Node):
def __init__(self, node, op, expr, lineno=-1):
@@ -466,13 +594,36 @@
def accept(self, visitor):
return visitor.visitAugAssign(self)
+ 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
+ def fget_op( space, self):
+ return space.wrap(self.op)
+ def fset_op( space, self, w_arg):
+ self.op = space.str_w(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
+
def descr_AugAssign_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitAugAssign'))
args = Arguments(space, [ w_self ])
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 ] ))
+ 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 ),
+ )
class UnaryOp(Node):
def __init__(self, lineno=-1):
@@ -491,13 +642,15 @@
def accept(self, visitor):
return visitor.visitUnaryOp(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 ] ))
+ accept=interp2app(descr_UnaryOp_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ )
class Backquote(UnaryOp):
def __init__(self, expr, lineno=-1):
@@ -517,13 +670,23 @@
def accept(self, visitor):
return visitor.visitBackquote(self)
+ 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
+
def descr_Backquote_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitBackquote'))
args = Arguments(space, [ w_self ])
return space.call_args(w_callable, args)
-Backquote.typedef = TypeDef('Backquote', Node.typedef,
- accept=interp2app(descr_Backquote_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ))
+Backquote.typedef = TypeDef('Backquote', UnaryOp.typedef,
+ accept=interp2app(descr_Backquote_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ expr=GetSetProperty(Backquote.fget_expr, Backquote.fset_expr ),
+ )
class BitOp(Node):
def __init__(self, lineno=-1):
@@ -542,13 +705,15 @@
def accept(self, visitor):
return visitor.visitBitOp(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 ] ))
+ accept=interp2app(descr_BitOp_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ )
class Bitand(BitOp):
def __init__(self, nodes, lineno=-1):
@@ -570,13 +735,22 @@
def accept(self, visitor):
return visitor.visitBitand(self)
+ def fget_nodes( space, self):
+ 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 ) )
+
def descr_Bitand_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitBitand'))
args = Arguments(space, [ w_self ])
return space.call_args(w_callable, args)
-Bitand.typedef = TypeDef('Bitand', Node.typedef,
- accept=interp2app(descr_Bitand_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ))
+Bitand.typedef = TypeDef('Bitand', BitOp.typedef,
+ accept=interp2app(descr_Bitand_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ nodes=GetSetProperty(Bitand.fget_nodes, Bitand.fset_nodes ),
+ )
class Bitor(BitOp):
def __init__(self, nodes, lineno=-1):
@@ -598,13 +772,22 @@
def accept(self, visitor):
return visitor.visitBitor(self)
+ def fget_nodes( space, self):
+ 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 ) )
+
def descr_Bitor_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitBitor'))
args = Arguments(space, [ w_self ])
return space.call_args(w_callable, args)
-Bitor.typedef = TypeDef('Bitor', Node.typedef,
- accept=interp2app(descr_Bitor_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ))
+Bitor.typedef = TypeDef('Bitor', BitOp.typedef,
+ accept=interp2app(descr_Bitor_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ nodes=GetSetProperty(Bitor.fget_nodes, Bitor.fset_nodes ),
+ )
class Bitxor(BitOp):
def __init__(self, nodes, lineno=-1):
@@ -626,13 +809,22 @@
def accept(self, visitor):
return visitor.visitBitxor(self)
+ def fget_nodes( space, self):
+ 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 ) )
+
def descr_Bitxor_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitBitxor'))
args = Arguments(space, [ w_self ])
return space.call_args(w_callable, args)
-Bitxor.typedef = TypeDef('Bitxor', Node.typedef,
- accept=interp2app(descr_Bitxor_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ))
+Bitxor.typedef = TypeDef('Bitxor', BitOp.typedef,
+ accept=interp2app(descr_Bitxor_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ nodes=GetSetProperty(Bitxor.fget_nodes, Bitxor.fset_nodes ),
+ )
class Break(Node):
def __init__(self, lineno=-1):
@@ -651,13 +843,15 @@
def accept(self, visitor):
return visitor.visitBreak(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 ] ))
+ accept=interp2app(descr_Break_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ )
class CallFunc(Node):
def __init__(self, node, args, star_args = None, dstar_args = None, lineno=-1):
@@ -692,20 +886,65 @@
def accept(self, visitor):
return visitor.visitCallFunc(self)
+ 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
+ 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 ) )
+ 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
+ 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
+
def descr_CallFunc_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitCallFunc'))
args = Arguments(space, [ w_self ])
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 ] ))
+ 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 ),
+ dstar_args=GetSetProperty(CallFunc.fget_dstar_args, CallFunc.fset_dstar_args ),
+ )
class Class(Node):
- def __init__(self, name, bases, doc, code, lineno=-1):
+ def __init__(self, name, bases, w_doc, code, lineno=-1):
Node.__init__(self, lineno)
self.name = name
self.bases = bases
- self.doc = doc
+ self.w_doc = w_doc
self.code = code
def getChildren(self):
@@ -713,7 +952,7 @@
children = []
children.append(self.name)
children.extend(flatten(self.bases))
- children.append(self.doc)
+ children.append(self.w_doc)
children.append(self.code)
return tuple(children)
@@ -724,18 +963,45 @@
return nodelist
def __repr__(self):
- return "Class(%s, %s, %s, %s)" % (self.name.__repr__(), self.bases.__repr__(), self.doc.__repr__(), self.code.__repr__())
+ return "Class(%s, %s, %s, %s)" % (self.name.__repr__(), self.bases.__repr__(), self.w_doc.__repr__(), self.code.__repr__())
def accept(self, visitor):
return visitor.visitClass(self)
+ def fget_name( space, self):
+ return space.wrap(self.name)
+ def fset_name( space, self, w_arg):
+ self.name = space.str_w(w_arg)
+ def fget_bases( space, self):
+ 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 ) )
+ def fget_w_doc( space, self):
+ return self.w_doc
+ def fset_w_doc( space, self, w_arg):
+ self.w_doc = w_arg
+ 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
+
def descr_Class_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitClass'))
args = Arguments(space, [ w_self ])
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 ] ))
+ 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 ),
+ code=GetSetProperty(Class.fget_code, Class.fset_code ),
+ )
class Compare(Node):
def __init__(self, expr, ops, lineno=-1):
@@ -759,19 +1025,49 @@
nodelist.append(node)
return nodelist
+ def fset_ops( space, self, w_arg ):
+ del self.ops[:]
+ for w_obj in space.unpackiterable( w_arg ):
+ 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)"))
+ self.ops.append( (ops,node) )
+
+
+ def fget_ops( space, self ):
+ lst = []
+ for op_name, node in self.ops:
+ lst.append( space.newtuple( [ space.wrap(op_name), space.wrap(node) ] ) )
+ return space.newlist( lst )
+
+
def __repr__(self):
return "Compare(%s, %s)" % (self.expr.__repr__(), self.ops.__repr__())
def accept(self, visitor):
return visitor.visitCompare(self)
+ 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
+
def descr_Compare_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitCompare'))
args = Arguments(space, [ w_self ])
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 ] ))
+ 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 ),
+ )
class Const(Node):
def __init__(self, value, lineno=-1):
@@ -791,13 +1087,20 @@
def accept(self, visitor):
return visitor.visitConst(self)
+ def fget_value( space, self):
+ return self.value
+ def fset_value( space, self, w_arg):
+ self.value = w_arg
+
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 ] ))
+ accept=interp2app(descr_Const_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ value=GetSetProperty(Const.fget_value, Const.fset_value ),
+ )
class Continue(Node):
def __init__(self, lineno=-1):
@@ -816,13 +1119,15 @@
def accept(self, visitor):
return visitor.visitContinue(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 ] ))
+ accept=interp2app(descr_Continue_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ )
class Decorators(Node):
def __init__(self, nodes, lineno=-1):
@@ -844,13 +1149,22 @@
def accept(self, visitor):
return visitor.visitDecorators(self)
+ def fget_nodes( space, self):
+ 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 ) )
+
def descr_Decorators_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitDecorators'))
args = Arguments(space, [ w_self ])
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 ] ))
+ accept=interp2app(descr_Decorators_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ nodes=GetSetProperty(Decorators.fget_nodes, Decorators.fset_nodes ),
+ )
class Dict(Node):
def __init__(self, items, lineno=-1):
@@ -870,19 +1184,39 @@
nodelist.append(value)
return nodelist
+ def fset_items( space, self, w_arg ):
+ del self.items[:]
+ 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)"))
+ self.items.append( (key,value) )
+
+
+ def fget_items( space, self ):
+ return space.newlist( [ space.newtuple( [ space.wrap(key), space.wrap(value) ] )
+ for key, value in self.items ] )
+
+
def __repr__(self):
return "Dict(%s)" % (self.items.__repr__(),)
def accept(self, visitor):
return visitor.visitDict(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 ] ))
+ accept=interp2app(descr_Dict_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ items=GetSetProperty(Dict.fget_items, Dict.fset_items ),
+ )
class Discard(Node):
def __init__(self, expr, lineno=-1):
@@ -902,16 +1236,26 @@
def accept(self, visitor):
return visitor.visitDiscard(self)
+ 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
+
def descr_Discard_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitDiscard'))
args = Arguments(space, [ w_self ])
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 ] ))
+ accept=interp2app(descr_Discard_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ expr=GetSetProperty(Discard.fget_expr, Discard.fset_expr ),
+ )
class Div(BinaryOp):
- def __init__(self, (left, right), lineno=-1):
+ def __init__(self, left, right, lineno=-1):
Node.__init__(self, lineno)
self.left = left
self.right = right
@@ -924,18 +1268,36 @@
return [self.left, self.right]
def __repr__(self):
- return "Div((%s, %s))" % (self.left.__repr__(), self.right.__repr__())
+ return "Div(%s, %s)" % (self.left.__repr__(), self.right.__repr__())
def accept(self, visitor):
return visitor.visitDiv(self)
+ 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
+ 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
+
def descr_Div_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitDiv'))
args = Arguments(space, [ w_self ])
return space.call_args(w_callable, args)
-Div.typedef = TypeDef('Div', Node.typedef,
- accept=interp2app(descr_Div_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ))
+Div.typedef = TypeDef('Div', BinaryOp.typedef,
+ 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 ),
+ )
class Ellipsis(Node):
def __init__(self, lineno=-1):
@@ -954,13 +1316,15 @@
def accept(self, visitor):
return visitor.visitEllipsis(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 ] ))
+ accept=interp2app(descr_Ellipsis_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ )
class Exec(Node):
def __init__(self, expr, locals, globals, lineno=-1):
@@ -992,16 +1356,54 @@
def accept(self, visitor):
return visitor.visitExec(self)
+ 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
+ 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
+ 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
+
def descr_Exec_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitExec'))
args = Arguments(space, [ w_self ])
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 ] ))
+ 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 ),
+ )
class FloorDiv(BinaryOp):
- def __init__(self, (left, right), lineno=-1):
+ def __init__(self, left, right, lineno=-1):
Node.__init__(self, lineno)
self.left = left
self.right = right
@@ -1014,18 +1416,36 @@
return [self.left, self.right]
def __repr__(self):
- return "FloorDiv((%s, %s))" % (self.left.__repr__(), self.right.__repr__())
+ return "FloorDiv(%s, %s)" % (self.left.__repr__(), self.right.__repr__())
def accept(self, visitor):
return visitor.visitFloorDiv(self)
+ 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
+ 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
+
def descr_FloorDiv_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitFloorDiv'))
args = Arguments(space, [ w_self ])
return space.call_args(w_callable, args)
-FloorDiv.typedef = TypeDef('FloorDiv', Node.typedef,
- accept=interp2app(descr_FloorDiv_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ))
+FloorDiv.typedef = TypeDef('FloorDiv', BinaryOp.typedef,
+ 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 ),
+ )
class For(Node):
def __init__(self, assign, list, body, else_, lineno=-1):
@@ -1059,13 +1479,53 @@
def accept(self, visitor):
return visitor.visitFor(self)
+ 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
+ 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
+ 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
+ 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
+
def descr_For_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitFor'))
args = Arguments(space, [ w_self ])
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 ] ))
+ 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 ),
+ else_=GetSetProperty(For.fget_else_, For.fset_else_ ),
+ )
class From(Node):
def __init__(self, modname, names, lineno=-1):
@@ -1080,29 +1540,54 @@
def getChildNodes(self):
return []
+ def fget_names( space, self ):
+ return space.newlist( [ space.newtuple( [ space.wrap(name), space.wrap(as_name) ] )
+ for name, as_name in self.names ] )
+
+
+ def fset_names( space, self, w_arg ):
+ del self.names[:]
+ for w_tup in space.unpackiterable( w_arg ):
+ w_name = space.getitem( w_tup, space.wrap(0) )
+ w_as_name = space.getitem( w_tup, 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 )
+ self.names.append( (name, as_name) )
+
+
def __repr__(self):
return "From(%s, %s)" % (self.modname.__repr__(), self.names.__repr__())
def accept(self, visitor):
return visitor.visitFrom(self)
+ def fget_modname( space, self):
+ return space.wrap(self.modname)
+ def fset_modname( space, self, w_arg):
+ self.modname = space.str_w(w_arg)
+
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 ] ))
+ 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 ),
+ )
class Function(AbstractFunction):
- def __init__(self, decorators, name, argnames, defaults, flags, doc, code, lineno=-1):
+ def __init__(self, decorators, name, argnames, defaults, flags, w_doc, code, lineno=-1):
Node.__init__(self, lineno)
self.decorators = decorators
self.name = name
self.argnames = argnames
self.defaults = defaults
self.flags = flags
- self.doc = doc
+ self.w_doc = w_doc
self.code = code
self.varargs = self.kwargs = 0
if flags & CO_VARARGS:
@@ -1117,10 +1602,10 @@
children = []
children.append(self.decorators)
children.append(self.name)
- children.append(self.argnames)
+ children.extend(flatten(self.argnames))
children.extend(flatten(self.defaults))
children.append(self.flags)
- children.append(self.doc)
+ children.append(self.w_doc)
children.append(self.code)
return tuple(children)
@@ -1128,23 +1613,77 @@
nodelist = []
if self.decorators is not None:
nodelist.append(self.decorators)
+ nodelist.extend(self.argnames)
nodelist.extend(self.defaults)
nodelist.append(self.code)
return nodelist
def __repr__(self):
- return "Function(%s, %s, %s, %s, %s, %s, %s)" % (self.decorators.__repr__(), self.name.__repr__(), self.argnames.__repr__(), self.defaults.__repr__(), self.flags.__repr__(), self.doc.__repr__(), self.code.__repr__())
+ return "Function(%s, %s, %s, %s, %s, %s, %s)" % (self.decorators.__repr__(), self.name.__repr__(), self.argnames.__repr__(), self.defaults.__repr__(), self.flags.__repr__(), self.w_doc.__repr__(), self.code.__repr__())
def accept(self, visitor):
return visitor.visitFunction(self)
+ def fget_decorators( space, self):
+ if self.decorators is None:
+ return space.w_None
+ 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
+ def fget_name( space, self):
+ return space.wrap(self.name)
+ def fset_name( space, self, w_arg):
+ self.name = space.str_w(w_arg)
+ def fget_argnames( space, self):
+ 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 ) )
+ 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 ) )
+ def fget_flags( space, self):
+ return space.wrap(self.flags)
+ def fset_flags( space, self, w_arg):
+ self.flags = space.int_w(w_arg)
+ def fget_w_doc( space, self):
+ return self.w_doc
+ def fset_w_doc( space, self, w_arg):
+ self.w_doc = w_arg
+ 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
+
def descr_Function_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitFunction'))
args = Arguments(space, [ w_self ])
return space.call_args(w_callable, args)
-Function.typedef = TypeDef('Function', Node.typedef,
- accept=interp2app(descr_Function_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ))
+Function.typedef = TypeDef('Function', AbstractFunction.typedef,
+ 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 ),
+ defaults=GetSetProperty(Function.fget_defaults, Function.fset_defaults ),
+ flags=GetSetProperty(Function.fget_flags, Function.fset_flags ),
+ w_doc=GetSetProperty(Function.fget_w_doc, Function.fset_w_doc ),
+ code=GetSetProperty(Function.fget_code, Function.fset_code ),
+ )
class GenExpr(AbstractFunction):
def __init__(self, code, lineno=-1):
@@ -1168,13 +1707,23 @@
def accept(self, visitor):
return visitor.visitGenExpr(self)
+ 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
+
def descr_GenExpr_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitGenExpr'))
args = Arguments(space, [ w_self ])
return space.call_args(w_callable, args)
-GenExpr.typedef = TypeDef('GenExpr', Node.typedef,
- accept=interp2app(descr_GenExpr_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ))
+GenExpr.typedef = TypeDef('GenExpr', AbstractFunction.typedef,
+ accept=interp2app(descr_GenExpr_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ code=GetSetProperty(GenExpr.fget_code, GenExpr.fset_code ),
+ )
class GenExprFor(Node):
def __init__(self, assign, iter, ifs, lineno=-1):
@@ -1207,13 +1756,38 @@
def accept(self, visitor):
return visitor.visitGenExprFor(self)
+ 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
+ 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
+ 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 ) )
+
def descr_GenExprFor_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitGenExprFor'))
args = Arguments(space, [ w_self ])
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 ] ))
+ 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 ),
+ )
class GenExprIf(Node):
def __init__(self, test, lineno=-1):
@@ -1233,13 +1807,23 @@
def accept(self, visitor):
return visitor.visitGenExprIf(self)
+ 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
+
def descr_GenExprIf_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitGenExprIf'))
args = Arguments(space, [ w_self ])
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 ] ))
+ accept=interp2app(descr_GenExprIf_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ test=GetSetProperty(GenExprIf.fget_test, GenExprIf.fset_test ),
+ )
class GenExprInner(Node):
def __init__(self, expr, quals, lineno=-1):
@@ -1266,13 +1850,30 @@
def accept(self, visitor):
return visitor.visitGenExprInner(self)
+ 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
+ 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 ) )
+
def descr_GenExprInner_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitGenExprInner'))
args = Arguments(space, [ w_self ])
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 ] ))
+ 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 ),
+ )
class Getattr(Node):
def __init__(self, expr, attrname, lineno=-1):
@@ -1293,13 +1894,28 @@
def accept(self, visitor):
return visitor.visitGetattr(self)
+ 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
+ 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_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 ] ))
+ 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 ),
+ )
class Global(Node):
def __init__(self, names, lineno=-1):
@@ -1319,13 +1935,22 @@
def accept(self, visitor):
return visitor.visitGlobal(self)
+ def fget_names( space, self):
+ return space.newlist( [space.wrap(itm) for itm in self.names] )
+ def fset_names( space, self, w_arg):
+ del self.names[:]
+ for itm in space.unpackiterable(w_arg):
+ self.names.append( space.str_w(itm) )
+
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 ] ))
+ accept=interp2app(descr_Global_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ names=GetSetProperty(Global.fget_names, Global.fset_names ),
+ )
class If(Node):
def __init__(self, tests, else_, lineno=-1):
@@ -1351,19 +1976,56 @@
nodelist.append(self.else_)
return nodelist
+ def fset_tests( space, self, w_arg ):
+ del self.tests[:]
+ 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") )
+ self.tests.append( (test,suite) )
+
+
+
+
+ def fget_tests( space, self ):
+ return space.newlist( [ space.newtuple( [ space.wrap(test),
+ space.wrap(suite) ] )
+ for test, suite in self.tests ] )
+
+
def __repr__(self):
return "If(%s, %s)" % (self.tests.__repr__(), self.else_.__repr__())
def accept(self, visitor):
return visitor.visitIf(self)
+ 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
+
def descr_If_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitIf'))
args = Arguments(space, [ w_self ])
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 ] ))
+ 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_ ),
+ )
class Import(Node):
def __init__(self, names, lineno=-1):
@@ -1377,19 +2039,39 @@
def getChildNodes(self):
return []
+ def fget_names( space, self ):
+ return space.newlist( [ space.newtuple( [ space.wrap(name), space.wrap(as_name) ] )
+ for name, as_name in self.names ] )
+
+
+ def fset_names( space, self, w_arg ):
+ del self.names[:]
+ for w_tup in space.unpackiterable( w_arg ):
+ w_name = space.getitem( w_tup, space.wrap(0) )
+ w_as_name = space.getitem( w_tup, 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 )
+ self.names.append( (name, as_name) )
+
+
def __repr__(self):
return "Import(%s)" % (self.names.__repr__(),)
def accept(self, visitor):
return visitor.visitImport(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 ] ))
+ accept=interp2app(descr_Import_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ names=GetSetProperty(Import.fget_names, Import.fset_names ),
+ )
class Invert(UnaryOp):
def __init__(self, expr, lineno=-1):
@@ -1409,13 +2091,23 @@
def accept(self, visitor):
return visitor.visitInvert(self)
+ 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
+
def descr_Invert_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitInvert'))
args = Arguments(space, [ w_self ])
return space.call_args(w_callable, args)
-Invert.typedef = TypeDef('Invert', Node.typedef,
- accept=interp2app(descr_Invert_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ))
+Invert.typedef = TypeDef('Invert', UnaryOp.typedef,
+ accept=interp2app(descr_Invert_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ expr=GetSetProperty(Invert.fget_expr, Invert.fset_expr ),
+ )
class Keyword(Node):
def __init__(self, name, expr, lineno=-1):
@@ -1436,13 +2128,28 @@
def accept(self, visitor):
return visitor.visitKeyword(self)
+ def fget_name( space, self):
+ return space.wrap(self.name)
+ def fset_name( space, self, w_arg):
+ self.name = space.str_w(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
+
def descr_Keyword_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitKeyword'))
args = Arguments(space, [ w_self ])
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 ] ))
+ 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 ),
+ )
class Lambda(AbstractFunction):
def __init__(self, argnames, defaults, flags, code, lineno=-1):
@@ -1462,7 +2169,7 @@
def getChildren(self):
"NOT_RPYTHON"
children = []
- children.append(self.argnames)
+ children.extend(flatten(self.argnames))
children.extend(flatten(self.defaults))
children.append(self.flags)
children.append(self.code)
@@ -1470,6 +2177,7 @@
def getChildNodes(self):
nodelist = []
+ nodelist.extend(self.argnames)
nodelist.extend(self.defaults)
nodelist.append(self.code)
return nodelist
@@ -1480,16 +2188,45 @@
def accept(self, visitor):
return visitor.visitLambda(self)
+ def fget_argnames( space, self):
+ 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 ) )
+ 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 ) )
+ def fget_flags( space, self):
+ return space.wrap(self.flags)
+ def fset_flags( space, self, w_arg):
+ self.flags = space.int_w(w_arg)
+ 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
+
def descr_Lambda_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitLambda'))
args = Arguments(space, [ w_self ])
return space.call_args(w_callable, args)
-Lambda.typedef = TypeDef('Lambda', Node.typedef,
- accept=interp2app(descr_Lambda_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ))
+Lambda.typedef = TypeDef('Lambda', AbstractFunction.typedef,
+ 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 ),
+ code=GetSetProperty(Lambda.fget_code, Lambda.fset_code ),
+ )
class LeftShift(BinaryOp):
- def __init__(self, (left, right), lineno=-1):
+ def __init__(self, left, right, lineno=-1):
Node.__init__(self, lineno)
self.left = left
self.right = right
@@ -1502,18 +2239,36 @@
return [self.left, self.right]
def __repr__(self):
- return "LeftShift((%s, %s))" % (self.left.__repr__(), self.right.__repr__())
+ return "LeftShift(%s, %s)" % (self.left.__repr__(), self.right.__repr__())
def accept(self, visitor):
return visitor.visitLeftShift(self)
+ 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
+ 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
+
def descr_LeftShift_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitLeftShift'))
args = Arguments(space, [ w_self ])
return space.call_args(w_callable, args)
-LeftShift.typedef = TypeDef('LeftShift', Node.typedef,
- accept=interp2app(descr_LeftShift_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ))
+LeftShift.typedef = TypeDef('LeftShift', BinaryOp.typedef,
+ 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 ),
+ )
class List(Node):
def __init__(self, nodes, lineno=-1):
@@ -1535,13 +2290,22 @@
def accept(self, visitor):
return visitor.visitList(self)
+ def fget_nodes( space, self):
+ 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 ) )
+
def descr_List_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitList'))
args = Arguments(space, [ w_self ])
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 ] ))
+ accept=interp2app(descr_List_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ nodes=GetSetProperty(List.fget_nodes, List.fset_nodes ),
+ )
class ListComp(Node):
def __init__(self, expr, quals, lineno=-1):
@@ -1568,13 +2332,30 @@
def accept(self, visitor):
return visitor.visitListComp(self)
+ 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
+ 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 ) )
+
def descr_ListComp_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitListComp'))
args = Arguments(space, [ w_self ])
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 ] ))
+ 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 ),
+ )
class ListCompFor(Node):
def __init__(self, assign, list, ifs, lineno=-1):
@@ -1604,13 +2385,38 @@
def accept(self, visitor):
return visitor.visitListCompFor(self)
+ 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
+ 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
+ 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 ) )
+
def descr_ListCompFor_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitListCompFor'))
args = Arguments(space, [ w_self ])
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 ] ))
+ 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 ),
+ )
class ListCompIf(Node):
def __init__(self, test, lineno=-1):
@@ -1630,16 +2436,26 @@
def accept(self, visitor):
return visitor.visitListCompIf(self)
+ 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
+
def descr_ListCompIf_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitListCompIf'))
args = Arguments(space, [ w_self ])
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 ] ))
+ accept=interp2app(descr_ListCompIf_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ test=GetSetProperty(ListCompIf.fget_test, ListCompIf.fset_test ),
+ )
class Mod(BinaryOp):
- def __init__(self, (left, right), lineno=-1):
+ def __init__(self, left, right, lineno=-1):
Node.__init__(self, lineno)
self.left = left
self.right = right
@@ -1652,48 +2468,81 @@
return [self.left, self.right]
def __repr__(self):
- return "Mod((%s, %s))" % (self.left.__repr__(), self.right.__repr__())
+ return "Mod(%s, %s)" % (self.left.__repr__(), self.right.__repr__())
def accept(self, visitor):
return visitor.visitMod(self)
+ 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
+ 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
+
def descr_Mod_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitMod'))
args = Arguments(space, [ w_self ])
return space.call_args(w_callable, args)
-Mod.typedef = TypeDef('Mod', Node.typedef,
- accept=interp2app(descr_Mod_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ))
+Mod.typedef = TypeDef('Mod', BinaryOp.typedef,
+ 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 ),
+ )
class Module(Node):
- def __init__(self, doc, node, lineno=-1):
+ def __init__(self, w_doc, node, lineno=-1):
Node.__init__(self, lineno)
- self.doc = doc
+ self.w_doc = w_doc
self.node = node
def getChildren(self):
"NOT_RPYTHON"
- return self.doc, self.node
+ return self.w_doc, self.node
def getChildNodes(self):
return [self.node,]
def __repr__(self):
- return "Module(%s, %s)" % (self.doc.__repr__(), self.node.__repr__())
+ return "Module(%s, %s)" % (self.w_doc.__repr__(), self.node.__repr__())
def accept(self, visitor):
return visitor.visitModule(self)
+ def fget_w_doc( space, self):
+ return self.w_doc
+ def fset_w_doc( space, self, w_arg):
+ self.w_doc = w_arg
+ 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
+
def descr_Module_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitModule'))
args = Arguments(space, [ w_self ])
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 ] ))
+ 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 ),
+ )
class Mul(BinaryOp):
- def __init__(self, (left, right), lineno=-1):
+ def __init__(self, left, right, lineno=-1):
Node.__init__(self, lineno)
self.left = left
self.right = right
@@ -1706,18 +2555,36 @@
return [self.left, self.right]
def __repr__(self):
- return "Mul((%s, %s))" % (self.left.__repr__(), self.right.__repr__())
+ return "Mul(%s, %s)" % (self.left.__repr__(), self.right.__repr__())
def accept(self, visitor):
return visitor.visitMul(self)
+ 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
+ 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
+
def descr_Mul_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitMul'))
args = Arguments(space, [ w_self ])
return space.call_args(w_callable, args)
-Mul.typedef = TypeDef('Mul', Node.typedef,
- accept=interp2app(descr_Mul_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ))
+Mul.typedef = TypeDef('Mul', BinaryOp.typedef,
+ 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 ),
+ )
class Name(Node):
def __init__(self, varname, lineno=-1):
@@ -1737,13 +2604,20 @@
def accept(self, visitor):
return visitor.visitName(self)
+ def fget_varname( space, self):
+ return space.wrap(self.varname)
+ def fset_varname( space, self, w_arg):
+ self.varname = space.str_w(w_arg)
+
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 ] ))
+ accept=interp2app(descr_Name_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ varname=GetSetProperty(Name.fget_varname, Name.fset_varname ),
+ )
class NoneConst(Node):
def __init__(self, lineno=-1):
@@ -1762,13 +2636,15 @@
def accept(self, visitor):
return visitor.visitNoneConst(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 ] ))
+ accept=interp2app(descr_NoneConst_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ )
class Not(UnaryOp):
def __init__(self, expr, lineno=-1):
@@ -1788,39 +2664,23 @@
def accept(self, visitor):
return visitor.visitNot(self)
+ 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
+
def descr_Not_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitNot'))
args = Arguments(space, [ w_self ])
return space.call_args(w_callable, args)
-Not.typedef = TypeDef('Not', Node.typedef,
- accept=interp2app(descr_Not_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ))
-
-class NumberConst(Node):
- def __init__(self, number_value, lineno=-1):
- Node.__init__(self, lineno)
- self.number_value = number_value
-
- def getChildren(self):
- "NOT_RPYTHON"
- return self.number_value,
-
- def getChildNodes(self):
- return []
-
- def __repr__(self):
- return "NumberConst(%s)" % (self.number_value.__repr__(),)
-
- def accept(self, visitor):
- return visitor.visitNumberConst(self)
-
-def descr_NumberConst_accept( space, w_self, w_visitor):
- w_callable = space.getattr(w_visitor, space.wrap('visitNumberConst'))
- args = Arguments(space, [ w_self ])
- return space.call_args(w_callable, args)
-
-NumberConst.typedef = TypeDef('NumberConst', Node.typedef,
- accept=interp2app(descr_NumberConst_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ))
+Not.typedef = TypeDef('Not', UnaryOp.typedef,
+ accept=interp2app(descr_Not_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ expr=GetSetProperty(Not.fget_expr, Not.fset_expr ),
+ )
class Or(AbstractTest):
def __init__(self, nodes, lineno=-1):
@@ -1842,13 +2702,22 @@
def accept(self, visitor):
return visitor.visitOr(self)
+ def fget_nodes( space, self):
+ 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 ) )
+
def descr_Or_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitOr'))
args = Arguments(space, [ w_self ])
return space.call_args(w_callable, args)
-Or.typedef = TypeDef('Or', Node.typedef,
- accept=interp2app(descr_Or_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ))
+Or.typedef = TypeDef('Or', AbstractTest.typedef,
+ accept=interp2app(descr_Or_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ nodes=GetSetProperty(Or.fget_nodes, Or.fset_nodes ),
+ )
class Pass(Node):
def __init__(self, lineno=-1):
@@ -1867,16 +2736,18 @@
def accept(self, visitor):
return visitor.visitPass(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 ] ))
+ accept=interp2app(descr_Pass_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ )
class Power(BinaryOp):
- def __init__(self, (left, right), lineno=-1):
+ def __init__(self, left, right, lineno=-1):
Node.__init__(self, lineno)
self.left = left
self.right = right
@@ -1889,18 +2760,36 @@
return [self.left, self.right]
def __repr__(self):
- return "Power((%s, %s))" % (self.left.__repr__(), self.right.__repr__())
+ return "Power(%s, %s)" % (self.left.__repr__(), self.right.__repr__())
def accept(self, visitor):
return visitor.visitPower(self)
+ 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
+ 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
+
def descr_Power_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitPower'))
args = Arguments(space, [ w_self ])
return space.call_args(w_callable, args)
-Power.typedef = TypeDef('Power', Node.typedef,
- accept=interp2app(descr_Power_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ))
+Power.typedef = TypeDef('Power', BinaryOp.typedef,
+ 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 ),
+ )
class Print(Node):
def __init__(self, nodes, dest, lineno=-1):
@@ -1928,13 +2817,36 @@
def accept(self, visitor):
return visitor.visitPrint(self)
+ def fget_nodes( space, self):
+ 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 ) )
+ 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
+
def descr_Print_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitPrint'))
args = Arguments(space, [ w_self ])
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 ] ))
+ 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 ),
+ )
class Printnl(Node):
def __init__(self, nodes, dest, lineno=-1):
@@ -1962,13 +2874,36 @@
def accept(self, visitor):
return visitor.visitPrintnl(self)
+ def fget_nodes( space, self):
+ 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 ) )
+ 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
+
def descr_Printnl_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitPrintnl'))
args = Arguments(space, [ w_self ])
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 ] ))
+ 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 ),
+ )
class Raise(Node):
def __init__(self, expr1, expr2, expr3, lineno=-1):
@@ -2001,13 +2936,57 @@
def accept(self, visitor):
return visitor.visitRaise(self)
+ def fget_expr1( space, self):
+ if self.expr1 is None:
+ return space.w_None
+ 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
+ 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
+ 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
+
def descr_Raise_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitRaise'))
args = Arguments(space, [ w_self ])
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 ] ))
+ 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 ),
+ )
class Return(Node):
def __init__(self, value, lineno=-1):
@@ -2030,16 +3009,32 @@
def accept(self, visitor):
return visitor.visitReturn(self)
+ def fget_value( space, self):
+ if self.value is None:
+ return space.w_None
+ 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
+
def descr_Return_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitReturn'))
args = Arguments(space, [ w_self ])
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 ] ))
+ accept=interp2app(descr_Return_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ value=GetSetProperty(Return.fget_value, Return.fset_value ),
+ )
class RightShift(BinaryOp):
- def __init__(self, (left, right), lineno=-1):
+ def __init__(self, left, right, lineno=-1):
Node.__init__(self, lineno)
self.left = left
self.right = right
@@ -2052,18 +3047,36 @@
return [self.left, self.right]
def __repr__(self):
- return "RightShift((%s, %s))" % (self.left.__repr__(), self.right.__repr__())
+ return "RightShift(%s, %s)" % (self.left.__repr__(), self.right.__repr__())
def accept(self, visitor):
return visitor.visitRightShift(self)
+ 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
+ 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
+
def descr_RightShift_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitRightShift'))
args = Arguments(space, [ w_self ])
return space.call_args(w_callable, args)
-RightShift.typedef = TypeDef('RightShift', Node.typedef,
- accept=interp2app(descr_RightShift_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ))
+RightShift.typedef = TypeDef('RightShift', BinaryOp.typedef,
+ 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 ),
+ )
class Slice(Node):
def __init__(self, expr, flags, lower, upper, lineno=-1):
@@ -2097,13 +3110,56 @@
def accept(self, visitor):
return visitor.visitSlice(self)
+ 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
+ def fget_flags( space, self):
+ return space.wrap(self.flags)
+ def fset_flags( space, self, w_arg):
+ self.flags = space.int_w(w_arg)
+ def fget_lower( space, self):
+ if self.lower is None:
+ return space.w_None
+ 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
+ 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
+
def descr_Slice_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitSlice'))
args = Arguments(space, [ w_self ])
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 ] ))
+ 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 ),
+ upper=GetSetProperty(Slice.fget_upper, Slice.fset_upper ),
+ )
class Sliceobj(Node):
def __init__(self, nodes, lineno=-1):
@@ -2125,13 +3181,22 @@
def accept(self, visitor):
return visitor.visitSliceobj(self)
+ def fget_nodes( space, self):
+ 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 ) )
+
def descr_Sliceobj_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitSliceobj'))
args = Arguments(space, [ w_self ])
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 ] ))
+ accept=interp2app(descr_Sliceobj_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ nodes=GetSetProperty(Sliceobj.fget_nodes, Sliceobj.fset_nodes ),
+ )
class Stmt(Node):
def __init__(self, nodes, lineno=-1):
@@ -2153,42 +3218,25 @@
def accept(self, visitor):
return visitor.visitStmt(self)
+ def fget_nodes( space, self):
+ 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 ) )
+
def descr_Stmt_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitStmt'))
args = Arguments(space, [ w_self ])
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 ] ))
-
-class StringConst(Node):
- def __init__(self, string_value, lineno=-1):
- Node.__init__(self, lineno)
- self.string_value = string_value
-
- def getChildren(self):
- "NOT_RPYTHON"
- return self.string_value,
-
- def getChildNodes(self):
- return []
-
- def __repr__(self):
- return "StringConst(%s)" % (self.string_value.__repr__(),)
-
- def accept(self, visitor):
- return visitor.visitStringConst(self)
-
-def descr_StringConst_accept( space, w_self, w_visitor):
- w_callable = space.getattr(w_visitor, space.wrap('visitStringConst'))
- args = Arguments(space, [ w_self ])
- return space.call_args(w_callable, args)
-
-StringConst.typedef = TypeDef('StringConst', Node.typedef,
- accept=interp2app(descr_StringConst_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ))
+ accept=interp2app(descr_Stmt_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ nodes=GetSetProperty(Stmt.fget_nodes, Stmt.fset_nodes ),
+ )
class Sub(BinaryOp):
- def __init__(self, (left, right), lineno=-1):
+ def __init__(self, left, right, lineno=-1):
Node.__init__(self, lineno)
self.left = left
self.right = right
@@ -2201,18 +3249,36 @@
return [self.left, self.right]
def __repr__(self):
- return "Sub((%s, %s))" % (self.left.__repr__(), self.right.__repr__())
+ return "Sub(%s, %s)" % (self.left.__repr__(), self.right.__repr__())
def accept(self, visitor):
return visitor.visitSub(self)
+ 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
+ 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
+
def descr_Sub_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitSub'))
args = Arguments(space, [ w_self ])
return space.call_args(w_callable, args)
-Sub.typedef = TypeDef('Sub', Node.typedef,
- accept=interp2app(descr_Sub_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ))
+Sub.typedef = TypeDef('Sub', BinaryOp.typedef,
+ 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 ),
+ )
class Subscript(Node):
def __init__(self, expr, flags, subs, lineno=-1):
@@ -2241,13 +3307,35 @@
def accept(self, visitor):
return visitor.visitSubscript(self)
+ 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
+ def fget_flags( space, self):
+ return space.wrap(self.flags)
+ def fset_flags( space, self, w_arg):
+ self.flags = space.int_w(w_arg)
+ def fget_subs( space, self):
+ 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 ) )
+
def descr_Subscript_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitSubscript'))
args = Arguments(space, [ w_self ])
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 ] ))
+ 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 ),
+ )
class TryExcept(Node):
def __init__(self, body, handlers, else_, lineno=-1):
@@ -2280,19 +3368,65 @@
nodelist.append(self.else_)
return nodelist
+ def fget_handlers( space, self ):
+ return space.newlist( [ space.newtuple( [ space.wrap(expr1),
+ space.wrap(expr2),
+ space.wrap(body) ] )
+ for expr1, expr2, body in self.handlers ] )
+
+
+ def fset_handlers( space, self, w_arg ):
+ del self.handlers[:]
+ for w_tup in space.unpackiterable( w_arg ):
+ 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") )
+ self.handlers.append( (expr1,expr2,body) )
+
+
def __repr__(self):
return "TryExcept(%s, %s, %s)" % (self.body.__repr__(), self.handlers.__repr__(), self.else_.__repr__())
def accept(self, visitor):
return visitor.visitTryExcept(self)
+ 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
+ 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
+
def descr_TryExcept_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitTryExcept'))
args = Arguments(space, [ w_self ])
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 ] ))
+ 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_ ),
+ )
class TryFinally(Node):
def __init__(self, body, final, lineno=-1):
@@ -2313,13 +3447,31 @@
def accept(self, visitor):
return visitor.visitTryFinally(self)
+ 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
+ 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
+
def descr_TryFinally_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitTryFinally'))
args = Arguments(space, [ w_self ])
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 ] ))
+ 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 ),
+ )
class Tuple(Node):
def __init__(self, nodes, lineno=-1):
@@ -2341,13 +3493,22 @@
def accept(self, visitor):
return visitor.visitTuple(self)
+ def fget_nodes( space, self):
+ 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 ) )
+
def descr_Tuple_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitTuple'))
args = Arguments(space, [ w_self ])
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 ] ))
+ accept=interp2app(descr_Tuple_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ nodes=GetSetProperty(Tuple.fget_nodes, Tuple.fset_nodes ),
+ )
class UnaryAdd(UnaryOp):
def __init__(self, expr, lineno=-1):
@@ -2367,13 +3528,23 @@
def accept(self, visitor):
return visitor.visitUnaryAdd(self)
+ 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
+
def descr_UnaryAdd_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitUnaryAdd'))
args = Arguments(space, [ w_self ])
return space.call_args(w_callable, args)
-UnaryAdd.typedef = TypeDef('UnaryAdd', Node.typedef,
- accept=interp2app(descr_UnaryAdd_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ))
+UnaryAdd.typedef = TypeDef('UnaryAdd', UnaryOp.typedef,
+ accept=interp2app(descr_UnaryAdd_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ expr=GetSetProperty(UnaryAdd.fget_expr, UnaryAdd.fset_expr ),
+ )
class UnarySub(UnaryOp):
def __init__(self, expr, lineno=-1):
@@ -2393,13 +3564,23 @@
def accept(self, visitor):
return visitor.visitUnarySub(self)
+ 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
+
def descr_UnarySub_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitUnarySub'))
args = Arguments(space, [ w_self ])
return space.call_args(w_callable, args)
-UnarySub.typedef = TypeDef('UnarySub', Node.typedef,
- accept=interp2app(descr_UnarySub_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ))
+UnarySub.typedef = TypeDef('UnarySub', UnaryOp.typedef,
+ accept=interp2app(descr_UnarySub_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ expr=GetSetProperty(UnarySub.fget_expr, UnarySub.fset_expr ),
+ )
class While(Node):
def __init__(self, test, body, else_, lineno=-1):
@@ -2430,13 +3611,45 @@
def accept(self, visitor):
return visitor.visitWhile(self)
+ 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
+ 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
+ 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
+
def descr_While_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitWhile'))
args = Arguments(space, [ w_self ])
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 ] ))
+ 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_ ),
+ )
class Yield(Node):
def __init__(self, value, lineno=-1):
@@ -2456,13 +3669,23 @@
def accept(self, visitor):
return visitor.visitYield(self)
+ 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
+
def descr_Yield_accept( space, w_self, w_visitor):
w_callable = space.getattr(w_visitor, space.wrap('visitYield'))
args = Arguments(space, [ w_self ])
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 ] ))
+ accept=interp2app(descr_Yield_accept, unwrap_spec=[ ObjSpace, W_Root, W_Root ] ),
+ value=GetSetProperty(Yield.fget_value, Yield.fset_value ),
+ )
class ASTVisitor(object):
@@ -2594,8 +3817,6 @@
return self.default( node )
def visitNot(self, node):
return self.default( node )
- def visitNumberConst(self, node):
- return self.default( node )
def visitOr(self, node):
return self.default( node )
def visitPass(self, node):
@@ -2618,8 +3839,6 @@
return self.default( node )
def visitStmt(self, node):
return self.default( node )
- def visitStringConst(self, node):
- return self.default( node )
def visitSub(self, node):
return self.default( node )
def visitSubscript(self, node):
Modified: pypy/dist/pypy/interpreter/astcompiler/ast.txt
==============================================================================
--- pypy/dist/pypy/interpreter/astcompiler/ast.txt (original)
+++ pypy/dist/pypy/interpreter/astcompiler/ast.txt Thu Dec 8 18:25:31 2005
@@ -2,17 +2,27 @@
# generated by astgen.py.
# The descriptions use the following special notation to describe
# properties of the children:
+
# * this child is not a node
+
+# *int this child is not a node
+# *str this child is not a node
+# *[int] this child is not a node
+# *[str] this child is not a node
+
+# % this child is a wrapped object
# ! this child is a sequence that contains nodes in it
# & this child may be set to None
+# (type) where type is int, str
+# [type]
# = ... a default value for the node constructor (optional args)
-Module: doc*, node
+Module: w_doc%, node
Stmt: nodes!
Decorators: nodes!
AbstractFunction:
-Function(AbstractFunction): decorators&, name*, argnames*, defaults!, flags*, doc*, code
-Lambda(AbstractFunction): argnames*, defaults!, flags*, code
-Class: name*, bases!, doc*, code
+Function(AbstractFunction): decorators&, name*str, argnames!, defaults!, flags*int, w_doc%, code
+Lambda(AbstractFunction): argnames!, defaults!, flags*int, code
+Class: name*str, bases!, w_doc%, code
Pass:
Break:
Continue:
@@ -20,27 +30,27 @@
While: test, body, else_&
If: tests!, else_&
Exec: expr, locals&, globals&
-From: modname*, names*
+From: modname*str, names*
Import: names*
Raise: expr1&, expr2&, expr3&
TryFinally: body, final
TryExcept: body, handlers!, else_&
Return: value&
Yield: value
-Const: value*
+Const: value%
NoneConst:
-StringConst: string_value*
-NumberConst: number_value*
+#StringConst: string_value*
+#NumberConst: number_value*
Print: nodes!, dest&
Printnl: nodes!, dest&
Discard: expr
-AugAssign: node, op*, expr
+AugAssign: node, op*str, expr
Assign: nodes!, expr
AssSeq:
AssTuple(AssSeq): nodes!
AssList(AssSeq): nodes!
-AssName: name*, flags*
-AssAttr: expr, attrname*, flags*
+AssName: name*str, flags*int
+AssAttr: expr, attrname*str, flags*int
ListComp: expr, quals!
ListCompFor: assign, list, ifs!
ListCompIf: test
@@ -53,16 +63,16 @@
UnaryOp:
Not(UnaryOp): expr
Compare: expr, ops!
-Name: varname*
-Global: names*
+Name: varname*str
+Global: names*[str]
Backquote(UnaryOp): expr
-Getattr: expr, attrname*
+Getattr: expr, attrname*str
CallFunc: node, args!, star_args& = None, dstar_args& = None
-Keyword: name*, expr
-Subscript: expr, flags*, subs!
+Keyword: name*str, expr
+Subscript: expr, flags*int, subs!
Ellipsis:
Sliceobj: nodes!
-Slice: expr, flags*, lower&, upper&
+Slice: expr, flags*int, lower&, upper&
Assert: test, fail&
Tuple: nodes!
AbstractTest:
@@ -73,19 +83,21 @@
Bitxor(BitOp): nodes!
Bitand(BitOp): nodes!
BinaryOp:
-LeftShift(BinaryOp): (left, right)
-RightShift(BinaryOp): (left, right)
-Add(BinaryOp): (left, right)
-Sub(BinaryOp): (left, right)
-Mul(BinaryOp): (left, right)
-Div(BinaryOp): (left, right)
-Mod(BinaryOp): (left, right)
-Power(BinaryOp): (left, right)
-FloorDiv(BinaryOp): (left, right)
+LeftShift(BinaryOp): left, right
+RightShift(BinaryOp): left, right
+Add(BinaryOp): left, right
+Sub(BinaryOp): left, right
+Mul(BinaryOp): left, right
+Div(BinaryOp): left, right
+Mod(BinaryOp): left, right
+Power(BinaryOp): left, right
+FloorDiv(BinaryOp): left, right
UnaryAdd(UnaryOp): expr
UnarySub(UnaryOp): expr
Invert(UnaryOp): expr
+== OVERRIDES ==
+
init(Function):
self.varargs = self.kwargs = 0
if flags & CO_VARARGS:
@@ -146,3 +158,120 @@
else:
assert False, "should only have AssName and AssTuple as children"
return argnames
+
+Compare.fget_ops( space, self ):
+ lst = []
+ for op_name, node in self.ops:
+ lst.append( space.newtuple( [ space.wrap(op_name), space.wrap(node) ] ) )
+ return space.newlist( lst )
+
+Compare.fset_ops( space, self, w_arg ):
+ del self.ops[:]
+ for w_obj in space.unpackiterable( w_arg ):
+ 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)"))
+ self.ops.append( (ops,node) )
+
+Dict.fget_items( space, self ):
+ return space.newlist( [ space.newtuple( [ space.wrap(key), space.wrap(value) ] )
+ for key, value in self.items ] )
+
+Dict.fset_items( space, self, w_arg ):
+ del self.items[:]
+ 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)"))
+ 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),
+ space.wrap(suite) ] )
+ for test, suite in self.tests ] )
+
+If.fset_tests( space, self, w_arg ):
+ del self.tests[:]
+ 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") )
+ self.tests.append( (test,suite) )
+
+
+
+TryExcept.fget_handlers( space, self ):
+ return space.newlist( [ space.newtuple( [ space.wrap(expr1),
+ space.wrap(expr2),
+ space.wrap(body) ] )
+ for expr1, expr2, body in self.handlers ] )
+
+TryExcept.fset_handlers( space, self, w_arg ):
+ del self.handlers[:]
+ for w_tup in space.unpackiterable( w_arg ):
+ 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") )
+ self.handlers.append( (expr1,expr2,body) )
+
+Import.fget_names( space, self ):
+ return space.newlist( [ space.newtuple( [ space.wrap(name), space.wrap(as_name) ] )
+ for name, as_name in self.names ] )
+
+Import.fset_names( space, self, w_arg ):
+ del self.names[:]
+ for w_tup in space.unpackiterable( w_arg ):
+ w_name = space.getitem( w_tup, space.wrap(0) )
+ w_as_name = space.getitem( w_tup, 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 )
+ self.names.append( (name, as_name) )
+
+From.fget_names( space, self ):
+ return space.newlist( [ space.newtuple( [ space.wrap(name), space.wrap(as_name) ] )
+ for name, as_name in self.names ] )
+
+From.fset_names( space, self, w_arg ):
+ del self.names[:]
+ for w_tup in space.unpackiterable( w_arg ):
+ w_name = space.getitem( w_tup, space.wrap(0) )
+ w_as_name = space.getitem( w_tup, 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 )
+ self.names.append( (name, as_name) )
+
Modified: pypy/dist/pypy/interpreter/astcompiler/astgen.py
==============================================================================
--- pypy/dist/pypy/interpreter/astcompiler/astgen.py (original)
+++ pypy/dist/pypy/interpreter/astcompiler/astgen.py Thu Dec 8 18:25:31 2005
@@ -6,7 +6,7 @@
Instead, it is rather complex to generate the appropriate code. And
the Node interface has changed more often than the grammar.
"""
-# This is a slightly modified version from the original that adds a
+# This is a heavily modified version from the original that adds a
# visit method to each node
import fileinput
@@ -28,8 +28,13 @@
P_NODE = 1
P_OTHER = 2
-P_NESTED = 3
-P_NONE = 4
+P_STR = 3
+P_INT = 4
+P_STR_LIST = 5
+P_INT_LIST = 6
+P_WRAPPED = 7
+P_NESTED = 8
+P_NONE = 9
class NodeInfo:
"""Each instance describes a specific AST node"""
@@ -51,12 +56,7 @@
self.parent = Node_NodeInfo
def get_argnames(self):
- if '(' in self.args:
- i = self.args.find('(')
- j = self.args.rfind(')')
- args = self.args[i+1:j]
- else:
- args = self.args
+ args = self.args
return [strip_default(arg.strip())
for arg in args.split(',') if arg]
@@ -73,6 +73,26 @@
arg = self.argnames[i] = arg[:-1]
d[arg] = P_OTHER
hardest_arg = max(hardest_arg, P_OTHER)
+ elif arg.endswith('*int'):
+ arg = self.argnames[i] = arg[:-4]
+ d[arg] = P_INT
+ hardest_arg = max(hardest_arg, P_INT)
+ elif arg.endswith('*str'):
+ arg = self.argnames[i] = arg[:-4]
+ d[arg] = P_STR
+ hardest_arg = max(hardest_arg, P_STR)
+ elif arg.endswith('*[int]'):
+ arg = self.argnames[i] = arg[:-6]
+ d[arg] = P_INT_LIST
+ hardest_arg = max(hardest_arg, P_INT_LIST)
+ elif arg.endswith('*[str]'):
+ arg = self.argnames[i] = arg[:-6]
+ d[arg] = P_STR_LIST
+ hardest_arg = max(hardest_arg, P_STR_LIST)
+ elif arg.endswith('%'):
+ arg = self.argnames[i] = arg[:-1]
+ d[arg] = P_WRAPPED
+ hardest_arg = max(hardest_arg, P_WRAPPED)
elif arg.endswith('!'):
arg = self.argnames[i] = arg[:-1]
d[arg] = P_NESTED
@@ -86,9 +106,14 @@
self.hardest_arg = hardest_arg
if hardest_arg > P_NODE:
+ self.args = self.args.replace('*str', '')
+ self.args = self.args.replace('*int', '')
+ self.args = self.args.replace('*[str]', '')
+ self.args = self.args.replace('*[int]', '')
self.args = self.args.replace('*', '')
self.args = self.args.replace('!', '')
self.args = self.args.replace('&', '')
+ self.args = self.args.replace('%', '')
return d
@@ -106,6 +131,8 @@
print >> buf
self._gen_visit(buf)
print >> buf
+ self._gen_attrs(buf)
+ print >> buf
self._gen_typedef(buf)
buf.seek(0, 0)
return buf.read()
@@ -218,91 +245,185 @@
print >> buf, " def accept(self, visitor):"
print >> buf, " return visitor.visit%s(self)" % self.name
+
+ def _gen_fget_func(self, buf, attr, prop ):
+ # FGET
+ print >> buf, " def fget_%s( space, self):" % attr
+ if prop[attr]==P_WRAPPED:
+ print >> buf, " return self.%s" % attr
+ elif prop[attr] in (P_INT,P_STR, P_NODE):
+ print >> buf, " return space.wrap(self.%s)" % attr
+ elif prop[attr] in (P_INT_LIST, P_STR_LIST, P_NESTED ):
+ print >> buf, " return space.newlist( [space.wrap(itm) for itm in self.%s] )" % attr
+ elif prop[attr]==P_NONE:
+ print >> buf, " if self.%s is None:" % attr
+ print >> buf, " return space.w_None"
+ print >> buf, " else:"
+ print >> buf, " return space.wrap(self.%s)" % attr
+ else:
+ assert False, "Unkown node type"
+
+ def _gen_fset_func(self, buf, attr, prop ):
+ # FSET
+ print >> buf, " def fset_%s( space, self, w_arg):" % attr
+ if prop[attr]==P_WRAPPED:
+ print >> buf, " self.%s = w_arg" % attr
+ elif prop[attr]==P_INT:
+ print >> buf, " self.%s = space.int_w(w_arg)" % attr
+ elif prop[attr]==P_STR:
+ print >> buf, " self.%s = space.str_w(w_arg)" % attr
+ 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:
+ 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:
+ 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
+ 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
+
+ def _gen_attrs(self, buf):
+ prop = self.argprops
+ for attr in self.argnames:
+ if "fget_%s" % attr not in self.additional_methods:
+ self._gen_fget_func( buf, attr, prop )
+
+ if "fset_%s" % attr not in self.additional_methods:
+ self._gen_fset_func( buf, attr, prop )
+
+
def _gen_typedef(self, buf):
+ 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', Node.typedef, " % (self.name,self.name)
- 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, " 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, " )"
def _gen_additional_methods(self, buf):
for key, value in self.additional_methods.iteritems():
- if key not in '_cur_':
- print >> buf, ''.join(value)
- # print >> buf, '\n\n'
+ print >> buf, ''.join(value)
def gen_base_visit(self, buf):
print >> buf, " def visit%s(self, node):" % self.name
print >> buf, " return self.default( node )"
+ def gen_print_visit(self, buf):
+ # This is a print visitor for application level tests
+ print >> buf, " def visit%s(self, node):" % self.name
+ print >> buf, " print '%s('," % self.name
+ for attr in self.argnames:
+ if self.argprops[attr] == P_NODE:
+ print >> buf, " node.%s.accept(self)" % attr
+ print >> buf, " print ',',"
+ if self.argprops[attr] == P_NONE:
+ print >> buf, " if node.%s: node.%s.accept(self)" % (attr,attr)
+ print >> buf, " print ',',"
+ elif self.argprops[attr] == P_NESTED:
+ print >> buf, " for nd in node.%s:" % attr
+ print >> buf, " nd.accept(self)"
+ print >> buf, " print ',',"
+ else:
+ print >> buf, " print node.%s,','," % attr
+ print >> buf, " print ')',"
+
+
+
Node_NodeInfo = NodeInfo("Node","")
rx_init = re.compile('init\((.*)\):')
rx_flatten_nodes = re.compile('flatten_nodes\((.*)\.(.*)\):')
-rx_additional_methods = re.compile('(.*)\.(.*)\((.*?)\):')
+rx_additional_methods = re.compile('(\\w+)\.(\w+)\((.*?)\):')
def parse_spec(file):
classes = {}
cur = None
kind = None
- for line in fileinput.input(file):
- mo = None
+ fiter = fileinput.input(file)
+ for line in fiter:
+ if line.startswith("== OVERRIDES =="):
+ break
comment = line.strip().startswith('#')
- if not comment:
- mo = rx_init.search(line)
- if mo:
- kind = 'init'
- else:
- mo = rx_flatten_nodes.search(line)
- if mo:
- kind = 'flatten_nodes'
- else:
- mo = rx_additional_methods.search(line)
- if mo:
- kind = 'additional_method'
- if mo is None:
- if cur is None:
- if comment:
- continue
- # a normal entry
- try:
- name, args = line.split(':')
- except ValueError:
- continue
- if "(" in name:
- name, parent = name.split("(")
- parent = parent[:-1]
- else:
- parent = None
- classes[name] = NodeInfo(name, args, parent)
- cur = None
- elif kind == 'init':
- # some code for the __init__ method
- cur.init.append(line)
- elif kind == 'flatten_nodes':
- cur.flatten_nodes['_cur_'].append(line)
- elif kind == 'additional_method':
- cur.additional_methods['_cur_'].append(' '*4 + line)
- elif kind == 'init':
- # some extra code for a Node's __init__ method
- name = mo.group(1)
- cur = classes[name]
- elif kind == 'flatten_nodes':
- # special case for getChildNodes flattening
- name = mo.group(1)
- attr = mo.group(2)
- cur = classes[name]
- cur.flatten_nodes[attr] = cur.flatten_nodes['_cur_'] = []
- elif kind == 'additional_method':
- name = mo.group(1)
- methname = mo.group(2)
- params = mo.group(3)
- cur = classes[name]
- cur.additional_methods['_cur_'] = [' def %s(%s):\n' % (methname, params)]
- cur.additional_methods[methname] = cur.additional_methods['_cur_']
+ if comment:
+ continue
+ # a normal entry
+ try:
+ name, args = line.split(':')
+ except ValueError:
+ continue
+ if "(" in name:
+ name, parent = name.split("(")
+ parent = parent[:-1]
+ else:
+ parent = None
+ classes[name] = NodeInfo(name, args, parent)
+
+
+ for line in fiter:
+ mo = None
+ mo = rx_init.match(line)
+ if mo:
+ kind = 'init'
+ # some extra code for a Node's __init__ method
+ name = mo.group(1)
+ cur = classes[name]
+ continue
+
+ mo = rx_flatten_nodes.match(line)
+ if mo:
+ kind = 'flatten_nodes'
+ # special case for getChildNodes flattening
+ name = mo.group(1)
+ attr = mo.group(2)
+ cur = classes[name]
+ _cur_ = attr
+ cur.flatten_nodes[attr] = []
+ flatten_expect_comment = True
+ continue
+
+ mo = rx_additional_methods.match(line)
+ if mo:
+ kind = 'additional_method'
+ name = mo.group(1)
+ methname = mo.group(2)
+ params = mo.group(3)
+ cur = classes[name]
+ _cur_ = methname
+ cur.additional_methods[_cur_] = [' def %s(%s):\n' % (methname, params)]
+ continue
+
+ if kind == 'init':
+ # some code for the __init__ method
+ cur.init.append(line)
+ elif kind == 'flatten_nodes':
+ if flatten_expect_comment:
+ assert line.strip().startswith("#")
+ flatten_expect_comment=False
+ cur.flatten_nodes[_cur_].append(line)
+ elif kind == 'additional_method':
+ cur.additional_methods[_cur_].append(' '*4 + line)
for node in classes.values():
node.setup_parent(classes)
@@ -334,6 +455,19 @@
info.gen_base_visit(buf)
print buf.getvalue()
+def gen_print_visitor(classes, f):
+ print >>f, ASTVISITORCLASS
+ buf = StringIO()
+ for info in classes:
+ info.gen_base_visit(buf)
+ print >>f, buf.getvalue()
+ print >>f, "class ASTPrintVisitor(ASTVisitor):"
+ buf = StringIO()
+ for info in classes:
+ info.gen_print_visit(buf)
+ print >>f, buf.getvalue()
+
+
def main():
print prologue
print
@@ -348,6 +482,7 @@
for info in classes:
emit(info)
gen_ast_visitor(classes)
+ gen_print_visitor(classes,file("ast_test.py","w"))
print epilogue
prologue = '''
@@ -357,9 +492,10 @@
"""
from consts import CO_VARARGS, CO_VARKEYWORDS, OP_ASSIGN
from pypy.interpreter.baseobjspace import Wrappable
-from pypy.interpreter.typedef import TypeDef
+from pypy.interpreter.typedef import TypeDef, GetSetProperty
from pypy.interpreter.gateway import interp2app, W_Root, ObjSpace
from pypy.interpreter.argument import Arguments
+from pypy.interpreter.error import OperationError
def flatten(list):
l = []
Modified: pypy/dist/pypy/interpreter/astcompiler/consts.py
==============================================================================
--- pypy/dist/pypy/interpreter/astcompiler/consts.py (original)
+++ pypy/dist/pypy/interpreter/astcompiler/consts.py Thu Dec 8 18:25:31 2005
@@ -1,7 +1,8 @@
# operation flags
-OP_ASSIGN = 'OP_ASSIGN'
-OP_DELETE = 'OP_DELETE'
-OP_APPLY = 'OP_APPLY'
+OP_ASSIGN = 0 # 'OP_ASSIGN'
+OP_DELETE = 1 # 'OP_DELETE'
+OP_APPLY = 2 # 'OP_APPLY'
+OP_NONE = 3
SC_LOCAL = 1
SC_GLOBAL = 2
Modified: pypy/dist/pypy/interpreter/astcompiler/pycodegen.py
==============================================================================
--- pypy/dist/pypy/interpreter/astcompiler/pycodegen.py (original)
+++ pypy/dist/pypy/interpreter/astcompiler/pycodegen.py Thu Dec 8 18:25:31 2005
@@ -7,7 +7,7 @@
from pypy.interpreter.astcompiler import ast, parse, walk, syntax
from pypy.interpreter.astcompiler import pyassem, misc, future, symbols
from pypy.interpreter.astcompiler.consts import SC_LOCAL, SC_GLOBAL, \
- SC_FREE, SC_CELL, SC_DEFAULT
+ SC_FREE, SC_CELL, SC_DEFAULT, OP_APPLY, OP_ASSIGN, OP_DELETE, OP_NONE
from pypy.interpreter.astcompiler.consts import CO_VARARGS, CO_VARKEYWORDS, \
CO_NEWLOCALS, CO_NESTED, CO_GENERATOR, CO_GENERATOR_ALLOWED, CO_FUTURE_DIVISION
from pypy.interpreter.pyparser.error import SyntaxError
@@ -313,9 +313,9 @@
assert node.scope is not None
self.scope = node.scope
self.emitop_int('SET_LINENO', 0)
- if not space.is_w(node.doc, space.w_None):
+ if not space.is_w(node.w_doc, space.w_None):
self.set_lineno(node)
- self.emitop_obj('LOAD_CONST', node.doc)
+ self.emitop_obj('LOAD_CONST', node.w_doc)
self.storeName('__doc__', node.lineno)
node.node.accept( self )
self.emitop_obj('LOAD_CONST', space.w_None )
@@ -332,8 +332,8 @@
def visitFunction(self, node):
self._visitFuncOrLambda(node, isLambda=0)
space = self.space
- if not space.is_w(node.doc, space.w_None):
- self.setDocstring(node.doc)
+ if not space.is_w(node.w_doc, space.w_None):
+ self.setDocstring(node.w_doc)
self.storeName(node.name, node.lineno)
def visitLambda(self, node):
@@ -892,29 +892,29 @@
elt.accept( self )
def visitAssName(self, node):
- if node.flags == 'OP_ASSIGN':
+ if node.flags == OP_ASSIGN:
self.storeName(node.name, node.lineno)
- elif node.flags == 'OP_DELETE':
+ elif node.flags == OP_DELETE:
self.set_lineno(node)
self.delName(node.name, node.lineno)
else:
- assert False, "visitAssName unexpected flags: %s" % node.flags
+ assert False, "visitAssName unexpected flags: %d" % node.flags
def visitAssAttr(self, node):
node.expr.accept( self )
- if node.flags == 'OP_ASSIGN':
+ if node.flags == OP_ASSIGN:
if node.attrname == 'None':
raise SyntaxError('assignment to None is not allowed', node.lineno)
self.emitop('STORE_ATTR', self.mangle(node.attrname))
- elif node.flags == 'OP_DELETE':
+ elif node.flags == OP_DELETE:
if node.attrname == 'None':
raise SyntaxError('deleting None is not allowed', node.lineno)
self.emitop('DELETE_ATTR', self.mangle(node.attrname))
else:
- assert False, "visitAssAttr unexpected flags: %s" % node.flags
+ assert False, "visitAssAttr unexpected flags: %d" % node.flags
def _visitAssSequence(self, node, op='UNPACK_SEQUENCE'):
- if findOp(node) != 'OP_DELETE':
+ if findOp(node) != OP_DELETE:
self.emitop_int(op, len(node.nodes))
for child in node.nodes:
child.accept( self )
@@ -1052,14 +1052,14 @@
self.emitop_int('DUP_TOPX', 3)
else:
self.emitop_int('DUP_TOPX', 2)
- if node.flags == 'OP_APPLY':
+ if node.flags == OP_APPLY:
self.emit('SLICE+%d' % slice)
- elif node.flags == 'OP_ASSIGN':
+ elif node.flags == OP_ASSIGN:
self.emit('STORE_SLICE+%d' % slice)
- elif node.flags == 'OP_DELETE':
+ elif node.flags == OP_DELETE:
self.emit('DELETE_SLICE+%d' % slice)
else:
- assert False, "weird slice %s" % node.flags
+ assert False, "weird slice %d" % node.flags
def visitSubscript(self, node):
return self._visitSubscript(node, False)
@@ -1072,11 +1072,11 @@
self.emitop_int('DUP_TOPX', 2)
if len(node.subs) > 1:
self.emitop_int('BUILD_TUPLE', len(node.subs))
- if node.flags == 'OP_APPLY':
+ if node.flags == OP_APPLY:
self.emit('BINARY_SUBSCR')
- elif node.flags == 'OP_ASSIGN':
+ elif node.flags == OP_ASSIGN:
self.emit('STORE_SUBSCR')
- elif node.flags == 'OP_DELETE':
+ elif node.flags == OP_DELETE:
self.emit('DELETE_SUBSCR')
# binary ops
@@ -1268,8 +1268,8 @@
CodeGenerator.__init__(self, space, graph)
self.optimized = 1
- if not isLambda and not space.is_w(func.doc, space.w_None):
- self.setDocstring(func.doc)
+ if not isLambda and not space.is_w(func.w_doc, space.w_None):
+ self.setDocstring(func.w_doc)
if func.varargs:
self.graph.setFlag(CO_VARARGS)
@@ -1348,8 +1348,8 @@
CodeGenerator.__init__(self, space, graph)
self.class_name = klass.name
self.graph.setFlag(CO_NEWLOCALS)
- if not space.is_w(klass.doc, space.w_None):
- self.setDocstring(klass.doc)
+ if not space.is_w(klass.w_doc, space.w_None):
+ self.setDocstring(klass.w_doc)
def get_module(self):
return self.module
@@ -1371,8 +1371,8 @@
self.set_lineno(klass)
self.emitop("LOAD_GLOBAL", "__name__")
self.storeName("__module__", klass.lineno)
- if not space.is_w(klass.doc, space.w_None):
- self.emitop_obj("LOAD_CONST", klass.doc)
+ if not space.is_w(klass.w_doc, space.w_None):
+ self.emitop_obj("LOAD_CONST", klass.w_doc)
self.storeName('__doc__', klass.lineno)
def findOp(node):
@@ -1384,20 +1384,20 @@
class OpFinder(ast.ASTVisitor):
def __init__(self):
- self.op = None
+ self.op = OP_NONE
def visitAssName(self, node):
- if self.op is None:
+ if self.op is OP_NONE:
self.op = node.flags
elif self.op != node.flags:
raise ValueError("mixed ops in stmt")
def visitAssAttr(self, node):
- if self.op is None:
+ if self.op is OP_NONE:
self.op = node.flags
elif self.op != node.flags:
raise ValueError("mixed ops in stmt")
def visitSubscript(self, node):
- if self.op is None:
+ if self.op is OP_NONE:
self.op = node.flags
elif self.op != node.flags:
raise ValueError("mixed ops in stmt")
Modified: pypy/dist/pypy/interpreter/astcompiler/symbols.py
==============================================================================
--- pypy/dist/pypy/interpreter/astcompiler/symbols.py (original)
+++ pypy/dist/pypy/interpreter/astcompiler/symbols.py Thu Dec 8 18:25:31 2005
@@ -361,7 +361,7 @@
scope = ClassScope(node.name, self.module)
if parent.nested or isinstance(parent, FunctionScope):
scope.nested = 1
- if node.doc is not None:
+ if node.w_doc is not None:
scope.add_def('__doc__')
scope.add_def('__module__')
node.scope = scope
Modified: pypy/dist/pypy/interpreter/pyparser/astbuilder.py
==============================================================================
--- pypy/dist/pypy/interpreter/pyparser/astbuilder.py (original)
+++ pypy/dist/pypy/interpreter/pyparser/astbuilder.py Thu Dec 8 18:25:31 2005
@@ -591,7 +591,7 @@
token = atoms[-2]
if isinstance(token, TokenObject) and token.name == tok.DOUBLESTAR:
obj = parse_attraccess(slicecut(atoms, 0, -2))
- builder.push(ast.Power([obj, atoms[-1]], lineno))
+ builder.push(ast.Power( obj, atoms[-1], lineno))
else:
obj = parse_attraccess(atoms)
builder.push(obj)
@@ -620,13 +620,13 @@
op_node = atoms[i-1]
assert isinstance(op_node, TokenObject)
if op_node.name == tok.STAR:
- left = ast.Mul( [ left, right ], left.lineno )
+ left = ast.Mul( left, right, left.lineno )
elif op_node.name == tok.SLASH:
- left = ast.Div( [ left, right ], left.lineno )
+ left = ast.Div( left, right, left.lineno )
elif op_node.name == tok.PERCENT:
- left = ast.Mod( [ left, right ], left.lineno )
+ left = ast.Mod( left, right, left.lineno )
elif op_node.name == tok.DOUBLESLASH:
- left = ast.FloorDiv( [ left, right ], left.lineno )
+ left = ast.FloorDiv( left, right, left.lineno )
else:
token = atoms[i-1]
raise SyntaxError("unexpected token", token.lineno, token.col)
@@ -641,9 +641,9 @@
op_node = atoms[i-1]
assert isinstance(op_node, TokenObject)
if op_node.name == tok.PLUS:
- left = ast.Add([ left, right ], left.lineno)
+ left = ast.Add( left, right, left.lineno)
elif op_node.name == tok.MINUS:
- left = ast.Sub([ left, right ], left.lineno)
+ left = ast.Sub( left, right, left.lineno)
else:
token = atoms[i-1]
raise SyntaxError("unexpected token", token.lineno, token.col)
@@ -659,9 +659,9 @@
op_node = atoms[i-1]
assert isinstance(op_node, TokenObject)
if op_node.name == tok.LEFTSHIFT:
- left = ast.LeftShift( [left, right], lineno )
+ left = ast.LeftShift( left, right, lineno )
elif op_node.name == tok.RIGHTSHIFT:
- left = ast.RightShift( [ left, right ], lineno )
+ left = ast.RightShift( left, right, lineno )
else:
token = atoms[i-1]
raise SyntaxError("unexpected token", token.lineno, token.col)
@@ -1264,7 +1264,9 @@
names.append((name, as_name))
# move forward until next ','
# XXX: what is it supposed to do ?
- for atom in atoms[index:]:
+ while index<l:
+ atom = atoms[index]
+# for atom in atoms[index:]:
if isinstance(atom, TokenObject) and atom.name == tok.COMMA:
break
index += 1
Modified: pypy/dist/pypy/interpreter/pyparser/grammar.py
==============================================================================
--- pypy/dist/pypy/interpreter/pyparser/grammar.py (original)
+++ pypy/dist/pypy/interpreter/pyparser/grammar.py Thu Dec 8 18:25:31 2005
@@ -7,6 +7,11 @@
KleeneStar : as in S -> A* or S -> A+
Token : a lexer token
"""
+from pypy.interpreter.baseobjspace import Wrappable
+from pypy.interpreter.typedef import TypeDef
+from pypy.interpreter.gateway import interp2app, ObjSpace, W_Root
+from pypy.interpreter.argument import Arguments
+from pypy.interpreter.error import OperationError
DEBUG = 0
USE_LOOKAHEAD = True
@@ -193,7 +198,7 @@
#######################################################################
# Grammar Elements Classes (Alternative, Sequence, KleeneStar, Token) #
#######################################################################
-class GrammarElement(object):
+class GrammarElement(Wrappable):
"""Base parser class"""
symbols = {} # dirty trick to provide a symbols mapping while printing (and not putting it in every object)
@@ -344,6 +349,21 @@
pass
+ def descr_repr( self, space ):
+ """TODO: make __repr__ RPython"""
+ import pysymbol
+ return space.wrap( self.display(0, pysymbol.sym_name) )
+
+ def descr_get_children( self, space ):
+ return space.newlist( [ space.wrap(it) for it in self.args ] )
+
+GrammarElement.typedef = TypeDef( "GrammarElement",
+ #__repr__ = interp2app(GrammarElement.descr_repr,
+ # unwrap_spec=['self', ObjSpace] ),
+ get_children = interp2app(GrammarElement.descr_get_children,
+ unwrap_spec=['self', ObjSpace] ),
+ )
+
class Alternative(GrammarElement):
"""Represents an alternative in a grammar rule (as in S -> A | B | C)"""
def __init__(self, name, args):
@@ -440,7 +460,47 @@
return True
return False
-
+ def descr_alternative_append( self, space, w_rule ):
+ rule = space.interpclass_w(w_rule)
+ if not isinstance( rule, GrammarElement ):
+ raise OperationError( space.w_TypeError, space.wrap("Need a GrammarElement instance") )
+ self.args.append( rule )
+
+ def descr_alternative___getitem__(self, space, idx ):
+ return space.wrap(self.args[idx])
+
+ def descr_alternative___setitem__(self, space, idx, w_rule ):
+ rule = space.interpclass_w(w_rule)
+ if not isinstance( rule, GrammarElement ):
+ raise OperationError( space.w_TypeError, space.wrap("Need a GrammarElement instance") )
+ return space.wrap( self.args[idx] )
+
+ def descr_alternative___delitem__(self, space, idx ):
+ del self.args[idx]
+
+ def descr_alternative_insert(self, space, idx, w_rule ):
+ rule = space.interpclass_w(w_rule)
+ if not isinstance( rule, GrammarElement ):
+ raise OperationError( space.w_TypeError, space.wrap("Need a GrammarElement instance") )
+ if idx<0 or idx>len(self.args):
+ raise OperationError( space.w_IndexError, space.wrap("Invalid index") )
+ self.args.insert( idx, rule )
+
+
+
+Alternative.typedef = TypeDef("Alternative", GrammarElement.typedef,
+ __getitem__ = interp2app( Alternative.descr_alternative___getitem__,
+ unwrap_spec=['self',ObjSpace,int]),
+ __setitem__ = interp2app( Alternative.descr_alternative___setitem__,
+ unwrap_spec=['self',ObjSpace,int,W_Root]),
+ __delitem__ = interp2app( Alternative.descr_alternative___delitem__,
+ unwrap_spec=['self',ObjSpace,int]),
+ insert = interp2app( Alternative.descr_alternative_insert,
+ unwrap_spec = ['self', ObjSpace, int, W_Root ] ),
+ append = interp2app( Alternative.descr_alternative_append,
+ unwrap_spec = ['self', ObjSpace, W_Root ] ),
+ )
+
class Sequence(GrammarElement):
"""Reprensents a Sequence in a grammar rule (as in S -> A B C)"""
def __init__(self, name, args):
@@ -452,7 +512,7 @@
def _match(self, source, builder, level=0):
"""matches all of the symbols in order"""
if DEBUG > 1:
- print "try seq:", self.display(level, builder.symbols )
+ print "try seq:", self.display(0, builder.symbols )
ctx = source.context()
bctx = builder.context()
for rule in self.args:
@@ -474,7 +534,7 @@
return name
else:
name = ""
- items = [a.display(1) for a in self.args]
+ items = [a.display(1,symbols) for a in self.args]
return name + "(" + " ".join( items ) + ")"
def calc_first_set(self):
@@ -514,6 +574,47 @@
return False
return True
+ def descr_alternative_append( self, space, w_rule ):
+ rule = space.interpclass_w(w_rule)
+ if not isinstance( rule, GrammarElement ):
+ raise OperationError( space.w_TypeError, space.wrap("Need a GrammarElement instance") )
+ self.args.append( rule )
+
+ def descr_alternative___getitem__(self, space, idx ):
+ return space.wrap(self.args[idx])
+
+ def descr_alternative___setitem__(self, space, idx, w_rule ):
+ rule = space.interpclass_w(w_rule)
+ if not isinstance( rule, GrammarElement ):
+ raise OperationError( space.w_TypeError, space.wrap("Need a GrammarElement instance") )
+ return space.wrap( self.args[idx] )
+
+ def descr_alternative___delitem__(self, space, idx ):
+ del self.args[idx]
+
+ def descr_alternative_insert(self, space, idx, w_rule ):
+ rule = space.interpclass_w(w_rule)
+ if not isinstance( rule, GrammarElement ):
+ raise OperationError( space.w_TypeError, space.wrap("Need a GrammarElement instance") )
+ if idx<0 or idx>len(self.args):
+ raise OperationError( space.w_IndexError, space.wrap("Invalid index") )
+ self.args.insert( idx, rule )
+
+
+
+Sequence.typedef = TypeDef("Sequence", GrammarElement.typedef,
+ __getitem__ = interp2app( Sequence.descr_alternative___getitem__,
+ unwrap_spec=['self',ObjSpace,int]),
+ __setitem__ = interp2app( Sequence.descr_alternative___setitem__,
+ unwrap_spec=['self',ObjSpace,int,W_Root]),
+ __delitem__ = interp2app( Sequence.descr_alternative___delitem__,
+ unwrap_spec=['self',ObjSpace,int]),
+ insert = interp2app( Sequence.descr_alternative_insert,
+ unwrap_spec = ['self', ObjSpace, int, W_Root ] ),
+ append = interp2app( Sequence.descr_alternative_append,
+ unwrap_spec = ['self', ObjSpace, W_Root ] ),
+ )
+
class KleeneStar(GrammarElement):
"""Represents a KleeneStar in a grammar rule as in (S -> A+) or (S -> A*)"""
@@ -535,7 +636,7 @@
represent infinity
"""
if DEBUG > 1:
- print "try kle:", self.display()
+ print "try kle:", self.display(0,builder.symbols)
ctx = 0
bctx = None
if self.min:
@@ -573,7 +674,7 @@
star = "*"
elif self.min==1 and self.max==-1:
star = "+"
- s = self.args[0].display(1)
+ s = self.args[0].display(1, symbols)
return name + "%s%s" % (s, star)
@@ -605,6 +706,28 @@
return False
return True
+ def descr_kleenestar___getitem__(self, space, idx ):
+ if idx!=0:
+ raise OperationError( space.w_ValueError, space.wrap("KleeneStar only support one child"))
+ return space.wrap(self.args[idx])
+
+ def descr_kleenestar___setitem__(self, space, idx, w_rule ):
+ rule = space.interpclass_w(w_rule)
+ if idx!=0:
+ raise OperationError( space.w_ValueError, space.wrap("KleeneStar only support one child"))
+ if not isinstance( rule, GrammarElement ):
+ raise OperationError( space.w_TypeError, space.wrap("Need a GrammarElement instance") )
+ self.args[idx] = rule
+
+
+
+KleeneStar.typedef = TypeDef("KleeneStar", GrammarElement.typedef,
+ __getitem__ = interp2app(KleeneStar.descr_kleenestar___getitem__,
+ unwrap_spec=[ 'self', ObjSpace, int]),
+ __setitem__ = interp2app(KleeneStar.descr_kleenestar___setitem__,
+ unwrap_spec=[ 'self', ObjSpace, int, W_Root ]),
+ )
+
class Token(GrammarElement):
"""Represents a Token in a grammar rule (a lexer token)"""
@@ -681,6 +804,8 @@
return True
return False
+Token.typedef = TypeDef("Token", GrammarElement.typedef )
+
from pypy.interpreter.pyparser.pytoken import NULLTOKEN
EmptyToken = Token(NULLTOKEN, None)
Modified: pypy/dist/pypy/interpreter/pyparser/pythonparse.py
==============================================================================
--- pypy/dist/pypy/interpreter/pyparser/pythonparse.py (original)
+++ pypy/dist/pypy/interpreter/pyparser/pythonparse.py Thu Dec 8 18:25:31 2005
@@ -149,3 +149,7 @@
def parse_eval_input(textsrc, gram, builder):
"""Parse a python expression"""
return gram.parse_source( textsrc, "eval_input", builder )
+
+
+def grammar_rules( space ):
+ return space.wrap( PYTHON_PARSER.rules )
Modified: pypy/dist/pypy/interpreter/pyparser/test/test_astbuilder.py
==============================================================================
--- pypy/dist/pypy/interpreter/pyparser/test/test_astbuilder.py (original)
+++ pypy/dist/pypy/interpreter/pyparser/test/test_astbuilder.py Thu Dec 8 18:25:31 2005
@@ -7,6 +7,8 @@
import pypy.interpreter.stablecompiler.ast as test_ast
import pypy.interpreter.astcompiler.ast as ast_ast
+flatten = ast_ast.flatten
+
import py.test
from pypy.interpreter.astcompiler import ast
@@ -24,8 +26,10 @@
return False
else:
print "Type mismatch", repr(l), repr(r)
- print "l is str", type(l)==str
- print "r is AssName", isinstance(r,ast_ast.AssName)
+ print "l is str", repr(l), type(l)==str
+ print "r is AssName", repr(r), isinstance(r,ast_ast.AssName)
+ print "left is", repr(left)
+ print "right is", repr(right)
return False
return True
@@ -38,7 +42,14 @@
return False
if isinstance(left,test_ast.Function) and isinstance(right,ast_ast.Function):
left_nodes = list(left.getChildren())
- right_nodes = list(right.getChildren())
+ right_nodes = [] # generated ast differ here because argnames is a list of nodes in
+ right_nodes.append(right.decorators)
+ right_nodes.append(right.name)
+ right_nodes.append(right.argnames)
+ right_nodes.extend(flatten(right.defaults))
+ right_nodes.append(right.flags)
+ right_nodes.append(right.w_doc)
+ right_nodes.append(right.code)
left_args = left_nodes[2]
del left_nodes[2]
right_args = right_nodes[2]
@@ -47,7 +58,14 @@
return False
elif isinstance(left,test_ast.Lambda) and isinstance(right,ast_ast.Lambda):
left_nodes = list(left.getChildren())
- right_nodes = list(right.getChildren())
+ right_nodes = [] # generated ast differ here because argnames is a list of nodes in
+ right_nodes.append(right.argnames)
+ right_nodes.extend(flatten(right.defaults))
+ right_nodes.append(right.flags)
+ right_nodes.append(right.code)
+
+ print "left", repr(left_nodes)
+ print "right", repr(right_nodes)
left_args = left_nodes[0]
del left_nodes[0]
right_args = right_nodes[0]
Modified: pypy/dist/pypy/interpreter/pyparser/test/test_samples.py
==============================================================================
--- pypy/dist/pypy/interpreter/pyparser/test/test_samples.py (original)
+++ pypy/dist/pypy/interpreter/pyparser/test/test_samples.py Thu Dec 8 18:25:31 2005
@@ -95,6 +95,7 @@
from pypy.interpreter.stablecompiler.transformer import Transformer as PyPyTransformer
from compiler.transformer import Transformer as PythonTransformer
+from pypy.interpreter.astcompiler.consts import OP_ASSIGN, OP_DELETE, OP_APPLY
def _check_tuples_equality(pypy_tuples, python_tuples, testname):
# compare the two tuples by transforming them into AST, to hide irrelevant
@@ -126,6 +127,11 @@
# astbuilder.py
repr_pypy = repr_pypy.replace("[]", "()")
repr_python = repr_python.replace("[]", "()")
+ # We also changed constants 'OP_ASSIGN' 'OP_DELETE' 'OP_APPLY' to use numeric values
+ repr_python = repr_python.replace("'OP_ASSIGN'", repr(OP_ASSIGN) )
+ repr_python = repr_python.replace("'OP_DELETE'", repr(OP_DELETE) )
+ repr_python = repr_python.replace("'OP_APPLY'", repr(OP_APPLY) )
+
assert repr_pypy == repr_python
Modified: pypy/dist/pypy/interpreter/stablecompiler/consts.py
==============================================================================
--- pypy/dist/pypy/interpreter/stablecompiler/consts.py (original)
+++ pypy/dist/pypy/interpreter/stablecompiler/consts.py Thu Dec 8 18:25:31 2005
@@ -1,7 +1,7 @@
# operation flags
-OP_ASSIGN = 'OP_ASSIGN'
-OP_DELETE = 'OP_DELETE'
-OP_APPLY = 'OP_APPLY'
+OP_ASSIGN = 0 # 'OP_ASSIGN'
+OP_DELETE = 1 # 'OP_DELETE'
+OP_APPLY = 2 # 'OP_APPLY'
SC_LOCAL = 1
SC_GLOBAL = 2
Modified: pypy/dist/pypy/interpreter/stablecompiler/pycodegen.py
==============================================================================
--- pypy/dist/pypy/interpreter/stablecompiler/pycodegen.py (original)
+++ pypy/dist/pypy/interpreter/stablecompiler/pycodegen.py Thu Dec 8 18:25:31 2005
@@ -9,7 +9,7 @@
from pypy.interpreter.stablecompiler import ast, parse, walk, syntax
from pypy.interpreter.stablecompiler import pyassem, misc, future, symbols
from pypy.interpreter.stablecompiler.consts import SC_LOCAL, SC_GLOBAL, \
- SC_FREE, SC_CELL, SC_DEFAULT
+ SC_FREE, SC_CELL, SC_DEFAULT, OP_APPLY, OP_DELETE, OP_ASSIGN
from pypy.interpreter.stablecompiler.consts import CO_VARARGS, CO_VARKEYWORDS, \
CO_NEWLOCALS, CO_NESTED, CO_GENERATOR, CO_GENERATOR_ALLOWED, CO_FUTURE_DIVISION
from pypy.interpreter.stablecompiler.pyassem import TupleArg
@@ -914,9 +914,9 @@
self.visit(elt)
def visitAssName(self, node):
- if node.flags == 'OP_ASSIGN':
+ if node.flags == OP_ASSIGN:
self.storeName(node.name)
- elif node.flags == 'OP_DELETE':
+ elif node.flags == OP_DELETE:
self.set_lineno(node)
self.delName(node.name)
else:
@@ -924,16 +924,16 @@
def visitAssAttr(self, node):
self.visit(node.expr)
- if node.flags == 'OP_ASSIGN':
+ if node.flags == OP_ASSIGN:
self.emit('STORE_ATTR', self.mangle(node.attrname))
- elif node.flags == 'OP_DELETE':
+ elif node.flags == OP_DELETE:
self.emit('DELETE_ATTR', self.mangle(node.attrname))
else:
print "warning: unexpected flags:", node.flags
print node
def _visitAssSequence(self, node, op='UNPACK_SEQUENCE'):
- if findOp(node) != 'OP_DELETE':
+ if findOp(node) != OP_DELETE:
self.emit(op, len(node.nodes))
for child in node.nodes:
self.visit(child)
@@ -1098,11 +1098,11 @@
self.emit('DUP_TOPX', 3)
else:
self.emit('DUP_TOPX', 2)
- if node.flags == 'OP_APPLY':
+ if node.flags == OP_APPLY:
self.emit('SLICE+%d' % slice)
- elif node.flags == 'OP_ASSIGN':
+ elif node.flags == OP_ASSIGN:
self.emit('STORE_SLICE+%d' % slice)
- elif node.flags == 'OP_DELETE':
+ elif node.flags == OP_DELETE:
self.emit('DELETE_SLICE+%d' % slice)
else:
print "weird slice", node.flags
@@ -1116,11 +1116,11 @@
self.emit('DUP_TOPX', 2)
if len(node.subs) > 1:
self.emit('BUILD_TUPLE', len(node.subs))
- if node.flags == 'OP_APPLY':
+ if node.flags == OP_APPLY:
self.emit('BINARY_SUBSCR')
- elif node.flags == 'OP_ASSIGN':
+ elif node.flags == OP_ASSIGN:
self.emit('STORE_SUBSCR')
- elif node.flags == 'OP_DELETE':
+ elif node.flags == OP_DELETE:
self.emit('DELETE_SUBSCR')
# binary ops
Modified: pypy/dist/pypy/module/recparser/__init__.py
==============================================================================
--- pypy/dist/pypy/module/recparser/__init__.py (original)
+++ pypy/dist/pypy/module/recparser/__init__.py Thu Dec 8 18:25:31 2005
@@ -46,5 +46,6 @@
# PyPy extension
'decode_string_literal': 'pyparser.decode_string_literal',
'install_compiler_hook' : 'pypy.interpreter.pycompiler.install_compiler_hook',
+ 'rules' : 'pypy.interpreter.pyparser.pythonparse.grammar_rules',
}
More information about the Pypy-commit
mailing list