[pypy-svn] r66864 - in pypy/branch/parser-compiler: lib-python pypy/config pypy/interpreter pypy/interpreter/astcompiler pypy/interpreter/astcompiler/tools pypy/interpreter/pyparser pypy/module/__builtin__ pypy/module/_ast pypy/module/_ast/test
benjamin at codespeak.net
benjamin at codespeak.net
Sun Aug 16 23:51:14 CEST 2009
Author: benjamin
Date: Sun Aug 16 23:51:12 2009
New Revision: 66864
Added:
pypy/branch/parser-compiler/pypy/module/_ast/
pypy/branch/parser-compiler/pypy/module/_ast/__init__.py
pypy/branch/parser-compiler/pypy/module/_ast/test/
pypy/branch/parser-compiler/pypy/module/_ast/test/__init__.py
pypy/branch/parser-compiler/pypy/module/_ast/test/test_ast.py
Modified:
pypy/branch/parser-compiler/lib-python/conftest.py
pypy/branch/parser-compiler/pypy/config/pypyoption.py
pypy/branch/parser-compiler/pypy/interpreter/astcompiler/ast.py
pypy/branch/parser-compiler/pypy/interpreter/astcompiler/consts.py
pypy/branch/parser-compiler/pypy/interpreter/astcompiler/tools/asdl_py.py
pypy/branch/parser-compiler/pypy/interpreter/pycompiler.py
pypy/branch/parser-compiler/pypy/interpreter/pyparser/error.py
pypy/branch/parser-compiler/pypy/interpreter/pyparser/future.py
pypy/branch/parser-compiler/pypy/interpreter/pyparser/pyparse.py
pypy/branch/parser-compiler/pypy/module/__builtin__/compiling.py
Log:
expose AST to the applevel through the _ast module
Modified: pypy/branch/parser-compiler/lib-python/conftest.py
==============================================================================
--- pypy/branch/parser-compiler/lib-python/conftest.py (original)
+++ pypy/branch/parser-compiler/lib-python/conftest.py Sun Aug 16 23:51:12 2009
@@ -131,7 +131,7 @@
RegrTest('test__locale.py', skip=skip_win32),
RegrTest('test_aepack.py', skip=True),
RegrTest('test_al.py', skip=True),
- RegrTest('test_ast.py', skip="unsupported module _ast"),
+ RegrTest('test_ast.py', core=True),
RegrTest('test_anydbm.py'),
RegrTest('test_applesingle.py', skip=True),
RegrTest('test_array.py', core=True, usemodules='struct'),
Modified: pypy/branch/parser-compiler/pypy/config/pypyoption.py
==============================================================================
--- pypy/branch/parser-compiler/pypy/config/pypyoption.py (original)
+++ pypy/branch/parser-compiler/pypy/config/pypyoption.py Sun Aug 16 23:51:12 2009
@@ -18,7 +18,7 @@
default_modules.update(dict.fromkeys(
["_codecs", "gc", "_weakref", "marshal", "errno",
"math", "_sre", "_pickle_support", "operator",
- "parser", "symbol", "token", "_random", "__pypy__"]))
+ "parser", "symbol", "token", "_ast", "_random", "__pypy__"]))
# --allworkingmodules
Modified: pypy/branch/parser-compiler/pypy/interpreter/astcompiler/ast.py
==============================================================================
--- pypy/branch/parser-compiler/pypy/interpreter/astcompiler/ast.py (original)
+++ pypy/branch/parser-compiler/pypy/interpreter/astcompiler/ast.py Sun Aug 16 23:51:12 2009
@@ -1,11 +1,17 @@
# Generated by tools/asdl_py.py
-from pypy.interpreter.baseobjspace import Wrappable
+from pypy.interpreter.baseobjspace import Wrappable, ObjSpace, W_Root
from pypy.interpreter import typedef
+from pypy.interpreter.gateway import interp2app
+from pypy.interpreter.argument import Arguments
+from pypy.interpreter.error import OperationError
+from pypy.rlib.unroll import unrolling_iterable
from pypy.tool.pairtype import extendabletype
+from pypy.tool.sourcetools import func_with_new_name
+
class AST(Wrappable):
- __slots__ = ()
+ __slots__ = ("initialization_state",)
__metaclass__ = extendabletype
@@ -15,19 +21,66 @@
def mutate_over(self, visitor):
raise AssertionError("mutate_over() implementation not provided")
+ def sync_app_attrs(self, space):
+ raise NotImplementedError
+
+
class NodeVisitorNotImplemented(Exception):
pass
+
+class _FieldsWrapper(Wrappable):
+ "Hack around the fact we can't store tuples on a TypeDef."
+
+ def __init__(self, fields):
+ self.fields = fields
+
+ def __spacebind__(self, space):
+ return space.newtuple([space.wrap(field) for field in self.fields])
+
+
+def get_AST_new(node_class):
+ def generic_AST_new(space, w_type, __args__):
+ node = space.allocate_instance(node_class, w_type)
+ node.initialization_state = 0
+ return space.wrap(node)
+ generic_AST_new.unwrap_spec = [ObjSpace, W_Root, Arguments]
+ return func_with_new_name(generic_AST_new, "new_%s" % node_class.__name__)
+
+
+AST.typedef = typedef.TypeDef("AST",
+ _fields=_FieldsWrapper([]),
+ _attributes=_FieldsWrapper([]),
+)
+AST.typedef.acceptable_as_base_class = False
+
+
+def missing_field(space, state, required, host):
+ "Find which required field is missing."
+ for i in range(len(required)):
+ if not (state >> i) & 1:
+ missing = required[i]
+ if missing is not None:
+ err = "required attribute '%s' missing from %s"
+ err %= (missing, host)
+ w_err = space.wrap(err)
+ raise OperationError(space.w_TypeError, w_err)
+ raise AssertionError("should not reach here")
+
+
class mod(AST):
__slots__ = ()
class Module(mod):
- __slots__ = ('body')
+ __slots__ = ('body', 'w_body')
+
def __init__(self, body):
self.body = body
+ self.w_body = None
+ self.initialization_state = 1
def walkabout(self, visitor):
visitor.visit_Module(self)
@@ -37,12 +90,32 @@
visitor._mutate_sequence(self.body)
return visitor.visit_Module(self)
+ def sync_app_attrs(self, space):
+ if (self.initialization_state & ~0) ^ 1:
+ missing_field(space, self.initialization_state, ['body'], 'Module')
+ else:
+ pass
+ w_list = self.w_body
+ if w_list is not None:
+ list_w = space.viewiterable(w_list)
+ if list_w:
+ self.body = [space.interp_w(stmt, w_obj) for w_obj in list_w]
+ else:
+ self.body = None
+ if self.body is not None:
+ for node in self.body:
+ node.sync_app_attrs(space)
+
+
class Interactive(mod):
- __slots__ = ('body')
+ __slots__ = ('body', 'w_body')
+
def __init__(self, body):
self.body = body
+ self.w_body = None
+ self.initialization_state = 1
def walkabout(self, visitor):
visitor.visit_Interactive(self)
@@ -52,12 +125,31 @@
visitor._mutate_sequence(self.body)
return visitor.visit_Interactive(self)
+ def sync_app_attrs(self, space):
+ if (self.initialization_state & ~0) ^ 1:
+ missing_field(space, self.initialization_state, ['body'], 'Interactive')
+ else:
+ pass
+ w_list = self.w_body
+ if w_list is not None:
+ list_w = space.viewiterable(w_list)
+ if list_w:
+ self.body = [space.interp_w(stmt, w_obj) for w_obj in list_w]
+ else:
+ self.body = None
+ if self.body is not None:
+ for node in self.body:
+ node.sync_app_attrs(space)
+
+
class Expression(mod):
__slots__ = ('body')
+
def __init__(self, body):
self.body = body
+ self.initialization_state = 1
def walkabout(self, visitor):
visitor.visit_Expression(self)
@@ -66,12 +158,23 @@
self.body = self.body.mutate_over(visitor)
return visitor.visit_Expression(self)
+ def sync_app_attrs(self, space):
+ if (self.initialization_state & ~0) ^ 1:
+ missing_field(space, self.initialization_state, ['body'], 'Expression')
+ else:
+ pass
+ self.body.sync_app_attrs(space)
+
+
class Suite(mod):
- __slots__ = ('body')
+ __slots__ = ('body', 'w_body')
+
def __init__(self, body):
self.body = body
+ self.w_body = None
+ self.initialization_state = 1
def walkabout(self, visitor):
visitor.visit_Suite(self)
@@ -81,6 +184,23 @@
visitor._mutate_sequence(self.body)
return visitor.visit_Suite(self)
+ def sync_app_attrs(self, space):
+ if (self.initialization_state & ~0) ^ 1:
+ missing_field(space, self.initialization_state, ['body'], 'Suite')
+ else:
+ pass
+ w_list = self.w_body
+ if w_list is not None:
+ list_w = space.viewiterable(w_list)
+ if list_w:
+ self.body = [space.interp_w(stmt, w_obj) for w_obj in list_w]
+ else:
+ self.body = None
+ if self.body is not None:
+ for node in self.body:
+ node.sync_app_attrs(space)
+
+
class stmt(AST):
__slots__ = ('lineno', 'col_offset')
@@ -91,14 +211,20 @@
class FunctionDef(stmt):
- __slots__ = ('name', 'args', 'body', 'decorators')
+ __slots__ = ('name', 'args', 'body', 'w_body', 'decorators', 'w_decorators')
+
+ _lineno_mask = 16
+ _col_offset_mask = 32
def __init__(self, name, args, body, decorators, lineno, col_offset):
self.name = name
self.args = args
self.body = body
+ self.w_body = None
self.decorators = decorators
+ self.w_decorators = None
stmt.__init__(self, lineno, col_offset)
+ self.initialization_state = 63
def walkabout(self, visitor):
visitor.visit_FunctionDef(self)
@@ -110,15 +236,49 @@
visitor._mutate_sequence(self.decorators)
return visitor.visit_FunctionDef(self)
+ def sync_app_attrs(self, space):
+ if (self.initialization_state & ~0) ^ 63:
+ missing_field(space, self.initialization_state, ['name', 'args', 'body', 'decorators', 'lineno', 'col_offset'], 'FunctionDef')
+ else:
+ pass
+ self.args.sync_app_attrs(space)
+ w_list = self.w_body
+ if w_list is not None:
+ list_w = space.viewiterable(w_list)
+ if list_w:
+ self.body = [space.interp_w(stmt, w_obj) for w_obj in list_w]
+ else:
+ self.body = None
+ if self.body is not None:
+ for node in self.body:
+ node.sync_app_attrs(space)
+ w_list = self.w_decorators
+ if w_list is not None:
+ list_w = space.viewiterable(w_list)
+ if list_w:
+ self.decorators = [space.interp_w(expr, w_obj) for w_obj in list_w]
+ else:
+ self.decorators = None
+ if self.decorators is not None:
+ for node in self.decorators:
+ node.sync_app_attrs(space)
+
+
class ClassDef(stmt):
- __slots__ = ('name', 'bases', 'body')
+ __slots__ = ('name', 'bases', 'w_bases', 'body', 'w_body')
+
+ _lineno_mask = 8
+ _col_offset_mask = 16
def __init__(self, name, bases, body, lineno, col_offset):
self.name = name
self.bases = bases
+ self.w_bases = None
self.body = body
+ self.w_body = None
stmt.__init__(self, lineno, col_offset)
+ self.initialization_state = 31
def walkabout(self, visitor):
visitor.visit_ClassDef(self)
@@ -130,13 +290,44 @@
visitor._mutate_sequence(self.body)
return visitor.visit_ClassDef(self)
+ def sync_app_attrs(self, space):
+ if (self.initialization_state & ~0) ^ 31:
+ missing_field(space, self.initialization_state, ['name', 'bases', 'body', 'lineno', 'col_offset'], 'ClassDef')
+ else:
+ pass
+ w_list = self.w_bases
+ if w_list is not None:
+ list_w = space.viewiterable(w_list)
+ if list_w:
+ self.bases = [space.interp_w(expr, w_obj) for w_obj in list_w]
+ else:
+ self.bases = None
+ if self.bases is not None:
+ for node in self.bases:
+ node.sync_app_attrs(space)
+ w_list = self.w_body
+ if w_list is not None:
+ list_w = space.viewiterable(w_list)
+ if list_w:
+ self.body = [space.interp_w(stmt, w_obj) for w_obj in list_w]
+ else:
+ self.body = None
+ if self.body is not None:
+ for node in self.body:
+ node.sync_app_attrs(space)
+
+
class Return(stmt):
__slots__ = ('value')
+ _lineno_mask = 2
+ _col_offset_mask = 4
+
def __init__(self, value, lineno, col_offset):
self.value = value
stmt.__init__(self, lineno, col_offset)
+ self.initialization_state = 7
def walkabout(self, visitor):
visitor.visit_Return(self)
@@ -146,13 +337,27 @@
self.value = self.value.mutate_over(visitor)
return visitor.visit_Return(self)
+ def sync_app_attrs(self, space):
+ if (self.initialization_state & ~1) ^ 6:
+ missing_field(space, self.initialization_state, [None, 'lineno', 'col_offset'], 'Return')
+ else:
+ if not self.initialization_state & 1:
+ self.value = None
+ self.value.sync_app_attrs(space)
+
+
class Delete(stmt):
- __slots__ = ('targets')
+ __slots__ = ('targets', 'w_targets')
+
+ _lineno_mask = 2
+ _col_offset_mask = 4
def __init__(self, targets, lineno, col_offset):
self.targets = targets
+ self.w_targets = None
stmt.__init__(self, lineno, col_offset)
+ self.initialization_state = 7
def walkabout(self, visitor):
visitor.visit_Delete(self)
@@ -162,14 +367,36 @@
visitor._mutate_sequence(self.targets)
return visitor.visit_Delete(self)
+ def sync_app_attrs(self, space):
+ if (self.initialization_state & ~0) ^ 7:
+ missing_field(space, self.initialization_state, ['targets', 'lineno', 'col_offset'], 'Delete')
+ else:
+ pass
+ w_list = self.w_targets
+ if w_list is not None:
+ list_w = space.viewiterable(w_list)
+ if list_w:
+ self.targets = [space.interp_w(expr, w_obj) for w_obj in list_w]
+ else:
+ self.targets = None
+ if self.targets is not None:
+ for node in self.targets:
+ node.sync_app_attrs(space)
+
+
class Assign(stmt):
- __slots__ = ('targets', 'value')
+ __slots__ = ('targets', 'w_targets', 'value')
+
+ _lineno_mask = 4
+ _col_offset_mask = 8
def __init__(self, targets, value, lineno, col_offset):
self.targets = targets
+ self.w_targets = None
self.value = value
stmt.__init__(self, lineno, col_offset)
+ self.initialization_state = 15
def walkabout(self, visitor):
visitor.visit_Assign(self)
@@ -180,15 +407,37 @@
self.value = self.value.mutate_over(visitor)
return visitor.visit_Assign(self)
+ def sync_app_attrs(self, space):
+ if (self.initialization_state & ~0) ^ 15:
+ missing_field(space, self.initialization_state, ['targets', 'value', 'lineno', 'col_offset'], 'Assign')
+ else:
+ pass
+ w_list = self.w_targets
+ if w_list is not None:
+ list_w = space.viewiterable(w_list)
+ if list_w:
+ self.targets = [space.interp_w(expr, w_obj) for w_obj in list_w]
+ else:
+ self.targets = None
+ if self.targets is not None:
+ for node in self.targets:
+ node.sync_app_attrs(space)
+ self.value.sync_app_attrs(space)
+
+
class AugAssign(stmt):
__slots__ = ('target', 'op', 'value')
+ _lineno_mask = 8
+ _col_offset_mask = 16
+
def __init__(self, target, op, value, lineno, col_offset):
self.target = target
self.op = op
self.value = value
stmt.__init__(self, lineno, col_offset)
+ self.initialization_state = 31
def walkabout(self, visitor):
visitor.visit_AugAssign(self)
@@ -198,15 +447,29 @@
self.value = self.value.mutate_over(visitor)
return visitor.visit_AugAssign(self)
+ def sync_app_attrs(self, space):
+ if (self.initialization_state & ~0) ^ 31:
+ missing_field(space, self.initialization_state, ['target', 'op', 'value', 'lineno', 'col_offset'], 'AugAssign')
+ else:
+ pass
+ self.target.sync_app_attrs(space)
+ self.value.sync_app_attrs(space)
+
+
class Print(stmt):
- __slots__ = ('dest', 'values', 'nl')
+ __slots__ = ('dest', 'values', 'w_values', 'nl')
+
+ _lineno_mask = 8
+ _col_offset_mask = 16
def __init__(self, dest, values, nl, lineno, col_offset):
self.dest = dest
self.values = values
+ self.w_values = None
self.nl = nl
stmt.__init__(self, lineno, col_offset)
+ self.initialization_state = 31
def walkabout(self, visitor):
visitor.visit_Print(self)
@@ -218,16 +481,41 @@
visitor._mutate_sequence(self.values)
return visitor.visit_Print(self)
+ def sync_app_attrs(self, space):
+ if (self.initialization_state & ~1) ^ 30:
+ missing_field(space, self.initialization_state, [None, 'values', 'nl', 'lineno', 'col_offset'], 'Print')
+ else:
+ if not self.initialization_state & 1:
+ self.dest = None
+ self.dest.sync_app_attrs(space)
+ w_list = self.w_values
+ if w_list is not None:
+ list_w = space.viewiterable(w_list)
+ if list_w:
+ self.values = [space.interp_w(expr, w_obj) for w_obj in list_w]
+ else:
+ self.values = None
+ if self.values is not None:
+ for node in self.values:
+ node.sync_app_attrs(space)
+
+
class For(stmt):
- __slots__ = ('target', 'iter', 'body', 'orelse')
+ __slots__ = ('target', 'iter', 'body', 'w_body', 'orelse', 'w_orelse')
+
+ _lineno_mask = 16
+ _col_offset_mask = 32
def __init__(self, target, iter, body, orelse, lineno, col_offset):
self.target = target
self.iter = iter
self.body = body
+ self.w_body = None
self.orelse = orelse
+ self.w_orelse = None
stmt.__init__(self, lineno, col_offset)
+ self.initialization_state = 63
def walkabout(self, visitor):
visitor.visit_For(self)
@@ -241,15 +529,50 @@
visitor._mutate_sequence(self.orelse)
return visitor.visit_For(self)
+ def sync_app_attrs(self, space):
+ if (self.initialization_state & ~0) ^ 63:
+ missing_field(space, self.initialization_state, ['target', 'iter', 'body', 'orelse', 'lineno', 'col_offset'], 'For')
+ else:
+ pass
+ self.target.sync_app_attrs(space)
+ self.iter.sync_app_attrs(space)
+ w_list = self.w_body
+ if w_list is not None:
+ list_w = space.viewiterable(w_list)
+ if list_w:
+ self.body = [space.interp_w(stmt, w_obj) for w_obj in list_w]
+ else:
+ self.body = None
+ if self.body is not None:
+ for node in self.body:
+ node.sync_app_attrs(space)
+ w_list = self.w_orelse
+ if w_list is not None:
+ list_w = space.viewiterable(w_list)
+ if list_w:
+ self.orelse = [space.interp_w(stmt, w_obj) for w_obj in list_w]
+ else:
+ self.orelse = None
+ if self.orelse is not None:
+ for node in self.orelse:
+ node.sync_app_attrs(space)
+
+
class While(stmt):
- __slots__ = ('test', 'body', 'orelse')
+ __slots__ = ('test', 'body', 'w_body', 'orelse', 'w_orelse')
+
+ _lineno_mask = 8
+ _col_offset_mask = 16
def __init__(self, test, body, orelse, lineno, col_offset):
self.test = test
self.body = body
+ self.w_body = None
self.orelse = orelse
+ self.w_orelse = None
stmt.__init__(self, lineno, col_offset)
+ self.initialization_state = 31
def walkabout(self, visitor):
visitor.visit_While(self)
@@ -262,15 +585,49 @@
visitor._mutate_sequence(self.orelse)
return visitor.visit_While(self)
+ def sync_app_attrs(self, space):
+ if (self.initialization_state & ~0) ^ 31:
+ missing_field(space, self.initialization_state, ['test', 'body', 'orelse', 'lineno', 'col_offset'], 'While')
+ else:
+ pass
+ self.test.sync_app_attrs(space)
+ w_list = self.w_body
+ if w_list is not None:
+ list_w = space.viewiterable(w_list)
+ if list_w:
+ self.body = [space.interp_w(stmt, w_obj) for w_obj in list_w]
+ else:
+ self.body = None
+ if self.body is not None:
+ for node in self.body:
+ node.sync_app_attrs(space)
+ w_list = self.w_orelse
+ if w_list is not None:
+ list_w = space.viewiterable(w_list)
+ if list_w:
+ self.orelse = [space.interp_w(stmt, w_obj) for w_obj in list_w]
+ else:
+ self.orelse = None
+ if self.orelse is not None:
+ for node in self.orelse:
+ node.sync_app_attrs(space)
+
+
class If(stmt):
- __slots__ = ('test', 'body', 'orelse')
+ __slots__ = ('test', 'body', 'w_body', 'orelse', 'w_orelse')
+
+ _lineno_mask = 8
+ _col_offset_mask = 16
def __init__(self, test, body, orelse, lineno, col_offset):
self.test = test
self.body = body
+ self.w_body = None
self.orelse = orelse
+ self.w_orelse = None
stmt.__init__(self, lineno, col_offset)
+ self.initialization_state = 31
def walkabout(self, visitor):
visitor.visit_If(self)
@@ -283,15 +640,48 @@
visitor._mutate_sequence(self.orelse)
return visitor.visit_If(self)
+ def sync_app_attrs(self, space):
+ if (self.initialization_state & ~0) ^ 31:
+ missing_field(space, self.initialization_state, ['test', 'body', 'orelse', 'lineno', 'col_offset'], 'If')
+ else:
+ pass
+ self.test.sync_app_attrs(space)
+ w_list = self.w_body
+ if w_list is not None:
+ list_w = space.viewiterable(w_list)
+ if list_w:
+ self.body = [space.interp_w(stmt, w_obj) for w_obj in list_w]
+ else:
+ self.body = None
+ if self.body is not None:
+ for node in self.body:
+ node.sync_app_attrs(space)
+ w_list = self.w_orelse
+ if w_list is not None:
+ list_w = space.viewiterable(w_list)
+ if list_w:
+ self.orelse = [space.interp_w(stmt, w_obj) for w_obj in list_w]
+ else:
+ self.orelse = None
+ if self.orelse is not None:
+ for node in self.orelse:
+ node.sync_app_attrs(space)
+
+
class With(stmt):
- __slots__ = ('context_expr', 'optional_vars', 'body')
+ __slots__ = ('context_expr', 'optional_vars', 'body', 'w_body')
+
+ _lineno_mask = 8
+ _col_offset_mask = 16
def __init__(self, context_expr, optional_vars, body, lineno, col_offset):
self.context_expr = context_expr
self.optional_vars = optional_vars
self.body = body
+ self.w_body = None
stmt.__init__(self, lineno, col_offset)
+ self.initialization_state = 31
def walkabout(self, visitor):
visitor.visit_With(self)
@@ -304,15 +694,39 @@
visitor._mutate_sequence(self.body)
return visitor.visit_With(self)
+ def sync_app_attrs(self, space):
+ if (self.initialization_state & ~2) ^ 29:
+ missing_field(space, self.initialization_state, ['context_expr', None, 'body', 'lineno', 'col_offset'], 'With')
+ else:
+ if not self.initialization_state & 2:
+ self.optional_vars = None
+ self.context_expr.sync_app_attrs(space)
+ self.optional_vars.sync_app_attrs(space)
+ w_list = self.w_body
+ if w_list is not None:
+ list_w = space.viewiterable(w_list)
+ if list_w:
+ self.body = [space.interp_w(stmt, w_obj) for w_obj in list_w]
+ else:
+ self.body = None
+ if self.body is not None:
+ for node in self.body:
+ node.sync_app_attrs(space)
+
+
class Raise(stmt):
__slots__ = ('type', 'inst', 'tback')
+ _lineno_mask = 8
+ _col_offset_mask = 16
+
def __init__(self, type, inst, tback, lineno, col_offset):
self.type = type
self.inst = inst
self.tback = tback
stmt.__init__(self, lineno, col_offset)
+ self.initialization_state = 31
def walkabout(self, visitor):
visitor.visit_Raise(self)
@@ -326,15 +740,37 @@
self.tback = self.tback.mutate_over(visitor)
return visitor.visit_Raise(self)
+ def sync_app_attrs(self, space):
+ if (self.initialization_state & ~7) ^ 24:
+ missing_field(space, self.initialization_state, [None, None, None, 'lineno', 'col_offset'], 'Raise')
+ else:
+ if not self.initialization_state & 1:
+ self.type = None
+ if not self.initialization_state & 2:
+ self.inst = None
+ if not self.initialization_state & 4:
+ self.tback = None
+ self.type.sync_app_attrs(space)
+ self.inst.sync_app_attrs(space)
+ self.tback.sync_app_attrs(space)
+
+
class TryExcept(stmt):
- __slots__ = ('body', 'handlers', 'orelse')
+ __slots__ = ('body', 'w_body', 'handlers', 'w_handlers', 'orelse', 'w_orelse')
+
+ _lineno_mask = 8
+ _col_offset_mask = 16
def __init__(self, body, handlers, orelse, lineno, col_offset):
self.body = body
+ self.w_body = None
self.handlers = handlers
+ self.w_handlers = None
self.orelse = orelse
+ self.w_orelse = None
stmt.__init__(self, lineno, col_offset)
+ self.initialization_state = 31
def walkabout(self, visitor):
visitor.visit_TryExcept(self)
@@ -346,14 +782,57 @@
visitor._mutate_sequence(self.orelse)
return visitor.visit_TryExcept(self)
+ def sync_app_attrs(self, space):
+ if (self.initialization_state & ~0) ^ 31:
+ missing_field(space, self.initialization_state, ['body', 'handlers', 'orelse', 'lineno', 'col_offset'], 'TryExcept')
+ else:
+ pass
+ w_list = self.w_body
+ if w_list is not None:
+ list_w = space.viewiterable(w_list)
+ if list_w:
+ self.body = [space.interp_w(stmt, w_obj) for w_obj in list_w]
+ else:
+ self.body = None
+ if self.body is not None:
+ for node in self.body:
+ node.sync_app_attrs(space)
+ w_list = self.w_handlers
+ if w_list is not None:
+ list_w = space.viewiterable(w_list)
+ if list_w:
+ self.handlers = [space.interp_w(excepthandler, w_obj) for w_obj in list_w]
+ else:
+ self.handlers = None
+ if self.handlers is not None:
+ for node in self.handlers:
+ node.sync_app_attrs(space)
+ w_list = self.w_orelse
+ if w_list is not None:
+ list_w = space.viewiterable(w_list)
+ if list_w:
+ self.orelse = [space.interp_w(stmt, w_obj) for w_obj in list_w]
+ else:
+ self.orelse = None
+ if self.orelse is not None:
+ for node in self.orelse:
+ node.sync_app_attrs(space)
+
+
class TryFinally(stmt):
- __slots__ = ('body', 'finalbody')
+ __slots__ = ('body', 'w_body', 'finalbody', 'w_finalbody')
+
+ _lineno_mask = 4
+ _col_offset_mask = 8
def __init__(self, body, finalbody, lineno, col_offset):
self.body = body
+ self.w_body = None
self.finalbody = finalbody
+ self.w_finalbody = None
stmt.__init__(self, lineno, col_offset)
+ self.initialization_state = 15
def walkabout(self, visitor):
visitor.visit_TryFinally(self)
@@ -365,14 +844,45 @@
visitor._mutate_sequence(self.finalbody)
return visitor.visit_TryFinally(self)
+ def sync_app_attrs(self, space):
+ if (self.initialization_state & ~0) ^ 15:
+ missing_field(space, self.initialization_state, ['body', 'finalbody', 'lineno', 'col_offset'], 'TryFinally')
+ else:
+ pass
+ w_list = self.w_body
+ if w_list is not None:
+ list_w = space.viewiterable(w_list)
+ if list_w:
+ self.body = [space.interp_w(stmt, w_obj) for w_obj in list_w]
+ else:
+ self.body = None
+ if self.body is not None:
+ for node in self.body:
+ node.sync_app_attrs(space)
+ w_list = self.w_finalbody
+ if w_list is not None:
+ list_w = space.viewiterable(w_list)
+ if list_w:
+ self.finalbody = [space.interp_w(stmt, w_obj) for w_obj in list_w]
+ else:
+ self.finalbody = None
+ if self.finalbody is not None:
+ for node in self.finalbody:
+ node.sync_app_attrs(space)
+
+
class Assert(stmt):
__slots__ = ('test', 'msg')
+ _lineno_mask = 4
+ _col_offset_mask = 8
+
def __init__(self, test, msg, lineno, col_offset):
self.test = test
self.msg = msg
stmt.__init__(self, lineno, col_offset)
+ self.initialization_state = 15
def walkabout(self, visitor):
visitor.visit_Assert(self)
@@ -383,13 +893,28 @@
self.msg = self.msg.mutate_over(visitor)
return visitor.visit_Assert(self)
+ def sync_app_attrs(self, space):
+ if (self.initialization_state & ~2) ^ 13:
+ missing_field(space, self.initialization_state, ['test', None, 'lineno', 'col_offset'], 'Assert')
+ else:
+ if not self.initialization_state & 2:
+ self.msg = None
+ self.test.sync_app_attrs(space)
+ self.msg.sync_app_attrs(space)
+
+
class Import(stmt):
- __slots__ = ('names')
+ __slots__ = ('names', 'w_names')
+
+ _lineno_mask = 2
+ _col_offset_mask = 4
def __init__(self, names, lineno, col_offset):
self.names = names
+ self.w_names = None
stmt.__init__(self, lineno, col_offset)
+ self.initialization_state = 7
def walkabout(self, visitor):
visitor.visit_Import(self)
@@ -397,15 +922,37 @@
def mutate_over(self, visitor):
return visitor.visit_Import(self)
+ def sync_app_attrs(self, space):
+ if (self.initialization_state & ~0) ^ 7:
+ missing_field(space, self.initialization_state, ['names', 'lineno', 'col_offset'], 'Import')
+ else:
+ pass
+ w_list = self.w_names
+ if w_list is not None:
+ list_w = space.viewiterable(w_list)
+ if list_w:
+ self.names = [space.interp_w(alias, w_obj) for w_obj in list_w]
+ else:
+ self.names = None
+ if self.names is not None:
+ for node in self.names:
+ node.sync_app_attrs(space)
+
+
class ImportFrom(stmt):
- __slots__ = ('module', 'names', 'level')
+ __slots__ = ('module', 'names', 'w_names', 'level')
+
+ _lineno_mask = 8
+ _col_offset_mask = 16
def __init__(self, module, names, level, lineno, col_offset):
self.module = module
self.names = names
+ self.w_names = None
self.level = level
stmt.__init__(self, lineno, col_offset)
+ self.initialization_state = 31
def walkabout(self, visitor):
visitor.visit_ImportFrom(self)
@@ -413,15 +960,39 @@
def mutate_over(self, visitor):
return visitor.visit_ImportFrom(self)
+ def sync_app_attrs(self, space):
+ if (self.initialization_state & ~5) ^ 26:
+ missing_field(space, self.initialization_state, [None, 'names', None, 'lineno', 'col_offset'], 'ImportFrom')
+ else:
+ if not self.initialization_state & 1:
+ self.module = None
+ if not self.initialization_state & 4:
+ self.level = 0
+ w_list = self.w_names
+ if w_list is not None:
+ list_w = space.viewiterable(w_list)
+ if list_w:
+ self.names = [space.interp_w(alias, w_obj) for w_obj in list_w]
+ else:
+ self.names = None
+ if self.names is not None:
+ for node in self.names:
+ node.sync_app_attrs(space)
+
+
class Exec(stmt):
__slots__ = ('body', 'globals', 'locals')
+ _lineno_mask = 8
+ _col_offset_mask = 16
+
def __init__(self, body, globals, locals, lineno, col_offset):
self.body = body
self.globals = globals
self.locals = locals
stmt.__init__(self, lineno, col_offset)
+ self.initialization_state = 31
def walkabout(self, visitor):
visitor.visit_Exec(self)
@@ -434,13 +1005,31 @@
self.locals = self.locals.mutate_over(visitor)
return visitor.visit_Exec(self)
+ def sync_app_attrs(self, space):
+ if (self.initialization_state & ~6) ^ 25:
+ missing_field(space, self.initialization_state, ['body', None, None, 'lineno', 'col_offset'], 'Exec')
+ else:
+ if not self.initialization_state & 2:
+ self.globals = None
+ if not self.initialization_state & 4:
+ self.locals = None
+ self.body.sync_app_attrs(space)
+ self.globals.sync_app_attrs(space)
+ self.locals.sync_app_attrs(space)
+
+
class Global(stmt):
- __slots__ = ('names')
+ __slots__ = ('names', 'w_names')
+
+ _lineno_mask = 2
+ _col_offset_mask = 4
def __init__(self, names, lineno, col_offset):
self.names = names
+ self.w_names = None
stmt.__init__(self, lineno, col_offset)
+ self.initialization_state = 7
def walkabout(self, visitor):
visitor.visit_Global(self)
@@ -448,13 +1037,31 @@
def mutate_over(self, visitor):
return visitor.visit_Global(self)
+ def sync_app_attrs(self, space):
+ if (self.initialization_state & ~0) ^ 7:
+ missing_field(space, self.initialization_state, ['names', 'lineno', 'col_offset'], 'Global')
+ else:
+ pass
+ w_list = self.w_names
+ if w_list is not None:
+ list_w = space.viewiterable(w_list)
+ if list_w:
+ self.names = [space.str_w(w_obj) for w_obj in list_w]
+ else:
+ self.names = None
+
+
class Expr(stmt):
__slots__ = ('value')
+ _lineno_mask = 2
+ _col_offset_mask = 4
+
def __init__(self, value, lineno, col_offset):
self.value = value
stmt.__init__(self, lineno, col_offset)
+ self.initialization_state = 7
def walkabout(self, visitor):
visitor.visit_Expr(self)
@@ -463,12 +1070,24 @@
self.value = self.value.mutate_over(visitor)
return visitor.visit_Expr(self)
+ def sync_app_attrs(self, space):
+ if (self.initialization_state & ~0) ^ 7:
+ missing_field(space, self.initialization_state, ['value', 'lineno', 'col_offset'], 'Expr')
+ else:
+ pass
+ self.value.sync_app_attrs(space)
+
+
class Pass(stmt):
__slots__ = ()
+ _lineno_mask = 1
+ _col_offset_mask = 2
+
def __init__(self, lineno, col_offset):
stmt.__init__(self, lineno, col_offset)
+ self.initialization_state = 3
def walkabout(self, visitor):
visitor.visit_Pass(self)
@@ -476,12 +1095,23 @@
def mutate_over(self, visitor):
return visitor.visit_Pass(self)
+ def sync_app_attrs(self, space):
+ if (self.initialization_state & ~0) ^ 3:
+ missing_field(space, self.initialization_state, ['lineno', 'col_offset'], 'Pass')
+ else:
+ pass
+
+
class Break(stmt):
__slots__ = ()
+ _lineno_mask = 1
+ _col_offset_mask = 2
+
def __init__(self, lineno, col_offset):
stmt.__init__(self, lineno, col_offset)
+ self.initialization_state = 3
def walkabout(self, visitor):
visitor.visit_Break(self)
@@ -489,12 +1119,23 @@
def mutate_over(self, visitor):
return visitor.visit_Break(self)
+ def sync_app_attrs(self, space):
+ if (self.initialization_state & ~0) ^ 3:
+ missing_field(space, self.initialization_state, ['lineno', 'col_offset'], 'Break')
+ else:
+ pass
+
+
class Continue(stmt):
__slots__ = ()
+ _lineno_mask = 1
+ _col_offset_mask = 2
+
def __init__(self, lineno, col_offset):
stmt.__init__(self, lineno, col_offset)
+ self.initialization_state = 3
def walkabout(self, visitor):
visitor.visit_Continue(self)
@@ -502,6 +1143,13 @@
def mutate_over(self, visitor):
return visitor.visit_Continue(self)
+ def sync_app_attrs(self, space):
+ if (self.initialization_state & ~0) ^ 3:
+ missing_field(space, self.initialization_state, ['lineno', 'col_offset'], 'Continue')
+ else:
+ pass
+
+
class expr(AST):
__slots__ = ('lineno', 'col_offset')
@@ -512,12 +1160,17 @@
class BoolOp(expr):
- __slots__ = ('op', 'values')
+ __slots__ = ('op', 'values', 'w_values')
+
+ _lineno_mask = 4
+ _col_offset_mask = 8
def __init__(self, op, values, lineno, col_offset):
self.op = op
self.values = values
+ self.w_values = None
expr.__init__(self, lineno, col_offset)
+ self.initialization_state = 15
def walkabout(self, visitor):
visitor.visit_BoolOp(self)
@@ -527,15 +1180,36 @@
visitor._mutate_sequence(self.values)
return visitor.visit_BoolOp(self)
+ def sync_app_attrs(self, space):
+ if (self.initialization_state & ~0) ^ 15:
+ missing_field(space, self.initialization_state, ['op', 'values', 'lineno', 'col_offset'], 'BoolOp')
+ else:
+ pass
+ w_list = self.w_values
+ if w_list is not None:
+ list_w = space.viewiterable(w_list)
+ if list_w:
+ self.values = [space.interp_w(expr, w_obj) for w_obj in list_w]
+ else:
+ self.values = None
+ if self.values is not None:
+ for node in self.values:
+ node.sync_app_attrs(space)
+
+
class BinOp(expr):
__slots__ = ('left', 'op', 'right')
+ _lineno_mask = 8
+ _col_offset_mask = 16
+
def __init__(self, left, op, right, lineno, col_offset):
self.left = left
self.op = op
self.right = right
expr.__init__(self, lineno, col_offset)
+ self.initialization_state = 31
def walkabout(self, visitor):
visitor.visit_BinOp(self)
@@ -545,14 +1219,27 @@
self.right = self.right.mutate_over(visitor)
return visitor.visit_BinOp(self)
+ def sync_app_attrs(self, space):
+ if (self.initialization_state & ~0) ^ 31:
+ missing_field(space, self.initialization_state, ['left', 'op', 'right', 'lineno', 'col_offset'], 'BinOp')
+ else:
+ pass
+ self.left.sync_app_attrs(space)
+ self.right.sync_app_attrs(space)
+
+
class UnaryOp(expr):
__slots__ = ('op', 'operand')
+ _lineno_mask = 4
+ _col_offset_mask = 8
+
def __init__(self, op, operand, lineno, col_offset):
self.op = op
self.operand = operand
expr.__init__(self, lineno, col_offset)
+ self.initialization_state = 15
def walkabout(self, visitor):
visitor.visit_UnaryOp(self)
@@ -561,14 +1248,26 @@
self.operand = self.operand.mutate_over(visitor)
return visitor.visit_UnaryOp(self)
+ def sync_app_attrs(self, space):
+ if (self.initialization_state & ~0) ^ 15:
+ missing_field(space, self.initialization_state, ['op', 'operand', 'lineno', 'col_offset'], 'UnaryOp')
+ else:
+ pass
+ self.operand.sync_app_attrs(space)
+
+
class Lambda(expr):
__slots__ = ('args', 'body')
+ _lineno_mask = 4
+ _col_offset_mask = 8
+
def __init__(self, args, body, lineno, col_offset):
self.args = args
self.body = body
expr.__init__(self, lineno, col_offset)
+ self.initialization_state = 15
def walkabout(self, visitor):
visitor.visit_Lambda(self)
@@ -577,15 +1276,28 @@
self.body = self.body.mutate_over(visitor)
return visitor.visit_Lambda(self)
+ def sync_app_attrs(self, space):
+ if (self.initialization_state & ~0) ^ 15:
+ missing_field(space, self.initialization_state, ['args', 'body', 'lineno', 'col_offset'], 'Lambda')
+ else:
+ pass
+ self.args.sync_app_attrs(space)
+ self.body.sync_app_attrs(space)
+
+
class IfExp(expr):
__slots__ = ('test', 'body', 'orelse')
+ _lineno_mask = 8
+ _col_offset_mask = 16
+
def __init__(self, test, body, orelse, lineno, col_offset):
self.test = test
self.body = body
self.orelse = orelse
expr.__init__(self, lineno, col_offset)
+ self.initialization_state = 31
def walkabout(self, visitor):
visitor.visit_IfExp(self)
@@ -596,14 +1308,30 @@
self.orelse = self.orelse.mutate_over(visitor)
return visitor.visit_IfExp(self)
+ def sync_app_attrs(self, space):
+ if (self.initialization_state & ~0) ^ 31:
+ missing_field(space, self.initialization_state, ['test', 'body', 'orelse', 'lineno', 'col_offset'], 'IfExp')
+ else:
+ pass
+ self.test.sync_app_attrs(space)
+ self.body.sync_app_attrs(space)
+ self.orelse.sync_app_attrs(space)
+
+
class Dict(expr):
- __slots__ = ('keys', 'values')
+ __slots__ = ('keys', 'w_keys', 'values', 'w_values')
+
+ _lineno_mask = 4
+ _col_offset_mask = 8
def __init__(self, keys, values, lineno, col_offset):
self.keys = keys
+ self.w_keys = None
self.values = values
+ self.w_values = None
expr.__init__(self, lineno, col_offset)
+ self.initialization_state = 15
def walkabout(self, visitor):
visitor.visit_Dict(self)
@@ -615,14 +1343,46 @@
visitor._mutate_sequence(self.values)
return visitor.visit_Dict(self)
+ def sync_app_attrs(self, space):
+ if (self.initialization_state & ~0) ^ 15:
+ missing_field(space, self.initialization_state, ['keys', 'values', 'lineno', 'col_offset'], 'Dict')
+ else:
+ pass
+ w_list = self.w_keys
+ if w_list is not None:
+ list_w = space.viewiterable(w_list)
+ if list_w:
+ self.keys = [space.interp_w(expr, w_obj) for w_obj in list_w]
+ else:
+ self.keys = None
+ if self.keys is not None:
+ for node in self.keys:
+ node.sync_app_attrs(space)
+ w_list = self.w_values
+ if w_list is not None:
+ list_w = space.viewiterable(w_list)
+ if list_w:
+ self.values = [space.interp_w(expr, w_obj) for w_obj in list_w]
+ else:
+ self.values = None
+ if self.values is not None:
+ for node in self.values:
+ node.sync_app_attrs(space)
+
+
class ListComp(expr):
- __slots__ = ('elt', 'generators')
+ __slots__ = ('elt', 'generators', 'w_generators')
+
+ _lineno_mask = 4
+ _col_offset_mask = 8
def __init__(self, elt, generators, lineno, col_offset):
self.elt = elt
self.generators = generators
+ self.w_generators = None
expr.__init__(self, lineno, col_offset)
+ self.initialization_state = 15
def walkabout(self, visitor):
visitor.visit_ListComp(self)
@@ -631,14 +1391,37 @@
self.elt = self.elt.mutate_over(visitor)
return visitor.visit_ListComp(self)
+ def sync_app_attrs(self, space):
+ if (self.initialization_state & ~0) ^ 15:
+ missing_field(space, self.initialization_state, ['elt', 'generators', 'lineno', 'col_offset'], 'ListComp')
+ else:
+ pass
+ self.elt.sync_app_attrs(space)
+ w_list = self.w_generators
+ if w_list is not None:
+ list_w = space.viewiterable(w_list)
+ if list_w:
+ self.generators = [space.interp_w(comprehension, w_obj) for w_obj in list_w]
+ else:
+ self.generators = None
+ if self.generators is not None:
+ for node in self.generators:
+ node.sync_app_attrs(space)
+
+
class GeneratorExp(expr):
- __slots__ = ('elt', 'generators')
+ __slots__ = ('elt', 'generators', 'w_generators')
+
+ _lineno_mask = 4
+ _col_offset_mask = 8
def __init__(self, elt, generators, lineno, col_offset):
self.elt = elt
self.generators = generators
+ self.w_generators = None
expr.__init__(self, lineno, col_offset)
+ self.initialization_state = 15
def walkabout(self, visitor):
visitor.visit_GeneratorExp(self)
@@ -647,13 +1430,35 @@
self.elt = self.elt.mutate_over(visitor)
return visitor.visit_GeneratorExp(self)
+ def sync_app_attrs(self, space):
+ if (self.initialization_state & ~0) ^ 15:
+ missing_field(space, self.initialization_state, ['elt', 'generators', 'lineno', 'col_offset'], 'GeneratorExp')
+ else:
+ pass
+ self.elt.sync_app_attrs(space)
+ w_list = self.w_generators
+ if w_list is not None:
+ list_w = space.viewiterable(w_list)
+ if list_w:
+ self.generators = [space.interp_w(comprehension, w_obj) for w_obj in list_w]
+ else:
+ self.generators = None
+ if self.generators is not None:
+ for node in self.generators:
+ node.sync_app_attrs(space)
+
+
class Yield(expr):
__slots__ = ('value')
+ _lineno_mask = 2
+ _col_offset_mask = 4
+
def __init__(self, value, lineno, col_offset):
self.value = value
expr.__init__(self, lineno, col_offset)
+ self.initialization_state = 7
def walkabout(self, visitor):
visitor.visit_Yield(self)
@@ -663,15 +1468,30 @@
self.value = self.value.mutate_over(visitor)
return visitor.visit_Yield(self)
+ def sync_app_attrs(self, space):
+ if (self.initialization_state & ~1) ^ 6:
+ missing_field(space, self.initialization_state, [None, 'lineno', 'col_offset'], 'Yield')
+ else:
+ if not self.initialization_state & 1:
+ self.value = None
+ self.value.sync_app_attrs(space)
+
+
class Compare(expr):
- __slots__ = ('left', 'ops', 'comparators')
+ __slots__ = ('left', 'ops', 'w_ops', 'comparators', 'w_comparators')
+
+ _lineno_mask = 8
+ _col_offset_mask = 16
def __init__(self, left, ops, comparators, lineno, col_offset):
self.left = left
self.ops = ops
+ self.w_ops = None
self.comparators = comparators
+ self.w_comparators = None
expr.__init__(self, lineno, col_offset)
+ self.initialization_state = 31
def walkabout(self, visitor):
visitor.visit_Compare(self)
@@ -682,17 +1502,48 @@
visitor._mutate_sequence(self.comparators)
return visitor.visit_Compare(self)
+ def sync_app_attrs(self, space):
+ if (self.initialization_state & ~0) ^ 31:
+ missing_field(space, self.initialization_state, ['left', 'ops', 'comparators', 'lineno', 'col_offset'], 'Compare')
+ else:
+ pass
+ self.left.sync_app_attrs(space)
+ w_list = self.w_ops
+ if w_list is not None:
+ list_w = space.viewiterable(w_list)
+ if list_w:
+ self.ops = [w_obj.to_simple_int() for w_obj in list_w]
+ else:
+ self.ops = None
+ w_list = self.w_comparators
+ if w_list is not None:
+ list_w = space.viewiterable(w_list)
+ if list_w:
+ self.comparators = [space.interp_w(expr, w_obj) for w_obj in list_w]
+ else:
+ self.comparators = None
+ if self.comparators is not None:
+ for node in self.comparators:
+ node.sync_app_attrs(space)
+
+
class Call(expr):
- __slots__ = ('func', 'args', 'keywords', 'starargs', 'kwargs')
+ __slots__ = ('func', 'args', 'w_args', 'keywords', 'w_keywords', 'starargs', 'kwargs')
+
+ _lineno_mask = 32
+ _col_offset_mask = 64
def __init__(self, func, args, keywords, starargs, kwargs, lineno, col_offset):
self.func = func
self.args = args
+ self.w_args = None
self.keywords = keywords
+ self.w_keywords = None
self.starargs = starargs
self.kwargs = kwargs
expr.__init__(self, lineno, col_offset)
+ self.initialization_state = 127
def walkabout(self, visitor):
visitor.visit_Call(self)
@@ -707,13 +1558,50 @@
self.kwargs = self.kwargs.mutate_over(visitor)
return visitor.visit_Call(self)
+ def sync_app_attrs(self, space):
+ if (self.initialization_state & ~24) ^ 103:
+ missing_field(space, self.initialization_state, ['func', 'args', 'keywords', None, None, 'lineno', 'col_offset'], 'Call')
+ else:
+ if not self.initialization_state & 8:
+ self.starargs = None
+ if not self.initialization_state & 16:
+ self.kwargs = None
+ self.func.sync_app_attrs(space)
+ w_list = self.w_args
+ if w_list is not None:
+ list_w = space.viewiterable(w_list)
+ if list_w:
+ self.args = [space.interp_w(expr, w_obj) for w_obj in list_w]
+ else:
+ self.args = None
+ if self.args is not None:
+ for node in self.args:
+ node.sync_app_attrs(space)
+ w_list = self.w_keywords
+ if w_list is not None:
+ list_w = space.viewiterable(w_list)
+ if list_w:
+ self.keywords = [space.interp_w(keyword, w_obj) for w_obj in list_w]
+ else:
+ self.keywords = None
+ if self.keywords is not None:
+ for node in self.keywords:
+ node.sync_app_attrs(space)
+ self.starargs.sync_app_attrs(space)
+ self.kwargs.sync_app_attrs(space)
+
+
class Repr(expr):
__slots__ = ('value')
+ _lineno_mask = 2
+ _col_offset_mask = 4
+
def __init__(self, value, lineno, col_offset):
self.value = value
expr.__init__(self, lineno, col_offset)
+ self.initialization_state = 7
def walkabout(self, visitor):
visitor.visit_Repr(self)
@@ -722,13 +1610,25 @@
self.value = self.value.mutate_over(visitor)
return visitor.visit_Repr(self)
+ def sync_app_attrs(self, space):
+ if (self.initialization_state & ~0) ^ 7:
+ missing_field(space, self.initialization_state, ['value', 'lineno', 'col_offset'], 'Repr')
+ else:
+ pass
+ self.value.sync_app_attrs(space)
+
+
class Num(expr):
__slots__ = ('n')
+ _lineno_mask = 2
+ _col_offset_mask = 4
+
def __init__(self, n, lineno, col_offset):
self.n = n
expr.__init__(self, lineno, col_offset)
+ self.initialization_state = 7
def walkabout(self, visitor):
visitor.visit_Num(self)
@@ -736,13 +1636,24 @@
def mutate_over(self, visitor):
return visitor.visit_Num(self)
+ def sync_app_attrs(self, space):
+ if (self.initialization_state & ~0) ^ 7:
+ missing_field(space, self.initialization_state, ['n', 'lineno', 'col_offset'], 'Num')
+ else:
+ pass
+
+
class Str(expr):
__slots__ = ('s')
+ _lineno_mask = 2
+ _col_offset_mask = 4
+
def __init__(self, s, lineno, col_offset):
self.s = s
expr.__init__(self, lineno, col_offset)
+ self.initialization_state = 7
def walkabout(self, visitor):
visitor.visit_Str(self)
@@ -750,15 +1661,26 @@
def mutate_over(self, visitor):
return visitor.visit_Str(self)
+ def sync_app_attrs(self, space):
+ if (self.initialization_state & ~0) ^ 7:
+ missing_field(space, self.initialization_state, ['s', 'lineno', 'col_offset'], 'Str')
+ else:
+ pass
+
+
class Attribute(expr):
__slots__ = ('value', 'attr', 'ctx')
+ _lineno_mask = 8
+ _col_offset_mask = 16
+
def __init__(self, value, attr, ctx, lineno, col_offset):
self.value = value
self.attr = attr
self.ctx = ctx
expr.__init__(self, lineno, col_offset)
+ self.initialization_state = 31
def walkabout(self, visitor):
visitor.visit_Attribute(self)
@@ -767,15 +1689,27 @@
self.value = self.value.mutate_over(visitor)
return visitor.visit_Attribute(self)
+ def sync_app_attrs(self, space):
+ if (self.initialization_state & ~0) ^ 31:
+ missing_field(space, self.initialization_state, ['value', 'attr', 'ctx', 'lineno', 'col_offset'], 'Attribute')
+ else:
+ pass
+ self.value.sync_app_attrs(space)
+
+
class Subscript(expr):
__slots__ = ('value', 'slice', 'ctx')
+ _lineno_mask = 8
+ _col_offset_mask = 16
+
def __init__(self, value, slice, ctx, lineno, col_offset):
self.value = value
self.slice = slice
self.ctx = ctx
expr.__init__(self, lineno, col_offset)
+ self.initialization_state = 31
def walkabout(self, visitor):
visitor.visit_Subscript(self)
@@ -785,14 +1719,27 @@
self.slice = self.slice.mutate_over(visitor)
return visitor.visit_Subscript(self)
+ def sync_app_attrs(self, space):
+ if (self.initialization_state & ~0) ^ 31:
+ missing_field(space, self.initialization_state, ['value', 'slice', 'ctx', 'lineno', 'col_offset'], 'Subscript')
+ else:
+ pass
+ self.value.sync_app_attrs(space)
+ self.slice.sync_app_attrs(space)
+
+
class Name(expr):
__slots__ = ('id', 'ctx')
+ _lineno_mask = 4
+ _col_offset_mask = 8
+
def __init__(self, id, ctx, lineno, col_offset):
self.id = id
self.ctx = ctx
expr.__init__(self, lineno, col_offset)
+ self.initialization_state = 15
def walkabout(self, visitor):
visitor.visit_Name(self)
@@ -800,14 +1747,26 @@
def mutate_over(self, visitor):
return visitor.visit_Name(self)
+ def sync_app_attrs(self, space):
+ if (self.initialization_state & ~0) ^ 15:
+ missing_field(space, self.initialization_state, ['id', 'ctx', 'lineno', 'col_offset'], 'Name')
+ else:
+ pass
+
+
class List(expr):
- __slots__ = ('elts', 'ctx')
+ __slots__ = ('elts', 'w_elts', 'ctx')
+
+ _lineno_mask = 4
+ _col_offset_mask = 8
def __init__(self, elts, ctx, lineno, col_offset):
self.elts = elts
+ self.w_elts = None
self.ctx = ctx
expr.__init__(self, lineno, col_offset)
+ self.initialization_state = 15
def walkabout(self, visitor):
visitor.visit_List(self)
@@ -817,14 +1776,36 @@
visitor._mutate_sequence(self.elts)
return visitor.visit_List(self)
+ def sync_app_attrs(self, space):
+ if (self.initialization_state & ~0) ^ 15:
+ missing_field(space, self.initialization_state, ['elts', 'ctx', 'lineno', 'col_offset'], 'List')
+ else:
+ pass
+ w_list = self.w_elts
+ if w_list is not None:
+ list_w = space.viewiterable(w_list)
+ if list_w:
+ self.elts = [space.interp_w(expr, w_obj) for w_obj in list_w]
+ else:
+ self.elts = None
+ if self.elts is not None:
+ for node in self.elts:
+ node.sync_app_attrs(space)
+
+
class Tuple(expr):
- __slots__ = ('elts', 'ctx')
+ __slots__ = ('elts', 'w_elts', 'ctx')
+
+ _lineno_mask = 4
+ _col_offset_mask = 8
def __init__(self, elts, ctx, lineno, col_offset):
self.elts = elts
+ self.w_elts = None
self.ctx = ctx
expr.__init__(self, lineno, col_offset)
+ self.initialization_state = 15
def walkabout(self, visitor):
visitor.visit_Tuple(self)
@@ -834,13 +1815,34 @@
visitor._mutate_sequence(self.elts)
return visitor.visit_Tuple(self)
+ def sync_app_attrs(self, space):
+ if (self.initialization_state & ~0) ^ 15:
+ missing_field(space, self.initialization_state, ['elts', 'ctx', 'lineno', 'col_offset'], 'Tuple')
+ else:
+ pass
+ w_list = self.w_elts
+ if w_list is not None:
+ list_w = space.viewiterable(w_list)
+ if list_w:
+ self.elts = [space.interp_w(expr, w_obj) for w_obj in list_w]
+ else:
+ self.elts = None
+ if self.elts is not None:
+ for node in self.elts:
+ node.sync_app_attrs(space)
+
+
class Const(expr):
__slots__ = ('value')
+ _lineno_mask = 2
+ _col_offset_mask = 4
+
def __init__(self, value, lineno, col_offset):
self.value = value
expr.__init__(self, lineno, col_offset)
+ self.initialization_state = 7
def walkabout(self, visitor):
visitor.visit_Const(self)
@@ -848,6 +1850,49 @@
def mutate_over(self, visitor):
return visitor.visit_Const(self)
+ def sync_app_attrs(self, space):
+ if (self.initialization_state & ~0) ^ 7:
+ missing_field(space, self.initialization_state, ['value', 'lineno', 'col_offset'], 'Const')
+ else:
+ pass
+
+
+class expr_context(AST):
+
+ def to_simple_int(self, space):
+ w_msg = space.wrap("not a valid expr_context")
+ raise OperationError(space.w_TypeError, w_msg)
+
+class _Load(expr_context):
+
+ def to_simple_int(self):
+ return 1
+
+class _Store(expr_context):
+
+ def to_simple_int(self):
+ return 2
+
+class _Del(expr_context):
+
+ def to_simple_int(self):
+ return 3
+
+class _AugLoad(expr_context):
+
+ def to_simple_int(self):
+ return 4
+
+class _AugStore(expr_context):
+
+ def to_simple_int(self):
+ return 5
+
+class _Param(expr_context):
+
+ def to_simple_int(self):
+ return 6
+
Load = 1
Store = 2
Del = 3
@@ -855,6 +1900,15 @@
AugStore = 5
Param = 6
+expr_context_to_class = [
+ _Load,
+ _Store,
+ _Del,
+ _AugLoad,
+ _AugStore,
+ _Param,
+]
+
class slice(AST):
__slots__ = ()
@@ -863,8 +1917,9 @@
__slots__ = ()
+
def __init__(self):
- pass
+ self.initialization_state = 0
def walkabout(self, visitor):
visitor.visit_Ellipsis(self)
@@ -872,14 +1927,23 @@
def mutate_over(self, visitor):
return visitor.visit_Ellipsis(self)
+ def sync_app_attrs(self, space):
+ if (self.initialization_state & ~0) ^ 0:
+ missing_field(space, self.initialization_state, [], 'Ellipsis')
+ else:
+ pass
+
+
class Slice(slice):
__slots__ = ('lower', 'upper', 'step')
+
def __init__(self, lower, upper, step):
self.lower = lower
self.upper = upper
self.step = step
+ self.initialization_state = 7
def walkabout(self, visitor):
visitor.visit_Slice(self)
@@ -893,12 +1957,30 @@
self.step = self.step.mutate_over(visitor)
return visitor.visit_Slice(self)
+ def sync_app_attrs(self, space):
+ if (self.initialization_state & ~7) ^ 0:
+ missing_field(space, self.initialization_state, [None, None, None], 'Slice')
+ else:
+ if not self.initialization_state & 1:
+ self.lower = None
+ if not self.initialization_state & 2:
+ self.upper = None
+ if not self.initialization_state & 4:
+ self.step = None
+ self.lower.sync_app_attrs(space)
+ self.upper.sync_app_attrs(space)
+ self.step.sync_app_attrs(space)
+
+
class ExtSlice(slice):
- __slots__ = ('dims')
+ __slots__ = ('dims', 'w_dims')
+
def __init__(self, dims):
self.dims = dims
+ self.w_dims = None
+ self.initialization_state = 1
def walkabout(self, visitor):
visitor.visit_ExtSlice(self)
@@ -908,12 +1990,31 @@
visitor._mutate_sequence(self.dims)
return visitor.visit_ExtSlice(self)
+ def sync_app_attrs(self, space):
+ if (self.initialization_state & ~0) ^ 1:
+ missing_field(space, self.initialization_state, ['dims'], 'ExtSlice')
+ else:
+ pass
+ w_list = self.w_dims
+ if w_list is not None:
+ list_w = space.viewiterable(w_list)
+ if list_w:
+ self.dims = [space.interp_w(slice, w_obj) for w_obj in list_w]
+ else:
+ self.dims = None
+ if self.dims is not None:
+ for node in self.dims:
+ node.sync_app_attrs(space)
+
+
class Index(slice):
__slots__ = ('value')
+
def __init__(self, value):
self.value = value
+ self.initialization_state = 1
def walkabout(self, visitor):
visitor.visit_Index(self)
@@ -922,9 +2023,104 @@
self.value = self.value.mutate_over(visitor)
return visitor.visit_Index(self)
+ def sync_app_attrs(self, space):
+ if (self.initialization_state & ~0) ^ 1:
+ missing_field(space, self.initialization_state, ['value'], 'Index')
+ else:
+ pass
+ self.value.sync_app_attrs(space)
+
+
+class boolop(AST):
+
+ def to_simple_int(self, space):
+ w_msg = space.wrap("not a valid boolop")
+ raise OperationError(space.w_TypeError, w_msg)
+
+class _And(boolop):
+
+ def to_simple_int(self):
+ return 1
+
+class _Or(boolop):
+
+ def to_simple_int(self):
+ return 2
+
And = 1
Or = 2
+boolop_to_class = [
+ _And,
+ _Or,
+]
+
+class operator(AST):
+
+ def to_simple_int(self, space):
+ w_msg = space.wrap("not a valid operator")
+ raise OperationError(space.w_TypeError, w_msg)
+
+class _Add(operator):
+
+ def to_simple_int(self):
+ return 1
+
+class _Sub(operator):
+
+ def to_simple_int(self):
+ return 2
+
+class _Mult(operator):
+
+ def to_simple_int(self):
+ return 3
+
+class _Div(operator):
+
+ def to_simple_int(self):
+ return 4
+
+class _Mod(operator):
+
+ def to_simple_int(self):
+ return 5
+
+class _Pow(operator):
+
+ def to_simple_int(self):
+ return 6
+
+class _LShift(operator):
+
+ def to_simple_int(self):
+ return 7
+
+class _RShift(operator):
+
+ def to_simple_int(self):
+ return 8
+
+class _BitOr(operator):
+
+ def to_simple_int(self):
+ return 9
+
+class _BitXor(operator):
+
+ def to_simple_int(self):
+ return 10
+
+class _BitAnd(operator):
+
+ def to_simple_int(self):
+ return 11
+
+class _FloorDiv(operator):
+
+ def to_simple_int(self):
+ return 12
+
Add = 1
Sub = 2
Mult = 3
@@ -938,11 +2134,115 @@
BitAnd = 11
FloorDiv = 12
+operator_to_class = [
+ _Add,
+ _Sub,
+ _Mult,
+ _Div,
+ _Mod,
+ _Pow,
+ _LShift,
+ _RShift,
+ _BitOr,
+ _BitXor,
+ _BitAnd,
+ _FloorDiv,
+]
+
+class unaryop(AST):
+
+ def to_simple_int(self, space):
+ w_msg = space.wrap("not a valid unaryop")
+ raise OperationError(space.w_TypeError, w_msg)
+
+class _Invert(unaryop):
+
+ def to_simple_int(self):
+ return 1
+
+class _Not(unaryop):
+
+ def to_simple_int(self):
+ return 2
+
+class _UAdd(unaryop):
+
+ def to_simple_int(self):
+ return 3
+
+class _USub(unaryop):
+
+ def to_simple_int(self):
+ return 4
+
Invert = 1
Not = 2
UAdd = 3
USub = 4
+unaryop_to_class = [
+ _Invert,
+ _Not,
+ _UAdd,
+ _USub,
+]
+
+class cmpop(AST):
+
+ def to_simple_int(self, space):
+ w_msg = space.wrap("not a valid cmpop")
+ raise OperationError(space.w_TypeError, w_msg)
+
+class _Eq(cmpop):
+
+ def to_simple_int(self):
+ return 1
+
+class _NotEq(cmpop):
+
+ def to_simple_int(self):
+ return 2
+
+class _Lt(cmpop):
+
+ def to_simple_int(self):
+ return 3
+
+class _LtE(cmpop):
+
+ def to_simple_int(self):
+ return 4
+
+class _Gt(cmpop):
+
+ def to_simple_int(self):
+ return 5
+
+class _GtE(cmpop):
+
+ def to_simple_int(self):
+ return 6
+
+class _Is(cmpop):
+
+ def to_simple_int(self):
+ return 7
+
+class _IsNot(cmpop):
+
+ def to_simple_int(self):
+ return 8
+
+class _In(cmpop):
+
+ def to_simple_int(self):
+ return 9
+
+class _NotIn(cmpop):
+
+ def to_simple_int(self):
+ return 10
+
Eq = 1
NotEq = 2
Lt = 3
@@ -954,45 +2254,133 @@
In = 9
NotIn = 10
+cmpop_to_class = [
+ _Eq,
+ _NotEq,
+ _Lt,
+ _LtE,
+ _Gt,
+ _GtE,
+ _Is,
+ _IsNot,
+ _In,
+ _NotIn,
+]
+
class comprehension(AST):
- __slots__ = ('target', 'iter', 'ifs')
+ __slots__ = ('target', 'iter', 'ifs', 'w_ifs')
def __init__(self, target, iter, ifs):
self.target = target
self.iter = iter
self.ifs = ifs
+ self.w_ifs = None
+ self.initialization_state = 7
def walkabout(self, visitor):
visitor.visit_comprehension(self)
+ def sync_app_attrs(self, space):
+ if (self.initialization_state & ~0) ^ 7:
+ missing_field(space, self.initialization_state, ['target', 'iter', 'ifs'], 'comprehension')
+ else:
+ pass
+ self.target.sync_app_attrs(space)
+ self.iter.sync_app_attrs(space)
+ w_list = self.w_ifs
+ if w_list is not None:
+ list_w = space.viewiterable(w_list)
+ if list_w:
+ self.ifs = [space.interp_w(expr, w_obj) for w_obj in list_w]
+ else:
+ self.ifs = None
+ if self.ifs is not None:
+ for node in self.ifs:
+ node.sync_app_attrs(space)
+
class excepthandler(AST):
- __slots__ = ('type', 'name', 'body', 'lineno', 'col_offset')
+ __slots__ = ('type', 'name', 'body', 'w_body', 'lineno', 'col_offset')
def __init__(self, type, name, body, lineno, col_offset):
self.type = type
self.name = name
self.body = body
+ self.w_body = None
self.lineno = lineno
self.col_offset = col_offset
+ self.initialization_state = 31
def walkabout(self, visitor):
visitor.visit_excepthandler(self)
+ def sync_app_attrs(self, space):
+ if (self.initialization_state & ~3) ^ 28:
+ missing_field(space, self.initialization_state, [None, None, 'body', 'lineno', 'col_offset'], 'excepthandler')
+ else:
+ if not self.initialization_state & 1:
+ self.type = None
+ if not self.initialization_state & 2:
+ self.name = None
+ self.type.sync_app_attrs(space)
+ self.name.sync_app_attrs(space)
+ w_list = self.w_body
+ if w_list is not None:
+ list_w = space.viewiterable(w_list)
+ if list_w:
+ self.body = [space.interp_w(stmt, w_obj) for w_obj in list_w]
+ else:
+ self.body = None
+ if self.body is not None:
+ for node in self.body:
+ node.sync_app_attrs(space)
+
class arguments(AST):
- __slots__ = ('args', 'vararg', 'kwarg', 'defaults')
+ __slots__ = ('args', 'w_args', 'vararg', 'kwarg', 'defaults', 'w_defaults')
def __init__(self, args, vararg, kwarg, defaults):
self.args = args
+ self.w_args = None
self.vararg = vararg
self.kwarg = kwarg
self.defaults = defaults
+ self.w_defaults = None
+ self.initialization_state = 15
def walkabout(self, visitor):
visitor.visit_arguments(self)
+ def sync_app_attrs(self, space):
+ if (self.initialization_state & ~6) ^ 9:
+ missing_field(space, self.initialization_state, ['args', None, None, 'defaults'], 'arguments')
+ else:
+ if not self.initialization_state & 2:
+ self.vararg = None
+ if not self.initialization_state & 4:
+ self.kwarg = None
+ w_list = self.w_args
+ if w_list is not None:
+ list_w = space.viewiterable(w_list)
+ if list_w:
+ self.args = [space.interp_w(expr, w_obj) for w_obj in list_w]
+ else:
+ self.args = None
+ if self.args is not None:
+ for node in self.args:
+ node.sync_app_attrs(space)
+ w_list = self.w_defaults
+ if w_list is not None:
+ list_w = space.viewiterable(w_list)
+ if list_w:
+ self.defaults = [space.interp_w(expr, w_obj) for w_obj in list_w]
+ else:
+ self.defaults = None
+ if self.defaults is not None:
+ for node in self.defaults:
+ node.sync_app_attrs(space)
+
class keyword(AST):
__slots__ = ('arg', 'value')
@@ -1000,10 +2388,18 @@
def __init__(self, arg, value):
self.arg = arg
self.value = value
+ self.initialization_state = 3
def walkabout(self, visitor):
visitor.visit_keyword(self)
+ def sync_app_attrs(self, space):
+ if (self.initialization_state & ~0) ^ 3:
+ missing_field(space, self.initialization_state, ['arg', 'value'], 'keyword')
+ else:
+ pass
+ self.value.sync_app_attrs(space)
+
class alias(AST):
__slots__ = ('name', 'asname')
@@ -1011,10 +2407,18 @@
def __init__(self, name, asname):
self.name = name
self.asname = asname
+ self.initialization_state = 3
def walkabout(self, visitor):
visitor.visit_alias(self)
+ def sync_app_attrs(self, space):
+ if (self.initialization_state & ~2) ^ 1:
+ missing_field(space, self.initialization_state, ['name', None], 'alias')
+ else:
+ if not self.initialization_state & 2:
+ self.asname = None
+
class ASTVisitor(object):
def visit_sequence(self, seq):
@@ -1411,3 +2815,3154 @@
pass
+mod.typedef = typedef.TypeDef("mod",
+ AST.typedef,
+ _attributes=_FieldsWrapper([]),
+)
+mod.typedef.acceptable_as_base_class = False
+
+def Module_get_body(space, w_self):
+ if not w_self.initialization_state & 1:
+ w_err = space.wrap("attribute 'body' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ if w_self.w_body is None:
+ if w_self.body is None:
+ w_list = space.newlist([])
+ else:
+ list_w = [space.wrap(node) for node in w_self.body]
+ w_list = space.newlist(list_w)
+ w_self.w_body = w_list
+ return w_self.w_body
+
+def Module_set_body(space, w_self, w_new_value):
+ w_self.w_body = w_new_value
+ w_self.initialization_state |= 1
+
+def Module_init(space, w_self, args):
+ w_self = space.descr_self_interp_w(Module, w_self)
+ w_self.w_body = None
+ args_w, kwargs_w = args.unpack()
+ if args_w:
+ if len(args_w) != 1:
+ w_err = space.wrap("Module constructor takes 0 or 1 positional arguments")
+ raise OperationError(space.w_TypeError, w_err)
+ for i, field in unrolling_iterable(enumerate(['body'])):
+ space.setattr(w_self, space.wrap(field), args_w[i])
+ for field, w_value in kwargs_w.iteritems():
+ space.setattr(w_self, space.wrap(field), w_value)
+Module_init.unwrap_spec = [ObjSpace, W_Root, Arguments]
+
+Module.typedef = typedef.TypeDef("Module",
+ mod.typedef,
+ _fields=_FieldsWrapper(['body']),
+ body=typedef.GetSetProperty(Module_get_body, Module_set_body, cls=Module),
+ __new__=interp2app(get_AST_new(Module)),
+ __init__=interp2app(Module_init),
+)
+Module.typedef.acceptable_as_base_class = False
+
+def Interactive_get_body(space, w_self):
+ if not w_self.initialization_state & 1:
+ w_err = space.wrap("attribute 'body' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ if w_self.w_body is None:
+ if w_self.body is None:
+ w_list = space.newlist([])
+ else:
+ list_w = [space.wrap(node) for node in w_self.body]
+ w_list = space.newlist(list_w)
+ w_self.w_body = w_list
+ return w_self.w_body
+
+def Interactive_set_body(space, w_self, w_new_value):
+ w_self.w_body = w_new_value
+ w_self.initialization_state |= 1
+
+def Interactive_init(space, w_self, args):
+ w_self = space.descr_self_interp_w(Interactive, w_self)
+ w_self.w_body = None
+ args_w, kwargs_w = args.unpack()
+ if args_w:
+ if len(args_w) != 1:
+ w_err = space.wrap("Interactive constructor takes 0 or 1 positional arguments")
+ raise OperationError(space.w_TypeError, w_err)
+ for i, field in unrolling_iterable(enumerate(['body'])):
+ space.setattr(w_self, space.wrap(field), args_w[i])
+ for field, w_value in kwargs_w.iteritems():
+ space.setattr(w_self, space.wrap(field), w_value)
+Interactive_init.unwrap_spec = [ObjSpace, W_Root, Arguments]
+
+Interactive.typedef = typedef.TypeDef("Interactive",
+ mod.typedef,
+ _fields=_FieldsWrapper(['body']),
+ body=typedef.GetSetProperty(Interactive_get_body, Interactive_set_body, cls=Interactive),
+ __new__=interp2app(get_AST_new(Interactive)),
+ __init__=interp2app(Interactive_init),
+)
+Interactive.typedef.acceptable_as_base_class = False
+
+def Expression_get_body(space, w_self):
+ if not w_self.initialization_state & 1:
+ w_err = space.wrap("attribute 'body' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ return space.wrap(w_self.body)
+
+def Expression_set_body(space, w_self, w_new_value):
+ w_self.body = space.interp_w(expr, w_new_value, False)
+ w_self.initialization_state |= 1
+
+def Expression_init(space, w_self, args):
+ w_self = space.descr_self_interp_w(Expression, w_self)
+ args_w, kwargs_w = args.unpack()
+ if args_w:
+ if len(args_w) != 1:
+ w_err = space.wrap("Expression constructor takes 0 or 1 positional arguments")
+ raise OperationError(space.w_TypeError, w_err)
+ for i, field in unrolling_iterable(enumerate(['body'])):
+ space.setattr(w_self, space.wrap(field), args_w[i])
+ for field, w_value in kwargs_w.iteritems():
+ space.setattr(w_self, space.wrap(field), w_value)
+Expression_init.unwrap_spec = [ObjSpace, W_Root, Arguments]
+
+Expression.typedef = typedef.TypeDef("Expression",
+ mod.typedef,
+ _fields=_FieldsWrapper(['body']),
+ body=typedef.GetSetProperty(Expression_get_body, Expression_set_body, cls=Expression),
+ __new__=interp2app(get_AST_new(Expression)),
+ __init__=interp2app(Expression_init),
+)
+Expression.typedef.acceptable_as_base_class = False
+
+def Suite_get_body(space, w_self):
+ if not w_self.initialization_state & 1:
+ w_err = space.wrap("attribute 'body' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ if w_self.w_body is None:
+ if w_self.body is None:
+ w_list = space.newlist([])
+ else:
+ list_w = [space.wrap(node) for node in w_self.body]
+ w_list = space.newlist(list_w)
+ w_self.w_body = w_list
+ return w_self.w_body
+
+def Suite_set_body(space, w_self, w_new_value):
+ w_self.w_body = w_new_value
+ w_self.initialization_state |= 1
+
+def Suite_init(space, w_self, args):
+ w_self = space.descr_self_interp_w(Suite, w_self)
+ w_self.w_body = None
+ args_w, kwargs_w = args.unpack()
+ if args_w:
+ if len(args_w) != 1:
+ w_err = space.wrap("Suite constructor takes 0 or 1 positional arguments")
+ raise OperationError(space.w_TypeError, w_err)
+ for i, field in unrolling_iterable(enumerate(['body'])):
+ space.setattr(w_self, space.wrap(field), args_w[i])
+ for field, w_value in kwargs_w.iteritems():
+ space.setattr(w_self, space.wrap(field), w_value)
+Suite_init.unwrap_spec = [ObjSpace, W_Root, Arguments]
+
+Suite.typedef = typedef.TypeDef("Suite",
+ mod.typedef,
+ _fields=_FieldsWrapper(['body']),
+ body=typedef.GetSetProperty(Suite_get_body, Suite_set_body, cls=Suite),
+ __new__=interp2app(get_AST_new(Suite)),
+ __init__=interp2app(Suite_init),
+)
+Suite.typedef.acceptable_as_base_class = False
+
+def stmt_get_lineno(space, w_self):
+ if not w_self.initialization_state & w_self._lineno_mask:
+ w_err = space.wrap("attribute 'lineno' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ return space.wrap(w_self.lineno)
+
+def stmt_set_lineno(space, w_self, w_new_value):
+ w_self.lineno = space.int_w(w_new_value)
+ w_self.initialization_state |= w_self._lineno_mask
+
+def stmt_get_col_offset(space, w_self):
+ if not w_self.initialization_state & w_self._col_offset_mask:
+ w_err = space.wrap("attribute 'col_offset' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ return space.wrap(w_self.col_offset)
+
+def stmt_set_col_offset(space, w_self, w_new_value):
+ w_self.col_offset = space.int_w(w_new_value)
+ w_self.initialization_state |= w_self._col_offset_mask
+
+stmt.typedef = typedef.TypeDef("stmt",
+ AST.typedef,
+ _attributes=_FieldsWrapper(['lineno', 'col_offset']),
+ lineno=typedef.GetSetProperty(stmt_get_lineno, stmt_set_lineno, cls=stmt),
+ col_offset=typedef.GetSetProperty(stmt_get_col_offset, stmt_set_col_offset, cls=stmt),
+)
+stmt.typedef.acceptable_as_base_class = False
+
+def FunctionDef_get_name(space, w_self):
+ if not w_self.initialization_state & 1:
+ w_err = space.wrap("attribute 'name' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ return space.wrap(w_self.name)
+
+def FunctionDef_set_name(space, w_self, w_new_value):
+ w_self.name = space.str_w(w_new_value)
+ w_self.initialization_state |= 1
+
+def FunctionDef_get_args(space, w_self):
+ if not w_self.initialization_state & 2:
+ w_err = space.wrap("attribute 'args' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ return space.wrap(w_self.args)
+
+def FunctionDef_set_args(space, w_self, w_new_value):
+ w_self.args = space.interp_w(arguments, w_new_value, False)
+ w_self.initialization_state |= 2
+
+def FunctionDef_get_body(space, w_self):
+ if not w_self.initialization_state & 4:
+ w_err = space.wrap("attribute 'body' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ if w_self.w_body is None:
+ if w_self.body is None:
+ w_list = space.newlist([])
+ else:
+ list_w = [space.wrap(node) for node in w_self.body]
+ w_list = space.newlist(list_w)
+ w_self.w_body = w_list
+ return w_self.w_body
+
+def FunctionDef_set_body(space, w_self, w_new_value):
+ w_self.w_body = w_new_value
+ w_self.initialization_state |= 4
+
+def FunctionDef_get_decorators(space, w_self):
+ if not w_self.initialization_state & 8:
+ w_err = space.wrap("attribute 'decorators' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ if w_self.w_decorators is None:
+ if w_self.decorators is None:
+ w_list = space.newlist([])
+ else:
+ list_w = [space.wrap(node) for node in w_self.decorators]
+ w_list = space.newlist(list_w)
+ w_self.w_decorators = w_list
+ return w_self.w_decorators
+
+def FunctionDef_set_decorators(space, w_self, w_new_value):
+ w_self.w_decorators = w_new_value
+ w_self.initialization_state |= 8
+
+def FunctionDef_init(space, w_self, args):
+ w_self = space.descr_self_interp_w(FunctionDef, w_self)
+ w_self.w_body = None
+ w_self.w_decorators = None
+ args_w, kwargs_w = args.unpack()
+ if args_w:
+ if len(args_w) != 6:
+ w_err = space.wrap("FunctionDef constructor takes 0 or 6 positional arguments")
+ raise OperationError(space.w_TypeError, w_err)
+ for i, field in unrolling_iterable(enumerate(['name', 'args', 'body', 'decorators', 'lineno', 'col_offset'])):
+ space.setattr(w_self, space.wrap(field), args_w[i])
+ for field, w_value in kwargs_w.iteritems():
+ space.setattr(w_self, space.wrap(field), w_value)
+FunctionDef_init.unwrap_spec = [ObjSpace, W_Root, Arguments]
+
+FunctionDef.typedef = typedef.TypeDef("FunctionDef",
+ stmt.typedef,
+ _fields=_FieldsWrapper(['name', 'args', 'body', 'decorators']),
+ name=typedef.GetSetProperty(FunctionDef_get_name, FunctionDef_set_name, cls=FunctionDef),
+ args=typedef.GetSetProperty(FunctionDef_get_args, FunctionDef_set_args, cls=FunctionDef),
+ body=typedef.GetSetProperty(FunctionDef_get_body, FunctionDef_set_body, cls=FunctionDef),
+ decorators=typedef.GetSetProperty(FunctionDef_get_decorators, FunctionDef_set_decorators, cls=FunctionDef),
+ __new__=interp2app(get_AST_new(FunctionDef)),
+ __init__=interp2app(FunctionDef_init),
+)
+FunctionDef.typedef.acceptable_as_base_class = False
+
+def ClassDef_get_name(space, w_self):
+ if not w_self.initialization_state & 1:
+ w_err = space.wrap("attribute 'name' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ return space.wrap(w_self.name)
+
+def ClassDef_set_name(space, w_self, w_new_value):
+ w_self.name = space.str_w(w_new_value)
+ w_self.initialization_state |= 1
+
+def ClassDef_get_bases(space, w_self):
+ if not w_self.initialization_state & 2:
+ w_err = space.wrap("attribute 'bases' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ if w_self.w_bases is None:
+ if w_self.bases is None:
+ w_list = space.newlist([])
+ else:
+ list_w = [space.wrap(node) for node in w_self.bases]
+ w_list = space.newlist(list_w)
+ w_self.w_bases = w_list
+ return w_self.w_bases
+
+def ClassDef_set_bases(space, w_self, w_new_value):
+ w_self.w_bases = w_new_value
+ w_self.initialization_state |= 2
+
+def ClassDef_get_body(space, w_self):
+ if not w_self.initialization_state & 4:
+ w_err = space.wrap("attribute 'body' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ if w_self.w_body is None:
+ if w_self.body is None:
+ w_list = space.newlist([])
+ else:
+ list_w = [space.wrap(node) for node in w_self.body]
+ w_list = space.newlist(list_w)
+ w_self.w_body = w_list
+ return w_self.w_body
+
+def ClassDef_set_body(space, w_self, w_new_value):
+ w_self.w_body = w_new_value
+ w_self.initialization_state |= 4
+
+def ClassDef_init(space, w_self, args):
+ w_self = space.descr_self_interp_w(ClassDef, w_self)
+ w_self.w_bases = None
+ w_self.w_body = None
+ args_w, kwargs_w = args.unpack()
+ if args_w:
+ if len(args_w) != 5:
+ w_err = space.wrap("ClassDef constructor takes 0 or 5 positional arguments")
+ raise OperationError(space.w_TypeError, w_err)
+ for i, field in unrolling_iterable(enumerate(['name', 'bases', 'body', 'lineno', 'col_offset'])):
+ space.setattr(w_self, space.wrap(field), args_w[i])
+ for field, w_value in kwargs_w.iteritems():
+ space.setattr(w_self, space.wrap(field), w_value)
+ClassDef_init.unwrap_spec = [ObjSpace, W_Root, Arguments]
+
+ClassDef.typedef = typedef.TypeDef("ClassDef",
+ stmt.typedef,
+ _fields=_FieldsWrapper(['name', 'bases', 'body']),
+ name=typedef.GetSetProperty(ClassDef_get_name, ClassDef_set_name, cls=ClassDef),
+ bases=typedef.GetSetProperty(ClassDef_get_bases, ClassDef_set_bases, cls=ClassDef),
+ body=typedef.GetSetProperty(ClassDef_get_body, ClassDef_set_body, cls=ClassDef),
+ __new__=interp2app(get_AST_new(ClassDef)),
+ __init__=interp2app(ClassDef_init),
+)
+ClassDef.typedef.acceptable_as_base_class = False
+
+def Return_get_value(space, w_self):
+ if not w_self.initialization_state & 1:
+ w_err = space.wrap("attribute 'value' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ return space.wrap(w_self.value)
+
+def Return_set_value(space, w_self, w_new_value):
+ w_self.value = space.interp_w(expr, w_new_value, True)
+ w_self.initialization_state |= 1
+
+def Return_init(space, w_self, args):
+ w_self = space.descr_self_interp_w(Return, w_self)
+ args_w, kwargs_w = args.unpack()
+ if args_w:
+ if len(args_w) != 3:
+ w_err = space.wrap("Return constructor takes 0 or 3 positional arguments")
+ raise OperationError(space.w_TypeError, w_err)
+ for i, field in unrolling_iterable(enumerate(['value', 'lineno', 'col_offset'])):
+ space.setattr(w_self, space.wrap(field), args_w[i])
+ for field, w_value in kwargs_w.iteritems():
+ space.setattr(w_self, space.wrap(field), w_value)
+Return_init.unwrap_spec = [ObjSpace, W_Root, Arguments]
+
+Return.typedef = typedef.TypeDef("Return",
+ stmt.typedef,
+ _fields=_FieldsWrapper(['value']),
+ value=typedef.GetSetProperty(Return_get_value, Return_set_value, cls=Return),
+ __new__=interp2app(get_AST_new(Return)),
+ __init__=interp2app(Return_init),
+)
+Return.typedef.acceptable_as_base_class = False
+
+def Delete_get_targets(space, w_self):
+ if not w_self.initialization_state & 1:
+ w_err = space.wrap("attribute 'targets' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ if w_self.w_targets is None:
+ if w_self.targets is None:
+ w_list = space.newlist([])
+ else:
+ list_w = [space.wrap(node) for node in w_self.targets]
+ w_list = space.newlist(list_w)
+ w_self.w_targets = w_list
+ return w_self.w_targets
+
+def Delete_set_targets(space, w_self, w_new_value):
+ w_self.w_targets = w_new_value
+ w_self.initialization_state |= 1
+
+def Delete_init(space, w_self, args):
+ w_self = space.descr_self_interp_w(Delete, w_self)
+ w_self.w_targets = None
+ args_w, kwargs_w = args.unpack()
+ if args_w:
+ if len(args_w) != 3:
+ w_err = space.wrap("Delete constructor takes 0 or 3 positional arguments")
+ raise OperationError(space.w_TypeError, w_err)
+ for i, field in unrolling_iterable(enumerate(['targets', 'lineno', 'col_offset'])):
+ space.setattr(w_self, space.wrap(field), args_w[i])
+ for field, w_value in kwargs_w.iteritems():
+ space.setattr(w_self, space.wrap(field), w_value)
+Delete_init.unwrap_spec = [ObjSpace, W_Root, Arguments]
+
+Delete.typedef = typedef.TypeDef("Delete",
+ stmt.typedef,
+ _fields=_FieldsWrapper(['targets']),
+ targets=typedef.GetSetProperty(Delete_get_targets, Delete_set_targets, cls=Delete),
+ __new__=interp2app(get_AST_new(Delete)),
+ __init__=interp2app(Delete_init),
+)
+Delete.typedef.acceptable_as_base_class = False
+
+def Assign_get_targets(space, w_self):
+ if not w_self.initialization_state & 1:
+ w_err = space.wrap("attribute 'targets' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ if w_self.w_targets is None:
+ if w_self.targets is None:
+ w_list = space.newlist([])
+ else:
+ list_w = [space.wrap(node) for node in w_self.targets]
+ w_list = space.newlist(list_w)
+ w_self.w_targets = w_list
+ return w_self.w_targets
+
+def Assign_set_targets(space, w_self, w_new_value):
+ w_self.w_targets = w_new_value
+ w_self.initialization_state |= 1
+
+def Assign_get_value(space, w_self):
+ if not w_self.initialization_state & 2:
+ w_err = space.wrap("attribute 'value' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ return space.wrap(w_self.value)
+
+def Assign_set_value(space, w_self, w_new_value):
+ w_self.value = space.interp_w(expr, w_new_value, False)
+ w_self.initialization_state |= 2
+
+def Assign_init(space, w_self, args):
+ w_self = space.descr_self_interp_w(Assign, w_self)
+ w_self.w_targets = None
+ args_w, kwargs_w = args.unpack()
+ if args_w:
+ if len(args_w) != 4:
+ w_err = space.wrap("Assign constructor takes 0 or 4 positional arguments")
+ raise OperationError(space.w_TypeError, w_err)
+ for i, field in unrolling_iterable(enumerate(['targets', 'value', 'lineno', 'col_offset'])):
+ space.setattr(w_self, space.wrap(field), args_w[i])
+ for field, w_value in kwargs_w.iteritems():
+ space.setattr(w_self, space.wrap(field), w_value)
+Assign_init.unwrap_spec = [ObjSpace, W_Root, Arguments]
+
+Assign.typedef = typedef.TypeDef("Assign",
+ stmt.typedef,
+ _fields=_FieldsWrapper(['targets', 'value']),
+ targets=typedef.GetSetProperty(Assign_get_targets, Assign_set_targets, cls=Assign),
+ value=typedef.GetSetProperty(Assign_get_value, Assign_set_value, cls=Assign),
+ __new__=interp2app(get_AST_new(Assign)),
+ __init__=interp2app(Assign_init),
+)
+Assign.typedef.acceptable_as_base_class = False
+
+def AugAssign_get_target(space, w_self):
+ if not w_self.initialization_state & 1:
+ w_err = space.wrap("attribute 'target' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ return space.wrap(w_self.target)
+
+def AugAssign_set_target(space, w_self, w_new_value):
+ w_self.target = space.interp_w(expr, w_new_value, False)
+ w_self.initialization_state |= 1
+
+def AugAssign_get_op(space, w_self):
+ if not w_self.initialization_state & 2:
+ w_err = space.wrap("attribute 'op' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ return operator_to_class[w_self.op - 1]()
+
+def AugAssign_set_op(space, w_self, w_new_value):
+ obj = space.interp_w(operator, w_new_value)
+ w_self.op = obj.to_simple_int()
+ w_self.initialization_state |= 2
+
+def AugAssign_get_value(space, w_self):
+ if not w_self.initialization_state & 4:
+ w_err = space.wrap("attribute 'value' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ return space.wrap(w_self.value)
+
+def AugAssign_set_value(space, w_self, w_new_value):
+ w_self.value = space.interp_w(expr, w_new_value, False)
+ w_self.initialization_state |= 4
+
+def AugAssign_init(space, w_self, args):
+ w_self = space.descr_self_interp_w(AugAssign, w_self)
+ args_w, kwargs_w = args.unpack()
+ if args_w:
+ if len(args_w) != 5:
+ w_err = space.wrap("AugAssign constructor takes 0 or 5 positional arguments")
+ raise OperationError(space.w_TypeError, w_err)
+ for i, field in unrolling_iterable(enumerate(['target', 'op', 'value', 'lineno', 'col_offset'])):
+ space.setattr(w_self, space.wrap(field), args_w[i])
+ for field, w_value in kwargs_w.iteritems():
+ space.setattr(w_self, space.wrap(field), w_value)
+AugAssign_init.unwrap_spec = [ObjSpace, W_Root, Arguments]
+
+AugAssign.typedef = typedef.TypeDef("AugAssign",
+ stmt.typedef,
+ _fields=_FieldsWrapper(['target', 'op', 'value']),
+ target=typedef.GetSetProperty(AugAssign_get_target, AugAssign_set_target, cls=AugAssign),
+ op=typedef.GetSetProperty(AugAssign_get_op, AugAssign_set_op, cls=AugAssign),
+ value=typedef.GetSetProperty(AugAssign_get_value, AugAssign_set_value, cls=AugAssign),
+ __new__=interp2app(get_AST_new(AugAssign)),
+ __init__=interp2app(AugAssign_init),
+)
+AugAssign.typedef.acceptable_as_base_class = False
+
+def Print_get_dest(space, w_self):
+ if not w_self.initialization_state & 1:
+ w_err = space.wrap("attribute 'dest' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ return space.wrap(w_self.dest)
+
+def Print_set_dest(space, w_self, w_new_value):
+ w_self.dest = space.interp_w(expr, w_new_value, True)
+ w_self.initialization_state |= 1
+
+def Print_get_values(space, w_self):
+ if not w_self.initialization_state & 2:
+ w_err = space.wrap("attribute 'values' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ if w_self.w_values is None:
+ if w_self.values is None:
+ w_list = space.newlist([])
+ else:
+ list_w = [space.wrap(node) for node in w_self.values]
+ w_list = space.newlist(list_w)
+ w_self.w_values = w_list
+ return w_self.w_values
+
+def Print_set_values(space, w_self, w_new_value):
+ w_self.w_values = w_new_value
+ w_self.initialization_state |= 2
+
+def Print_get_nl(space, w_self):
+ if not w_self.initialization_state & 4:
+ w_err = space.wrap("attribute 'nl' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ return space.wrap(w_self.nl)
+
+def Print_set_nl(space, w_self, w_new_value):
+ w_self.nl = space.bool_w(w_new_value)
+ w_self.initialization_state |= 4
+
+def Print_init(space, w_self, args):
+ w_self = space.descr_self_interp_w(Print, w_self)
+ w_self.w_values = None
+ args_w, kwargs_w = args.unpack()
+ if args_w:
+ if len(args_w) != 5:
+ w_err = space.wrap("Print constructor takes 0 or 5 positional arguments")
+ raise OperationError(space.w_TypeError, w_err)
+ for i, field in unrolling_iterable(enumerate(['dest', 'values', 'nl', 'lineno', 'col_offset'])):
+ space.setattr(w_self, space.wrap(field), args_w[i])
+ for field, w_value in kwargs_w.iteritems():
+ space.setattr(w_self, space.wrap(field), w_value)
+Print_init.unwrap_spec = [ObjSpace, W_Root, Arguments]
+
+Print.typedef = typedef.TypeDef("Print",
+ stmt.typedef,
+ _fields=_FieldsWrapper(['dest', 'values', 'nl']),
+ dest=typedef.GetSetProperty(Print_get_dest, Print_set_dest, cls=Print),
+ values=typedef.GetSetProperty(Print_get_values, Print_set_values, cls=Print),
+ nl=typedef.GetSetProperty(Print_get_nl, Print_set_nl, cls=Print),
+ __new__=interp2app(get_AST_new(Print)),
+ __init__=interp2app(Print_init),
+)
+Print.typedef.acceptable_as_base_class = False
+
+def For_get_target(space, w_self):
+ if not w_self.initialization_state & 1:
+ w_err = space.wrap("attribute 'target' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ return space.wrap(w_self.target)
+
+def For_set_target(space, w_self, w_new_value):
+ w_self.target = space.interp_w(expr, w_new_value, False)
+ w_self.initialization_state |= 1
+
+def For_get_iter(space, w_self):
+ if not w_self.initialization_state & 2:
+ w_err = space.wrap("attribute 'iter' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ return space.wrap(w_self.iter)
+
+def For_set_iter(space, w_self, w_new_value):
+ w_self.iter = space.interp_w(expr, w_new_value, False)
+ w_self.initialization_state |= 2
+
+def For_get_body(space, w_self):
+ if not w_self.initialization_state & 4:
+ w_err = space.wrap("attribute 'body' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ if w_self.w_body is None:
+ if w_self.body is None:
+ w_list = space.newlist([])
+ else:
+ list_w = [space.wrap(node) for node in w_self.body]
+ w_list = space.newlist(list_w)
+ w_self.w_body = w_list
+ return w_self.w_body
+
+def For_set_body(space, w_self, w_new_value):
+ w_self.w_body = w_new_value
+ w_self.initialization_state |= 4
+
+def For_get_orelse(space, w_self):
+ if not w_self.initialization_state & 8:
+ w_err = space.wrap("attribute 'orelse' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ if w_self.w_orelse is None:
+ if w_self.orelse is None:
+ w_list = space.newlist([])
+ else:
+ list_w = [space.wrap(node) for node in w_self.orelse]
+ w_list = space.newlist(list_w)
+ w_self.w_orelse = w_list
+ return w_self.w_orelse
+
+def For_set_orelse(space, w_self, w_new_value):
+ w_self.w_orelse = w_new_value
+ w_self.initialization_state |= 8
+
+def For_init(space, w_self, args):
+ w_self = space.descr_self_interp_w(For, w_self)
+ w_self.w_body = None
+ w_self.w_orelse = None
+ args_w, kwargs_w = args.unpack()
+ if args_w:
+ if len(args_w) != 6:
+ w_err = space.wrap("For constructor takes 0 or 6 positional arguments")
+ raise OperationError(space.w_TypeError, w_err)
+ for i, field in unrolling_iterable(enumerate(['target', 'iter', 'body', 'orelse', 'lineno', 'col_offset'])):
+ space.setattr(w_self, space.wrap(field), args_w[i])
+ for field, w_value in kwargs_w.iteritems():
+ space.setattr(w_self, space.wrap(field), w_value)
+For_init.unwrap_spec = [ObjSpace, W_Root, Arguments]
+
+For.typedef = typedef.TypeDef("For",
+ stmt.typedef,
+ _fields=_FieldsWrapper(['target', 'iter', 'body', 'orelse']),
+ target=typedef.GetSetProperty(For_get_target, For_set_target, cls=For),
+ iter=typedef.GetSetProperty(For_get_iter, For_set_iter, cls=For),
+ body=typedef.GetSetProperty(For_get_body, For_set_body, cls=For),
+ orelse=typedef.GetSetProperty(For_get_orelse, For_set_orelse, cls=For),
+ __new__=interp2app(get_AST_new(For)),
+ __init__=interp2app(For_init),
+)
+For.typedef.acceptable_as_base_class = False
+
+def While_get_test(space, w_self):
+ if not w_self.initialization_state & 1:
+ w_err = space.wrap("attribute 'test' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ return space.wrap(w_self.test)
+
+def While_set_test(space, w_self, w_new_value):
+ w_self.test = space.interp_w(expr, w_new_value, False)
+ w_self.initialization_state |= 1
+
+def While_get_body(space, w_self):
+ if not w_self.initialization_state & 2:
+ w_err = space.wrap("attribute 'body' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ if w_self.w_body is None:
+ if w_self.body is None:
+ w_list = space.newlist([])
+ else:
+ list_w = [space.wrap(node) for node in w_self.body]
+ w_list = space.newlist(list_w)
+ w_self.w_body = w_list
+ return w_self.w_body
+
+def While_set_body(space, w_self, w_new_value):
+ w_self.w_body = w_new_value
+ w_self.initialization_state |= 2
+
+def While_get_orelse(space, w_self):
+ if not w_self.initialization_state & 4:
+ w_err = space.wrap("attribute 'orelse' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ if w_self.w_orelse is None:
+ if w_self.orelse is None:
+ w_list = space.newlist([])
+ else:
+ list_w = [space.wrap(node) for node in w_self.orelse]
+ w_list = space.newlist(list_w)
+ w_self.w_orelse = w_list
+ return w_self.w_orelse
+
+def While_set_orelse(space, w_self, w_new_value):
+ w_self.w_orelse = w_new_value
+ w_self.initialization_state |= 4
+
+def While_init(space, w_self, args):
+ w_self = space.descr_self_interp_w(While, w_self)
+ w_self.w_body = None
+ w_self.w_orelse = None
+ args_w, kwargs_w = args.unpack()
+ if args_w:
+ if len(args_w) != 5:
+ w_err = space.wrap("While constructor takes 0 or 5 positional arguments")
+ raise OperationError(space.w_TypeError, w_err)
+ for i, field in unrolling_iterable(enumerate(['test', 'body', 'orelse', 'lineno', 'col_offset'])):
+ space.setattr(w_self, space.wrap(field), args_w[i])
+ for field, w_value in kwargs_w.iteritems():
+ space.setattr(w_self, space.wrap(field), w_value)
+While_init.unwrap_spec = [ObjSpace, W_Root, Arguments]
+
+While.typedef = typedef.TypeDef("While",
+ stmt.typedef,
+ _fields=_FieldsWrapper(['test', 'body', 'orelse']),
+ test=typedef.GetSetProperty(While_get_test, While_set_test, cls=While),
+ body=typedef.GetSetProperty(While_get_body, While_set_body, cls=While),
+ orelse=typedef.GetSetProperty(While_get_orelse, While_set_orelse, cls=While),
+ __new__=interp2app(get_AST_new(While)),
+ __init__=interp2app(While_init),
+)
+While.typedef.acceptable_as_base_class = False
+
+def If_get_test(space, w_self):
+ if not w_self.initialization_state & 1:
+ w_err = space.wrap("attribute 'test' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ return space.wrap(w_self.test)
+
+def If_set_test(space, w_self, w_new_value):
+ w_self.test = space.interp_w(expr, w_new_value, False)
+ w_self.initialization_state |= 1
+
+def If_get_body(space, w_self):
+ if not w_self.initialization_state & 2:
+ w_err = space.wrap("attribute 'body' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ if w_self.w_body is None:
+ if w_self.body is None:
+ w_list = space.newlist([])
+ else:
+ list_w = [space.wrap(node) for node in w_self.body]
+ w_list = space.newlist(list_w)
+ w_self.w_body = w_list
+ return w_self.w_body
+
+def If_set_body(space, w_self, w_new_value):
+ w_self.w_body = w_new_value
+ w_self.initialization_state |= 2
+
+def If_get_orelse(space, w_self):
+ if not w_self.initialization_state & 4:
+ w_err = space.wrap("attribute 'orelse' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ if w_self.w_orelse is None:
+ if w_self.orelse is None:
+ w_list = space.newlist([])
+ else:
+ list_w = [space.wrap(node) for node in w_self.orelse]
+ w_list = space.newlist(list_w)
+ w_self.w_orelse = w_list
+ return w_self.w_orelse
+
+def If_set_orelse(space, w_self, w_new_value):
+ w_self.w_orelse = w_new_value
+ w_self.initialization_state |= 4
+
+def If_init(space, w_self, args):
+ w_self = space.descr_self_interp_w(If, w_self)
+ w_self.w_body = None
+ w_self.w_orelse = None
+ args_w, kwargs_w = args.unpack()
+ if args_w:
+ if len(args_w) != 5:
+ w_err = space.wrap("If constructor takes 0 or 5 positional arguments")
+ raise OperationError(space.w_TypeError, w_err)
+ for i, field in unrolling_iterable(enumerate(['test', 'body', 'orelse', 'lineno', 'col_offset'])):
+ space.setattr(w_self, space.wrap(field), args_w[i])
+ for field, w_value in kwargs_w.iteritems():
+ space.setattr(w_self, space.wrap(field), w_value)
+If_init.unwrap_spec = [ObjSpace, W_Root, Arguments]
+
+If.typedef = typedef.TypeDef("If",
+ stmt.typedef,
+ _fields=_FieldsWrapper(['test', 'body', 'orelse']),
+ test=typedef.GetSetProperty(If_get_test, If_set_test, cls=If),
+ body=typedef.GetSetProperty(If_get_body, If_set_body, cls=If),
+ orelse=typedef.GetSetProperty(If_get_orelse, If_set_orelse, cls=If),
+ __new__=interp2app(get_AST_new(If)),
+ __init__=interp2app(If_init),
+)
+If.typedef.acceptable_as_base_class = False
+
+def With_get_context_expr(space, w_self):
+ if not w_self.initialization_state & 1:
+ w_err = space.wrap("attribute 'context_expr' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ return space.wrap(w_self.context_expr)
+
+def With_set_context_expr(space, w_self, w_new_value):
+ w_self.context_expr = space.interp_w(expr, w_new_value, False)
+ w_self.initialization_state |= 1
+
+def With_get_optional_vars(space, w_self):
+ if not w_self.initialization_state & 2:
+ w_err = space.wrap("attribute 'optional_vars' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ return space.wrap(w_self.optional_vars)
+
+def With_set_optional_vars(space, w_self, w_new_value):
+ w_self.optional_vars = space.interp_w(expr, w_new_value, True)
+ w_self.initialization_state |= 2
+
+def With_get_body(space, w_self):
+ if not w_self.initialization_state & 4:
+ w_err = space.wrap("attribute 'body' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ if w_self.w_body is None:
+ if w_self.body is None:
+ w_list = space.newlist([])
+ else:
+ list_w = [space.wrap(node) for node in w_self.body]
+ w_list = space.newlist(list_w)
+ w_self.w_body = w_list
+ return w_self.w_body
+
+def With_set_body(space, w_self, w_new_value):
+ w_self.w_body = w_new_value
+ w_self.initialization_state |= 4
+
+def With_init(space, w_self, args):
+ w_self = space.descr_self_interp_w(With, w_self)
+ w_self.w_body = None
+ args_w, kwargs_w = args.unpack()
+ if args_w:
+ if len(args_w) != 5:
+ w_err = space.wrap("With constructor takes 0 or 5 positional arguments")
+ raise OperationError(space.w_TypeError, w_err)
+ for i, field in unrolling_iterable(enumerate(['context_expr', 'optional_vars', 'body', 'lineno', 'col_offset'])):
+ space.setattr(w_self, space.wrap(field), args_w[i])
+ for field, w_value in kwargs_w.iteritems():
+ space.setattr(w_self, space.wrap(field), w_value)
+With_init.unwrap_spec = [ObjSpace, W_Root, Arguments]
+
+With.typedef = typedef.TypeDef("With",
+ stmt.typedef,
+ _fields=_FieldsWrapper(['context_expr', 'optional_vars', 'body']),
+ context_expr=typedef.GetSetProperty(With_get_context_expr, With_set_context_expr, cls=With),
+ optional_vars=typedef.GetSetProperty(With_get_optional_vars, With_set_optional_vars, cls=With),
+ body=typedef.GetSetProperty(With_get_body, With_set_body, cls=With),
+ __new__=interp2app(get_AST_new(With)),
+ __init__=interp2app(With_init),
+)
+With.typedef.acceptable_as_base_class = False
+
+def Raise_get_type(space, w_self):
+ if not w_self.initialization_state & 1:
+ w_err = space.wrap("attribute 'type' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ return space.wrap(w_self.type)
+
+def Raise_set_type(space, w_self, w_new_value):
+ w_self.type = space.interp_w(expr, w_new_value, True)
+ w_self.initialization_state |= 1
+
+def Raise_get_inst(space, w_self):
+ if not w_self.initialization_state & 2:
+ w_err = space.wrap("attribute 'inst' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ return space.wrap(w_self.inst)
+
+def Raise_set_inst(space, w_self, w_new_value):
+ w_self.inst = space.interp_w(expr, w_new_value, True)
+ w_self.initialization_state |= 2
+
+def Raise_get_tback(space, w_self):
+ if not w_self.initialization_state & 4:
+ w_err = space.wrap("attribute 'tback' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ return space.wrap(w_self.tback)
+
+def Raise_set_tback(space, w_self, w_new_value):
+ w_self.tback = space.interp_w(expr, w_new_value, True)
+ w_self.initialization_state |= 4
+
+def Raise_init(space, w_self, args):
+ w_self = space.descr_self_interp_w(Raise, w_self)
+ args_w, kwargs_w = args.unpack()
+ if args_w:
+ if len(args_w) != 5:
+ w_err = space.wrap("Raise constructor takes 0 or 5 positional arguments")
+ raise OperationError(space.w_TypeError, w_err)
+ for i, field in unrolling_iterable(enumerate(['type', 'inst', 'tback', 'lineno', 'col_offset'])):
+ space.setattr(w_self, space.wrap(field), args_w[i])
+ for field, w_value in kwargs_w.iteritems():
+ space.setattr(w_self, space.wrap(field), w_value)
+Raise_init.unwrap_spec = [ObjSpace, W_Root, Arguments]
+
+Raise.typedef = typedef.TypeDef("Raise",
+ stmt.typedef,
+ _fields=_FieldsWrapper(['type', 'inst', 'tback']),
+ type=typedef.GetSetProperty(Raise_get_type, Raise_set_type, cls=Raise),
+ inst=typedef.GetSetProperty(Raise_get_inst, Raise_set_inst, cls=Raise),
+ tback=typedef.GetSetProperty(Raise_get_tback, Raise_set_tback, cls=Raise),
+ __new__=interp2app(get_AST_new(Raise)),
+ __init__=interp2app(Raise_init),
+)
+Raise.typedef.acceptable_as_base_class = False
+
+def TryExcept_get_body(space, w_self):
+ if not w_self.initialization_state & 1:
+ w_err = space.wrap("attribute 'body' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ if w_self.w_body is None:
+ if w_self.body is None:
+ w_list = space.newlist([])
+ else:
+ list_w = [space.wrap(node) for node in w_self.body]
+ w_list = space.newlist(list_w)
+ w_self.w_body = w_list
+ return w_self.w_body
+
+def TryExcept_set_body(space, w_self, w_new_value):
+ w_self.w_body = w_new_value
+ w_self.initialization_state |= 1
+
+def TryExcept_get_handlers(space, w_self):
+ if not w_self.initialization_state & 2:
+ w_err = space.wrap("attribute 'handlers' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ if w_self.w_handlers is None:
+ if w_self.handlers is None:
+ w_list = space.newlist([])
+ else:
+ list_w = [space.wrap(node) for node in w_self.handlers]
+ w_list = space.newlist(list_w)
+ w_self.w_handlers = w_list
+ return w_self.w_handlers
+
+def TryExcept_set_handlers(space, w_self, w_new_value):
+ w_self.w_handlers = w_new_value
+ w_self.initialization_state |= 2
+
+def TryExcept_get_orelse(space, w_self):
+ if not w_self.initialization_state & 4:
+ w_err = space.wrap("attribute 'orelse' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ if w_self.w_orelse is None:
+ if w_self.orelse is None:
+ w_list = space.newlist([])
+ else:
+ list_w = [space.wrap(node) for node in w_self.orelse]
+ w_list = space.newlist(list_w)
+ w_self.w_orelse = w_list
+ return w_self.w_orelse
+
+def TryExcept_set_orelse(space, w_self, w_new_value):
+ w_self.w_orelse = w_new_value
+ w_self.initialization_state |= 4
+
+def TryExcept_init(space, w_self, args):
+ w_self = space.descr_self_interp_w(TryExcept, w_self)
+ w_self.w_body = None
+ w_self.w_handlers = None
+ w_self.w_orelse = None
+ args_w, kwargs_w = args.unpack()
+ if args_w:
+ if len(args_w) != 5:
+ w_err = space.wrap("TryExcept constructor takes 0 or 5 positional arguments")
+ raise OperationError(space.w_TypeError, w_err)
+ for i, field in unrolling_iterable(enumerate(['body', 'handlers', 'orelse', 'lineno', 'col_offset'])):
+ space.setattr(w_self, space.wrap(field), args_w[i])
+ for field, w_value in kwargs_w.iteritems():
+ space.setattr(w_self, space.wrap(field), w_value)
+TryExcept_init.unwrap_spec = [ObjSpace, W_Root, Arguments]
+
+TryExcept.typedef = typedef.TypeDef("TryExcept",
+ stmt.typedef,
+ _fields=_FieldsWrapper(['body', 'handlers', 'orelse']),
+ body=typedef.GetSetProperty(TryExcept_get_body, TryExcept_set_body, cls=TryExcept),
+ handlers=typedef.GetSetProperty(TryExcept_get_handlers, TryExcept_set_handlers, cls=TryExcept),
+ orelse=typedef.GetSetProperty(TryExcept_get_orelse, TryExcept_set_orelse, cls=TryExcept),
+ __new__=interp2app(get_AST_new(TryExcept)),
+ __init__=interp2app(TryExcept_init),
+)
+TryExcept.typedef.acceptable_as_base_class = False
+
+def TryFinally_get_body(space, w_self):
+ if not w_self.initialization_state & 1:
+ w_err = space.wrap("attribute 'body' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ if w_self.w_body is None:
+ if w_self.body is None:
+ w_list = space.newlist([])
+ else:
+ list_w = [space.wrap(node) for node in w_self.body]
+ w_list = space.newlist(list_w)
+ w_self.w_body = w_list
+ return w_self.w_body
+
+def TryFinally_set_body(space, w_self, w_new_value):
+ w_self.w_body = w_new_value
+ w_self.initialization_state |= 1
+
+def TryFinally_get_finalbody(space, w_self):
+ if not w_self.initialization_state & 2:
+ w_err = space.wrap("attribute 'finalbody' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ if w_self.w_finalbody is None:
+ if w_self.finalbody is None:
+ w_list = space.newlist([])
+ else:
+ list_w = [space.wrap(node) for node in w_self.finalbody]
+ w_list = space.newlist(list_w)
+ w_self.w_finalbody = w_list
+ return w_self.w_finalbody
+
+def TryFinally_set_finalbody(space, w_self, w_new_value):
+ w_self.w_finalbody = w_new_value
+ w_self.initialization_state |= 2
+
+def TryFinally_init(space, w_self, args):
+ w_self = space.descr_self_interp_w(TryFinally, w_self)
+ w_self.w_body = None
+ w_self.w_finalbody = None
+ args_w, kwargs_w = args.unpack()
+ if args_w:
+ if len(args_w) != 4:
+ w_err = space.wrap("TryFinally constructor takes 0 or 4 positional arguments")
+ raise OperationError(space.w_TypeError, w_err)
+ for i, field in unrolling_iterable(enumerate(['body', 'finalbody', 'lineno', 'col_offset'])):
+ space.setattr(w_self, space.wrap(field), args_w[i])
+ for field, w_value in kwargs_w.iteritems():
+ space.setattr(w_self, space.wrap(field), w_value)
+TryFinally_init.unwrap_spec = [ObjSpace, W_Root, Arguments]
+
+TryFinally.typedef = typedef.TypeDef("TryFinally",
+ stmt.typedef,
+ _fields=_FieldsWrapper(['body', 'finalbody']),
+ body=typedef.GetSetProperty(TryFinally_get_body, TryFinally_set_body, cls=TryFinally),
+ finalbody=typedef.GetSetProperty(TryFinally_get_finalbody, TryFinally_set_finalbody, cls=TryFinally),
+ __new__=interp2app(get_AST_new(TryFinally)),
+ __init__=interp2app(TryFinally_init),
+)
+TryFinally.typedef.acceptable_as_base_class = False
+
+def Assert_get_test(space, w_self):
+ if not w_self.initialization_state & 1:
+ w_err = space.wrap("attribute 'test' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ return space.wrap(w_self.test)
+
+def Assert_set_test(space, w_self, w_new_value):
+ w_self.test = space.interp_w(expr, w_new_value, False)
+ w_self.initialization_state |= 1
+
+def Assert_get_msg(space, w_self):
+ if not w_self.initialization_state & 2:
+ w_err = space.wrap("attribute 'msg' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ return space.wrap(w_self.msg)
+
+def Assert_set_msg(space, w_self, w_new_value):
+ w_self.msg = space.interp_w(expr, w_new_value, True)
+ w_self.initialization_state |= 2
+
+def Assert_init(space, w_self, args):
+ w_self = space.descr_self_interp_w(Assert, w_self)
+ args_w, kwargs_w = args.unpack()
+ if args_w:
+ if len(args_w) != 4:
+ w_err = space.wrap("Assert constructor takes 0 or 4 positional arguments")
+ raise OperationError(space.w_TypeError, w_err)
+ for i, field in unrolling_iterable(enumerate(['test', 'msg', 'lineno', 'col_offset'])):
+ space.setattr(w_self, space.wrap(field), args_w[i])
+ for field, w_value in kwargs_w.iteritems():
+ space.setattr(w_self, space.wrap(field), w_value)
+Assert_init.unwrap_spec = [ObjSpace, W_Root, Arguments]
+
+Assert.typedef = typedef.TypeDef("Assert",
+ stmt.typedef,
+ _fields=_FieldsWrapper(['test', 'msg']),
+ test=typedef.GetSetProperty(Assert_get_test, Assert_set_test, cls=Assert),
+ msg=typedef.GetSetProperty(Assert_get_msg, Assert_set_msg, cls=Assert),
+ __new__=interp2app(get_AST_new(Assert)),
+ __init__=interp2app(Assert_init),
+)
+Assert.typedef.acceptable_as_base_class = False
+
+def Import_get_names(space, w_self):
+ if not w_self.initialization_state & 1:
+ w_err = space.wrap("attribute 'names' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ if w_self.w_names is None:
+ if w_self.names is None:
+ w_list = space.newlist([])
+ else:
+ list_w = [space.wrap(node) for node in w_self.names]
+ w_list = space.newlist(list_w)
+ w_self.w_names = w_list
+ return w_self.w_names
+
+def Import_set_names(space, w_self, w_new_value):
+ w_self.w_names = w_new_value
+ w_self.initialization_state |= 1
+
+def Import_init(space, w_self, args):
+ w_self = space.descr_self_interp_w(Import, w_self)
+ w_self.w_names = None
+ args_w, kwargs_w = args.unpack()
+ if args_w:
+ if len(args_w) != 3:
+ w_err = space.wrap("Import constructor takes 0 or 3 positional arguments")
+ raise OperationError(space.w_TypeError, w_err)
+ for i, field in unrolling_iterable(enumerate(['names', 'lineno', 'col_offset'])):
+ space.setattr(w_self, space.wrap(field), args_w[i])
+ for field, w_value in kwargs_w.iteritems():
+ space.setattr(w_self, space.wrap(field), w_value)
+Import_init.unwrap_spec = [ObjSpace, W_Root, Arguments]
+
+Import.typedef = typedef.TypeDef("Import",
+ stmt.typedef,
+ _fields=_FieldsWrapper(['names']),
+ names=typedef.GetSetProperty(Import_get_names, Import_set_names, cls=Import),
+ __new__=interp2app(get_AST_new(Import)),
+ __init__=interp2app(Import_init),
+)
+Import.typedef.acceptable_as_base_class = False
+
+def ImportFrom_get_module(space, w_self):
+ if not w_self.initialization_state & 1:
+ w_err = space.wrap("attribute 'module' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ return space.wrap(w_self.module)
+
+def ImportFrom_set_module(space, w_self, w_new_value):
+ if space.is_w(w_new_value, space.w_None):
+ w_self.module = None
+ else:
+ w_self.module = space.str_w(w_new_value)
+ w_self.initialization_state |= 1
+
+def ImportFrom_get_names(space, w_self):
+ if not w_self.initialization_state & 2:
+ w_err = space.wrap("attribute 'names' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ if w_self.w_names is None:
+ if w_self.names is None:
+ w_list = space.newlist([])
+ else:
+ list_w = [space.wrap(node) for node in w_self.names]
+ w_list = space.newlist(list_w)
+ w_self.w_names = w_list
+ return w_self.w_names
+
+def ImportFrom_set_names(space, w_self, w_new_value):
+ w_self.w_names = w_new_value
+ w_self.initialization_state |= 2
+
+def ImportFrom_get_level(space, w_self):
+ if not w_self.initialization_state & 4:
+ w_err = space.wrap("attribute 'level' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ return space.wrap(w_self.level)
+
+def ImportFrom_set_level(space, w_self, w_new_value):
+ if space.is_w(w_new_value, space.w_None):
+ w_self.level = None
+ else:
+ w_self.level = space.int_w(w_new_value)
+ w_self.initialization_state |= 4
+
+def ImportFrom_init(space, w_self, args):
+ w_self = space.descr_self_interp_w(ImportFrom, w_self)
+ w_self.w_names = None
+ args_w, kwargs_w = args.unpack()
+ if args_w:
+ if len(args_w) != 5:
+ w_err = space.wrap("ImportFrom constructor takes 0 or 5 positional arguments")
+ raise OperationError(space.w_TypeError, w_err)
+ for i, field in unrolling_iterable(enumerate(['module', 'names', 'level', 'lineno', 'col_offset'])):
+ space.setattr(w_self, space.wrap(field), args_w[i])
+ for field, w_value in kwargs_w.iteritems():
+ space.setattr(w_self, space.wrap(field), w_value)
+ImportFrom_init.unwrap_spec = [ObjSpace, W_Root, Arguments]
+
+ImportFrom.typedef = typedef.TypeDef("ImportFrom",
+ stmt.typedef,
+ _fields=_FieldsWrapper(['module', 'names', 'level']),
+ module=typedef.GetSetProperty(ImportFrom_get_module, ImportFrom_set_module, cls=ImportFrom),
+ names=typedef.GetSetProperty(ImportFrom_get_names, ImportFrom_set_names, cls=ImportFrom),
+ level=typedef.GetSetProperty(ImportFrom_get_level, ImportFrom_set_level, cls=ImportFrom),
+ __new__=interp2app(get_AST_new(ImportFrom)),
+ __init__=interp2app(ImportFrom_init),
+)
+ImportFrom.typedef.acceptable_as_base_class = False
+
+def Exec_get_body(space, w_self):
+ if not w_self.initialization_state & 1:
+ w_err = space.wrap("attribute 'body' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ return space.wrap(w_self.body)
+
+def Exec_set_body(space, w_self, w_new_value):
+ w_self.body = space.interp_w(expr, w_new_value, False)
+ w_self.initialization_state |= 1
+
+def Exec_get_globals(space, w_self):
+ if not w_self.initialization_state & 2:
+ w_err = space.wrap("attribute 'globals' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ return space.wrap(w_self.globals)
+
+def Exec_set_globals(space, w_self, w_new_value):
+ w_self.globals = space.interp_w(expr, w_new_value, True)
+ w_self.initialization_state |= 2
+
+def Exec_get_locals(space, w_self):
+ if not w_self.initialization_state & 4:
+ w_err = space.wrap("attribute 'locals' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ return space.wrap(w_self.locals)
+
+def Exec_set_locals(space, w_self, w_new_value):
+ w_self.locals = space.interp_w(expr, w_new_value, True)
+ w_self.initialization_state |= 4
+
+def Exec_init(space, w_self, args):
+ w_self = space.descr_self_interp_w(Exec, w_self)
+ args_w, kwargs_w = args.unpack()
+ if args_w:
+ if len(args_w) != 5:
+ w_err = space.wrap("Exec constructor takes 0 or 5 positional arguments")
+ raise OperationError(space.w_TypeError, w_err)
+ for i, field in unrolling_iterable(enumerate(['body', 'globals', 'locals', 'lineno', 'col_offset'])):
+ space.setattr(w_self, space.wrap(field), args_w[i])
+ for field, w_value in kwargs_w.iteritems():
+ space.setattr(w_self, space.wrap(field), w_value)
+Exec_init.unwrap_spec = [ObjSpace, W_Root, Arguments]
+
+Exec.typedef = typedef.TypeDef("Exec",
+ stmt.typedef,
+ _fields=_FieldsWrapper(['body', 'globals', 'locals']),
+ body=typedef.GetSetProperty(Exec_get_body, Exec_set_body, cls=Exec),
+ globals=typedef.GetSetProperty(Exec_get_globals, Exec_set_globals, cls=Exec),
+ locals=typedef.GetSetProperty(Exec_get_locals, Exec_set_locals, cls=Exec),
+ __new__=interp2app(get_AST_new(Exec)),
+ __init__=interp2app(Exec_init),
+)
+Exec.typedef.acceptable_as_base_class = False
+
+def Global_get_names(space, w_self):
+ if not w_self.initialization_state & 1:
+ w_err = space.wrap("attribute 'names' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ if w_self.w_names is None:
+ if w_self.names is None:
+ w_list = space.newlist([])
+ else:
+ list_w = [space.wrap(node) for node in w_self.names]
+ w_list = space.newlist(list_w)
+ w_self.w_names = w_list
+ return w_self.w_names
+
+def Global_set_names(space, w_self, w_new_value):
+ w_self.w_names = w_new_value
+ w_self.initialization_state |= 1
+
+def Global_init(space, w_self, args):
+ w_self = space.descr_self_interp_w(Global, w_self)
+ w_self.w_names = None
+ args_w, kwargs_w = args.unpack()
+ if args_w:
+ if len(args_w) != 3:
+ w_err = space.wrap("Global constructor takes 0 or 3 positional arguments")
+ raise OperationError(space.w_TypeError, w_err)
+ for i, field in unrolling_iterable(enumerate(['names', 'lineno', 'col_offset'])):
+ space.setattr(w_self, space.wrap(field), args_w[i])
+ for field, w_value in kwargs_w.iteritems():
+ space.setattr(w_self, space.wrap(field), w_value)
+Global_init.unwrap_spec = [ObjSpace, W_Root, Arguments]
+
+Global.typedef = typedef.TypeDef("Global",
+ stmt.typedef,
+ _fields=_FieldsWrapper(['names']),
+ names=typedef.GetSetProperty(Global_get_names, Global_set_names, cls=Global),
+ __new__=interp2app(get_AST_new(Global)),
+ __init__=interp2app(Global_init),
+)
+Global.typedef.acceptable_as_base_class = False
+
+def Expr_get_value(space, w_self):
+ if not w_self.initialization_state & 1:
+ w_err = space.wrap("attribute 'value' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ return space.wrap(w_self.value)
+
+def Expr_set_value(space, w_self, w_new_value):
+ w_self.value = space.interp_w(expr, w_new_value, False)
+ w_self.initialization_state |= 1
+
+def Expr_init(space, w_self, args):
+ w_self = space.descr_self_interp_w(Expr, w_self)
+ args_w, kwargs_w = args.unpack()
+ if args_w:
+ if len(args_w) != 3:
+ w_err = space.wrap("Expr constructor takes 0 or 3 positional arguments")
+ raise OperationError(space.w_TypeError, w_err)
+ for i, field in unrolling_iterable(enumerate(['value', 'lineno', 'col_offset'])):
+ space.setattr(w_self, space.wrap(field), args_w[i])
+ for field, w_value in kwargs_w.iteritems():
+ space.setattr(w_self, space.wrap(field), w_value)
+Expr_init.unwrap_spec = [ObjSpace, W_Root, Arguments]
+
+Expr.typedef = typedef.TypeDef("Expr",
+ stmt.typedef,
+ _fields=_FieldsWrapper(['value']),
+ value=typedef.GetSetProperty(Expr_get_value, Expr_set_value, cls=Expr),
+ __new__=interp2app(get_AST_new(Expr)),
+ __init__=interp2app(Expr_init),
+)
+Expr.typedef.acceptable_as_base_class = False
+
+def Pass_init(space, w_self, args):
+ w_self = space.descr_self_interp_w(Pass, w_self)
+ args_w, kwargs_w = args.unpack()
+ if args_w:
+ if len(args_w) != 2:
+ w_err = space.wrap("Pass constructor takes 0 or 2 positional arguments")
+ raise OperationError(space.w_TypeError, w_err)
+ for i, field in unrolling_iterable(enumerate(['lineno', 'col_offset'])):
+ space.setattr(w_self, space.wrap(field), args_w[i])
+ for field, w_value in kwargs_w.iteritems():
+ space.setattr(w_self, space.wrap(field), w_value)
+Pass_init.unwrap_spec = [ObjSpace, W_Root, Arguments]
+
+Pass.typedef = typedef.TypeDef("Pass",
+ stmt.typedef,
+ _fields=_FieldsWrapper([]),
+ __new__=interp2app(get_AST_new(Pass)),
+ __init__=interp2app(Pass_init),
+)
+Pass.typedef.acceptable_as_base_class = False
+
+def Break_init(space, w_self, args):
+ w_self = space.descr_self_interp_w(Break, w_self)
+ args_w, kwargs_w = args.unpack()
+ if args_w:
+ if len(args_w) != 2:
+ w_err = space.wrap("Break constructor takes 0 or 2 positional arguments")
+ raise OperationError(space.w_TypeError, w_err)
+ for i, field in unrolling_iterable(enumerate(['lineno', 'col_offset'])):
+ space.setattr(w_self, space.wrap(field), args_w[i])
+ for field, w_value in kwargs_w.iteritems():
+ space.setattr(w_self, space.wrap(field), w_value)
+Break_init.unwrap_spec = [ObjSpace, W_Root, Arguments]
+
+Break.typedef = typedef.TypeDef("Break",
+ stmt.typedef,
+ _fields=_FieldsWrapper([]),
+ __new__=interp2app(get_AST_new(Break)),
+ __init__=interp2app(Break_init),
+)
+Break.typedef.acceptable_as_base_class = False
+
+def Continue_init(space, w_self, args):
+ w_self = space.descr_self_interp_w(Continue, w_self)
+ args_w, kwargs_w = args.unpack()
+ if args_w:
+ if len(args_w) != 2:
+ w_err = space.wrap("Continue constructor takes 0 or 2 positional arguments")
+ raise OperationError(space.w_TypeError, w_err)
+ for i, field in unrolling_iterable(enumerate(['lineno', 'col_offset'])):
+ space.setattr(w_self, space.wrap(field), args_w[i])
+ for field, w_value in kwargs_w.iteritems():
+ space.setattr(w_self, space.wrap(field), w_value)
+Continue_init.unwrap_spec = [ObjSpace, W_Root, Arguments]
+
+Continue.typedef = typedef.TypeDef("Continue",
+ stmt.typedef,
+ _fields=_FieldsWrapper([]),
+ __new__=interp2app(get_AST_new(Continue)),
+ __init__=interp2app(Continue_init),
+)
+Continue.typedef.acceptable_as_base_class = False
+
+def expr_get_lineno(space, w_self):
+ if not w_self.initialization_state & w_self._lineno_mask:
+ w_err = space.wrap("attribute 'lineno' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ return space.wrap(w_self.lineno)
+
+def expr_set_lineno(space, w_self, w_new_value):
+ w_self.lineno = space.int_w(w_new_value)
+ w_self.initialization_state |= w_self._lineno_mask
+
+def expr_get_col_offset(space, w_self):
+ if not w_self.initialization_state & w_self._col_offset_mask:
+ w_err = space.wrap("attribute 'col_offset' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ return space.wrap(w_self.col_offset)
+
+def expr_set_col_offset(space, w_self, w_new_value):
+ w_self.col_offset = space.int_w(w_new_value)
+ w_self.initialization_state |= w_self._col_offset_mask
+
+expr.typedef = typedef.TypeDef("expr",
+ AST.typedef,
+ _attributes=_FieldsWrapper(['lineno', 'col_offset']),
+ lineno=typedef.GetSetProperty(expr_get_lineno, expr_set_lineno, cls=expr),
+ col_offset=typedef.GetSetProperty(expr_get_col_offset, expr_set_col_offset, cls=expr),
+)
+expr.typedef.acceptable_as_base_class = False
+
+def BoolOp_get_op(space, w_self):
+ if not w_self.initialization_state & 1:
+ w_err = space.wrap("attribute 'op' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ return boolop_to_class[w_self.op - 1]()
+
+def BoolOp_set_op(space, w_self, w_new_value):
+ obj = space.interp_w(boolop, w_new_value)
+ w_self.op = obj.to_simple_int()
+ w_self.initialization_state |= 1
+
+def BoolOp_get_values(space, w_self):
+ if not w_self.initialization_state & 2:
+ w_err = space.wrap("attribute 'values' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ if w_self.w_values is None:
+ if w_self.values is None:
+ w_list = space.newlist([])
+ else:
+ list_w = [space.wrap(node) for node in w_self.values]
+ w_list = space.newlist(list_w)
+ w_self.w_values = w_list
+ return w_self.w_values
+
+def BoolOp_set_values(space, w_self, w_new_value):
+ w_self.w_values = w_new_value
+ w_self.initialization_state |= 2
+
+def BoolOp_init(space, w_self, args):
+ w_self = space.descr_self_interp_w(BoolOp, w_self)
+ w_self.w_values = None
+ args_w, kwargs_w = args.unpack()
+ if args_w:
+ if len(args_w) != 4:
+ w_err = space.wrap("BoolOp constructor takes 0 or 4 positional arguments")
+ raise OperationError(space.w_TypeError, w_err)
+ for i, field in unrolling_iterable(enumerate(['op', 'values', 'lineno', 'col_offset'])):
+ space.setattr(w_self, space.wrap(field), args_w[i])
+ for field, w_value in kwargs_w.iteritems():
+ space.setattr(w_self, space.wrap(field), w_value)
+BoolOp_init.unwrap_spec = [ObjSpace, W_Root, Arguments]
+
+BoolOp.typedef = typedef.TypeDef("BoolOp",
+ expr.typedef,
+ _fields=_FieldsWrapper(['op', 'values']),
+ op=typedef.GetSetProperty(BoolOp_get_op, BoolOp_set_op, cls=BoolOp),
+ values=typedef.GetSetProperty(BoolOp_get_values, BoolOp_set_values, cls=BoolOp),
+ __new__=interp2app(get_AST_new(BoolOp)),
+ __init__=interp2app(BoolOp_init),
+)
+BoolOp.typedef.acceptable_as_base_class = False
+
+def BinOp_get_left(space, w_self):
+ if not w_self.initialization_state & 1:
+ w_err = space.wrap("attribute 'left' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ return space.wrap(w_self.left)
+
+def BinOp_set_left(space, w_self, w_new_value):
+ w_self.left = space.interp_w(expr, w_new_value, False)
+ w_self.initialization_state |= 1
+
+def BinOp_get_op(space, w_self):
+ if not w_self.initialization_state & 2:
+ w_err = space.wrap("attribute 'op' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ return operator_to_class[w_self.op - 1]()
+
+def BinOp_set_op(space, w_self, w_new_value):
+ obj = space.interp_w(operator, w_new_value)
+ w_self.op = obj.to_simple_int()
+ w_self.initialization_state |= 2
+
+def BinOp_get_right(space, w_self):
+ if not w_self.initialization_state & 4:
+ w_err = space.wrap("attribute 'right' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ return space.wrap(w_self.right)
+
+def BinOp_set_right(space, w_self, w_new_value):
+ w_self.right = space.interp_w(expr, w_new_value, False)
+ w_self.initialization_state |= 4
+
+def BinOp_init(space, w_self, args):
+ w_self = space.descr_self_interp_w(BinOp, w_self)
+ args_w, kwargs_w = args.unpack()
+ if args_w:
+ if len(args_w) != 5:
+ w_err = space.wrap("BinOp constructor takes 0 or 5 positional arguments")
+ raise OperationError(space.w_TypeError, w_err)
+ for i, field in unrolling_iterable(enumerate(['left', 'op', 'right', 'lineno', 'col_offset'])):
+ space.setattr(w_self, space.wrap(field), args_w[i])
+ for field, w_value in kwargs_w.iteritems():
+ space.setattr(w_self, space.wrap(field), w_value)
+BinOp_init.unwrap_spec = [ObjSpace, W_Root, Arguments]
+
+BinOp.typedef = typedef.TypeDef("BinOp",
+ expr.typedef,
+ _fields=_FieldsWrapper(['left', 'op', 'right']),
+ left=typedef.GetSetProperty(BinOp_get_left, BinOp_set_left, cls=BinOp),
+ op=typedef.GetSetProperty(BinOp_get_op, BinOp_set_op, cls=BinOp),
+ right=typedef.GetSetProperty(BinOp_get_right, BinOp_set_right, cls=BinOp),
+ __new__=interp2app(get_AST_new(BinOp)),
+ __init__=interp2app(BinOp_init),
+)
+BinOp.typedef.acceptable_as_base_class = False
+
+def UnaryOp_get_op(space, w_self):
+ if not w_self.initialization_state & 1:
+ w_err = space.wrap("attribute 'op' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ return unaryop_to_class[w_self.op - 1]()
+
+def UnaryOp_set_op(space, w_self, w_new_value):
+ obj = space.interp_w(unaryop, w_new_value)
+ w_self.op = obj.to_simple_int()
+ w_self.initialization_state |= 1
+
+def UnaryOp_get_operand(space, w_self):
+ if not w_self.initialization_state & 2:
+ w_err = space.wrap("attribute 'operand' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ return space.wrap(w_self.operand)
+
+def UnaryOp_set_operand(space, w_self, w_new_value):
+ w_self.operand = space.interp_w(expr, w_new_value, False)
+ w_self.initialization_state |= 2
+
+def UnaryOp_init(space, w_self, args):
+ w_self = space.descr_self_interp_w(UnaryOp, w_self)
+ args_w, kwargs_w = args.unpack()
+ if args_w:
+ if len(args_w) != 4:
+ w_err = space.wrap("UnaryOp constructor takes 0 or 4 positional arguments")
+ raise OperationError(space.w_TypeError, w_err)
+ for i, field in unrolling_iterable(enumerate(['op', 'operand', 'lineno', 'col_offset'])):
+ space.setattr(w_self, space.wrap(field), args_w[i])
+ for field, w_value in kwargs_w.iteritems():
+ space.setattr(w_self, space.wrap(field), w_value)
+UnaryOp_init.unwrap_spec = [ObjSpace, W_Root, Arguments]
+
+UnaryOp.typedef = typedef.TypeDef("UnaryOp",
+ expr.typedef,
+ _fields=_FieldsWrapper(['op', 'operand']),
+ op=typedef.GetSetProperty(UnaryOp_get_op, UnaryOp_set_op, cls=UnaryOp),
+ operand=typedef.GetSetProperty(UnaryOp_get_operand, UnaryOp_set_operand, cls=UnaryOp),
+ __new__=interp2app(get_AST_new(UnaryOp)),
+ __init__=interp2app(UnaryOp_init),
+)
+UnaryOp.typedef.acceptable_as_base_class = False
+
+def Lambda_get_args(space, w_self):
+ if not w_self.initialization_state & 1:
+ w_err = space.wrap("attribute 'args' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ return space.wrap(w_self.args)
+
+def Lambda_set_args(space, w_self, w_new_value):
+ w_self.args = space.interp_w(arguments, w_new_value, False)
+ w_self.initialization_state |= 1
+
+def Lambda_get_body(space, w_self):
+ if not w_self.initialization_state & 2:
+ w_err = space.wrap("attribute 'body' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ return space.wrap(w_self.body)
+
+def Lambda_set_body(space, w_self, w_new_value):
+ w_self.body = space.interp_w(expr, w_new_value, False)
+ w_self.initialization_state |= 2
+
+def Lambda_init(space, w_self, args):
+ w_self = space.descr_self_interp_w(Lambda, w_self)
+ args_w, kwargs_w = args.unpack()
+ if args_w:
+ if len(args_w) != 4:
+ w_err = space.wrap("Lambda constructor takes 0 or 4 positional arguments")
+ raise OperationError(space.w_TypeError, w_err)
+ for i, field in unrolling_iterable(enumerate(['args', 'body', 'lineno', 'col_offset'])):
+ space.setattr(w_self, space.wrap(field), args_w[i])
+ for field, w_value in kwargs_w.iteritems():
+ space.setattr(w_self, space.wrap(field), w_value)
+Lambda_init.unwrap_spec = [ObjSpace, W_Root, Arguments]
+
+Lambda.typedef = typedef.TypeDef("Lambda",
+ expr.typedef,
+ _fields=_FieldsWrapper(['args', 'body']),
+ args=typedef.GetSetProperty(Lambda_get_args, Lambda_set_args, cls=Lambda),
+ body=typedef.GetSetProperty(Lambda_get_body, Lambda_set_body, cls=Lambda),
+ __new__=interp2app(get_AST_new(Lambda)),
+ __init__=interp2app(Lambda_init),
+)
+Lambda.typedef.acceptable_as_base_class = False
+
+def IfExp_get_test(space, w_self):
+ if not w_self.initialization_state & 1:
+ w_err = space.wrap("attribute 'test' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ return space.wrap(w_self.test)
+
+def IfExp_set_test(space, w_self, w_new_value):
+ w_self.test = space.interp_w(expr, w_new_value, False)
+ w_self.initialization_state |= 1
+
+def IfExp_get_body(space, w_self):
+ if not w_self.initialization_state & 2:
+ w_err = space.wrap("attribute 'body' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ return space.wrap(w_self.body)
+
+def IfExp_set_body(space, w_self, w_new_value):
+ w_self.body = space.interp_w(expr, w_new_value, False)
+ w_self.initialization_state |= 2
+
+def IfExp_get_orelse(space, w_self):
+ if not w_self.initialization_state & 4:
+ w_err = space.wrap("attribute 'orelse' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ return space.wrap(w_self.orelse)
+
+def IfExp_set_orelse(space, w_self, w_new_value):
+ w_self.orelse = space.interp_w(expr, w_new_value, False)
+ w_self.initialization_state |= 4
+
+def IfExp_init(space, w_self, args):
+ w_self = space.descr_self_interp_w(IfExp, w_self)
+ args_w, kwargs_w = args.unpack()
+ if args_w:
+ if len(args_w) != 5:
+ w_err = space.wrap("IfExp constructor takes 0 or 5 positional arguments")
+ raise OperationError(space.w_TypeError, w_err)
+ for i, field in unrolling_iterable(enumerate(['test', 'body', 'orelse', 'lineno', 'col_offset'])):
+ space.setattr(w_self, space.wrap(field), args_w[i])
+ for field, w_value in kwargs_w.iteritems():
+ space.setattr(w_self, space.wrap(field), w_value)
+IfExp_init.unwrap_spec = [ObjSpace, W_Root, Arguments]
+
+IfExp.typedef = typedef.TypeDef("IfExp",
+ expr.typedef,
+ _fields=_FieldsWrapper(['test', 'body', 'orelse']),
+ test=typedef.GetSetProperty(IfExp_get_test, IfExp_set_test, cls=IfExp),
+ body=typedef.GetSetProperty(IfExp_get_body, IfExp_set_body, cls=IfExp),
+ orelse=typedef.GetSetProperty(IfExp_get_orelse, IfExp_set_orelse, cls=IfExp),
+ __new__=interp2app(get_AST_new(IfExp)),
+ __init__=interp2app(IfExp_init),
+)
+IfExp.typedef.acceptable_as_base_class = False
+
+def Dict_get_keys(space, w_self):
+ if not w_self.initialization_state & 1:
+ w_err = space.wrap("attribute 'keys' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ if w_self.w_keys is None:
+ if w_self.keys is None:
+ w_list = space.newlist([])
+ else:
+ list_w = [space.wrap(node) for node in w_self.keys]
+ w_list = space.newlist(list_w)
+ w_self.w_keys = w_list
+ return w_self.w_keys
+
+def Dict_set_keys(space, w_self, w_new_value):
+ w_self.w_keys = w_new_value
+ w_self.initialization_state |= 1
+
+def Dict_get_values(space, w_self):
+ if not w_self.initialization_state & 2:
+ w_err = space.wrap("attribute 'values' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ if w_self.w_values is None:
+ if w_self.values is None:
+ w_list = space.newlist([])
+ else:
+ list_w = [space.wrap(node) for node in w_self.values]
+ w_list = space.newlist(list_w)
+ w_self.w_values = w_list
+ return w_self.w_values
+
+def Dict_set_values(space, w_self, w_new_value):
+ w_self.w_values = w_new_value
+ w_self.initialization_state |= 2
+
+def Dict_init(space, w_self, args):
+ w_self = space.descr_self_interp_w(Dict, w_self)
+ w_self.w_keys = None
+ w_self.w_values = None
+ args_w, kwargs_w = args.unpack()
+ if args_w:
+ if len(args_w) != 4:
+ w_err = space.wrap("Dict constructor takes 0 or 4 positional arguments")
+ raise OperationError(space.w_TypeError, w_err)
+ for i, field in unrolling_iterable(enumerate(['keys', 'values', 'lineno', 'col_offset'])):
+ space.setattr(w_self, space.wrap(field), args_w[i])
+ for field, w_value in kwargs_w.iteritems():
+ space.setattr(w_self, space.wrap(field), w_value)
+Dict_init.unwrap_spec = [ObjSpace, W_Root, Arguments]
+
+Dict.typedef = typedef.TypeDef("Dict",
+ expr.typedef,
+ _fields=_FieldsWrapper(['keys', 'values']),
+ keys=typedef.GetSetProperty(Dict_get_keys, Dict_set_keys, cls=Dict),
+ values=typedef.GetSetProperty(Dict_get_values, Dict_set_values, cls=Dict),
+ __new__=interp2app(get_AST_new(Dict)),
+ __init__=interp2app(Dict_init),
+)
+Dict.typedef.acceptable_as_base_class = False
+
+def ListComp_get_elt(space, w_self):
+ if not w_self.initialization_state & 1:
+ w_err = space.wrap("attribute 'elt' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ return space.wrap(w_self.elt)
+
+def ListComp_set_elt(space, w_self, w_new_value):
+ w_self.elt = space.interp_w(expr, w_new_value, False)
+ w_self.initialization_state |= 1
+
+def ListComp_get_generators(space, w_self):
+ if not w_self.initialization_state & 2:
+ w_err = space.wrap("attribute 'generators' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ if w_self.w_generators is None:
+ if w_self.generators is None:
+ w_list = space.newlist([])
+ else:
+ list_w = [space.wrap(node) for node in w_self.generators]
+ w_list = space.newlist(list_w)
+ w_self.w_generators = w_list
+ return w_self.w_generators
+
+def ListComp_set_generators(space, w_self, w_new_value):
+ w_self.w_generators = w_new_value
+ w_self.initialization_state |= 2
+
+def ListComp_init(space, w_self, args):
+ w_self = space.descr_self_interp_w(ListComp, w_self)
+ w_self.w_generators = None
+ args_w, kwargs_w = args.unpack()
+ if args_w:
+ if len(args_w) != 4:
+ w_err = space.wrap("ListComp constructor takes 0 or 4 positional arguments")
+ raise OperationError(space.w_TypeError, w_err)
+ for i, field in unrolling_iterable(enumerate(['elt', 'generators', 'lineno', 'col_offset'])):
+ space.setattr(w_self, space.wrap(field), args_w[i])
+ for field, w_value in kwargs_w.iteritems():
+ space.setattr(w_self, space.wrap(field), w_value)
+ListComp_init.unwrap_spec = [ObjSpace, W_Root, Arguments]
+
+ListComp.typedef = typedef.TypeDef("ListComp",
+ expr.typedef,
+ _fields=_FieldsWrapper(['elt', 'generators']),
+ elt=typedef.GetSetProperty(ListComp_get_elt, ListComp_set_elt, cls=ListComp),
+ generators=typedef.GetSetProperty(ListComp_get_generators, ListComp_set_generators, cls=ListComp),
+ __new__=interp2app(get_AST_new(ListComp)),
+ __init__=interp2app(ListComp_init),
+)
+ListComp.typedef.acceptable_as_base_class = False
+
+def GeneratorExp_get_elt(space, w_self):
+ if not w_self.initialization_state & 1:
+ w_err = space.wrap("attribute 'elt' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ return space.wrap(w_self.elt)
+
+def GeneratorExp_set_elt(space, w_self, w_new_value):
+ w_self.elt = space.interp_w(expr, w_new_value, False)
+ w_self.initialization_state |= 1
+
+def GeneratorExp_get_generators(space, w_self):
+ if not w_self.initialization_state & 2:
+ w_err = space.wrap("attribute 'generators' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ if w_self.w_generators is None:
+ if w_self.generators is None:
+ w_list = space.newlist([])
+ else:
+ list_w = [space.wrap(node) for node in w_self.generators]
+ w_list = space.newlist(list_w)
+ w_self.w_generators = w_list
+ return w_self.w_generators
+
+def GeneratorExp_set_generators(space, w_self, w_new_value):
+ w_self.w_generators = w_new_value
+ w_self.initialization_state |= 2
+
+def GeneratorExp_init(space, w_self, args):
+ w_self = space.descr_self_interp_w(GeneratorExp, w_self)
+ w_self.w_generators = None
+ args_w, kwargs_w = args.unpack()
+ if args_w:
+ if len(args_w) != 4:
+ w_err = space.wrap("GeneratorExp constructor takes 0 or 4 positional arguments")
+ raise OperationError(space.w_TypeError, w_err)
+ for i, field in unrolling_iterable(enumerate(['elt', 'generators', 'lineno', 'col_offset'])):
+ space.setattr(w_self, space.wrap(field), args_w[i])
+ for field, w_value in kwargs_w.iteritems():
+ space.setattr(w_self, space.wrap(field), w_value)
+GeneratorExp_init.unwrap_spec = [ObjSpace, W_Root, Arguments]
+
+GeneratorExp.typedef = typedef.TypeDef("GeneratorExp",
+ expr.typedef,
+ _fields=_FieldsWrapper(['elt', 'generators']),
+ elt=typedef.GetSetProperty(GeneratorExp_get_elt, GeneratorExp_set_elt, cls=GeneratorExp),
+ generators=typedef.GetSetProperty(GeneratorExp_get_generators, GeneratorExp_set_generators, cls=GeneratorExp),
+ __new__=interp2app(get_AST_new(GeneratorExp)),
+ __init__=interp2app(GeneratorExp_init),
+)
+GeneratorExp.typedef.acceptable_as_base_class = False
+
+def Yield_get_value(space, w_self):
+ if not w_self.initialization_state & 1:
+ w_err = space.wrap("attribute 'value' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ return space.wrap(w_self.value)
+
+def Yield_set_value(space, w_self, w_new_value):
+ w_self.value = space.interp_w(expr, w_new_value, True)
+ w_self.initialization_state |= 1
+
+def Yield_init(space, w_self, args):
+ w_self = space.descr_self_interp_w(Yield, w_self)
+ args_w, kwargs_w = args.unpack()
+ if args_w:
+ if len(args_w) != 3:
+ w_err = space.wrap("Yield constructor takes 0 or 3 positional arguments")
+ raise OperationError(space.w_TypeError, w_err)
+ for i, field in unrolling_iterable(enumerate(['value', 'lineno', 'col_offset'])):
+ space.setattr(w_self, space.wrap(field), args_w[i])
+ for field, w_value in kwargs_w.iteritems():
+ space.setattr(w_self, space.wrap(field), w_value)
+Yield_init.unwrap_spec = [ObjSpace, W_Root, Arguments]
+
+Yield.typedef = typedef.TypeDef("Yield",
+ expr.typedef,
+ _fields=_FieldsWrapper(['value']),
+ value=typedef.GetSetProperty(Yield_get_value, Yield_set_value, cls=Yield),
+ __new__=interp2app(get_AST_new(Yield)),
+ __init__=interp2app(Yield_init),
+)
+Yield.typedef.acceptable_as_base_class = False
+
+def Compare_get_left(space, w_self):
+ if not w_self.initialization_state & 1:
+ w_err = space.wrap("attribute 'left' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ return space.wrap(w_self.left)
+
+def Compare_set_left(space, w_self, w_new_value):
+ w_self.left = space.interp_w(expr, w_new_value, False)
+ w_self.initialization_state |= 1
+
+def Compare_get_ops(space, w_self):
+ if not w_self.initialization_state & 2:
+ w_err = space.wrap("attribute 'ops' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ if w_self.w_ops is None:
+ if w_self.ops is None:
+ w_list = space.newlist([])
+ else:
+ list_w = [cmpop_to_class[node - 1]() for node in w_self.ops]
+ w_list = space.newlist(list_w)
+ w_self.w_ops = w_list
+ return w_self.w_ops
+
+def Compare_set_ops(space, w_self, w_new_value):
+ w_self.w_ops = w_new_value
+ w_self.initialization_state |= 2
+
+def Compare_get_comparators(space, w_self):
+ if not w_self.initialization_state & 4:
+ w_err = space.wrap("attribute 'comparators' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ if w_self.w_comparators is None:
+ if w_self.comparators is None:
+ w_list = space.newlist([])
+ else:
+ list_w = [space.wrap(node) for node in w_self.comparators]
+ w_list = space.newlist(list_w)
+ w_self.w_comparators = w_list
+ return w_self.w_comparators
+
+def Compare_set_comparators(space, w_self, w_new_value):
+ w_self.w_comparators = w_new_value
+ w_self.initialization_state |= 4
+
+def Compare_init(space, w_self, args):
+ w_self = space.descr_self_interp_w(Compare, w_self)
+ w_self.w_ops = None
+ w_self.w_comparators = None
+ args_w, kwargs_w = args.unpack()
+ if args_w:
+ if len(args_w) != 5:
+ w_err = space.wrap("Compare constructor takes 0 or 5 positional arguments")
+ raise OperationError(space.w_TypeError, w_err)
+ for i, field in unrolling_iterable(enumerate(['left', 'ops', 'comparators', 'lineno', 'col_offset'])):
+ space.setattr(w_self, space.wrap(field), args_w[i])
+ for field, w_value in kwargs_w.iteritems():
+ space.setattr(w_self, space.wrap(field), w_value)
+Compare_init.unwrap_spec = [ObjSpace, W_Root, Arguments]
+
+Compare.typedef = typedef.TypeDef("Compare",
+ expr.typedef,
+ _fields=_FieldsWrapper(['left', 'ops', 'comparators']),
+ left=typedef.GetSetProperty(Compare_get_left, Compare_set_left, cls=Compare),
+ ops=typedef.GetSetProperty(Compare_get_ops, Compare_set_ops, cls=Compare),
+ comparators=typedef.GetSetProperty(Compare_get_comparators, Compare_set_comparators, cls=Compare),
+ __new__=interp2app(get_AST_new(Compare)),
+ __init__=interp2app(Compare_init),
+)
+Compare.typedef.acceptable_as_base_class = False
+
+def Call_get_func(space, w_self):
+ if not w_self.initialization_state & 1:
+ w_err = space.wrap("attribute 'func' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ return space.wrap(w_self.func)
+
+def Call_set_func(space, w_self, w_new_value):
+ w_self.func = space.interp_w(expr, w_new_value, False)
+ w_self.initialization_state |= 1
+
+def Call_get_args(space, w_self):
+ if not w_self.initialization_state & 2:
+ w_err = space.wrap("attribute 'args' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ if w_self.w_args is None:
+ if w_self.args is None:
+ w_list = space.newlist([])
+ else:
+ list_w = [space.wrap(node) for node in w_self.args]
+ w_list = space.newlist(list_w)
+ w_self.w_args = w_list
+ return w_self.w_args
+
+def Call_set_args(space, w_self, w_new_value):
+ w_self.w_args = w_new_value
+ w_self.initialization_state |= 2
+
+def Call_get_keywords(space, w_self):
+ if not w_self.initialization_state & 4:
+ w_err = space.wrap("attribute 'keywords' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ if w_self.w_keywords is None:
+ if w_self.keywords is None:
+ w_list = space.newlist([])
+ else:
+ list_w = [space.wrap(node) for node in w_self.keywords]
+ w_list = space.newlist(list_w)
+ w_self.w_keywords = w_list
+ return w_self.w_keywords
+
+def Call_set_keywords(space, w_self, w_new_value):
+ w_self.w_keywords = w_new_value
+ w_self.initialization_state |= 4
+
+def Call_get_starargs(space, w_self):
+ if not w_self.initialization_state & 8:
+ w_err = space.wrap("attribute 'starargs' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ return space.wrap(w_self.starargs)
+
+def Call_set_starargs(space, w_self, w_new_value):
+ w_self.starargs = space.interp_w(expr, w_new_value, True)
+ w_self.initialization_state |= 8
+
+def Call_get_kwargs(space, w_self):
+ if not w_self.initialization_state & 16:
+ w_err = space.wrap("attribute 'kwargs' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ return space.wrap(w_self.kwargs)
+
+def Call_set_kwargs(space, w_self, w_new_value):
+ w_self.kwargs = space.interp_w(expr, w_new_value, True)
+ w_self.initialization_state |= 16
+
+def Call_init(space, w_self, args):
+ w_self = space.descr_self_interp_w(Call, w_self)
+ w_self.w_args = None
+ w_self.w_keywords = None
+ args_w, kwargs_w = args.unpack()
+ if args_w:
+ if len(args_w) != 7:
+ w_err = space.wrap("Call constructor takes 0 or 7 positional arguments")
+ raise OperationError(space.w_TypeError, w_err)
+ for i, field in unrolling_iterable(enumerate(['func', 'args', 'keywords', 'starargs', 'kwargs', 'lineno', 'col_offset'])):
+ space.setattr(w_self, space.wrap(field), args_w[i])
+ for field, w_value in kwargs_w.iteritems():
+ space.setattr(w_self, space.wrap(field), w_value)
+Call_init.unwrap_spec = [ObjSpace, W_Root, Arguments]
+
+Call.typedef = typedef.TypeDef("Call",
+ expr.typedef,
+ _fields=_FieldsWrapper(['func', 'args', 'keywords', 'starargs', 'kwargs']),
+ func=typedef.GetSetProperty(Call_get_func, Call_set_func, cls=Call),
+ args=typedef.GetSetProperty(Call_get_args, Call_set_args, cls=Call),
+ keywords=typedef.GetSetProperty(Call_get_keywords, Call_set_keywords, cls=Call),
+ starargs=typedef.GetSetProperty(Call_get_starargs, Call_set_starargs, cls=Call),
+ kwargs=typedef.GetSetProperty(Call_get_kwargs, Call_set_kwargs, cls=Call),
+ __new__=interp2app(get_AST_new(Call)),
+ __init__=interp2app(Call_init),
+)
+Call.typedef.acceptable_as_base_class = False
+
+def Repr_get_value(space, w_self):
+ if not w_self.initialization_state & 1:
+ w_err = space.wrap("attribute 'value' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ return space.wrap(w_self.value)
+
+def Repr_set_value(space, w_self, w_new_value):
+ w_self.value = space.interp_w(expr, w_new_value, False)
+ w_self.initialization_state |= 1
+
+def Repr_init(space, w_self, args):
+ w_self = space.descr_self_interp_w(Repr, w_self)
+ args_w, kwargs_w = args.unpack()
+ if args_w:
+ if len(args_w) != 3:
+ w_err = space.wrap("Repr constructor takes 0 or 3 positional arguments")
+ raise OperationError(space.w_TypeError, w_err)
+ for i, field in unrolling_iterable(enumerate(['value', 'lineno', 'col_offset'])):
+ space.setattr(w_self, space.wrap(field), args_w[i])
+ for field, w_value in kwargs_w.iteritems():
+ space.setattr(w_self, space.wrap(field), w_value)
+Repr_init.unwrap_spec = [ObjSpace, W_Root, Arguments]
+
+Repr.typedef = typedef.TypeDef("Repr",
+ expr.typedef,
+ _fields=_FieldsWrapper(['value']),
+ value=typedef.GetSetProperty(Repr_get_value, Repr_set_value, cls=Repr),
+ __new__=interp2app(get_AST_new(Repr)),
+ __init__=interp2app(Repr_init),
+)
+Repr.typedef.acceptable_as_base_class = False
+
+def Num_get_n(space, w_self):
+ if not w_self.initialization_state & 1:
+ w_err = space.wrap("attribute 'n' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ return w_self.n
+
+def Num_set_n(space, w_self, w_new_value):
+ w_self.n = w_new_value
+ w_self.initialization_state |= 1
+
+def Num_init(space, w_self, args):
+ w_self = space.descr_self_interp_w(Num, w_self)
+ args_w, kwargs_w = args.unpack()
+ if args_w:
+ if len(args_w) != 3:
+ w_err = space.wrap("Num constructor takes 0 or 3 positional arguments")
+ raise OperationError(space.w_TypeError, w_err)
+ for i, field in unrolling_iterable(enumerate(['n', 'lineno', 'col_offset'])):
+ space.setattr(w_self, space.wrap(field), args_w[i])
+ for field, w_value in kwargs_w.iteritems():
+ space.setattr(w_self, space.wrap(field), w_value)
+Num_init.unwrap_spec = [ObjSpace, W_Root, Arguments]
+
+Num.typedef = typedef.TypeDef("Num",
+ expr.typedef,
+ _fields=_FieldsWrapper(['n']),
+ n=typedef.GetSetProperty(Num_get_n, Num_set_n, cls=Num),
+ __new__=interp2app(get_AST_new(Num)),
+ __init__=interp2app(Num_init),
+)
+Num.typedef.acceptable_as_base_class = False
+
+def Str_get_s(space, w_self):
+ if not w_self.initialization_state & 1:
+ w_err = space.wrap("attribute 's' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ return w_self.s
+
+def Str_set_s(space, w_self, w_new_value):
+ if not space.is_true(space.isinstance(w_new_value, space.w_basestring)):
+ w_err = space.wrap("some kind of string required")
+ raise OperationError(space.w_TypeError, w_err)
+ w_self.s = w_new_value
+ w_self.initialization_state |= 1
+
+def Str_init(space, w_self, args):
+ w_self = space.descr_self_interp_w(Str, w_self)
+ args_w, kwargs_w = args.unpack()
+ if args_w:
+ if len(args_w) != 3:
+ w_err = space.wrap("Str constructor takes 0 or 3 positional arguments")
+ raise OperationError(space.w_TypeError, w_err)
+ for i, field in unrolling_iterable(enumerate(['s', 'lineno', 'col_offset'])):
+ space.setattr(w_self, space.wrap(field), args_w[i])
+ for field, w_value in kwargs_w.iteritems():
+ space.setattr(w_self, space.wrap(field), w_value)
+Str_init.unwrap_spec = [ObjSpace, W_Root, Arguments]
+
+Str.typedef = typedef.TypeDef("Str",
+ expr.typedef,
+ _fields=_FieldsWrapper(['s']),
+ s=typedef.GetSetProperty(Str_get_s, Str_set_s, cls=Str),
+ __new__=interp2app(get_AST_new(Str)),
+ __init__=interp2app(Str_init),
+)
+Str.typedef.acceptable_as_base_class = False
+
+def Attribute_get_value(space, w_self):
+ if not w_self.initialization_state & 1:
+ w_err = space.wrap("attribute 'value' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ return space.wrap(w_self.value)
+
+def Attribute_set_value(space, w_self, w_new_value):
+ w_self.value = space.interp_w(expr, w_new_value, False)
+ w_self.initialization_state |= 1
+
+def Attribute_get_attr(space, w_self):
+ if not w_self.initialization_state & 2:
+ w_err = space.wrap("attribute 'attr' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ return space.wrap(w_self.attr)
+
+def Attribute_set_attr(space, w_self, w_new_value):
+ w_self.attr = space.str_w(w_new_value)
+ w_self.initialization_state |= 2
+
+def Attribute_get_ctx(space, w_self):
+ if not w_self.initialization_state & 4:
+ w_err = space.wrap("attribute 'ctx' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ return expr_context_to_class[w_self.ctx - 1]()
+
+def Attribute_set_ctx(space, w_self, w_new_value):
+ obj = space.interp_w(expr_context, w_new_value)
+ w_self.ctx = obj.to_simple_int()
+ w_self.initialization_state |= 4
+
+def Attribute_init(space, w_self, args):
+ w_self = space.descr_self_interp_w(Attribute, w_self)
+ args_w, kwargs_w = args.unpack()
+ if args_w:
+ if len(args_w) != 5:
+ w_err = space.wrap("Attribute constructor takes 0 or 5 positional arguments")
+ raise OperationError(space.w_TypeError, w_err)
+ for i, field in unrolling_iterable(enumerate(['value', 'attr', 'ctx', 'lineno', 'col_offset'])):
+ space.setattr(w_self, space.wrap(field), args_w[i])
+ for field, w_value in kwargs_w.iteritems():
+ space.setattr(w_self, space.wrap(field), w_value)
+Attribute_init.unwrap_spec = [ObjSpace, W_Root, Arguments]
+
+Attribute.typedef = typedef.TypeDef("Attribute",
+ expr.typedef,
+ _fields=_FieldsWrapper(['value', 'attr', 'ctx']),
+ value=typedef.GetSetProperty(Attribute_get_value, Attribute_set_value, cls=Attribute),
+ attr=typedef.GetSetProperty(Attribute_get_attr, Attribute_set_attr, cls=Attribute),
+ ctx=typedef.GetSetProperty(Attribute_get_ctx, Attribute_set_ctx, cls=Attribute),
+ __new__=interp2app(get_AST_new(Attribute)),
+ __init__=interp2app(Attribute_init),
+)
+Attribute.typedef.acceptable_as_base_class = False
+
+def Subscript_get_value(space, w_self):
+ if not w_self.initialization_state & 1:
+ w_err = space.wrap("attribute 'value' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ return space.wrap(w_self.value)
+
+def Subscript_set_value(space, w_self, w_new_value):
+ w_self.value = space.interp_w(expr, w_new_value, False)
+ w_self.initialization_state |= 1
+
+def Subscript_get_slice(space, w_self):
+ if not w_self.initialization_state & 2:
+ w_err = space.wrap("attribute 'slice' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ return space.wrap(w_self.slice)
+
+def Subscript_set_slice(space, w_self, w_new_value):
+ w_self.slice = space.interp_w(slice, w_new_value, False)
+ w_self.initialization_state |= 2
+
+def Subscript_get_ctx(space, w_self):
+ if not w_self.initialization_state & 4:
+ w_err = space.wrap("attribute 'ctx' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ return expr_context_to_class[w_self.ctx - 1]()
+
+def Subscript_set_ctx(space, w_self, w_new_value):
+ obj = space.interp_w(expr_context, w_new_value)
+ w_self.ctx = obj.to_simple_int()
+ w_self.initialization_state |= 4
+
+def Subscript_init(space, w_self, args):
+ w_self = space.descr_self_interp_w(Subscript, w_self)
+ args_w, kwargs_w = args.unpack()
+ if args_w:
+ if len(args_w) != 5:
+ w_err = space.wrap("Subscript constructor takes 0 or 5 positional arguments")
+ raise OperationError(space.w_TypeError, w_err)
+ for i, field in unrolling_iterable(enumerate(['value', 'slice', 'ctx', 'lineno', 'col_offset'])):
+ space.setattr(w_self, space.wrap(field), args_w[i])
+ for field, w_value in kwargs_w.iteritems():
+ space.setattr(w_self, space.wrap(field), w_value)
+Subscript_init.unwrap_spec = [ObjSpace, W_Root, Arguments]
+
+Subscript.typedef = typedef.TypeDef("Subscript",
+ expr.typedef,
+ _fields=_FieldsWrapper(['value', 'slice', 'ctx']),
+ value=typedef.GetSetProperty(Subscript_get_value, Subscript_set_value, cls=Subscript),
+ slice=typedef.GetSetProperty(Subscript_get_slice, Subscript_set_slice, cls=Subscript),
+ ctx=typedef.GetSetProperty(Subscript_get_ctx, Subscript_set_ctx, cls=Subscript),
+ __new__=interp2app(get_AST_new(Subscript)),
+ __init__=interp2app(Subscript_init),
+)
+Subscript.typedef.acceptable_as_base_class = False
+
+def Name_get_id(space, w_self):
+ if not w_self.initialization_state & 1:
+ w_err = space.wrap("attribute 'id' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ return space.wrap(w_self.id)
+
+def Name_set_id(space, w_self, w_new_value):
+ w_self.id = space.str_w(w_new_value)
+ w_self.initialization_state |= 1
+
+def Name_get_ctx(space, w_self):
+ if not w_self.initialization_state & 2:
+ w_err = space.wrap("attribute 'ctx' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ return expr_context_to_class[w_self.ctx - 1]()
+
+def Name_set_ctx(space, w_self, w_new_value):
+ obj = space.interp_w(expr_context, w_new_value)
+ w_self.ctx = obj.to_simple_int()
+ w_self.initialization_state |= 2
+
+def Name_init(space, w_self, args):
+ w_self = space.descr_self_interp_w(Name, w_self)
+ args_w, kwargs_w = args.unpack()
+ if args_w:
+ if len(args_w) != 4:
+ w_err = space.wrap("Name constructor takes 0 or 4 positional arguments")
+ raise OperationError(space.w_TypeError, w_err)
+ for i, field in unrolling_iterable(enumerate(['id', 'ctx', 'lineno', 'col_offset'])):
+ space.setattr(w_self, space.wrap(field), args_w[i])
+ for field, w_value in kwargs_w.iteritems():
+ space.setattr(w_self, space.wrap(field), w_value)
+Name_init.unwrap_spec = [ObjSpace, W_Root, Arguments]
+
+Name.typedef = typedef.TypeDef("Name",
+ expr.typedef,
+ _fields=_FieldsWrapper(['id', 'ctx']),
+ id=typedef.GetSetProperty(Name_get_id, Name_set_id, cls=Name),
+ ctx=typedef.GetSetProperty(Name_get_ctx, Name_set_ctx, cls=Name),
+ __new__=interp2app(get_AST_new(Name)),
+ __init__=interp2app(Name_init),
+)
+Name.typedef.acceptable_as_base_class = False
+
+def List_get_elts(space, w_self):
+ if not w_self.initialization_state & 1:
+ w_err = space.wrap("attribute 'elts' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ if w_self.w_elts is None:
+ if w_self.elts is None:
+ w_list = space.newlist([])
+ else:
+ list_w = [space.wrap(node) for node in w_self.elts]
+ w_list = space.newlist(list_w)
+ w_self.w_elts = w_list
+ return w_self.w_elts
+
+def List_set_elts(space, w_self, w_new_value):
+ w_self.w_elts = w_new_value
+ w_self.initialization_state |= 1
+
+def List_get_ctx(space, w_self):
+ if not w_self.initialization_state & 2:
+ w_err = space.wrap("attribute 'ctx' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ return expr_context_to_class[w_self.ctx - 1]()
+
+def List_set_ctx(space, w_self, w_new_value):
+ obj = space.interp_w(expr_context, w_new_value)
+ w_self.ctx = obj.to_simple_int()
+ w_self.initialization_state |= 2
+
+def List_init(space, w_self, args):
+ w_self = space.descr_self_interp_w(List, w_self)
+ w_self.w_elts = None
+ args_w, kwargs_w = args.unpack()
+ if args_w:
+ if len(args_w) != 4:
+ w_err = space.wrap("List constructor takes 0 or 4 positional arguments")
+ raise OperationError(space.w_TypeError, w_err)
+ for i, field in unrolling_iterable(enumerate(['elts', 'ctx', 'lineno', 'col_offset'])):
+ space.setattr(w_self, space.wrap(field), args_w[i])
+ for field, w_value in kwargs_w.iteritems():
+ space.setattr(w_self, space.wrap(field), w_value)
+List_init.unwrap_spec = [ObjSpace, W_Root, Arguments]
+
+List.typedef = typedef.TypeDef("List",
+ expr.typedef,
+ _fields=_FieldsWrapper(['elts', 'ctx']),
+ elts=typedef.GetSetProperty(List_get_elts, List_set_elts, cls=List),
+ ctx=typedef.GetSetProperty(List_get_ctx, List_set_ctx, cls=List),
+ __new__=interp2app(get_AST_new(List)),
+ __init__=interp2app(List_init),
+)
+List.typedef.acceptable_as_base_class = False
+
+def Tuple_get_elts(space, w_self):
+ if not w_self.initialization_state & 1:
+ w_err = space.wrap("attribute 'elts' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ if w_self.w_elts is None:
+ if w_self.elts is None:
+ w_list = space.newlist([])
+ else:
+ list_w = [space.wrap(node) for node in w_self.elts]
+ w_list = space.newlist(list_w)
+ w_self.w_elts = w_list
+ return w_self.w_elts
+
+def Tuple_set_elts(space, w_self, w_new_value):
+ w_self.w_elts = w_new_value
+ w_self.initialization_state |= 1
+
+def Tuple_get_ctx(space, w_self):
+ if not w_self.initialization_state & 2:
+ w_err = space.wrap("attribute 'ctx' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ return expr_context_to_class[w_self.ctx - 1]()
+
+def Tuple_set_ctx(space, w_self, w_new_value):
+ obj = space.interp_w(expr_context, w_new_value)
+ w_self.ctx = obj.to_simple_int()
+ w_self.initialization_state |= 2
+
+def Tuple_init(space, w_self, args):
+ w_self = space.descr_self_interp_w(Tuple, w_self)
+ w_self.w_elts = None
+ args_w, kwargs_w = args.unpack()
+ if args_w:
+ if len(args_w) != 4:
+ w_err = space.wrap("Tuple constructor takes 0 or 4 positional arguments")
+ raise OperationError(space.w_TypeError, w_err)
+ for i, field in unrolling_iterable(enumerate(['elts', 'ctx', 'lineno', 'col_offset'])):
+ space.setattr(w_self, space.wrap(field), args_w[i])
+ for field, w_value in kwargs_w.iteritems():
+ space.setattr(w_self, space.wrap(field), w_value)
+Tuple_init.unwrap_spec = [ObjSpace, W_Root, Arguments]
+
+Tuple.typedef = typedef.TypeDef("Tuple",
+ expr.typedef,
+ _fields=_FieldsWrapper(['elts', 'ctx']),
+ elts=typedef.GetSetProperty(Tuple_get_elts, Tuple_set_elts, cls=Tuple),
+ ctx=typedef.GetSetProperty(Tuple_get_ctx, Tuple_set_ctx, cls=Tuple),
+ __new__=interp2app(get_AST_new(Tuple)),
+ __init__=interp2app(Tuple_init),
+)
+Tuple.typedef.acceptable_as_base_class = False
+
+def Const_get_value(space, w_self):
+ if not w_self.initialization_state & 1:
+ w_err = space.wrap("attribute 'value' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ return w_self.value
+
+def Const_set_value(space, w_self, w_new_value):
+ w_self.value = w_new_value
+ w_self.initialization_state |= 1
+
+def Const_init(space, w_self, args):
+ w_self = space.descr_self_interp_w(Const, w_self)
+ args_w, kwargs_w = args.unpack()
+ if args_w:
+ if len(args_w) != 3:
+ w_err = space.wrap("Const constructor takes 0 or 3 positional arguments")
+ raise OperationError(space.w_TypeError, w_err)
+ for i, field in unrolling_iterable(enumerate(['value', 'lineno', 'col_offset'])):
+ space.setattr(w_self, space.wrap(field), args_w[i])
+ for field, w_value in kwargs_w.iteritems():
+ space.setattr(w_self, space.wrap(field), w_value)
+Const_init.unwrap_spec = [ObjSpace, W_Root, Arguments]
+
+Const.typedef = typedef.TypeDef("Const",
+ expr.typedef,
+ _fields=_FieldsWrapper(['value']),
+ value=typedef.GetSetProperty(Const_get_value, Const_set_value, cls=Const),
+ __new__=interp2app(get_AST_new(Const)),
+ __init__=interp2app(Const_init),
+)
+Const.typedef.acceptable_as_base_class = False
+
+expr_context.typedef = typedef.TypeDef("expr_context",
+ AST.typedef,
+ _attributes=_FieldsWrapper([]),
+)
+expr_context.typedef.acceptable_as_base_class = False
+
+_Load.typedef = typedef.TypeDef("Load",
+ expr_context.typedef,
+ _fields=_FieldsWrapper([]),
+ __new__=interp2app(get_AST_new(_Load)),
+)
+_Load.typedef.acceptable_as_base_class = False
+
+_Store.typedef = typedef.TypeDef("Store",
+ expr_context.typedef,
+ _fields=_FieldsWrapper([]),
+ __new__=interp2app(get_AST_new(_Store)),
+)
+_Store.typedef.acceptable_as_base_class = False
+
+_Del.typedef = typedef.TypeDef("Del",
+ expr_context.typedef,
+ _fields=_FieldsWrapper([]),
+ __new__=interp2app(get_AST_new(_Del)),
+)
+_Del.typedef.acceptable_as_base_class = False
+
+_AugLoad.typedef = typedef.TypeDef("AugLoad",
+ expr_context.typedef,
+ _fields=_FieldsWrapper([]),
+ __new__=interp2app(get_AST_new(_AugLoad)),
+)
+_AugLoad.typedef.acceptable_as_base_class = False
+
+_AugStore.typedef = typedef.TypeDef("AugStore",
+ expr_context.typedef,
+ _fields=_FieldsWrapper([]),
+ __new__=interp2app(get_AST_new(_AugStore)),
+)
+_AugStore.typedef.acceptable_as_base_class = False
+
+_Param.typedef = typedef.TypeDef("Param",
+ expr_context.typedef,
+ _fields=_FieldsWrapper([]),
+ __new__=interp2app(get_AST_new(_Param)),
+)
+_Param.typedef.acceptable_as_base_class = False
+
+slice.typedef = typedef.TypeDef("slice",
+ AST.typedef,
+ _attributes=_FieldsWrapper([]),
+)
+slice.typedef.acceptable_as_base_class = False
+
+def Ellipsis_init(space, w_self, args):
+ w_self = space.descr_self_interp_w(Ellipsis, w_self)
+ args_w, kwargs_w = args.unpack()
+ if args_w:
+ w_err = space.wrap("Ellipsis constructor takes no arguments")
+ raise OperationError(space.w_TypeError, w_err)
+ for field, w_value in kwargs_w.iteritems():
+ space.setattr(w_self, space.wrap(field), w_value)
+Ellipsis_init.unwrap_spec = [ObjSpace, W_Root, Arguments]
+
+Ellipsis.typedef = typedef.TypeDef("Ellipsis",
+ slice.typedef,
+ _fields=_FieldsWrapper([]),
+ __new__=interp2app(get_AST_new(Ellipsis)),
+ __init__=interp2app(Ellipsis_init),
+)
+Ellipsis.typedef.acceptable_as_base_class = False
+
+def Slice_get_lower(space, w_self):
+ if not w_self.initialization_state & 1:
+ w_err = space.wrap("attribute 'lower' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ return space.wrap(w_self.lower)
+
+def Slice_set_lower(space, w_self, w_new_value):
+ w_self.lower = space.interp_w(expr, w_new_value, True)
+ w_self.initialization_state |= 1
+
+def Slice_get_upper(space, w_self):
+ if not w_self.initialization_state & 2:
+ w_err = space.wrap("attribute 'upper' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ return space.wrap(w_self.upper)
+
+def Slice_set_upper(space, w_self, w_new_value):
+ w_self.upper = space.interp_w(expr, w_new_value, True)
+ w_self.initialization_state |= 2
+
+def Slice_get_step(space, w_self):
+ if not w_self.initialization_state & 4:
+ w_err = space.wrap("attribute 'step' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ return space.wrap(w_self.step)
+
+def Slice_set_step(space, w_self, w_new_value):
+ w_self.step = space.interp_w(expr, w_new_value, True)
+ w_self.initialization_state |= 4
+
+def Slice_init(space, w_self, args):
+ w_self = space.descr_self_interp_w(Slice, w_self)
+ args_w, kwargs_w = args.unpack()
+ if args_w:
+ if len(args_w) != 3:
+ w_err = space.wrap("Slice constructor takes 0 or 3 positional arguments")
+ raise OperationError(space.w_TypeError, w_err)
+ for i, field in unrolling_iterable(enumerate(['lower', 'upper', 'step'])):
+ space.setattr(w_self, space.wrap(field), args_w[i])
+ for field, w_value in kwargs_w.iteritems():
+ space.setattr(w_self, space.wrap(field), w_value)
+Slice_init.unwrap_spec = [ObjSpace, W_Root, Arguments]
+
+Slice.typedef = typedef.TypeDef("Slice",
+ slice.typedef,
+ _fields=_FieldsWrapper(['lower', 'upper', 'step']),
+ lower=typedef.GetSetProperty(Slice_get_lower, Slice_set_lower, cls=Slice),
+ upper=typedef.GetSetProperty(Slice_get_upper, Slice_set_upper, cls=Slice),
+ step=typedef.GetSetProperty(Slice_get_step, Slice_set_step, cls=Slice),
+ __new__=interp2app(get_AST_new(Slice)),
+ __init__=interp2app(Slice_init),
+)
+Slice.typedef.acceptable_as_base_class = False
+
+def ExtSlice_get_dims(space, w_self):
+ if not w_self.initialization_state & 1:
+ w_err = space.wrap("attribute 'dims' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ if w_self.w_dims is None:
+ if w_self.dims is None:
+ w_list = space.newlist([])
+ else:
+ list_w = [space.wrap(node) for node in w_self.dims]
+ w_list = space.newlist(list_w)
+ w_self.w_dims = w_list
+ return w_self.w_dims
+
+def ExtSlice_set_dims(space, w_self, w_new_value):
+ w_self.w_dims = w_new_value
+ w_self.initialization_state |= 1
+
+def ExtSlice_init(space, w_self, args):
+ w_self = space.descr_self_interp_w(ExtSlice, w_self)
+ w_self.w_dims = None
+ args_w, kwargs_w = args.unpack()
+ if args_w:
+ if len(args_w) != 1:
+ w_err = space.wrap("ExtSlice constructor takes 0 or 1 positional arguments")
+ raise OperationError(space.w_TypeError, w_err)
+ for i, field in unrolling_iterable(enumerate(['dims'])):
+ space.setattr(w_self, space.wrap(field), args_w[i])
+ for field, w_value in kwargs_w.iteritems():
+ space.setattr(w_self, space.wrap(field), w_value)
+ExtSlice_init.unwrap_spec = [ObjSpace, W_Root, Arguments]
+
+ExtSlice.typedef = typedef.TypeDef("ExtSlice",
+ slice.typedef,
+ _fields=_FieldsWrapper(['dims']),
+ dims=typedef.GetSetProperty(ExtSlice_get_dims, ExtSlice_set_dims, cls=ExtSlice),
+ __new__=interp2app(get_AST_new(ExtSlice)),
+ __init__=interp2app(ExtSlice_init),
+)
+ExtSlice.typedef.acceptable_as_base_class = False
+
+def Index_get_value(space, w_self):
+ if not w_self.initialization_state & 1:
+ w_err = space.wrap("attribute 'value' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ return space.wrap(w_self.value)
+
+def Index_set_value(space, w_self, w_new_value):
+ w_self.value = space.interp_w(expr, w_new_value, False)
+ w_self.initialization_state |= 1
+
+def Index_init(space, w_self, args):
+ w_self = space.descr_self_interp_w(Index, w_self)
+ args_w, kwargs_w = args.unpack()
+ if args_w:
+ if len(args_w) != 1:
+ w_err = space.wrap("Index constructor takes 0 or 1 positional arguments")
+ raise OperationError(space.w_TypeError, w_err)
+ for i, field in unrolling_iterable(enumerate(['value'])):
+ space.setattr(w_self, space.wrap(field), args_w[i])
+ for field, w_value in kwargs_w.iteritems():
+ space.setattr(w_self, space.wrap(field), w_value)
+Index_init.unwrap_spec = [ObjSpace, W_Root, Arguments]
+
+Index.typedef = typedef.TypeDef("Index",
+ slice.typedef,
+ _fields=_FieldsWrapper(['value']),
+ value=typedef.GetSetProperty(Index_get_value, Index_set_value, cls=Index),
+ __new__=interp2app(get_AST_new(Index)),
+ __init__=interp2app(Index_init),
+)
+Index.typedef.acceptable_as_base_class = False
+
+boolop.typedef = typedef.TypeDef("boolop",
+ AST.typedef,
+ _attributes=_FieldsWrapper([]),
+)
+boolop.typedef.acceptable_as_base_class = False
+
+_And.typedef = typedef.TypeDef("And",
+ boolop.typedef,
+ _fields=_FieldsWrapper([]),
+ __new__=interp2app(get_AST_new(_And)),
+)
+_And.typedef.acceptable_as_base_class = False
+
+_Or.typedef = typedef.TypeDef("Or",
+ boolop.typedef,
+ _fields=_FieldsWrapper([]),
+ __new__=interp2app(get_AST_new(_Or)),
+)
+_Or.typedef.acceptable_as_base_class = False
+
+operator.typedef = typedef.TypeDef("operator",
+ AST.typedef,
+ _attributes=_FieldsWrapper([]),
+)
+operator.typedef.acceptable_as_base_class = False
+
+_Add.typedef = typedef.TypeDef("Add",
+ operator.typedef,
+ _fields=_FieldsWrapper([]),
+ __new__=interp2app(get_AST_new(_Add)),
+)
+_Add.typedef.acceptable_as_base_class = False
+
+_Sub.typedef = typedef.TypeDef("Sub",
+ operator.typedef,
+ _fields=_FieldsWrapper([]),
+ __new__=interp2app(get_AST_new(_Sub)),
+)
+_Sub.typedef.acceptable_as_base_class = False
+
+_Mult.typedef = typedef.TypeDef("Mult",
+ operator.typedef,
+ _fields=_FieldsWrapper([]),
+ __new__=interp2app(get_AST_new(_Mult)),
+)
+_Mult.typedef.acceptable_as_base_class = False
+
+_Div.typedef = typedef.TypeDef("Div",
+ operator.typedef,
+ _fields=_FieldsWrapper([]),
+ __new__=interp2app(get_AST_new(_Div)),
+)
+_Div.typedef.acceptable_as_base_class = False
+
+_Mod.typedef = typedef.TypeDef("Mod",
+ operator.typedef,
+ _fields=_FieldsWrapper([]),
+ __new__=interp2app(get_AST_new(_Mod)),
+)
+_Mod.typedef.acceptable_as_base_class = False
+
+_Pow.typedef = typedef.TypeDef("Pow",
+ operator.typedef,
+ _fields=_FieldsWrapper([]),
+ __new__=interp2app(get_AST_new(_Pow)),
+)
+_Pow.typedef.acceptable_as_base_class = False
+
+_LShift.typedef = typedef.TypeDef("LShift",
+ operator.typedef,
+ _fields=_FieldsWrapper([]),
+ __new__=interp2app(get_AST_new(_LShift)),
+)
+_LShift.typedef.acceptable_as_base_class = False
+
+_RShift.typedef = typedef.TypeDef("RShift",
+ operator.typedef,
+ _fields=_FieldsWrapper([]),
+ __new__=interp2app(get_AST_new(_RShift)),
+)
+_RShift.typedef.acceptable_as_base_class = False
+
+_BitOr.typedef = typedef.TypeDef("BitOr",
+ operator.typedef,
+ _fields=_FieldsWrapper([]),
+ __new__=interp2app(get_AST_new(_BitOr)),
+)
+_BitOr.typedef.acceptable_as_base_class = False
+
+_BitXor.typedef = typedef.TypeDef("BitXor",
+ operator.typedef,
+ _fields=_FieldsWrapper([]),
+ __new__=interp2app(get_AST_new(_BitXor)),
+)
+_BitXor.typedef.acceptable_as_base_class = False
+
+_BitAnd.typedef = typedef.TypeDef("BitAnd",
+ operator.typedef,
+ _fields=_FieldsWrapper([]),
+ __new__=interp2app(get_AST_new(_BitAnd)),
+)
+_BitAnd.typedef.acceptable_as_base_class = False
+
+_FloorDiv.typedef = typedef.TypeDef("FloorDiv",
+ operator.typedef,
+ _fields=_FieldsWrapper([]),
+ __new__=interp2app(get_AST_new(_FloorDiv)),
+)
+_FloorDiv.typedef.acceptable_as_base_class = False
+
+unaryop.typedef = typedef.TypeDef("unaryop",
+ AST.typedef,
+ _attributes=_FieldsWrapper([]),
+)
+unaryop.typedef.acceptable_as_base_class = False
+
+_Invert.typedef = typedef.TypeDef("Invert",
+ unaryop.typedef,
+ _fields=_FieldsWrapper([]),
+ __new__=interp2app(get_AST_new(_Invert)),
+)
+_Invert.typedef.acceptable_as_base_class = False
+
+_Not.typedef = typedef.TypeDef("Not",
+ unaryop.typedef,
+ _fields=_FieldsWrapper([]),
+ __new__=interp2app(get_AST_new(_Not)),
+)
+_Not.typedef.acceptable_as_base_class = False
+
+_UAdd.typedef = typedef.TypeDef("UAdd",
+ unaryop.typedef,
+ _fields=_FieldsWrapper([]),
+ __new__=interp2app(get_AST_new(_UAdd)),
+)
+_UAdd.typedef.acceptable_as_base_class = False
+
+_USub.typedef = typedef.TypeDef("USub",
+ unaryop.typedef,
+ _fields=_FieldsWrapper([]),
+ __new__=interp2app(get_AST_new(_USub)),
+)
+_USub.typedef.acceptable_as_base_class = False
+
+cmpop.typedef = typedef.TypeDef("cmpop",
+ AST.typedef,
+ _attributes=_FieldsWrapper([]),
+)
+cmpop.typedef.acceptable_as_base_class = False
+
+_Eq.typedef = typedef.TypeDef("Eq",
+ cmpop.typedef,
+ _fields=_FieldsWrapper([]),
+ __new__=interp2app(get_AST_new(_Eq)),
+)
+_Eq.typedef.acceptable_as_base_class = False
+
+_NotEq.typedef = typedef.TypeDef("NotEq",
+ cmpop.typedef,
+ _fields=_FieldsWrapper([]),
+ __new__=interp2app(get_AST_new(_NotEq)),
+)
+_NotEq.typedef.acceptable_as_base_class = False
+
+_Lt.typedef = typedef.TypeDef("Lt",
+ cmpop.typedef,
+ _fields=_FieldsWrapper([]),
+ __new__=interp2app(get_AST_new(_Lt)),
+)
+_Lt.typedef.acceptable_as_base_class = False
+
+_LtE.typedef = typedef.TypeDef("LtE",
+ cmpop.typedef,
+ _fields=_FieldsWrapper([]),
+ __new__=interp2app(get_AST_new(_LtE)),
+)
+_LtE.typedef.acceptable_as_base_class = False
+
+_Gt.typedef = typedef.TypeDef("Gt",
+ cmpop.typedef,
+ _fields=_FieldsWrapper([]),
+ __new__=interp2app(get_AST_new(_Gt)),
+)
+_Gt.typedef.acceptable_as_base_class = False
+
+_GtE.typedef = typedef.TypeDef("GtE",
+ cmpop.typedef,
+ _fields=_FieldsWrapper([]),
+ __new__=interp2app(get_AST_new(_GtE)),
+)
+_GtE.typedef.acceptable_as_base_class = False
+
+_Is.typedef = typedef.TypeDef("Is",
+ cmpop.typedef,
+ _fields=_FieldsWrapper([]),
+ __new__=interp2app(get_AST_new(_Is)),
+)
+_Is.typedef.acceptable_as_base_class = False
+
+_IsNot.typedef = typedef.TypeDef("IsNot",
+ cmpop.typedef,
+ _fields=_FieldsWrapper([]),
+ __new__=interp2app(get_AST_new(_IsNot)),
+)
+_IsNot.typedef.acceptable_as_base_class = False
+
+_In.typedef = typedef.TypeDef("In",
+ cmpop.typedef,
+ _fields=_FieldsWrapper([]),
+ __new__=interp2app(get_AST_new(_In)),
+)
+_In.typedef.acceptable_as_base_class = False
+
+_NotIn.typedef = typedef.TypeDef("NotIn",
+ cmpop.typedef,
+ _fields=_FieldsWrapper([]),
+ __new__=interp2app(get_AST_new(_NotIn)),
+)
+_NotIn.typedef.acceptable_as_base_class = False
+
+def comprehension_get_target(space, w_self):
+ if not w_self.initialization_state & 1:
+ w_err = space.wrap("attribute 'target' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ return space.wrap(w_self.target)
+
+def comprehension_set_target(space, w_self, w_new_value):
+ w_self.target = space.interp_w(expr, w_new_value, False)
+ w_self.initialization_state |= 1
+
+def comprehension_get_iter(space, w_self):
+ if not w_self.initialization_state & 2:
+ w_err = space.wrap("attribute 'iter' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ return space.wrap(w_self.iter)
+
+def comprehension_set_iter(space, w_self, w_new_value):
+ w_self.iter = space.interp_w(expr, w_new_value, False)
+ w_self.initialization_state |= 2
+
+def comprehension_get_ifs(space, w_self):
+ if not w_self.initialization_state & 4:
+ w_err = space.wrap("attribute 'ifs' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ if w_self.w_ifs is None:
+ if w_self.ifs is None:
+ w_list = space.newlist([])
+ else:
+ list_w = [space.wrap(node) for node in w_self.ifs]
+ w_list = space.newlist(list_w)
+ w_self.w_ifs = w_list
+ return w_self.w_ifs
+
+def comprehension_set_ifs(space, w_self, w_new_value):
+ w_self.w_ifs = w_new_value
+ w_self.initialization_state |= 4
+
+def comprehension_init(space, w_self, args):
+ w_self = space.descr_self_interp_w(comprehension, w_self)
+ w_self.w_ifs = None
+ args_w, kwargs_w = args.unpack()
+ if args_w:
+ if len(args_w) != 3:
+ w_err = space.wrap("comprehension constructor takes 0 or 3 positional arguments")
+ raise OperationError(space.w_TypeError, w_err)
+ for i, field in unrolling_iterable(enumerate(['target', 'iter', 'ifs'])):
+ space.setattr(w_self, space.wrap(field), args_w[i])
+ for field, w_value in kwargs_w.iteritems():
+ space.setattr(w_self, space.wrap(field), w_value)
+comprehension_init.unwrap_spec = [ObjSpace, W_Root, Arguments]
+
+comprehension.typedef = typedef.TypeDef("comprehension",
+ AST.typedef,
+ _fields=_FieldsWrapper(['target', 'iter', 'ifs']),
+ target=typedef.GetSetProperty(comprehension_get_target, comprehension_set_target, cls=comprehension),
+ iter=typedef.GetSetProperty(comprehension_get_iter, comprehension_set_iter, cls=comprehension),
+ ifs=typedef.GetSetProperty(comprehension_get_ifs, comprehension_set_ifs, cls=comprehension),
+ __new__=interp2app(get_AST_new(comprehension)),
+ __init__=interp2app(comprehension_init),
+)
+comprehension.typedef.acceptable_as_base_class = False
+
+def excepthandler_get_type(space, w_self):
+ if not w_self.initialization_state & 1:
+ w_err = space.wrap("attribute 'type' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ return space.wrap(w_self.type)
+
+def excepthandler_set_type(space, w_self, w_new_value):
+ w_self.type = space.interp_w(expr, w_new_value, True)
+ w_self.initialization_state |= 1
+
+def excepthandler_get_name(space, w_self):
+ if not w_self.initialization_state & 2:
+ w_err = space.wrap("attribute 'name' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ return space.wrap(w_self.name)
+
+def excepthandler_set_name(space, w_self, w_new_value):
+ w_self.name = space.interp_w(expr, w_new_value, True)
+ w_self.initialization_state |= 2
+
+def excepthandler_get_body(space, w_self):
+ if not w_self.initialization_state & 4:
+ w_err = space.wrap("attribute 'body' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ if w_self.w_body is None:
+ if w_self.body is None:
+ w_list = space.newlist([])
+ else:
+ list_w = [space.wrap(node) for node in w_self.body]
+ w_list = space.newlist(list_w)
+ w_self.w_body = w_list
+ return w_self.w_body
+
+def excepthandler_set_body(space, w_self, w_new_value):
+ w_self.w_body = w_new_value
+ w_self.initialization_state |= 4
+
+def excepthandler_get_lineno(space, w_self):
+ if not w_self.initialization_state & 8:
+ w_err = space.wrap("attribute 'lineno' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ return space.wrap(w_self.lineno)
+
+def excepthandler_set_lineno(space, w_self, w_new_value):
+ w_self.lineno = space.int_w(w_new_value)
+ w_self.initialization_state |= 8
+
+def excepthandler_get_col_offset(space, w_self):
+ if not w_self.initialization_state & 16:
+ w_err = space.wrap("attribute 'col_offset' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ return space.wrap(w_self.col_offset)
+
+def excepthandler_set_col_offset(space, w_self, w_new_value):
+ w_self.col_offset = space.int_w(w_new_value)
+ w_self.initialization_state |= 16
+
+def excepthandler_init(space, w_self, args):
+ w_self = space.descr_self_interp_w(excepthandler, w_self)
+ w_self.w_body = None
+ args_w, kwargs_w = args.unpack()
+ if args_w:
+ if len(args_w) != 5:
+ w_err = space.wrap("excepthandler constructor takes 0 or 5 positional arguments")
+ raise OperationError(space.w_TypeError, w_err)
+ for i, field in unrolling_iterable(enumerate(['type', 'name', 'body', 'lineno', 'col_offset'])):
+ space.setattr(w_self, space.wrap(field), args_w[i])
+ for field, w_value in kwargs_w.iteritems():
+ space.setattr(w_self, space.wrap(field), w_value)
+excepthandler_init.unwrap_spec = [ObjSpace, W_Root, Arguments]
+
+excepthandler.typedef = typedef.TypeDef("excepthandler",
+ AST.typedef,
+ _fields=_FieldsWrapper(['type', 'name', 'body', 'lineno', 'col_offset']),
+ type=typedef.GetSetProperty(excepthandler_get_type, excepthandler_set_type, cls=excepthandler),
+ name=typedef.GetSetProperty(excepthandler_get_name, excepthandler_set_name, cls=excepthandler),
+ body=typedef.GetSetProperty(excepthandler_get_body, excepthandler_set_body, cls=excepthandler),
+ lineno=typedef.GetSetProperty(excepthandler_get_lineno, excepthandler_set_lineno, cls=excepthandler),
+ col_offset=typedef.GetSetProperty(excepthandler_get_col_offset, excepthandler_set_col_offset, cls=excepthandler),
+ __new__=interp2app(get_AST_new(excepthandler)),
+ __init__=interp2app(excepthandler_init),
+)
+excepthandler.typedef.acceptable_as_base_class = False
+
+def arguments_get_args(space, w_self):
+ if not w_self.initialization_state & 1:
+ w_err = space.wrap("attribute 'args' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ if w_self.w_args is None:
+ if w_self.args is None:
+ w_list = space.newlist([])
+ else:
+ list_w = [space.wrap(node) for node in w_self.args]
+ w_list = space.newlist(list_w)
+ w_self.w_args = w_list
+ return w_self.w_args
+
+def arguments_set_args(space, w_self, w_new_value):
+ w_self.w_args = w_new_value
+ w_self.initialization_state |= 1
+
+def arguments_get_vararg(space, w_self):
+ if not w_self.initialization_state & 2:
+ w_err = space.wrap("attribute 'vararg' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ return space.wrap(w_self.vararg)
+
+def arguments_set_vararg(space, w_self, w_new_value):
+ if space.is_w(w_new_value, space.w_None):
+ w_self.vararg = None
+ else:
+ w_self.vararg = space.str_w(w_new_value)
+ w_self.initialization_state |= 2
+
+def arguments_get_kwarg(space, w_self):
+ if not w_self.initialization_state & 4:
+ w_err = space.wrap("attribute 'kwarg' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ return space.wrap(w_self.kwarg)
+
+def arguments_set_kwarg(space, w_self, w_new_value):
+ if space.is_w(w_new_value, space.w_None):
+ w_self.kwarg = None
+ else:
+ w_self.kwarg = space.str_w(w_new_value)
+ w_self.initialization_state |= 4
+
+def arguments_get_defaults(space, w_self):
+ if not w_self.initialization_state & 8:
+ w_err = space.wrap("attribute 'defaults' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ if w_self.w_defaults is None:
+ if w_self.defaults is None:
+ w_list = space.newlist([])
+ else:
+ list_w = [space.wrap(node) for node in w_self.defaults]
+ w_list = space.newlist(list_w)
+ w_self.w_defaults = w_list
+ return w_self.w_defaults
+
+def arguments_set_defaults(space, w_self, w_new_value):
+ w_self.w_defaults = w_new_value
+ w_self.initialization_state |= 8
+
+def arguments_init(space, w_self, args):
+ w_self = space.descr_self_interp_w(arguments, w_self)
+ w_self.w_args = None
+ w_self.w_defaults = None
+ args_w, kwargs_w = args.unpack()
+ if args_w:
+ if len(args_w) != 4:
+ w_err = space.wrap("arguments constructor takes 0 or 4 positional arguments")
+ raise OperationError(space.w_TypeError, w_err)
+ for i, field in unrolling_iterable(enumerate(['args', 'vararg', 'kwarg', 'defaults'])):
+ space.setattr(w_self, space.wrap(field), args_w[i])
+ for field, w_value in kwargs_w.iteritems():
+ space.setattr(w_self, space.wrap(field), w_value)
+arguments_init.unwrap_spec = [ObjSpace, W_Root, Arguments]
+
+arguments.typedef = typedef.TypeDef("arguments",
+ AST.typedef,
+ _fields=_FieldsWrapper(['args', 'vararg', 'kwarg', 'defaults']),
+ args=typedef.GetSetProperty(arguments_get_args, arguments_set_args, cls=arguments),
+ vararg=typedef.GetSetProperty(arguments_get_vararg, arguments_set_vararg, cls=arguments),
+ kwarg=typedef.GetSetProperty(arguments_get_kwarg, arguments_set_kwarg, cls=arguments),
+ defaults=typedef.GetSetProperty(arguments_get_defaults, arguments_set_defaults, cls=arguments),
+ __new__=interp2app(get_AST_new(arguments)),
+ __init__=interp2app(arguments_init),
+)
+arguments.typedef.acceptable_as_base_class = False
+
+def keyword_get_arg(space, w_self):
+ if not w_self.initialization_state & 1:
+ w_err = space.wrap("attribute 'arg' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ return space.wrap(w_self.arg)
+
+def keyword_set_arg(space, w_self, w_new_value):
+ w_self.arg = space.str_w(w_new_value)
+ w_self.initialization_state |= 1
+
+def keyword_get_value(space, w_self):
+ if not w_self.initialization_state & 2:
+ w_err = space.wrap("attribute 'value' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ return space.wrap(w_self.value)
+
+def keyword_set_value(space, w_self, w_new_value):
+ w_self.value = space.interp_w(expr, w_new_value, False)
+ w_self.initialization_state |= 2
+
+def keyword_init(space, w_self, args):
+ w_self = space.descr_self_interp_w(keyword, w_self)
+ args_w, kwargs_w = args.unpack()
+ if args_w:
+ if len(args_w) != 2:
+ w_err = space.wrap("keyword constructor takes 0 or 2 positional arguments")
+ raise OperationError(space.w_TypeError, w_err)
+ for i, field in unrolling_iterable(enumerate(['arg', 'value'])):
+ space.setattr(w_self, space.wrap(field), args_w[i])
+ for field, w_value in kwargs_w.iteritems():
+ space.setattr(w_self, space.wrap(field), w_value)
+keyword_init.unwrap_spec = [ObjSpace, W_Root, Arguments]
+
+keyword.typedef = typedef.TypeDef("keyword",
+ AST.typedef,
+ _fields=_FieldsWrapper(['arg', 'value']),
+ arg=typedef.GetSetProperty(keyword_get_arg, keyword_set_arg, cls=keyword),
+ value=typedef.GetSetProperty(keyword_get_value, keyword_set_value, cls=keyword),
+ __new__=interp2app(get_AST_new(keyword)),
+ __init__=interp2app(keyword_init),
+)
+keyword.typedef.acceptable_as_base_class = False
+
+def alias_get_name(space, w_self):
+ if not w_self.initialization_state & 1:
+ w_err = space.wrap("attribute 'name' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ return space.wrap(w_self.name)
+
+def alias_set_name(space, w_self, w_new_value):
+ w_self.name = space.str_w(w_new_value)
+ w_self.initialization_state |= 1
+
+def alias_get_asname(space, w_self):
+ if not w_self.initialization_state & 2:
+ w_err = space.wrap("attribute 'asname' has not been set")
+ raise OperationError(space.w_AttributeError, w_err)
+ return space.wrap(w_self.asname)
+
+def alias_set_asname(space, w_self, w_new_value):
+ if space.is_w(w_new_value, space.w_None):
+ w_self.asname = None
+ else:
+ w_self.asname = space.str_w(w_new_value)
+ w_self.initialization_state |= 2
+
+def alias_init(space, w_self, args):
+ w_self = space.descr_self_interp_w(alias, w_self)
+ args_w, kwargs_w = args.unpack()
+ if args_w:
+ if len(args_w) != 2:
+ w_err = space.wrap("alias constructor takes 0 or 2 positional arguments")
+ raise OperationError(space.w_TypeError, w_err)
+ for i, field in unrolling_iterable(enumerate(['name', 'asname'])):
+ space.setattr(w_self, space.wrap(field), args_w[i])
+ for field, w_value in kwargs_w.iteritems():
+ space.setattr(w_self, space.wrap(field), w_value)
+alias_init.unwrap_spec = [ObjSpace, W_Root, Arguments]
+
+alias.typedef = typedef.TypeDef("alias",
+ AST.typedef,
+ _fields=_FieldsWrapper(['name', 'asname']),
+ name=typedef.GetSetProperty(alias_get_name, alias_set_name, cls=alias),
+ asname=typedef.GetSetProperty(alias_get_asname, alias_set_asname, cls=alias),
+ __new__=interp2app(get_AST_new(alias)),
+ __init__=interp2app(alias_init),
+)
+alias.typedef.acceptable_as_base_class = False
+
Modified: pypy/branch/parser-compiler/pypy/interpreter/astcompiler/consts.py
==============================================================================
--- pypy/branch/parser-compiler/pypy/interpreter/astcompiler/consts.py (original)
+++ pypy/branch/parser-compiler/pypy/interpreter/astcompiler/consts.py Sun Aug 16 23:51:12 2009
@@ -25,3 +25,4 @@
PyCF_SOURCE_IS_UTF8 = 0x0100
PyCF_DONT_IMPLY_DEDENT = 0x0200
+PyCF_AST_ONLY = 0x0400
Modified: pypy/branch/parser-compiler/pypy/interpreter/astcompiler/tools/asdl_py.py
==============================================================================
--- pypy/branch/parser-compiler/pypy/interpreter/astcompiler/tools/asdl_py.py (original)
+++ pypy/branch/parser-compiler/pypy/interpreter/astcompiler/tools/asdl_py.py Sun Aug 16 23:51:12 2009
@@ -9,9 +9,10 @@
class ASDLVisitor(asdl.VisitorBase):
- def __init__(self, stream):
+ def __init__(self, stream, data):
super(ASDLVisitor, self).__init__()
self.stream = stream
+ self.data = data
def visitModule(self, mod, *args):
for df in mod.dfns:
@@ -39,32 +40,42 @@
indent = " "*level
self.stream.write(indent + line + "\n")
- def is_simple_sum(self, sum):
- assert isinstance(sum, asdl.Sum)
- for constructor in sum.types:
- if constructor.fields:
- return False
- return True
+def is_simple_sum(sum):
+ assert isinstance(sum, asdl.Sum)
+ for constructor in sum.types:
+ if constructor.fields:
+ return False
+ return True
-class ASTNodeVisitor(ASDLVisitor):
- def visitModule(self, mod):
- dont_touch = set()
- for type in mod.dfns:
- if isinstance(type.value, asdl.Product) or \
- self.is_simple_sum(type.value):
- dont_touch.add(type.name.value)
- super(ASTNodeVisitor, self).visitModule(mod, dont_touch)
+class ASTNodeVisitor(ASDLVisitor):
- def visitType(self, tp, simple):
- self.visit(tp.value, tp.name, simple)
+ def visitType(self, tp):
+ self.visit(tp.value, tp.name)
- def visitSum(self, sum, base, simple):
- if self.is_simple_sum(sum):
+ def visitSum(self, sum, base):
+ if is_simple_sum(sum):
+ self.emit("class %s(AST):" % (base,))
+ self.emit("")
+ self.emit("def to_simple_int(self, space):", 1)
+ self.emit("w_msg = space.wrap(\"not a valid %s\")" % (base,), 2)
+ self.emit("raise OperationError(space.w_TypeError, w_msg)", 2)
+ self.emit("")
+ for i, cons in enumerate(sum.types):
+ self.emit("class _%s(%s):" % (cons.name, base))
+ self.emit("")
+ self.emit("def to_simple_int(self):", 1)
+ self.emit("return %i" % (i + 1,), 2)
+ self.emit("")
for i, cons in enumerate(sum.types):
self.emit("%s = %i" % (cons.name, i + 1))
self.emit("")
+ self.emit("%s_to_class = [" % (base,))
+ for cons in sum.types:
+ self.emit("_%s," % (cons.name,), 1)
+ self.emit("]")
+ self.emit("")
else:
self.emit("class %s(AST):" % (base,))
self.emit("")
@@ -78,22 +89,82 @@
self.visit(attr)
self.emit("")
for cons in sum.types:
- self.visit(cons, base, sum.attributes, simple)
+ self.visit(cons, base, sum.attributes)
self.emit("")
- def visitProduct(self, product, name, simple):
+ def visitProduct(self, product, name):
self.emit("class %s(AST):" % (name,))
self.emit("")
- slots = ", ".join(repr(field.name.value) for field in product.fields)
+ slots = self.make_slots(product.fields)
self.emit("__slots__ = (%s)" % (slots,), 1)
self.emit("")
- self.make_constructor(product.fields)
+ self.make_constructor(product.fields, product)
self.emit("")
self.emit("def walkabout(self, visitor):", 1)
self.emit("visitor.visit_%s(self)" % (name,), 2)
self.emit("")
+ self.make_var_syncer(product.fields, product, name)
+
+ def make_slots(self, fields):
+ slots = []
+ for field in fields:
+ name = repr(field.name.value)
+ slots.append(name)
+ if field.seq:
+ slots.append("'w_%s'" % (field.name,))
+ return ", ".join(slots)
- def make_constructor(self, fields, extras=None, base=None):
+ def make_var_syncer(self, fields, node, name):
+ self.emit("def sync_app_attrs(self, space):", 1)
+ config = (self.data.optional_masks[node],
+ self.data.required_masks[node])
+ self.emit("if (self.initialization_state & ~%i) ^ %i:" % config, 2)
+ names = []
+ for field in fields:
+ if field.opt:
+ names.append("None")
+ else:
+ names.append(repr(field.name.value))
+ sub = (", ".join(names), name.value)
+ self.emit("missing_field(space, self.initialization_state, [%s], %r)"
+ % sub, 3)
+ self.emit("else:", 2)
+ # Fill in all the default fields.
+ doing_something = False
+ for field in fields:
+ if field.opt:
+ doing_something = True
+ flag = self.data.field_masks[field]
+ self.emit("if not self.initialization_state & %i:" % (flag,), 3)
+ default = "0" if field.type.value == "int" else "None"
+ self.emit("self.%s = %s" % (field.name, default), 4)
+ if not doing_something:
+ self.emit("pass", 3)
+ for attr in fields:
+ if attr.seq:
+ self.emit("w_list = self.w_%s" % (attr.name,), 2)
+ self.emit("if w_list is not None:", 2)
+ self.emit("list_w = space.viewiterable(w_list)", 3)
+ self.emit("if list_w:", 3)
+ unwrapper = get_unwrapper(attr.type.value, "w_obj",
+ self.data.simple_types)
+ config = (attr.name, unwrapper)
+ self.emit("self.%s = [%s for w_obj in list_w]" % config,
+ 4),
+ self.emit("else:", 3)
+ self.emit("self.%s = None" % (attr.name,), 4)
+ if attr.type.value not in asdl.builtin_types and \
+ attr.type.value not in self.data.simple_types:
+ self.emit("if self.%s is not None:" % (attr.name,), 2)
+ self.emit("for node in self.%s:" % (attr.name,), 3)
+ self.emit("node.sync_app_attrs(space)", 4)
+ elif attr.type.value not in asdl.builtin_types and \
+ attr.type.value not in self.data.simple_types:
+ doing_something = True
+ self.emit("self.%s.sync_app_attrs(space)" % (attr.name,), 2)
+ self.emit("")
+
+ def make_constructor(self, fields, node, extras=None, base=None):
if fields or extras:
arg_fields = fields + extras if extras else fields
args = ", ".join(str(field.name) for field in arg_fields)
@@ -105,15 +176,21 @@
self.emit("%s.__init__(self, %s)" % (base, base_args), 2)
else:
self.emit("def __init__(self):", 1)
- self.emit("pass", 2)
+ have_everything = self.data.required_masks[node] | \
+ self.data.optional_masks[node]
+ self.emit("self.initialization_state = %i" % (have_everything,), 2)
- def visitConstructor(self, cons, base, extra_attributes, simple):
+ def visitConstructor(self, cons, base, extra_attributes):
self.emit("class %s(%s):" % (cons.name, base))
self.emit("")
- slots = ", ".join(repr(field.name.value) for field in cons.fields)
+ slots = self.make_slots(cons.fields)
self.emit("__slots__ = (%s)" % (slots,), 1)
self.emit("")
- self.make_constructor(cons.fields, extra_attributes, base)
+ for field in self.data.cons_attributes[cons]:
+ subst = (field.name, self.data.field_masks[field])
+ self.emit("_%s_mask = %i" % subst, 1)
+ self.emit("")
+ self.make_constructor(cons.fields, cons, extra_attributes, base)
self.emit("")
self.emit("def walkabout(self, visitor):", 1)
self.emit("visitor.visit_%s(self)" % (cons.name,), 2)
@@ -121,7 +198,7 @@
self.emit("def mutate_over(self, visitor):", 1)
for field in cons.fields:
if field.type.value not in asdl.builtin_types and \
- field.type.value not in simple:
+ field.type.value not in self.data.prod_simple:
if field.opt or field.seq:
level = 3
self.emit("if self.%s:" % (field.name,), 2)
@@ -135,9 +212,14 @@
self.emit("self.%s = self.%s.mutate_over(visitor)" % sub,
level)
self.emit("return visitor.visit_%s(self)" % (cons.name,), 2)
+ self.emit("")
+ self.make_var_syncer(cons.fields + self.data.cons_attributes[cons],
+ cons, cons.name)
def visitField(self, field):
self.emit("self.%s = %s" % (field.name, field.name), 2)
+ if field.seq:
+ self.emit("self.w_%s = None" % (field.name,), 2)
class ASTVisitorVisitor(ASDLVisitor):
@@ -162,7 +244,7 @@
def visitType(self, tp):
if not (isinstance(tp.value, asdl.Sum) and
- self.is_simple_sum(tp.value)):
+ is_simple_sum(tp.value)):
super(ASTVisitorVisitor, self).visitType(tp, tp.name)
def visitProduct(self, prod, name):
@@ -179,37 +261,33 @@
def visitModule(self, mod):
self.emit("class GenericASTVisitor(ASTVisitor):")
self.emit("")
- simple = set()
- for tp in mod.dfns:
- if isinstance(tp.value, asdl.Sum) and self.is_simple_sum(tp.value):
- simple.add(tp.name.value)
- super(GenericASTVisitorVisitor, self).visitModule(mod, simple)
+ super(GenericASTVisitorVisitor, self).visitModule(mod)
self.emit("")
- def visitType(self, tp, simple):
+ def visitType(self, tp):
if not (isinstance(tp.value, asdl.Sum) and
- self.is_simple_sum(tp.value)):
- super(GenericASTVisitorVisitor, self).visitType(tp, tp.name, simple)
+ is_simple_sum(tp.value)):
+ super(GenericASTVisitorVisitor, self).visitType(tp, tp.name)
- def visitProduct(self, prod, name, simple):
- self.make_visitor(name, prod.fields, simple)
+ def visitProduct(self, prod, name):
+ self.make_visitor(name, prod.fields)
- def visitConstructor(self, cons, _, simple):
- self.make_visitor(cons.name, cons.fields, simple)
+ def visitConstructor(self, cons, _):
+ self.make_visitor(cons.name, cons.fields)
- def make_visitor(self, name, fields, simple):
+ def make_visitor(self, name, fields):
self.emit("def visit_%s(self, node):" % (name,), 1)
have_body = False
for field in fields:
- if self.visitField(field, simple):
+ if self.visitField(field):
have_body = True
if not have_body:
self.emit("pass", 2)
self.emit("")
- def visitField(self, field, simple):
+ def visitField(self, field):
if field.type.value not in asdl.builtin_types and \
- field.type.value not in simple:
+ field.type.value not in self.data.simple_types:
if field.seq or field.opt:
self.emit("if node.%s:" % (field.name,), 2)
level = 3
@@ -224,14 +302,240 @@
return False
+asdl_type_map = {
+ "int" : "int_w",
+ "identifier" : "str_w",
+ "bool" : "bool_w"
+}
+
+def get_unwrapper(tp, name, simple_types):
+ if tp in asdl.builtin_types:
+ return "space.%s(%s)" % (asdl_type_map[tp], name)
+ elif tp in simple_types:
+ return "%s.to_simple_int()" % (name,)
+ return "space.interp_w(%s, %s)" % (tp, name)
+
+
+class AppExposeVisitor(ASDLVisitor):
+
+ def visitType(self, tp):
+ super(AppExposeVisitor, self).visitType(tp, tp.name)
+
+ def visitSum(self, sum, name):
+ for field in sum.attributes:
+ self.make_property(field, name, True)
+ self.make_typedef(name, "AST", sum.attributes,
+ fields_name="_attributes")
+ if not is_simple_sum(sum):
+ super(AppExposeVisitor, self).visitSum(sum, name)
+ else:
+ for cons in sum.types:
+ self.make_typedef("_" + cons.name.value, name, (), cons.name,
+ concrete=True)
+
+ def make_typedef(self, name, base, fields, display_name=None,
+ fields_name="_fields", concrete=False, needs_init=False):
+ if display_name is None:
+ display_name = name
+ self.emit("%s.typedef = typedef.TypeDef(\"%s\"," % (name, display_name))
+ self.emit("%s.typedef," % (base,), 1)
+ comma_fields = ", ".join(repr(field.name.value) for field in fields)
+ self.emit("%s=_FieldsWrapper([%s])," % (fields_name, comma_fields), 1)
+ for field in fields:
+ getter = "%s_get_%s" % (name, field.name)
+ setter = "%s_set_%s" % (name, field.name)
+ config = (field.name, getter, setter, name)
+ self.emit("%s=typedef.GetSetProperty(%s, %s, cls=%s)," % config, 1)
+ # CPython lets you create instances of "abstract" AST nodes
+ # like ast.expr or even ast.AST. This doesn't seem to useful
+ # and would be a pain to implement safely, so we don't allow
+ # it.
+ if concrete:
+ self.emit("__new__=interp2app(get_AST_new(%s))," % (name,), 1)
+ if needs_init:
+ self.emit("__init__=interp2app(%s_init)," % (name,), 1)
+ self.emit(")")
+ self.emit("%s.typedef.acceptable_as_base_class = False" % (name,))
+ self.emit("")
+
+ def make_init(self, name, fields):
+ self.emit("def %s_init(space, w_self, args):" % (name,))
+ self.emit("w_self = space.descr_self_interp_w(%s, w_self)" % (name,), 1)
+ for field in fields:
+ if field.seq:
+ self.emit("w_self.w_%s = None" % (field.name,), 1)
+ self.emit("args_w, kwargs_w = args.unpack()", 1)
+ self.emit("if args_w:", 1)
+ arity = len(fields)
+ comma_fields = ", ".join(repr(field.name.value) for field in fields)
+ if arity:
+ self.emit("if len(args_w) != %i:" % (arity,), 2)
+ self.emit("w_err = space.wrap(\"%s constructor takes 0 or %i " \
+ "positional arguments\")" % (name, arity), 3)
+ self.emit("raise OperationError(space.w_TypeError, w_err)", 3)
+ self.emit("for i, field in unrolling_iterable(enumerate([%s])):" %
+ (comma_fields,), 2)
+ self.emit("space.setattr(w_self, space.wrap(field), args_w[i])", 3)
+ else:
+ self.emit("w_err = space.wrap(\"%s constructor takes no " \
+ " arguments\")" % (name,), 2)
+ self.emit("raise OperationError(space.w_TypeError, w_err)", 2)
+ self.emit("for field, w_value in kwargs_w.iteritems():", 1)
+ self.emit("space.setattr(w_self, space.wrap(field), w_value)", 2)
+ self.emit("%s_init.unwrap_spec = [ObjSpace, W_Root, Arguments]"
+ % (name,))
+ self.emit("")
+
+ def visitConstructor(self, cons, base):
+ super(AppExposeVisitor, self).visitConstructor(cons, cons.name)
+ self.make_init(cons.name, cons.fields + self.data.cons_attributes[cons])
+ self.make_typedef(cons.name, base, cons.fields, concrete=True,
+ needs_init=True)
+
+ def visitProduct(self, product, name):
+ super(AppExposeVisitor, self).visitProduct(product, name)
+ self.make_init(name, product.fields)
+ self.make_typedef(name, "AST", product.fields, concrete=True,
+ needs_init=True)
+
+ def visitField(self, field, name):
+ self.make_property(field, name)
+
+ def make_property(self, field, name, different_masks=False):
+ func = "def %s_get_%s(space, w_self):" % (name, field.name)
+ self.emit(func)
+ if different_masks:
+ flag = "w_self._%s_mask" % (field.name,)
+ else:
+ flag = self.data.field_masks[field]
+ self.emit("if not w_self.initialization_state & %s:" % (flag,), 1)
+ self.emit("w_err = space.wrap(\"attribute '%s' has not been set\")" %
+ (field.name,), 2)
+ self.emit("raise OperationError(space.w_AttributeError, w_err)", 2)
+ if field.seq:
+ self.emit("if w_self.w_%s is None:" % (field.name,), 1)
+ self.emit("if w_self.%s is None:" % (field.name,), 2)
+ self.emit("w_list = space.newlist([])", 3)
+ self.emit("else:", 2)
+ if field.type.value in self.data.simple_types:
+ wrapper = "%s_to_class[node - 1]()" % (field.type,)
+ else:
+ wrapper = "space.wrap(node)"
+ self.emit("list_w = [%s for node in w_self.%s]" %
+ (wrapper, field.name), 3)
+ self.emit("w_list = space.newlist(list_w)", 3)
+ self.emit("w_self.w_%s = w_list" % (field.name,), 2)
+ self.emit("return w_self.w_%s" % (field.name,), 1)
+ elif field.type.value in self.data.simple_types:
+ config = (field.type, field.name)
+ self.emit("return %s_to_class[w_self.%s - 1]()" % config, 1)
+ elif field.type.value in ("object", "string"):
+ self.emit("return w_self.%s" % (field.name,), 1)
+ else:
+ self.emit("return space.wrap(w_self.%s)" % (field.name,), 1)
+ self.emit("")
+
+ func = "def %s_set_%s(space, w_self, w_new_value):" % (name, field.name)
+ self.emit(func)
+ if field.seq:
+ self.emit("w_self.w_%s = w_new_value" % (field.name,), 1)
+ elif field.type.value not in asdl.builtin_types:
+ # These are always other AST nodes.
+ if field.type.value in self.data.simple_types:
+ self.emit("obj = space.interp_w(%s, w_new_value)" % \
+ (field.type,), 1)
+ self.emit("w_self.%s = obj.to_simple_int()" % (field.name,), 1)
+ else:
+ config = (field.name, field.type, repr(field.opt))
+ self.emit("w_self.%s = space.interp_w(%s, w_new_value, %s)" %
+ config, 1)
+ else:
+ level = 1
+ if field.opt:
+ self.emit("if space.is_w(w_new_value, space.w_None):", 1)
+ self.emit("w_self.%s = None" % (field.name,), 2)
+ level += 1
+ self.emit("else:", 1)
+ if field.type.value == "object":
+ self.emit("w_self.%s = w_new_value" % (field.name,), level)
+ elif field.type.value == "string":
+ self.emit("if not space.is_true(space.isinstance(" \
+ "w_new_value, space.w_basestring)):", level)
+ line = "w_err = space.wrap(\"some kind of string required\")"
+ self.emit(line, level + 1)
+ self.emit("raise OperationError(space.w_TypeError, w_err)",
+ level + 1)
+ self.emit("w_self.%s = w_new_value" % (field.name,), level)
+ else:
+ space_method = asdl_type_map[field.type.value]
+ config = (field.name, space_method)
+ self.emit("w_self.%s = space.%s(w_new_value)" % config, level)
+ self.emit("w_self.initialization_state |= %s" % (flag,), 1)
+ self.emit("")
+
+
+def copy_field(field):
+ return asdl.Field(field.type, field.name, field.seq, field.opt)
+
+
+class ASDLData(object):
+
+ def __init__(self, tree):
+ simple_types = set()
+ prod_simple = set()
+ field_masks = {}
+ required_masks = {}
+ optional_masks = {}
+ cons_attributes = {}
+ def add_masks(fields, node):
+ required_mask = 0
+ optional_mask = 0
+ for i, field in enumerate(fields):
+ flag = 1 << i
+ field_masks[field] = flag
+ if field.opt:
+ optional_mask |= flag
+ else:
+ required_mask |= flag
+ required_masks[node] = required_mask
+ optional_masks[node] = optional_mask
+ for tp in tree.dfns:
+ if isinstance(tp.value, asdl.Sum):
+ sum = tp.value
+ if is_simple_sum(sum):
+ simple_types.add(tp.name.value)
+ else:
+ for cons in sum.types:
+ attrs = [copy_field(field) for field in sum.attributes]
+ add_masks(cons.fields + attrs, cons)
+ cons_attributes[cons] = attrs
+ else:
+ prod = tp.value
+ prod_simple.add(tp.name.value)
+ add_masks(prod.fields, prod)
+ prod_simple.update(simple_types)
+ self.cons_attributes = cons_attributes
+ self.simple_types = simple_types
+ self.prod_simple = prod_simple
+ self.field_masks = field_masks
+ self.required_masks = required_masks
+ self.optional_masks = optional_masks
+
+
HEAD = """# Generated by tools/asdl_py.py
-from pypy.interpreter.baseobjspace import Wrappable
+from pypy.interpreter.baseobjspace import Wrappable, ObjSpace, W_Root
from pypy.interpreter import typedef
+from pypy.interpreter.gateway import interp2app
+from pypy.interpreter.argument import Arguments
+from pypy.interpreter.error import OperationError
+from pypy.rlib.unroll import unrolling_iterable
from pypy.tool.pairtype import extendabletype
+from pypy.tool.sourcetools import func_with_new_name
+
class AST(Wrappable):
- __slots__ = ()
+ __slots__ = ("initialization_state",)
__metaclass__ = extendabletype
@@ -241,12 +545,57 @@
def mutate_over(self, visitor):
raise AssertionError("mutate_over() implementation not provided")
+ def sync_app_attrs(self, space):
+ raise NotImplementedError
+
+
class NodeVisitorNotImplemented(Exception):
pass
+
+class _FieldsWrapper(Wrappable):
+ "Hack around the fact we can't store tuples on a TypeDef."
+
+ def __init__(self, fields):
+ self.fields = fields
+
+ def __spacebind__(self, space):
+ return space.newtuple([space.wrap(field) for field in self.fields])
+
+
+def get_AST_new(node_class):
+ def generic_AST_new(space, w_type, __args__):
+ node = space.allocate_instance(node_class, w_type)
+ node.initialization_state = 0
+ return space.wrap(node)
+ generic_AST_new.unwrap_spec = [ObjSpace, W_Root, Arguments]
+ return func_with_new_name(generic_AST_new, "new_%s" % node_class.__name__)
+
+
+AST.typedef = typedef.TypeDef("AST",
+ _fields=_FieldsWrapper([]),
+ _attributes=_FieldsWrapper([]),
+)
+AST.typedef.acceptable_as_base_class = False
+
+
+def missing_field(space, state, required, host):
+ "Find which required field is missing."
+ for i in range(len(required)):
+ if not (state >> i) & 1:
+ missing = required[i]
+ if missing is not None:
+ err = "required attribute '%s' missing from %s"
+ err %= (missing, host)
+ w_err = space.wrap(err)
+ raise OperationError(space.w_TypeError, w_err)
+ raise AssertionError("should not reach here")
+
+
"""
-visitors = [ASTNodeVisitor, ASTVisitorVisitor, GenericASTVisitorVisitor]
+visitors = [ASTNodeVisitor, ASTVisitorVisitor, GenericASTVisitorVisitor,
+ AppExposeVisitor]
def main(argv):
@@ -261,11 +610,12 @@
print >> sys.stderr, "invalid arguments"
return 2
mod = asdl.parse(def_file)
+ data = ASDLData(mod)
fp = open(out_file, "w")
try:
fp.write(HEAD)
for visitor in visitors:
- visitor(fp).visit(mod)
+ visitor(fp, data).visit(mod)
finally:
fp.close()
Modified: pypy/branch/parser-compiler/pypy/interpreter/pycompiler.py
==============================================================================
--- pypy/branch/parser-compiler/pypy/interpreter/pycompiler.py (original)
+++ pypy/branch/parser-compiler/pypy/interpreter/pycompiler.py Sun Aug 16 23:51:12 2009
@@ -223,42 +223,55 @@
self.futureFlags = future.futureFlags_2_5
self.compiler_flags = self.futureFlags.allowed_flags
- def compile(self, source, filename, mode, flags):
- from pypy.interpreter.pyparser.error import (SyntaxError,
- IndentationError,
- TokenIndentationError)
- from pypy.interpreter.pycode import PyCode
+ def compile_ast(self, node, filename, mode, flags):
from pypy.interpreter.pyparser.pyparse import CompileInfo
- from pypy.interpreter.pyparser.future import getFutures
- from pypy.interpreter.astcompiler.astbuilder import ast_from_node
- from pypy.interpreter.astcompiler.codegen import compile_ast
- from pypy.interpreter.astcompiler import consts, optimize
+ info = CompileInfo(filename, mode, flags)
+ return self._compile_ast(node, info)
+ def _compile_ast(self, node, info):
+ from pypy.interpreter.astcompiler import optimize
+ from pypy.interpreter.astcompiler.codegen import compile_ast
+ from pypy.interpreter.pyparser.error import SyntaxError
space = self.space
+ try:
+ mod = optimize.optimize_ast(space, node, info)
+ code = compile_ast(space, mod, info)
+ except SyntaxError, e:
+ raise OperationError(space.w_SyntaxError,
+ e.wrap_info(space))
+ return code
- if flags & ~(consts.PyCF_SOURCE_IS_UTF8 | consts.PyCF_DONT_IMPLY_DEDENT
- | self.futureFlags.allowed_flags):
- raise OperationError(space.w_ValueError,
- space.wrap("invalid compile flags"))
+ def compile_to_ast(self, source, filename, mode, flags):
+ from pypy.interpreter.pyparser.pyparse import CompileInfo
+ info = CompileInfo(filename, mode, flags)
+ return self._compile_to_ast(source, info)
- space.timer.start("PythonAST compile")
+ def _compile_to_ast(self, source, info):
+ from pypy.interpreter.pyparser.future import getFutures
+ from pypy.interpreter.pyparser.error import (SyntaxError,
+ IndentationError,
+ TokenIndentationError)
+ from pypy.interpreter.astcompiler.astbuilder import ast_from_node
+ space = self.space
try:
- f_flags, future_lineno = getFutures(self.futureFlags, source)
- flags |= f_flags
- info = CompileInfo(filename, mode, flags, future_lineno)
+ f_flags, future_info = getFutures(self.futureFlags, source)
+ info.last_future_import = future_info
+ info.flags |= f_flags
parse_tree = self.parser.parse_source(source, info)
- module = ast_from_node(space, parse_tree, info)
- module = optimize.optimize_ast(space, module, info)
- code = compile_ast(space, module, info)
+ mod = ast_from_node(space, parse_tree, info)
except IndentationError, e:
raise OperationError(space.w_IndentationError,
- e.wrap_info(space, filename))
+ e.wrap_info(space))
except TokenIndentationError, e:
raise OperationError(space.w_IndentationError,
- e.wrap_info(space, filename))
+ e.wrap_info(space))
except SyntaxError, e:
raise OperationError(space.w_SyntaxError,
- e.wrap_info(space, filename))
- assert isinstance(code, PyCode)
- space.timer.stop("PythonAST compile")
- return code
+ e.wrap_info(space))
+ return mod
+
+ def compile(self, source, filename, mode, flags):
+ from pypy.interpreter.pyparser.pyparse import CompileInfo
+ info = CompileInfo(filename, mode, flags)
+ mod = self._compile_to_ast(source, info)
+ return self._compile_ast(mod, info)
Modified: pypy/branch/parser-compiler/pypy/interpreter/pyparser/error.py
==============================================================================
--- pypy/branch/parser-compiler/pypy/interpreter/pyparser/error.py (original)
+++ pypy/branch/parser-compiler/pypy/interpreter/pyparser/error.py Sun Aug 16 23:51:12 2009
@@ -10,9 +10,9 @@
self.filename = filename
self.print_file_and_line = False
- def wrap_info(self, space, filename):
+ def wrap_info(self, space):
return space.newtuple([space.wrap(self.msg),
- space.newtuple([space.wrap(filename),
+ space.newtuple([space.wrap(self.filename),
space.wrap(self.lineno),
space.wrap(self.offset),
space.wrap(self.text)])])
Modified: pypy/branch/parser-compiler/pypy/interpreter/pyparser/future.py
==============================================================================
--- pypy/branch/parser-compiler/pypy/interpreter/pyparser/future.py (original)
+++ pypy/branch/parser-compiler/pypy/interpreter/pyparser/future.py Sun Aug 16 23:51:12 2009
@@ -298,12 +298,9 @@
self.compiler_features[fname] = flag
if version >= feature.getMandatoryRelease():
self.mandatory_flags |= feature.compiler_flag
- self.allowed_flags = compiler_flags | PyCF_DONT_IMPLY_DEDENT
+ self.allowed_flags = compiler_flags
def get_flag_names(self, space, flags):
- if flags & ~self.allowed_flags:
- raise OperationError(space.w_ValueError,
- space.wrap("compile(): unrecognized flags"))
flag_names = []
for name, value in self.compiler_features.items():
if flags & value:
Modified: pypy/branch/parser-compiler/pypy/interpreter/pyparser/pyparse.py
==============================================================================
--- pypy/branch/parser-compiler/pypy/interpreter/pyparser/pyparse.py (original)
+++ pypy/branch/parser-compiler/pypy/interpreter/pyparser/pyparse.py Sun Aug 16 23:51:12 2009
@@ -150,6 +150,9 @@
for tp, value, lineno, column, line in tokens:
if self.add_token(tp, value, lineno, column, line):
break
+ except error.TokenError, e:
+ e.filename = compile_info.filename
+ raise
except parser.ParseError, e:
# Catch parse errors, pretty them up and reraise them as a
# SyntaxError.
Modified: pypy/branch/parser-compiler/pypy/module/__builtin__/compiling.py
==============================================================================
--- pypy/branch/parser-compiler/pypy/module/__builtin__/compiling.py (original)
+++ pypy/branch/parser-compiler/pypy/module/__builtin__/compiling.py Sun Aug 16 23:51:12 2009
@@ -5,7 +5,7 @@
from pypy.interpreter.pycode import PyCode
from pypy.interpreter.baseobjspace import W_Root, ObjSpace
from pypy.interpreter.error import OperationError
-from pypy.interpreter.astcompiler import consts
+from pypy.interpreter.astcompiler import consts, ast
from pypy.interpreter.gateway import NoneNotWrapped
def compile(space, w_source, filename, mode, flags=0, dont_inherit=0):
@@ -21,7 +21,13 @@
compile; if absent or zero these statements do influence the compilation,
in addition to any features explicitly specified.
"""
- if space.is_true(space.isinstance(w_source, space.w_unicode)):
+
+ ast_node = None
+ w_ast_type = space.gettypeobject(ast.AST.typedef)
+ if space.is_true(space.isinstance(w_source, w_ast_type)):
+ ast_node = space.interp_w(ast.mod, w_source)
+ ast_node.sync_app_attrs(space)
+ elif space.is_true(space.isinstance(w_source, space.w_unicode)):
w_utf_8_source = space.call_method(w_source, "encode",
space.wrap("utf-8"))
str_ = space.str_w(w_utf_8_source)
@@ -31,6 +37,10 @@
str_ = space.str_w(w_source)
ec = space.getexecutioncontext()
+ if flags & ~(ec.compiler.compiler_flags | consts.PyCF_AST_ONLY |
+ consts.PyCF_DONT_IMPLY_DEDENT | consts.PyCF_SOURCE_IS_UTF8):
+ raise OperationError(space.w_ValueError,
+ space.wrap("compile() unrecognized flags"))
if not dont_inherit:
try:
caller = ec.framestack.top()
@@ -44,7 +54,14 @@
space.wrap("compile() arg 3 must be 'exec' "
"or 'eval' or 'single'"))
- code = ec.compiler.compile(str_, filename, mode, flags)
+ if ast_node is None:
+ if flags & consts.PyCF_AST_ONLY:
+ mod = ec.compiler.compile_to_ast(str_, filename, mode, flags)
+ return space.wrap(mod)
+ else:
+ code = ec.compiler.compile(str_, filename, mode, flags)
+ else:
+ code = ec.compiler.compile_ast(ast_node, filename, mode, flags)
return space.wrap(code)
#
compile.unwrap_spec = [ObjSpace,W_Root,str,str,int,int]
Added: pypy/branch/parser-compiler/pypy/module/_ast/__init__.py
==============================================================================
--- (empty file)
+++ pypy/branch/parser-compiler/pypy/module/_ast/__init__.py Sun Aug 16 23:51:12 2009
@@ -0,0 +1,18 @@
+from pypy.interpreter.mixedmodule import MixedModule
+from pypy.interpreter.astcompiler import ast, consts
+
+
+class Module(MixedModule):
+
+ interpleveldefs = {
+ "PyCF_AST_ONLY" : "space.wrap(%s)" % consts.PyCF_AST_ONLY
+ }
+ appleveldefs = {}
+
+
+def _setup():
+ defs = Module.interpleveldefs
+ for name, cls in ast.__dict__.iteritems():
+ if isinstance(cls, type) and issubclass(cls, ast.AST):
+ defs[name.lstrip("_")] = cls.__module__ + "." + name
+_setup()
Added: pypy/branch/parser-compiler/pypy/module/_ast/test/__init__.py
==============================================================================
Added: pypy/branch/parser-compiler/pypy/module/_ast/test/test_ast.py
==============================================================================
--- (empty file)
+++ pypy/branch/parser-compiler/pypy/module/_ast/test/test_ast.py Sun Aug 16 23:51:12 2009
@@ -0,0 +1,161 @@
+import py
+
+from pypy.interpreter import gateway
+
+
+app = gateway.applevel("""def get_ast(source, mode="exec"):
+ import _ast as ast
+ mod = compile(source, "<test>", mode, ast.PyCF_AST_ONLY)
+ assert isinstance(mod, ast.mod)
+ return mod""")
+
+
+class AppTestAST:
+
+ def setup_class(cls):
+ cls.w_ast = cls.space.appexec([], """():
+ import _ast
+ return _ast""")
+ cls.w_get_ast = app.wget(cls.space, "get_ast")
+
+ def test_build_ast(self):
+ ast = self.ast
+ mod = self.get_ast("x = 4")
+ assert isinstance(mod, ast.Module)
+ assert len(mod.body) == 1
+
+ def test_simple_sums(self):
+ ast = self.ast
+ mod = self.get_ast("x = 4 + 5")
+ expr = mod.body[0].value
+ assert isinstance(expr, ast.BinOp)
+ assert isinstance(expr.op, ast.Add)
+ expr.op = ast.Sub()
+ assert isinstance(expr.op, ast.Sub)
+ co = compile(mod, "<example>", "exec")
+ ns = {}
+ exec co in ns
+ assert ns["x"] == -1
+ mod = self.get_ast("4 < 5 < 6", "eval")
+ assert isinstance(mod.body, ast.Compare)
+ assert len(mod.body.ops) == 2
+ for op in mod.body.ops:
+ assert isinstance(op, ast.Lt)
+ mod.body.ops[0] = ast.Gt()
+ co = compile(mod, "<string>", "exec")
+ assert not eval(co)
+
+ def test_string(self):
+ mod = self.get_ast("'hi'", "eval")
+ s = mod.body
+ assert s.s == "hi"
+ s.s = "pypy"
+ raises(TypeError, setattr, s, "s", 43)
+ assert eval(compile(mod, "<test>", "eval")) == "pypy"
+
+ def test_empty_initialization(self):
+ ast = self.ast
+ def com(node):
+ return compile(node, "<test>", "exec")
+ mod = ast.Module()
+ raises(AttributeError, getattr, mod, "body")
+ exc = raises(TypeError, com, mod)[1]
+ assert str(exc) == "required attribute 'body' missing from Module"
+ expr = ast.Name()
+ expr.id = "hi"
+ expr.ctx = ast.Load()
+ expr.lineno = 4
+ exc = raises(TypeError, com, ast.Module([ast.Expr(expr, 0, 0)]))[1]
+ assert str(exc) == "required attribute 'col_offset' missing from Name"
+
+ def test_int(self):
+ ast = self.ast
+ imp = ast.ImportFrom("", ["apples"], -1, 0, 0)
+ assert imp.level == -1
+ imp.level = 3
+ assert imp.level == 3
+
+ def test_identifier(self):
+ ast = self.ast
+ name = ast.Name("name_word", ast.Load(), 0, 0)
+ assert name.id == "name_word"
+ name.id = "hi"
+ assert name.id == "hi"
+ raises(TypeError, setattr, name, "id", 32)
+
+ def test_bool(self):
+ ast = self.ast
+ pr = ast.Print(None, [ast.Name("hi", ast.Load(), 0, 0)], False, 0, 0)
+ assert not pr.nl
+ assert isinstance(pr.nl, bool)
+ pr.nl = True
+ assert pr.nl
+
+ def test_object(self):
+ ast = self.ast
+ const = ast.Const(4, 0, 0)
+ assert const.value == 4
+ const.value = 5
+ assert const.value == 5
+
+ def test_list_syncing(self):
+ ast = self.ast
+ mod = ast.Module([ast.Lt()])
+ raises(TypeError, compile, mod, "<string>", "exec")
+ mod = self.get_ast("x = y = 3")
+ assign = mod.body[0]
+ assert len(assign.targets) == 2
+ assign.targets[1] = ast.Name("lemon", ast.Store(), 0, 0)
+ name = ast.Name("apple", ast.Store(), 0, 0)
+ mod.body.append(ast.Assign([name], ast.Num(4, 0, 0), 0, 0))
+ co = compile(mod, "<test>", "exec")
+ ns = {}
+ exec co in ns
+ assert "y" not in ns
+ assert ns["x"] == ns["lemon"] == 3
+ assert ns["apple"] == 4
+
+ def test_ast_types(self):
+ ast = self.ast
+ expr = ast.Expr()
+ raises(TypeError, setattr, expr, "value", ast.Lt())
+
+ def test_abstract_ast_types(self):
+ ast = self.ast
+ raises(TypeError, ast.expr)
+ raises(TypeError, ast.AST)
+ raises(TypeError, type, "X", (ast.AST,), {})
+ raises(TypeError, type, "Y", (ast.expr,), {})
+
+ def test_constructor(self):
+ ast = self.ast
+ body = []
+ mod = ast.Module(body)
+ assert mod.body is body
+ target = ast.Name("hi", ast.Store(), 0, 0)
+ expr = ast.Name("apples", ast.Load(), 0, 0)
+ otherwise = []
+ fr = ast.For(target, expr, body, otherwise, 0, 1)
+ assert fr.target is target
+ assert fr.iter is expr
+ assert fr.orelse is otherwise
+ assert fr.body is body
+ assert fr.lineno == 0
+ assert fr.col_offset == 1
+ fr = ast.For(body=body, target=target, iter=expr, col_offset=1,
+ lineno=0, orelse=otherwise)
+ assert fr.target is target
+ assert fr.iter is expr
+ assert fr.orelse is otherwise
+ assert fr.body is body
+ assert fr.lineno == 0
+ assert fr.col_offset == 1
+ exc = raises(TypeError, ast.Module, 1, 2)[1]
+ msg = str(exc)
+ assert msg == "Module constructor takes 0 or 1 positional arguments"
+ raises(AttributeError, ast.Module, nothing=23)
+
+ def test_future(self):
+ skip("have to write an AST future parser")
+ mod = self.get_ast("from __future__ import with_statement")
+ compile(mod, "<test>", "exec")
More information about the Pypy-commit
mailing list