Author: Carl Friedrich Bolz <cfb...@gmx.de>
Branch: optinfo-into-bridges-2
Changeset: r90262:1764a122b2bd
Date: 2017-02-21 13:56 +0100
http://bitbucket.org/pypy/pypy/changeset/1764a122b2bd/
Log: merge default
diff too long, truncating to 2000 out of 28018 lines
diff --git a/lib-python/2.7/sysconfig.py b/lib-python/2.7/sysconfig.py
--- a/lib-python/2.7/sysconfig.py
+++ b/lib-python/2.7/sysconfig.py
@@ -529,7 +529,9 @@
for suffix, mode, type_ in imp.get_suffixes():
if type_ == imp.C_EXTENSION:
_CONFIG_VARS['SOABI'] = suffix.split('.')[1]
- break
+ break
+ _CONFIG_VARS['INCLUDEPY'] = os.path.join(_CONFIG_VARS['prefix'],
+ 'include')
if args:
vals = []
diff --git a/lib_pypy/_ctypes/function.py b/lib_pypy/_ctypes/function.py
--- a/lib_pypy/_ctypes/function.py
+++ b/lib_pypy/_ctypes/function.py
@@ -604,7 +604,8 @@
"""
# hack for performance: if restype is a "simple" primitive type, don't
# allocate the buffer because it's going to be thrown away immediately
- if self._is_primitive(restype) and not restype._is_pointer_like():
+ if (self._is_primitive(restype) and restype._type_ != '?'
+ and not restype._is_pointer_like()):
return result
#
shape = restype._ffishape_
diff --git a/lib_pypy/cffi/backend_ctypes.py b/lib_pypy/cffi/backend_ctypes.py
--- a/lib_pypy/cffi/backend_ctypes.py
+++ b/lib_pypy/cffi/backend_ctypes.py
@@ -112,11 +112,20 @@
def _make_cmp(name):
cmpfunc = getattr(operator, name)
def cmp(self, other):
- if isinstance(other, CTypesData):
+ v_is_ptr = not isinstance(self, CTypesGenericPrimitive)
+ w_is_ptr = (isinstance(other, CTypesData) and
+ not isinstance(other, CTypesGenericPrimitive))
+ if v_is_ptr and w_is_ptr:
return cmpfunc(self._convert_to_address(None),
other._convert_to_address(None))
+ elif v_is_ptr or w_is_ptr:
+ return NotImplemented
else:
- return NotImplemented
+ if isinstance(self, CTypesGenericPrimitive):
+ self = self._value
+ if isinstance(other, CTypesGenericPrimitive):
+ other = other._value
+ return cmpfunc(self, other)
cmp.func_name = name
return cmp
@@ -128,7 +137,7 @@
__ge__ = _make_cmp('__ge__')
def __hash__(self):
- return hash(type(self)) ^ hash(self._convert_to_address(None))
+ return hash(self._convert_to_address(None))
def _to_string(self, maxlen):
raise TypeError("string(): %r" % (self,))
@@ -137,14 +146,8 @@
class CTypesGenericPrimitive(CTypesData):
__slots__ = []
- def __eq__(self, other):
- return self is other
-
- def __ne__(self, other):
- return self is not other
-
def __hash__(self):
- return object.__hash__(self)
+ return hash(self._value)
def _get_own_repr(self):
return repr(self._from_ctypes(self._value))
diff --git a/pypy/doc/objspace.rst b/pypy/doc/objspace.rst
--- a/pypy/doc/objspace.rst
+++ b/pypy/doc/objspace.rst
@@ -188,6 +188,7 @@
.. py:function:: wrap(x)
+ **Deprecated! Eventually this method should disappear.**
Returns a wrapped object that is a reference to the interpreter-level object
:py:obj:`x`. This can be used either on simple immutable objects (integers,
strings, etc) to create a new wrapped object, or on instances of
:py:class:`W_Root`
@@ -196,6 +197,35 @@
be directly exposed to application-level code in this way - functions,
frames,
code objects, etc.
+.. py:function:: newint(i)
+
+ Creates a wrapped object holding an integral value. `newint` creates an
object
+ of type `W_IntObject`.
+
+.. py:function:: newlong(l)
+
+ Creates a wrapped object holding an integral value. The main difference to
newint
+ is the type of the argument (which is rpython.rlib.rbigint.rbigint). On
PyPy3 this
+ method will return an :py:class:`int` (PyPy2 it returns a :py:class:`long`).
+
+.. py:function:: newbytes(t)
+
+ The given argument is a rpython bytestring. Creates a wrapped object
+ of type :py:class:`bytes` (both on PyPy2 and PyPy3).
+
+.. py:function:: newtext(t)
+
+ The given argument is a rpython bytestring. Creates a wrapped object
+ of type :py:class:`str`. On PyPy3 this will return a wrapped unicode
+ object. The object will hold a utf-8-nosg decoded value of `t`.
+ The "utf-8-nosg" codec used here is slightly different from the
+ "utf-8" implemented in Python 2 or Python 3: it is defined as utf-8
+ without any special handling of surrogate characters. They are
+ encoded using the same three-bytes sequence that encodes any char in
+ the range from ``'\u0800'`` to ``'\uffff'``.
+
+ PyPy2 will return a bytestring object. No encoding/decoding steps will be
applied.
+
.. py:function:: newbool(b)
Creates a wrapped :py:class:`bool` object from an :ref:`interpreter-level
<interpreter-level>`
@@ -217,15 +247,18 @@
Creates a new slice object.
-.. py:function:: newstring(asciilist)
+.. py:function:: newunicode(ustr)
- Creates a string from a list of wrapped integers. Note that this may not be
- a very useful method; usually you can just write ``space.wrap("mystring")``.
+ Creates a Unicode string from an rpython unicode string.
+ This method may disappear soon and be replaced by :py:function:`newutf8()`.
-.. py:function:: newunicode(codelist)
+.. py:function:: newutf8(bytestr)
- Creates a Unicode string from a list of integers (code points).
+ Creates a Unicode string from an rpython byte string, decoded as
+ "utf-8-nosg". On PyPy3 it is the same as :py:function:`newtext()`.
+Many more space operations can be found in `pypy/interpeter/baseobjspace.py`
and
+`pypy/objspace/std/objspace.py`.
Conversions from Application Level to Interpreter Level
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -258,11 +291,28 @@
If :py:obj:`w_x` is an application-level integer or long, return an
interpreter-level
:py:class:`rbigint`. Otherwise raise :py:exc:`TypeError`.
+.. py:function:: text_w(w_x)
+
+ Takes an application level :py:class:`str` and converts it to a rpython
byte string.
+ PyPy3 this method will return an utf-8-nosg encoded result.
+
+.. py:function:: bytes_w(w_x)
+
+ Takes an application level :py:class:`bytes` (PyPy2 this equals `str`) and
returns a rpython
+ byte string.
+
.. py:function:: str_w(w_x)
+ **Deprecated. use text_w or bytes_w instead**
If :py:obj:`w_x` is an application-level string, return an
interpreter-level string.
Otherwise raise :py:exc:`TypeError`.
+.. py:function:: unicode_w(w_x)
+
+ Takes an application level :py:class:`unicode` and return an
+ interpreter-level unicode string. This method may disappear soon and
+ be replaced by :py:function:`text_w()`.
+
.. py:function:: float_w(w_x)
If :py:obj:`w_x` is an application-level float, integer or long, return an
diff --git a/pypy/doc/whatsnew-head.rst b/pypy/doc/whatsnew-head.rst
--- a/pypy/doc/whatsnew-head.rst
+++ b/pypy/doc/whatsnew-head.rst
@@ -142,3 +142,15 @@
it is the standard ``OrderedDict.move_to_end()`` method, but the
behavior is also available on Python 2.x or for the ``dict`` type by
calling ``__pypy__.move_to_end(dict, key, last=True)``.
+
+.. branch: space-newtext
+
+Internal refactoring of ``space.wrap()``, which is now replaced with
+explicitly-typed methods. Notably, there are now ``space.newbytes()``
+and ``space.newtext()``: these two methods are identical on PyPy 2.7 but
+not on PyPy 3.x. The latter is used to get an app-level unicode string
+by decoding the RPython string, assumed to be utf-8.
+
+.. branch: fix_bool_restype
+
+Fix for ``ctypes.c_bool``-returning ctypes functions
diff --git a/pypy/goal/targetpypystandalone.py
b/pypy/goal/targetpypystandalone.py
--- a/pypy/goal/targetpypystandalone.py
+++ b/pypy/goal/targetpypystandalone.py
@@ -31,9 +31,9 @@
def create_entry_point(space, w_dict):
if w_dict is not None: # for tests
- w_entry_point = space.getitem(w_dict, space.wrap('entry_point'))
- w_run_toplevel = space.getitem(w_dict, space.wrap('run_toplevel'))
- w_initstdio = space.getitem(w_dict, space.wrap('initstdio'))
+ w_entry_point = space.getitem(w_dict, space.newtext('entry_point'))
+ w_run_toplevel = space.getitem(w_dict, space.newtext('run_toplevel'))
+ w_initstdio = space.getitem(w_dict, space.newtext('initstdio'))
withjit = space.config.objspace.usemodules.pypyjit
hashfunc = space.config.objspace.hash
else:
@@ -65,8 +65,8 @@
try:
try:
space.startup()
- w_executable = space.wrap(argv[0])
- w_argv = space.newlist([space.wrap(s) for s in argv[1:]])
+ w_executable = space.newtext(argv[0])
+ w_argv = space.newlist([space.newtext(s) for s in argv[1:]])
w_exitcode = space.call_function(w_entry_point, w_executable,
w_argv)
exitcode = space.int_w(w_exitcode)
# try to pull it all in
@@ -76,7 +76,7 @@
except OperationError as e:
debug("OperationError:")
debug(" operror-type: " + e.w_type.getname(space))
- debug(" operror-value: " +
space.str_w(space.str(e.get_w_value(space))))
+ debug(" operror-value: " +
space.text_w(space.str(e.get_w_value(space))))
return 1
finally:
try:
@@ -84,7 +84,7 @@
except OperationError as e:
debug("OperationError:")
debug(" operror-type: " + e.w_type.getname(space))
- debug(" operror-value: " +
space.str_w(space.str(e.get_w_value(space))))
+ debug(" operror-value: " +
space.text_w(space.str(e.get_w_value(space))))
return 1
return exitcode
@@ -123,7 +123,7 @@
try:
# initialize sys.{path,executable,stdin,stdout,stderr}
# (in unbuffered mode, to avoid troubles) and import site
- space.appexec([w_path, space.wrap(home), w_initstdio],
+ space.appexec([w_path, space.newtext(home), w_initstdio],
r"""(path, home, initstdio):
import sys
sys.path[:] = path
@@ -141,7 +141,7 @@
if verbose:
debug("OperationError:")
debug(" operror-type: " + e.w_type.getname(space))
- debug(" operror-value: " +
space.str_w(space.str(e.get_w_value(space))))
+ debug(" operror-value: " +
space.text_w(space.str(e.get_w_value(space))))
return rffi.cast(rffi.INT, -1)
finally:
if must_leave:
@@ -180,11 +180,11 @@
def _pypy_execute_source(source, c_argument):
try:
w_globals = space.newdict(module=True)
- space.setitem(w_globals, space.wrap('__builtins__'),
+ space.setitem(w_globals, space.newtext('__builtins__'),
space.builtin_modules['__builtin__'])
- space.setitem(w_globals, space.wrap('c_argument'),
- space.wrap(c_argument))
- space.appexec([space.wrap(source), w_globals], """(src, glob):
+ space.setitem(w_globals, space.newtext('c_argument'),
+ space.newint(c_argument))
+ space.appexec([space.newtext(source), w_globals], """(src, glob):
import sys
stmt = compile(src, 'c callback', 'exec')
if not hasattr(sys, '_pypy_execute_source'):
@@ -195,7 +195,7 @@
except OperationError as e:
debug("OperationError:")
debug(" operror-type: " + e.w_type.getname(space))
- debug(" operror-value: " +
space.str_w(space.str(e.get_w_value(space))))
+ debug(" operror-value: " +
space.text_w(space.str(e.get_w_value(space))))
return -1
return 0
@@ -323,7 +323,7 @@
# obscure hack to stuff the translation options into the translated
PyPy
import pypy.module.sys
options = make_dict(config)
- wrapstr = 'space.wrap(%r)' % (options)
+ wrapstr = 'space.wrap(%r)' % (options) # import time
pypy.module.sys.Module.interpleveldefs['pypy_translation_info'] =
wrapstr
if config.objspace.usemodules._cffi_backend:
self.hack_for_cffi_modules(driver)
diff --git a/pypy/interpreter/argument.py b/pypy/interpreter/argument.py
--- a/pypy/interpreter/argument.py
+++ b/pypy/interpreter/argument.py
@@ -363,7 +363,7 @@
i = 0
for w_key in keys_w:
try:
- key = space.str_w(w_key)
+ key = space.text_w(w_key)
except OperationError as e:
if e.match(space, space.w_TypeError):
raise oefmt(space.w_TypeError, "keywords must be strings")
@@ -547,11 +547,11 @@
except IndexError:
name = '?'
else:
- w_enc = space.wrap(space.sys.defaultencoding)
- w_err = space.wrap("replace")
+ w_enc = space.newtext(space.sys.defaultencoding)
+ w_err = space.newtext("replace")
w_name = space.call_method(w_name, "encode", w_enc,
w_err)
- name = space.str_w(w_name)
+ name = space.text_w(w_name)
break
self.kwd_name = name
diff --git a/pypy/interpreter/astcompiler/assemble.py
b/pypy/interpreter/astcompiler/assemble.py
--- a/pypy/interpreter/astcompiler/assemble.py
+++ b/pypy/interpreter/astcompiler/assemble.py
@@ -266,8 +266,8 @@
else:
w_key = space.newtuple([obj, space.w_float])
elif space.is_w(w_type, space.w_complex):
- w_real = space.getattr(obj, space.wrap("real"))
- w_imag = space.getattr(obj, space.wrap("imag"))
+ w_real = space.getattr(obj, space.newtext("real"))
+ w_imag = space.getattr(obj, space.newtext("imag"))
real = space.float_w(w_real)
imag = space.float_w(w_imag)
real_negzero = (real == 0.0 and
@@ -366,7 +366,7 @@
space = self.space
consts_w = [space.w_None] * space.len_w(w_consts)
w_iter = space.iter(w_consts)
- first = space.wrap(0)
+ first = space.newint(0)
while True:
try:
w_key = space.next(w_iter)
diff --git a/pypy/interpreter/astcompiler/ast.py
b/pypy/interpreter/astcompiler/ast.py
--- a/pypy/interpreter/astcompiler/ast.py
+++ b/pypy/interpreter/astcompiler/ast.py
@@ -13,7 +13,7 @@
"field %s is required for %T", name, w_obj)
def check_string(space, w_obj):
- if not (space.isinstance_w(w_obj, space.w_str) or
+ if not (space.isinstance_w(w_obj, space.w_bytes) or
space.isinstance_w(w_obj, space.w_unicode)):
raise oefmt(space.w_TypeError,
"AST string must be of type str or unicode")
@@ -48,10 +48,10 @@
"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])
+ assert fields == []
+
+ def spacebind(self, space):
+ return space.newtuple([])
class W_AST(W_Root):
@@ -67,14 +67,14 @@
if w_dict is None:
w_dict = space.newdict()
w_type = space.type(self)
- w_fields = space.getattr(w_type, space.wrap("_fields"))
+ w_fields = space.getattr(w_type, space.newtext("_fields"))
for w_name in space.fixedview(w_fields):
try:
space.setitem(w_dict, w_name,
space.getattr(self, w_name))
except OperationError:
pass
- w_attrs = space.findattr(w_type, space.wrap("_attributes"))
+ w_attrs = space.findattr(w_type, space.newtext("_attributes"))
if w_attrs:
for w_name in space.fixedview(w_attrs):
try:
@@ -93,12 +93,12 @@
def W_AST_new(space, w_type, __args__):
node = space.allocate_instance(W_AST, w_type)
- return space.wrap(node)
+ return node
def W_AST_init(space, w_self, __args__):
args_w, kwargs_w = __args__.unpack()
fields_w = space.fixedview(space.getattr(space.type(w_self),
- space.wrap("_fields")))
+ space.newtext("_fields")))
num_fields = len(fields_w) if fields_w else 0
if args_w and len(args_w) != num_fields:
if num_fields == 0:
@@ -114,7 +114,7 @@
for i, w_field in enumerate(fields_w):
space.setattr(w_self, w_field, args_w[i])
for field, w_value in kwargs_w.iteritems():
- space.setattr(w_self, space.wrap(field), w_value)
+ space.setattr(w_self, space.newtext(field), w_value)
W_AST.typedef = typedef.TypeDef("_ast.AST",
@@ -143,16 +143,16 @@
def make_new_type(self, space, name, base, fields, attributes):
w_base = getattr(self, 'w_%s' % base)
w_dict = space.newdict()
- space.setitem_str(w_dict, '__module__', space.wrap('_ast'))
+ space.setitem_str(w_dict, '__module__', space.newtext('_ast'))
if fields is not None:
space.setitem_str(w_dict, "_fields",
- space.newtuple([space.wrap(f) for f in fields]))
+ space.newtuple([space.newtext(f) for f in
fields]))
if attributes is not None:
space.setitem_str(w_dict, "_attributes",
- space.newtuple([space.wrap(a) for a in
attributes]))
+ space.newtuple([space.newtext(a) for a in
attributes]))
w_type = space.call_function(
space.w_type,
- space.wrap(name), space.newtuple([w_base]), w_dict)
+ space.newtext(name), space.newtuple([w_base]), w_dict)
setattr(self, 'w_%s' % name, w_type)
def get(space):
@@ -196,7 +196,7 @@
else:
body_w = [node.to_object(space) for node in self.body] # stmt
w_body = space.newlist(body_w)
- space.setattr(w_node, space.wrap('body'), w_body)
+ space.setattr(w_node, space.newtext('body'), w_body)
return w_node
@staticmethod
@@ -230,7 +230,7 @@
else:
body_w = [node.to_object(space) for node in self.body] # stmt
w_body = space.newlist(body_w)
- space.setattr(w_node, space.wrap('body'), w_body)
+ space.setattr(w_node, space.newtext('body'), w_body)
return w_node
@staticmethod
@@ -258,7 +258,7 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_Expression)
w_body = self.body.to_object(space) # expr
- space.setattr(w_node, space.wrap('body'), w_body)
+ space.setattr(w_node, space.newtext('body'), w_body)
return w_node
@staticmethod
@@ -293,7 +293,7 @@
else:
body_w = [node.to_object(space) for node in self.body] # stmt
w_body = space.newlist(body_w)
- space.setattr(w_node, space.wrap('body'), w_body)
+ space.setattr(w_node, space.newtext('body'), w_body)
return w_node
@staticmethod
@@ -390,26 +390,26 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_FunctionDef)
- w_name = space.wrap(self.name) # identifier
- space.setattr(w_node, space.wrap('name'), w_name)
+ w_name = space.newtext(self.name) # identifier
+ space.setattr(w_node, space.newtext('name'), w_name)
w_args = self.args.to_object(space) # arguments
- space.setattr(w_node, space.wrap('args'), w_args)
+ space.setattr(w_node, space.newtext('args'), w_args)
if self.body is None:
body_w = []
else:
body_w = [node.to_object(space) for node in self.body] # stmt
w_body = space.newlist(body_w)
- space.setattr(w_node, space.wrap('body'), w_body)
+ space.setattr(w_node, space.newtext('body'), w_body)
if self.decorator_list is None:
decorator_list_w = []
else:
decorator_list_w = [node.to_object(space) for node in
self.decorator_list] # expr
w_decorator_list = space.newlist(decorator_list_w)
- space.setattr(w_node, space.wrap('decorator_list'), w_decorator_list)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('decorator_list'),
w_decorator_list)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -463,30 +463,30 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_ClassDef)
- w_name = space.wrap(self.name) # identifier
- space.setattr(w_node, space.wrap('name'), w_name)
+ w_name = space.newtext(self.name) # identifier
+ space.setattr(w_node, space.newtext('name'), w_name)
if self.bases is None:
bases_w = []
else:
bases_w = [node.to_object(space) for node in self.bases] # expr
w_bases = space.newlist(bases_w)
- space.setattr(w_node, space.wrap('bases'), w_bases)
+ space.setattr(w_node, space.newtext('bases'), w_bases)
if self.body is None:
body_w = []
else:
body_w = [node.to_object(space) for node in self.body] # stmt
w_body = space.newlist(body_w)
- space.setattr(w_node, space.wrap('body'), w_body)
+ space.setattr(w_node, space.newtext('body'), w_body)
if self.decorator_list is None:
decorator_list_w = []
else:
decorator_list_w = [node.to_object(space) for node in
self.decorator_list] # expr
w_decorator_list = space.newlist(decorator_list_w)
- space.setattr(w_node, space.wrap('decorator_list'), w_decorator_list)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('decorator_list'),
w_decorator_list)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -530,11 +530,11 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_Return)
w_value = self.value.to_object(space) if self.value is not None else
space.w_None # expr
- space.setattr(w_node, space.wrap('value'), w_value)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('value'), w_value)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -572,11 +572,11 @@
else:
targets_w = [node.to_object(space) for node in self.targets] # expr
w_targets = space.newlist(targets_w)
- space.setattr(w_node, space.wrap('targets'), w_targets)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('targets'), w_targets)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -617,13 +617,13 @@
else:
targets_w = [node.to_object(space) for node in self.targets] # expr
w_targets = space.newlist(targets_w)
- space.setattr(w_node, space.wrap('targets'), w_targets)
+ space.setattr(w_node, space.newtext('targets'), w_targets)
w_value = self.value.to_object(space) # expr
- space.setattr(w_node, space.wrap('value'), w_value)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('value'), w_value)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -663,15 +663,15 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_AugAssign)
w_target = self.target.to_object(space) # expr
- space.setattr(w_node, space.wrap('target'), w_target)
+ space.setattr(w_node, space.newtext('target'), w_target)
w_op = operator_to_class[self.op - 1]().to_object(space) # operator
- space.setattr(w_node, space.wrap('op'), w_op)
+ space.setattr(w_node, space.newtext('op'), w_op)
w_value = self.value.to_object(space) # expr
- space.setattr(w_node, space.wrap('value'), w_value)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('value'), w_value)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -719,19 +719,19 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_Print)
w_dest = self.dest.to_object(space) if self.dest is not None else
space.w_None # expr
- space.setattr(w_node, space.wrap('dest'), w_dest)
+ space.setattr(w_node, space.newtext('dest'), w_dest)
if self.values is None:
values_w = []
else:
values_w = [node.to_object(space) for node in self.values] # expr
w_values = space.newlist(values_w)
- space.setattr(w_node, space.wrap('values'), w_values)
- w_nl = space.wrap(self.nl) # bool
- space.setattr(w_node, space.wrap('nl'), w_nl)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('values'), w_values)
+ w_nl = space.newbool(self.nl) # bool
+ space.setattr(w_node, space.newtext('nl'), w_nl)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -780,25 +780,25 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_For)
w_target = self.target.to_object(space) # expr
- space.setattr(w_node, space.wrap('target'), w_target)
+ space.setattr(w_node, space.newtext('target'), w_target)
w_iter = self.iter.to_object(space) # expr
- space.setattr(w_node, space.wrap('iter'), w_iter)
+ space.setattr(w_node, space.newtext('iter'), w_iter)
if self.body is None:
body_w = []
else:
body_w = [node.to_object(space) for node in self.body] # stmt
w_body = space.newlist(body_w)
- space.setattr(w_node, space.wrap('body'), w_body)
+ space.setattr(w_node, space.newtext('body'), w_body)
if self.orelse is None:
orelse_w = []
else:
orelse_w = [node.to_object(space) for node in self.orelse] # stmt
w_orelse = space.newlist(orelse_w)
- space.setattr(w_node, space.wrap('orelse'), w_orelse)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('orelse'), w_orelse)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -850,23 +850,23 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_While)
w_test = self.test.to_object(space) # expr
- space.setattr(w_node, space.wrap('test'), w_test)
+ space.setattr(w_node, space.newtext('test'), w_test)
if self.body is None:
body_w = []
else:
body_w = [node.to_object(space) for node in self.body] # stmt
w_body = space.newlist(body_w)
- space.setattr(w_node, space.wrap('body'), w_body)
+ space.setattr(w_node, space.newtext('body'), w_body)
if self.orelse is None:
orelse_w = []
else:
orelse_w = [node.to_object(space) for node in self.orelse] # stmt
w_orelse = space.newlist(orelse_w)
- space.setattr(w_node, space.wrap('orelse'), w_orelse)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('orelse'), w_orelse)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -914,23 +914,23 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_If)
w_test = self.test.to_object(space) # expr
- space.setattr(w_node, space.wrap('test'), w_test)
+ space.setattr(w_node, space.newtext('test'), w_test)
if self.body is None:
body_w = []
else:
body_w = [node.to_object(space) for node in self.body] # stmt
w_body = space.newlist(body_w)
- space.setattr(w_node, space.wrap('body'), w_body)
+ space.setattr(w_node, space.newtext('body'), w_body)
if self.orelse is None:
orelse_w = []
else:
orelse_w = [node.to_object(space) for node in self.orelse] # stmt
w_orelse = space.newlist(orelse_w)
- space.setattr(w_node, space.wrap('orelse'), w_orelse)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('orelse'), w_orelse)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -977,19 +977,19 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_With)
w_context_expr = self.context_expr.to_object(space) # expr
- space.setattr(w_node, space.wrap('context_expr'), w_context_expr)
+ space.setattr(w_node, space.newtext('context_expr'), w_context_expr)
w_optional_vars = self.optional_vars.to_object(space) if
self.optional_vars is not None else space.w_None # expr
- space.setattr(w_node, space.wrap('optional_vars'), w_optional_vars)
+ space.setattr(w_node, space.newtext('optional_vars'), w_optional_vars)
if self.body is None:
body_w = []
else:
body_w = [node.to_object(space) for node in self.body] # stmt
w_body = space.newlist(body_w)
- space.setattr(w_node, space.wrap('body'), w_body)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('body'), w_body)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -1035,15 +1035,15 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_Raise)
w_type = self.type.to_object(space) if self.type is not None else
space.w_None # expr
- space.setattr(w_node, space.wrap('type'), w_type)
+ space.setattr(w_node, space.newtext('type'), w_type)
w_inst = self.inst.to_object(space) if self.inst is not None else
space.w_None # expr
- space.setattr(w_node, space.wrap('inst'), w_inst)
+ space.setattr(w_node, space.newtext('inst'), w_inst)
w_tback = self.tback.to_object(space) if self.tback is not None else
space.w_None # expr
- space.setattr(w_node, space.wrap('tback'), w_tback)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('tback'), w_tback)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -1093,23 +1093,23 @@
else:
body_w = [node.to_object(space) for node in self.body] # stmt
w_body = space.newlist(body_w)
- space.setattr(w_node, space.wrap('body'), w_body)
+ space.setattr(w_node, space.newtext('body'), w_body)
if self.handlers is None:
handlers_w = []
else:
handlers_w = [node.to_object(space) for node in self.handlers] #
excepthandler
w_handlers = space.newlist(handlers_w)
- space.setattr(w_node, space.wrap('handlers'), w_handlers)
+ space.setattr(w_node, space.newtext('handlers'), w_handlers)
if self.orelse is None:
orelse_w = []
else:
orelse_w = [node.to_object(space) for node in self.orelse] # stmt
w_orelse = space.newlist(orelse_w)
- space.setattr(w_node, space.wrap('orelse'), w_orelse)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('orelse'), w_orelse)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -1158,17 +1158,17 @@
else:
body_w = [node.to_object(space) for node in self.body] # stmt
w_body = space.newlist(body_w)
- space.setattr(w_node, space.wrap('body'), w_body)
+ space.setattr(w_node, space.newtext('body'), w_body)
if self.finalbody is None:
finalbody_w = []
else:
finalbody_w = [node.to_object(space) for node in self.finalbody] #
stmt
w_finalbody = space.newlist(finalbody_w)
- space.setattr(w_node, space.wrap('finalbody'), w_finalbody)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('finalbody'), w_finalbody)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -1207,13 +1207,13 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_Assert)
w_test = self.test.to_object(space) # expr
- space.setattr(w_node, space.wrap('test'), w_test)
+ space.setattr(w_node, space.newtext('test'), w_test)
w_msg = self.msg.to_object(space) if self.msg is not None else
space.w_None # expr
- space.setattr(w_node, space.wrap('msg'), w_msg)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('msg'), w_msg)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -1255,11 +1255,11 @@
else:
names_w = [node.to_object(space) for node in self.names] # alias
w_names = space.newlist(names_w)
- space.setattr(w_node, space.wrap('names'), w_names)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('names'), w_names)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -1295,20 +1295,20 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_ImportFrom)
- w_module = space.wrap(self.module) # identifier
- space.setattr(w_node, space.wrap('module'), w_module)
+ w_module = space.newtext_or_none(self.module) # identifier
+ space.setattr(w_node, space.newtext('module'), w_module)
if self.names is None:
names_w = []
else:
names_w = [node.to_object(space) for node in self.names] # alias
w_names = space.newlist(names_w)
- space.setattr(w_node, space.wrap('names'), w_names)
- w_level = space.wrap(self.level) # int
- space.setattr(w_node, space.wrap('level'), w_level)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('names'), w_names)
+ w_level = space.newint(self.level) # int
+ space.setattr(w_node, space.newtext('level'), w_level)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -1351,15 +1351,15 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_Exec)
w_body = self.body.to_object(space) # expr
- space.setattr(w_node, space.wrap('body'), w_body)
+ space.setattr(w_node, space.newtext('body'), w_body)
w_globals = self.globals.to_object(space) if self.globals is not None
else space.w_None # expr
- space.setattr(w_node, space.wrap('globals'), w_globals)
+ space.setattr(w_node, space.newtext('globals'), w_globals)
w_locals = self.locals.to_object(space) if self.locals is not None
else space.w_None # expr
- space.setattr(w_node, space.wrap('locals'), w_locals)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('locals'), w_locals)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -1398,13 +1398,13 @@
if self.names is None:
names_w = []
else:
- names_w = [space.wrap(node) for node in self.names] # identifier
+ names_w = [space.newtext(node) for node in self.names] # identifier
w_names = space.newlist(names_w)
- space.setattr(w_node, space.wrap('names'), w_names)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('names'), w_names)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -1437,11 +1437,11 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_Expr)
w_value = self.value.to_object(space) # expr
- space.setattr(w_node, space.wrap('value'), w_value)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('value'), w_value)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -1472,10 +1472,10 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_Pass)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -1502,10 +1502,10 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_Break)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -1532,10 +1532,10 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_Continue)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -1628,17 +1628,17 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_BoolOp)
w_op = boolop_to_class[self.op - 1]().to_object(space) # boolop
- space.setattr(w_node, space.wrap('op'), w_op)
+ space.setattr(w_node, space.newtext('op'), w_op)
if self.values is None:
values_w = []
else:
values_w = [node.to_object(space) for node in self.values] # expr
w_values = space.newlist(values_w)
- space.setattr(w_node, space.wrap('values'), w_values)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('values'), w_values)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -1678,15 +1678,15 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_BinOp)
w_left = self.left.to_object(space) # expr
- space.setattr(w_node, space.wrap('left'), w_left)
+ space.setattr(w_node, space.newtext('left'), w_left)
w_op = operator_to_class[self.op - 1]().to_object(space) # operator
- space.setattr(w_node, space.wrap('op'), w_op)
+ space.setattr(w_node, space.newtext('op'), w_op)
w_right = self.right.to_object(space) # expr
- space.setattr(w_node, space.wrap('right'), w_right)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('right'), w_right)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -1729,13 +1729,13 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_UnaryOp)
w_op = unaryop_to_class[self.op - 1]().to_object(space) # unaryop
- space.setattr(w_node, space.wrap('op'), w_op)
+ space.setattr(w_node, space.newtext('op'), w_op)
w_operand = self.operand.to_object(space) # expr
- space.setattr(w_node, space.wrap('operand'), w_operand)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('operand'), w_operand)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -1775,13 +1775,13 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_Lambda)
w_args = self.args.to_object(space) # arguments
- space.setattr(w_node, space.wrap('args'), w_args)
+ space.setattr(w_node, space.newtext('args'), w_args)
w_body = self.body.to_object(space) # expr
- space.setattr(w_node, space.wrap('body'), w_body)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('body'), w_body)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -1823,15 +1823,15 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_IfExp)
w_test = self.test.to_object(space) # expr
- space.setattr(w_node, space.wrap('test'), w_test)
+ space.setattr(w_node, space.newtext('test'), w_test)
w_body = self.body.to_object(space) # expr
- space.setattr(w_node, space.wrap('body'), w_body)
+ space.setattr(w_node, space.newtext('body'), w_body)
w_orelse = self.orelse.to_object(space) # expr
- space.setattr(w_node, space.wrap('orelse'), w_orelse)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('orelse'), w_orelse)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -1883,17 +1883,17 @@
else:
keys_w = [node.to_object(space) for node in self.keys] # expr
w_keys = space.newlist(keys_w)
- space.setattr(w_node, space.wrap('keys'), w_keys)
+ space.setattr(w_node, space.newtext('keys'), w_keys)
if self.values is None:
values_w = []
else:
values_w = [node.to_object(space) for node in self.values] # expr
w_values = space.newlist(values_w)
- space.setattr(w_node, space.wrap('values'), w_values)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('values'), w_values)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -1935,11 +1935,11 @@
else:
elts_w = [node.to_object(space) for node in self.elts] # expr
w_elts = space.newlist(elts_w)
- space.setattr(w_node, space.wrap('elts'), w_elts)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('elts'), w_elts)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -1976,17 +1976,17 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_ListComp)
w_elt = self.elt.to_object(space) # expr
- space.setattr(w_node, space.wrap('elt'), w_elt)
+ space.setattr(w_node, space.newtext('elt'), w_elt)
if self.generators is None:
generators_w = []
else:
generators_w = [node.to_object(space) for node in self.generators]
# comprehension
w_generators = space.newlist(generators_w)
- space.setattr(w_node, space.wrap('generators'), w_generators)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('generators'), w_generators)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -2027,17 +2027,17 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_SetComp)
w_elt = self.elt.to_object(space) # expr
- space.setattr(w_node, space.wrap('elt'), w_elt)
+ space.setattr(w_node, space.newtext('elt'), w_elt)
if self.generators is None:
generators_w = []
else:
generators_w = [node.to_object(space) for node in self.generators]
# comprehension
w_generators = space.newlist(generators_w)
- space.setattr(w_node, space.wrap('generators'), w_generators)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('generators'), w_generators)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -2080,19 +2080,19 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_DictComp)
w_key = self.key.to_object(space) # expr
- space.setattr(w_node, space.wrap('key'), w_key)
+ space.setattr(w_node, space.newtext('key'), w_key)
w_value = self.value.to_object(space) # expr
- space.setattr(w_node, space.wrap('value'), w_value)
+ space.setattr(w_node, space.newtext('value'), w_value)
if self.generators is None:
generators_w = []
else:
generators_w = [node.to_object(space) for node in self.generators]
# comprehension
w_generators = space.newlist(generators_w)
- space.setattr(w_node, space.wrap('generators'), w_generators)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('generators'), w_generators)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -2137,17 +2137,17 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_GeneratorExp)
w_elt = self.elt.to_object(space) # expr
- space.setattr(w_node, space.wrap('elt'), w_elt)
+ space.setattr(w_node, space.newtext('elt'), w_elt)
if self.generators is None:
generators_w = []
else:
generators_w = [node.to_object(space) for node in self.generators]
# comprehension
w_generators = space.newlist(generators_w)
- space.setattr(w_node, space.wrap('generators'), w_generators)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('generators'), w_generators)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -2185,11 +2185,11 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_Yield)
w_value = self.value.to_object(space) if self.value is not None else
space.w_None # expr
- space.setattr(w_node, space.wrap('value'), w_value)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('value'), w_value)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -2226,23 +2226,23 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_Compare)
w_left = self.left.to_object(space) # expr
- space.setattr(w_node, space.wrap('left'), w_left)
+ space.setattr(w_node, space.newtext('left'), w_left)
if self.ops is None:
ops_w = []
else:
ops_w = [cmpop_to_class[node - 1]().to_object(space) for node in
self.ops] # cmpop
w_ops = space.newlist(ops_w)
- space.setattr(w_node, space.wrap('ops'), w_ops)
+ space.setattr(w_node, space.newtext('ops'), w_ops)
if self.comparators is None:
comparators_w = []
else:
comparators_w = [node.to_object(space) for node in
self.comparators] # expr
w_comparators = space.newlist(comparators_w)
- space.setattr(w_node, space.wrap('comparators'), w_comparators)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('comparators'), w_comparators)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -2296,27 +2296,27 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_Call)
w_func = self.func.to_object(space) # expr
- space.setattr(w_node, space.wrap('func'), w_func)
+ space.setattr(w_node, space.newtext('func'), w_func)
if self.args is None:
args_w = []
else:
args_w = [node.to_object(space) for node in self.args] # expr
w_args = space.newlist(args_w)
- space.setattr(w_node, space.wrap('args'), w_args)
+ space.setattr(w_node, space.newtext('args'), w_args)
if self.keywords is None:
keywords_w = []
else:
keywords_w = [node.to_object(space) for node in self.keywords] #
keyword
w_keywords = space.newlist(keywords_w)
- space.setattr(w_node, space.wrap('keywords'), w_keywords)
+ space.setattr(w_node, space.newtext('keywords'), w_keywords)
w_starargs = self.starargs.to_object(space) if self.starargs is not
None else space.w_None # expr
- space.setattr(w_node, space.wrap('starargs'), w_starargs)
+ space.setattr(w_node, space.newtext('starargs'), w_starargs)
w_kwargs = self.kwargs.to_object(space) if self.kwargs is not None
else space.w_None # expr
- space.setattr(w_node, space.wrap('kwargs'), w_kwargs)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('kwargs'), w_kwargs)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -2360,11 +2360,11 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_Repr)
w_value = self.value.to_object(space) # expr
- space.setattr(w_node, space.wrap('value'), w_value)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('value'), w_value)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -2397,11 +2397,11 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_Num)
w_n = self.n # object
- space.setattr(w_node, space.wrap('n'), w_n)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('n'), w_n)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -2434,11 +2434,11 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_Str)
w_s = self.s # string
- space.setattr(w_node, space.wrap('s'), w_s)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('s'), w_s)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -2474,15 +2474,15 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_Attribute)
w_value = self.value.to_object(space) # expr
- space.setattr(w_node, space.wrap('value'), w_value)
- w_attr = space.wrap(self.attr) # identifier
- space.setattr(w_node, space.wrap('attr'), w_attr)
+ space.setattr(w_node, space.newtext('value'), w_value)
+ w_attr = space.newtext(self.attr) # identifier
+ space.setattr(w_node, space.newtext('attr'), w_attr)
w_ctx = expr_context_to_class[self.ctx - 1]().to_object(space) #
expr_context
- space.setattr(w_node, space.wrap('ctx'), w_ctx)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('ctx'), w_ctx)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -2527,15 +2527,15 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_Subscript)
w_value = self.value.to_object(space) # expr
- space.setattr(w_node, space.wrap('value'), w_value)
+ space.setattr(w_node, space.newtext('value'), w_value)
w_slice = self.slice.to_object(space) # slice
- space.setattr(w_node, space.wrap('slice'), w_slice)
+ space.setattr(w_node, space.newtext('slice'), w_slice)
w_ctx = expr_context_to_class[self.ctx - 1]().to_object(space) #
expr_context
- space.setattr(w_node, space.wrap('ctx'), w_ctx)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('ctx'), w_ctx)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -2576,14 +2576,14 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_Name)
- w_id = space.wrap(self.id) # identifier
- space.setattr(w_node, space.wrap('id'), w_id)
+ w_id = space.newtext(self.id) # identifier
+ space.setattr(w_node, space.newtext('id'), w_id)
w_ctx = expr_context_to_class[self.ctx - 1]().to_object(space) #
expr_context
- space.setattr(w_node, space.wrap('ctx'), w_ctx)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('ctx'), w_ctx)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -2628,13 +2628,13 @@
else:
elts_w = [node.to_object(space) for node in self.elts] # expr
w_elts = space.newlist(elts_w)
- space.setattr(w_node, space.wrap('elts'), w_elts)
+ space.setattr(w_node, space.newtext('elts'), w_elts)
w_ctx = expr_context_to_class[self.ctx - 1]().to_object(space) #
expr_context
- space.setattr(w_node, space.wrap('ctx'), w_ctx)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('ctx'), w_ctx)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -2678,13 +2678,13 @@
else:
elts_w = [node.to_object(space) for node in self.elts] # expr
w_elts = space.newlist(elts_w)
- space.setattr(w_node, space.wrap('elts'), w_elts)
+ space.setattr(w_node, space.newtext('elts'), w_elts)
w_ctx = expr_context_to_class[self.ctx - 1]().to_object(space) #
expr_context
- space.setattr(w_node, space.wrap('ctx'), w_ctx)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('ctx'), w_ctx)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -2720,11 +2720,11 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_Const)
w_value = self.value # object
- space.setattr(w_node, space.wrap('value'), w_value)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('value'), w_value)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -2866,11 +2866,11 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_Slice)
w_lower = self.lower.to_object(space) if self.lower is not None else
space.w_None # expr
- space.setattr(w_node, space.wrap('lower'), w_lower)
+ space.setattr(w_node, space.newtext('lower'), w_lower)
w_upper = self.upper.to_object(space) if self.upper is not None else
space.w_None # expr
- space.setattr(w_node, space.wrap('upper'), w_upper)
+ space.setattr(w_node, space.newtext('upper'), w_upper)
w_step = self.step.to_object(space) if self.step is not None else
space.w_None # expr
- space.setattr(w_node, space.wrap('step'), w_step)
+ space.setattr(w_node, space.newtext('step'), w_step)
return w_node
@staticmethod
@@ -2907,7 +2907,7 @@
else:
dims_w = [node.to_object(space) for node in self.dims] # slice
w_dims = space.newlist(dims_w)
- space.setattr(w_node, space.wrap('dims'), w_dims)
+ space.setattr(w_node, space.newtext('dims'), w_dims)
return w_node
@staticmethod
@@ -2935,7 +2935,7 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_Index)
w_value = self.value.to_object(space) # expr
- space.setattr(w_node, space.wrap('value'), w_value)
+ space.setattr(w_node, space.newtext('value'), w_value)
return w_node
@staticmethod
@@ -3266,15 +3266,15 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_comprehension)
w_target = self.target.to_object(space) # expr
- space.setattr(w_node, space.wrap('target'), w_target)
+ space.setattr(w_node, space.newtext('target'), w_target)
w_iter = self.iter.to_object(space) # expr
- space.setattr(w_node, space.wrap('iter'), w_iter)
+ space.setattr(w_node, space.newtext('iter'), w_iter)
if self.ifs is None:
ifs_w = []
else:
ifs_w = [node.to_object(space) for node in self.ifs] # expr
w_ifs = space.newlist(ifs_w)
- space.setattr(w_node, space.wrap('ifs'), w_ifs)
+ space.setattr(w_node, space.newtext('ifs'), w_ifs)
return w_node
@staticmethod
@@ -3334,19 +3334,19 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_ExceptHandler)
w_type = self.type.to_object(space) if self.type is not None else
space.w_None # expr
- space.setattr(w_node, space.wrap('type'), w_type)
+ space.setattr(w_node, space.newtext('type'), w_type)
w_name = self.name.to_object(space) if self.name is not None else
space.w_None # expr
- space.setattr(w_node, space.wrap('name'), w_name)
+ space.setattr(w_node, space.newtext('name'), w_name)
if self.body is None:
body_w = []
else:
body_w = [node.to_object(space) for node in self.body] # stmt
w_body = space.newlist(body_w)
- space.setattr(w_node, space.wrap('body'), w_body)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('body'), w_body)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -3394,17 +3394,17 @@
else:
args_w = [node.to_object(space) for node in self.args] # expr
w_args = space.newlist(args_w)
- space.setattr(w_node, space.wrap('args'), w_args)
- w_vararg = space.wrap(self.vararg) # identifier
- space.setattr(w_node, space.wrap('vararg'), w_vararg)
- w_kwarg = space.wrap(self.kwarg) # identifier
- space.setattr(w_node, space.wrap('kwarg'), w_kwarg)
+ space.setattr(w_node, space.newtext('args'), w_args)
+ w_vararg = space.newtext_or_none(self.vararg) # identifier
+ space.setattr(w_node, space.newtext('vararg'), w_vararg)
+ w_kwarg = space.newtext_or_none(self.kwarg) # identifier
+ space.setattr(w_node, space.newtext('kwarg'), w_kwarg)
if self.defaults is None:
defaults_w = []
else:
defaults_w = [node.to_object(space) for node in self.defaults] #
expr
w_defaults = space.newlist(defaults_w)
- space.setattr(w_node, space.wrap('defaults'), w_defaults)
+ space.setattr(w_node, space.newtext('defaults'), w_defaults)
return w_node
@staticmethod
@@ -3438,10 +3438,10 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_keyword)
- w_arg = space.wrap(self.arg) # identifier
- space.setattr(w_node, space.wrap('arg'), w_arg)
+ w_arg = space.newtext(self.arg) # identifier
+ space.setattr(w_node, space.newtext('arg'), w_arg)
w_value = self.value.to_object(space) # expr
- space.setattr(w_node, space.wrap('value'), w_value)
+ space.setattr(w_node, space.newtext('value'), w_value)
return w_node
@staticmethod
@@ -3472,10 +3472,10 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_alias)
- w_name = space.wrap(self.name) # identifier
- space.setattr(w_node, space.wrap('name'), w_name)
- w_asname = space.wrap(self.asname) # identifier
- space.setattr(w_node, space.wrap('asname'), w_asname)
+ w_name = space.newtext(self.name) # identifier
+ space.setattr(w_node, space.newtext('name'), w_name)
+ w_asname = space.newtext_or_none(self.asname) # identifier
+ space.setattr(w_node, space.newtext('asname'), w_asname)
return w_node
@staticmethod
diff --git a/pypy/interpreter/astcompiler/astbuilder.py
b/pypy/interpreter/astcompiler/astbuilder.py
--- a/pypy/interpreter/astcompiler/astbuilder.py
+++ b/pypy/interpreter/astcompiler/astbuilder.py
@@ -1070,8 +1070,8 @@
raw = "0" + raw
if negative:
raw = "-" + raw
- w_num_str = self.space.wrap(raw)
- w_base = self.space.wrap(base)
+ w_num_str = self.space.newtext(raw)
+ w_base = self.space.newint(base)
if raw[-1] in "lL":
tp = self.space.w_long
return self.space.call_function(tp, w_num_str, w_base)
@@ -1105,12 +1105,12 @@
raise
# UnicodeError in literal: turn into SyntaxError
e.normalize_exception(space)
- errmsg = space.str_w(space.str(e.get_w_value(space)))
+ errmsg = space.text_w(space.str(e.get_w_value(space)))
raise self.error('(unicode error) %s' % errmsg, atom_node)
# This implements implicit string concatenation.
if len(sub_strings_w) > 1:
w_sub_strings = space.newlist(sub_strings_w)
- w_join = space.getattr(space.wrap(""), space.wrap("join"))
+ w_join = space.getattr(space.newtext(""),
space.newtext("join"))
final_string = space.call_function(w_join, w_sub_strings)
else:
final_string = sub_strings_w[0]
diff --git a/pypy/interpreter/astcompiler/codegen.py
b/pypy/interpreter/astcompiler/codegen.py
--- a/pypy/interpreter/astcompiler/codegen.py
+++ b/pypy/interpreter/astcompiler/codegen.py
@@ -322,7 +322,7 @@
def visit_ClassDef(self, cls):
self.update_position(cls.lineno, True)
self.visit_sequence(cls.decorator_list)
- self.load_const(self.space.wrap(cls.name))
+ self.load_const(self.space.newtext(cls.name))
self.visit_sequence(cls.bases)
bases_count = len(cls.bases) if cls.bases is not None else 0
self.emit_op_arg(ops.BUILD_TUPLE, bases_count)
@@ -611,7 +611,7 @@
level = 0
else:
level = -1
- self.load_const(self.space.wrap(level))
+ self.load_const(self.space.newint(level))
self.load_const(self.space.w_None)
self.emit_op_name(ops.IMPORT_NAME, self.names, alias.name)
# If there's no asname then we store the root module. If there is
@@ -654,12 +654,12 @@
level = -1
else:
level = imp.level
- self.load_const(space.wrap(level))
+ self.load_const(space.newint(level))
names_w = [None]*len(imp.names)
for i in range(len(imp.names)):
alias = imp.names[i]
assert isinstance(alias, ast.alias)
- names_w[i] = space.wrap(alias.name)
+ names_w[i] = space.newtext(alias.name)
self.load_const(space.newtuple(names_w))
if imp.module:
mod_name = imp.module
@@ -944,7 +944,7 @@
self.name_op(name.id, name.ctx)
def visit_keyword(self, keyword):
- self.load_const(self.space.wrap(keyword.arg))
+ self.load_const(self.space.newtext(keyword.arg))
keyword.value.walkabout(self)
def visit_Call(self, call):
diff --git a/pypy/interpreter/astcompiler/misc.py
b/pypy/interpreter/astcompiler/misc.py
--- a/pypy/interpreter/astcompiler/misc.py
+++ b/pypy/interpreter/astcompiler/misc.py
@@ -19,10 +19,10 @@
If the user has set this warning to raise an error, a SyntaxError will be
raised."""
- w_msg = space.wrap(msg)
- w_filename = space.wrap(fn)
- w_lineno = space.wrap(lineno)
- w_offset = space.wrap(offset)
+ w_msg = space.newtext(msg)
+ w_filename = space.newtext(fn)
+ w_lineno = space.newint(lineno)
+ w_offset = space.newint(offset)
_emit_syntax_warning(space, w_msg, w_filename, w_lineno, w_offset)
@@ -110,9 +110,9 @@
def intern_if_common_string(space, w_const):
# only intern identifier-like strings
- if not space.is_w(space.type(w_const), space.w_str):
+ if not space.is_w(space.type(w_const), space.w_text):
return w_const
- for c in space.str_w(w_const):
+ for c in space.text_w(w_const):
if not (c.isalnum() or c == '_'):
return w_const
return space.new_interned_w_str(w_const)
diff --git a/pypy/interpreter/astcompiler/optimize.py
b/pypy/interpreter/astcompiler/optimize.py
--- a/pypy/interpreter/astcompiler/optimize.py
+++ b/pypy/interpreter/astcompiler/optimize.py
@@ -120,7 +120,7 @@
return space.pow(w_left, w_right, space.w_None)
def _fold_not(space, operand):
- return space.wrap(not space.is_true(operand))
+ return space.newbool(not space.is_true(operand))
binary_folders = {
@@ -216,7 +216,7 @@
break
else:
raise AssertionError("unknown unary operation")
- w_minint = self.space.wrap(-sys.maxint - 1)
+ w_minint = self.space.newint(-sys.maxint - 1)
# This makes sure the result is an integer.
if self.space.eq_w(w_minint, w_const):
w_const = w_minint
diff --git a/pypy/interpreter/astcompiler/tools/asdl_py.py
b/pypy/interpreter/astcompiler/tools/asdl_py.py
--- a/pypy/interpreter/astcompiler/tools/asdl_py.py
+++ b/pypy/interpreter/astcompiler/tools/asdl_py.py
@@ -127,8 +127,14 @@
return "%s_to_class[%s - 1]().to_object(space)" % (field.type,
value)
elif field.type in ("object", "singleton", "string", "bytes"):
return value
- elif field.type in ("identifier", "int", "bool"):
- return "space.wrap(%s)" % (value,)
+ elif field.type == "bool":
+ return "space.newbool(%s)" % (value,)
+ elif field.type == "int":
+ return "space.newint(%s)" % (value,)
+ elif field.type == "identifier":
+ if field.opt:
+ return "space.newtext_or_none(%s)" % (value,)
+ return "space.newtext(%s)" % (value,)
else:
wrapper = "%s.to_object(space)" % (value,)
if field.opt:
@@ -194,7 +200,7 @@
wrapping_code = self.get_field_converter(field)
for line in wrapping_code:
self.emit(line, 2)
- self.emit("space.setattr(w_node, space.wrap(%r), w_%s)" % (
+ self.emit("space.setattr(w_node, space.newtext(%r), w_%s)" % (
str(field.name), field.name), 2)
self.emit("return w_node", 2)
self.emit("")
@@ -402,7 +408,7 @@
"field %s is required for %T", name, w_obj)
def check_string(space, w_obj):
- if not (space.isinstance_w(w_obj, space.w_str) or
+ if not (space.isinstance_w(w_obj, space.w_bytes) or
space.isinstance_w(w_obj, space.w_unicode)):
raise oefmt(space.w_TypeError,
"AST string must be of type str or unicode")
@@ -437,10 +443,10 @@
"Hack around the fact we can't store tuples on a TypeDef."
def __init__(self, fields):
- self.fields = fields
+ assert fields == []
- def __spacebind__(self, space):
- return space.newtuple([space.wrap(field) for field in self.fields])
+ def spacebind(self, space):
+ return space.newtuple([])
class W_AST(W_Root):
@@ -456,14 +462,14 @@
if w_dict is None:
w_dict = space.newdict()
w_type = space.type(self)
- w_fields = space.getattr(w_type, space.wrap("_fields"))
+ w_fields = space.getattr(w_type, space.newtext("_fields"))
for w_name in space.fixedview(w_fields):
try:
space.setitem(w_dict, w_name,
space.getattr(self, w_name))
except OperationError:
pass
- w_attrs = space.findattr(w_type, space.wrap("_attributes"))
+ w_attrs = space.findattr(w_type, space.newtext("_attributes"))
if w_attrs:
for w_name in space.fixedview(w_attrs):
try:
@@ -482,12 +488,12 @@
def W_AST_new(space, w_type, __args__):
node = space.allocate_instance(W_AST, w_type)
- return space.wrap(node)
+ return node
def W_AST_init(space, w_self, __args__):
args_w, kwargs_w = __args__.unpack()
fields_w = space.fixedview(space.getattr(space.type(w_self),
- space.wrap("_fields")))
+ space.newtext("_fields")))
num_fields = len(fields_w) if fields_w else 0
if args_w and len(args_w) != num_fields:
if num_fields == 0:
@@ -503,7 +509,7 @@
for i, w_field in enumerate(fields_w):
space.setattr(w_self, w_field, args_w[i])
for field, w_value in kwargs_w.iteritems():
- space.setattr(w_self, space.wrap(field), w_value)
+ space.setattr(w_self, space.newtext(field), w_value)
W_AST.typedef = typedef.TypeDef("_ast.AST",
@@ -532,16 +538,16 @@
def make_new_type(self, space, name, base, fields, attributes):
w_base = getattr(self, 'w_%s' % base)
w_dict = space.newdict()
- space.setitem_str(w_dict, '__module__', space.wrap('_ast'))
+ space.setitem_str(w_dict, '__module__', space.newtext('_ast'))
if fields is not None:
space.setitem_str(w_dict, "_fields",
- space.newtuple([space.wrap(f) for f in fields]))
+ space.newtuple([space.newtext(f) for f in
fields]))
if attributes is not None:
space.setitem_str(w_dict, "_attributes",
- space.newtuple([space.wrap(a) for a in
attributes]))
+ space.newtuple([space.newtext(a) for a in
attributes]))
w_type = space.call_function(
space.w_type,
- space.wrap(name), space.newtuple([w_base]), w_dict)
+ space.newtext(name), space.newtuple([w_base]), w_dict)
setattr(self, 'w_%s' % name, w_type)
def get(space):
diff --git a/pypy/interpreter/baseobjspace.py b/pypy/interpreter/baseobjspace.py
--- a/pypy/interpreter/baseobjspace.py
+++ b/pypy/interpreter/baseobjspace.py
@@ -5,7 +5,7 @@
from rpython.rlib import jit, types
from rpython.rlib.debug import make_sure_not_resized
from rpython.rlib.objectmodel import (we_are_translated, newlist_hint,
- compute_unique_id, specialize)
+ compute_unique_id, specialize, not_rpython)
from rpython.rlib.signature import signature
from rpython.rlib.rarithmetic import r_uint, SHRT_MIN, SHRT_MAX, \
INT_MIN, INT_MAX, UINT_MAX, USHRT_MAX
@@ -51,7 +51,7 @@
w_dict = self.getdict(space)
if w_dict is not None:
try:
- space.delitem(w_dict, space.wrap(attr))
+ space.delitem(w_dict, space.newtext(attr))
return True
except OperationError as ex:
if not ex.match(space, space.w_KeyError):
@@ -77,7 +77,7 @@
def getname(self, space):
try:
- return space.str_w(space.getattr(self, space.wrap('__name__')))
+ return space.text_w(space.getattr(self, space.newtext('__name__')))
except OperationError as e:
if e.match(space, space.w_TypeError) or e.match(space,
space.w_AttributeError):
return '?'
@@ -86,8 +86,8 @@
def getaddrstring(self, space):
# slowish
w_id = space.id(self)
- w_4 = space.wrap(4)
- w_0x0F = space.wrap(0x0F)
+ w_4 = space.newint(4)
+ w_0x0F = space.newint(0x0F)
i = 2 * HUGEVAL_BYTES
addrstring = [' '] * i
while True:
@@ -104,8 +104,8 @@
def getrepr(self, space, info, moreinfo=''):
addrstring = self.getaddrstring(space)
- return space.wrap("<%s at 0x%s%s>" % (info, addrstring,
- moreinfo))
+ return space.newtext("<%s at 0x%s%s>" % (info, addrstring,
+ moreinfo))
def getslotvalue(self, index):
raise NotImplementedError
@@ -321,11 +321,14 @@
raise oefmt(space.w_TypeError,
"ord() expected string of length 1, but %T found", self)
- def __spacebind__(self, space):
+ def spacebind(self, space):
+ """ Return a version of the object bound to a specific object space
+ instance. This is used for objects (like e.g. TypeDefs) that are
+ constructed before there is an object space instance. """
return self
+ @not_rpython
def unwrap(self, space):
- """NOT_RPYTHON"""
# _____ this code is here to support testing only _____
return self
@@ -408,8 +411,9 @@
"""Base class for the interpreter-level implementations of object spaces.
http://pypy.readthedocs.org/en/latest/objspace.html""";
+ @not_rpython
def __init__(self, config=None):
- "NOT_RPYTHON: Basic initialization of objects."
+ "Basic initialization of objects."
self.fromcache = InternalSpaceCache(self).getorbuild
self.threadlocals = ThreadLocals()
# set recursion limit
@@ -487,8 +491,9 @@
except AttributeError:
return self.__class__.__name__
+ @not_rpython
def setbuiltinmodule(self, importname):
- """NOT_RPYTHON. load a lazy pypy/module and put it into sys.modules"""
+ """load a lazy pypy/module and put it into sys.modules"""
if '.' in importname:
fullname = importname
importname = fullname.rsplit('.', 1)[1]
@@ -502,13 +507,13 @@
else:
name = importname
_______________________________________________
pypy-commit mailing list
pypy-commit@python.org
https://mail.python.org/mailman/listinfo/pypy-commit
