[pypy-commit] pypy py3.5: merge heads
arigo
pypy.commits at gmail.com
Thu Feb 16 14:57:03 EST 2017
Author: Armin Rigo <arigo at tunes.org>
Branch: py3.5
Changeset: r90173:f6c56ea574e6
Date: 2017-02-16 20:55 +0100
http://bitbucket.org/pypy/pypy/changeset/f6c56ea574e6/
Log: merge heads
diff too long, truncating to 2000 out of 25082 lines
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/goal/targetpypystandalone.py b/pypy/goal/targetpypystandalone.py
--- a/pypy/goal/targetpypystandalone.py
+++ b/pypy/goal/targetpypystandalone.py
@@ -32,9 +32,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:
@@ -83,7 +83,7 @@
except OperationError as e:
debug("OperationError:")
debug(" operror-type: " + e.w_type.getname(space).encode('utf-8'))
- 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:
@@ -91,7 +91,7 @@
except OperationError as e:
debug("OperationError:")
debug(" operror-type: " + e.w_type.getname(space).encode('utf-8'))
- 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
@@ -148,7 +148,7 @@
if verbose:
debug("OperationError:")
debug(" operror-type: " + e.w_type.getname(space).encode('utf-8'))
- 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:
@@ -187,11 +187,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['builtins'])
- 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'):
@@ -202,7 +202,7 @@
except OperationError as e:
debug("OperationError:")
debug(" operror-type: " + e.w_type.getname(space).encode('utf-8'))
- 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
@@ -333,7 +333,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
@@ -404,7 +404,7 @@
i = 0
for w_key in keys_w:
try:
- key = space.identifier_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,
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
@@ -269,8 +269,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
@@ -369,7 +369,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):
@@ -197,7 +197,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
@@ -232,7 +232,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
@@ -260,7 +260,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
@@ -296,7 +296,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
@@ -400,28 +400,28 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_FunctionDef)
- w_name = space.wrap(self.name.decode('utf-8')) # 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)
+ space.setattr(w_node, space.newtext('decorator_list'), w_decorator_list)
w_returns = self.returns.to_object(space) if self.returns is not None else space.w_None # expr
- space.setattr(w_node, space.wrap('returns'), w_returns)
- 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('returns'), w_returns)
+ 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
@@ -480,28 +480,28 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_AsyncFunctionDef)
- w_name = space.wrap(self.name.decode('utf-8')) # 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)
+ space.setattr(w_node, space.newtext('decorator_list'), w_decorator_list)
w_returns = self.returns.to_object(space) if self.returns is not None else space.w_None # expr
- space.setattr(w_node, space.wrap('returns'), w_returns)
- 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('returns'), w_returns)
+ 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
@@ -565,36 +565,36 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_ClassDef)
- w_name = space.wrap(self.name.decode('utf-8')) # 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.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)
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
@@ -641,11 +641,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
@@ -684,11 +684,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
@@ -730,13 +730,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
@@ -776,15 +776,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
@@ -838,25 +838,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
@@ -912,25 +912,25 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_AsyncFor)
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
@@ -984,23 +984,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
@@ -1050,23 +1050,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
@@ -1118,17 +1118,17 @@
else:
items_w = [node.to_object(space) for node in self.items] # withitem
w_items = space.newlist(items_w)
- space.setattr(w_node, space.wrap('items'), w_items)
+ space.setattr(w_node, space.newtext('items'), w_items)
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
@@ -1176,17 +1176,17 @@
else:
items_w = [node.to_object(space) for node in self.items] # withitem
w_items = space.newlist(items_w)
- space.setattr(w_node, space.wrap('items'), w_items)
+ space.setattr(w_node, space.newtext('items'), w_items)
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
@@ -1226,13 +1226,13 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_Raise)
w_exc = self.exc.to_object(space) if self.exc is not None else space.w_None # expr
- space.setattr(w_node, space.wrap('exc'), w_exc)
+ space.setattr(w_node, space.newtext('exc'), w_exc)
w_cause = self.cause.to_object(space) if self.cause is not None else space.w_None # expr
- space.setattr(w_node, space.wrap('cause'), w_cause)
- 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('cause'), w_cause)
+ 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
@@ -1288,29 +1288,29 @@
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)
+ space.setattr(w_node, space.newtext('orelse'), w_orelse)
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
@@ -1355,13 +1355,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
@@ -1404,11 +1404,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
@@ -1445,20 +1445,20 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_ImportFrom)
- w_module = space.wrap(self.module.decode('utf-8')) if self.module is not None else space.w_None # 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
@@ -1468,7 +1468,7 @@
w_level = get_field(space, w_node, 'level', True)
w_lineno = get_field(space, w_node, 'lineno', False)
w_col_offset = get_field(space, w_node, 'col_offset', False)
- _module = space.str_or_None_w(w_module)
+ _module = space.text_or_None_w(w_module)
names_w = space.unpackiterable(w_names)
_names = [alias.from_object(space, w_item) for w_item in names_w]
_level = space.int_w(w_level)
@@ -1496,13 +1496,13 @@
if self.names is None:
names_w = []
else:
- names_w = [space.wrap(node.decode('utf-8')) 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
@@ -1536,13 +1536,13 @@
if self.names is None:
names_w = []
else:
- names_w = [space.wrap(node.decode('utf-8')) 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
@@ -1575,11 +1575,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
@@ -1610,10 +1610,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
@@ -1640,10 +1640,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
@@ -1670,10 +1670,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
@@ -1781,17 +1781,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
@@ -1831,15 +1831,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
@@ -1882,13 +1882,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
@@ -1928,13 +1928,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
@@ -1976,15 +1976,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
@@ -2038,17 +2038,17 @@
else:
keys_w = [node.to_object(space) if node is not None else space.w_None 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
@@ -2091,11 +2091,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
@@ -2133,17 +2133,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
@@ -2185,17 +2185,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
@@ -2239,19 +2239,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
@@ -2297,17 +2297,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
@@ -2344,11 +2344,11 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_Await)
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
@@ -2383,11 +2383,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
@@ -2419,11 +2419,11 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_YieldFrom)
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
@@ -2463,23 +2463,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
@@ -2529,23 +2529,23 @@
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)
- 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('keywords'), w_keywords)
+ 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
@@ -2584,11 +2584,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
@@ -2621,11 +2621,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
@@ -2663,15 +2663,15 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_FormattedValue)
w_value = self.value.to_object(space) # expr
- space.setattr(w_node, space.wrap('value'), w_value)
- w_conversion = space.wrap(self.conversion) # int
- space.setattr(w_node, space.wrap('conversion'), w_conversion)
+ space.setattr(w_node, space.newtext('value'), w_value)
+ w_conversion = space.newint(self.conversion) # int
+ space.setattr(w_node, space.newtext('conversion'), w_conversion)
w_format_spec = self.format_spec.to_object(space) if self.format_spec is not None else space.w_None # expr
- space.setattr(w_node, space.wrap('format_spec'), w_format_spec)
- 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('format_spec'), w_format_spec)
+ 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
@@ -2716,11 +2716,11 @@
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
@@ -2752,11 +2752,11 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_Bytes)
w_s = self.s # bytes
- 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
@@ -2789,11 +2789,11 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_NameConstant)
w_value = self.value # singleton
- 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
@@ -2824,10 +2824,10 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_Ellipsis)
- 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
@@ -2859,15 +2859,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.decode('utf-8')) # 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
@@ -2912,15 +2912,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
@@ -2963,13 +2963,13 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_Starred)
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_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
@@ -3006,14 +3006,14 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_Name)
- w_id = space.wrap(self.id.decode('utf-8')) # 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
@@ -3059,13 +3059,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
@@ -3110,13 +3110,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
@@ -3152,11 +3152,11 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_Const)
w_obj = self.obj # object
- space.setattr(w_node, space.wrap('obj'), w_obj)
- 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('obj'), w_obj)
+ 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
@@ -3276,11 +3276,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
@@ -3318,7 +3318,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
@@ -3346,7 +3346,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
@@ -3687,15 +3687,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
@@ -3754,19 +3754,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)
- w_name = space.wrap(self.name.decode('utf-8')) if self.name is not None else space.w_None # identifier
- space.setattr(w_node, space.wrap('name'), w_name)
+ space.setattr(w_node, space.newtext('type'), w_type)
+ w_name = space.newtext_or_none(self.name) # identifier
+ 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
@@ -3777,7 +3777,7 @@
w_lineno = get_field(space, w_node, 'lineno', False)
w_col_offset = get_field(space, w_node, 'col_offset', False)
_type = expr.from_object(space, w_type)
- _name = space.str_or_None_w(w_name)
+ _name = space.text_or_None_w(w_name)
body_w = space.unpackiterable(w_body)
_body = [stmt.from_object(space, w_item) for w_item in body_w]
_lineno = space.int_w(w_lineno)
@@ -3830,29 +3830,29 @@
else:
args_w = [node.to_object(space) for node in self.args] # arg
w_args = space.newlist(args_w)
- space.setattr(w_node, space.wrap('args'), w_args)
+ space.setattr(w_node, space.newtext('args'), w_args)
w_vararg = self.vararg.to_object(space) if self.vararg is not None else space.w_None # arg
- space.setattr(w_node, space.wrap('vararg'), w_vararg)
+ space.setattr(w_node, space.newtext('vararg'), w_vararg)
if self.kwonlyargs is None:
kwonlyargs_w = []
else:
kwonlyargs_w = [node.to_object(space) for node in self.kwonlyargs] # arg
w_kwonlyargs = space.newlist(kwonlyargs_w)
- space.setattr(w_node, space.wrap('kwonlyargs'), w_kwonlyargs)
+ space.setattr(w_node, space.newtext('kwonlyargs'), w_kwonlyargs)
if self.kw_defaults is None:
kw_defaults_w = []
else:
kw_defaults_w = [node.to_object(space) if node is not None else space.w_None for node in self.kw_defaults] # expr
w_kw_defaults = space.newlist(kw_defaults_w)
- space.setattr(w_node, space.wrap('kw_defaults'), w_kw_defaults)
+ space.setattr(w_node, space.newtext('kw_defaults'), w_kw_defaults)
w_kwarg = self.kwarg.to_object(space) if self.kwarg is not None else space.w_None # arg
- space.setattr(w_node, space.wrap('kwarg'), w_kwarg)
+ 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
@@ -3895,14 +3895,14 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_arg)
- w_arg = space.wrap(self.arg.decode('utf-8')) # 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_annotation = self.annotation.to_object(space) if self.annotation is not None else space.w_None # expr
- space.setattr(w_node, space.wrap('annotation'), w_annotation)
- 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('annotation'), w_annotation)
+ 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
@@ -3936,17 +3936,17 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_keyword)
- w_arg = space.wrap(self.arg.decode('utf-8')) if self.arg is not None else space.w_None # identifier
- space.setattr(w_node, space.wrap('arg'), w_arg)
+ w_arg = space.newtext_or_none(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
def from_object(space, w_node):
w_arg = get_field(space, w_node, 'arg', True)
w_value = get_field(space, w_node, 'value', False)
- _arg = space.str_or_None_w(w_arg)
+ _arg = space.text_or_None_w(w_arg)
_value = expr.from_object(space, w_value)
if _value is None:
raise_required_value(space, w_node, 'value')
@@ -3968,10 +3968,10 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_alias)
- w_name = space.wrap(self.name.decode('utf-8')) # identifier
- space.setattr(w_node, space.wrap('name'), w_name)
- w_asname = space.wrap(self.asname.decode('utf-8')) if self.asname is not None else space.w_None # 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
@@ -3981,7 +3981,7 @@
_name = space.identifier_w(w_name)
if _name is None:
raise_required_value(space, w_node, 'name')
- _asname = space.str_or_None_w(w_asname)
+ _asname = space.text_or_None_w(w_asname)
return alias(_name, _asname)
State.ast_type('alias', 'AST', ['name', 'asname'])
@@ -4004,9 +4004,9 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_withitem)
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)
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
@@ -1168,8 +1168,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 "jJ":
tp = self.space.w_complex
return self.space.call_function(tp, w_num_str)
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
@@ -313,7 +313,7 @@
def _make_function(self, code, num_defaults=0, qualname=None):
"""Emit the opcodes to turn a code object into a function."""
- w_qualname = self.space.wrap((qualname or code.co_name).decode('utf-8'))
+ w_qualname = self.space.newtext(qualname or code.co_name)
if code.co_freevars:
# Load cell and free vars to pass on.
for free in code.co_freevars:
@@ -339,8 +339,8 @@
if default:
kwonly = args.kwonlyargs[i]
assert isinstance(kwonly, ast.arg)
- mangled = self.scope.mangle(kwonly.arg).decode('utf-8')
- self.load_const(self.space.wrap(mangled))
+ mangled = self.scope.mangle(kwonly.arg)
+ self.load_const(self.space.newtext(mangled))
default.walkabout(self)
defaults += 1
return defaults
@@ -375,8 +375,7 @@
if l:
if l > 65534:
self.error("too many annotations", func)
- w_tup = space.newtuple([space.wrap(name.decode('utf-8'))
- for name in names])
+ w_tup = space.newtuple([space.newtext(name) for name in names])
self.load_const(w_tup)
l += 1
return l
@@ -438,7 +437,7 @@
# 3. load a function (or closure) made from the code object
self._make_function(code, qualname=qualname)
# 4. load class name
- self.load_const(self.space.wrap(cls.name.decode('utf-8')))
+ self.load_const(self.space.newtext(cls.name))
# 5. generate the rest of the code for the call
self._make_call(2, cls.bases, cls.keywords)
# 6. apply decorators
@@ -808,7 +807,7 @@
for alias in imp.names:
assert isinstance(alias, ast.alias)
level = 0
- 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
@@ -846,12 +845,12 @@
self.error("not a chance", imp)
self.error("future feature %s is not defined" %
(alias.name,), imp)
- self.load_const(space.wrap(imp.level))
+ self.load_const(space.newint(imp.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.decode('utf-8'))
+ names_w[i] = space.newtext(alias.name)
self.load_const(space.newtuple(names_w))
if imp.module:
mod_name = imp.module
@@ -1250,7 +1249,7 @@
def visit_keyword(self, keyword):
if keyword.arg is not None:
- self.load_const(self.space.wrap(keyword.arg.decode('utf-8')))
+ self.load_const(self.space.newtext(keyword.arg))
keyword.value.walkabout(self)
def _make_call(self, n, # args already pushed
@@ -1308,7 +1307,7 @@
nsubkwargs += 1
elif nsubkwargs:
# A keyword argument and we already have a dict.
- self.load_const(self.space.wrap(kw.arg.decode('utf-8')))
+ self.load_const(self.space.newtext(kw.arg))
kw.value.walkabout(self)
nseen += 1
else:
@@ -1651,7 +1650,7 @@
# ... and store it as __module__
self.name_op("__module__", ast.Store)
# store the qualname
- w_qualname = self.space.wrap(self.qualname.decode("utf-8"))
+ w_qualname = self.space.newtext(self.qualname)
self.load_const(w_qualname)
self.name_op("__qualname__", ast.Store)
# compile the body proper
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_msg = space.newtext(msg)
w_filename = space.wrap_fsdecoded(fn)
- w_lineno = space.wrap(lineno)
- w_offset = space.wrap(offset)
+ w_lineno = space.newint(lineno)
+ w_offset = space.newint(offset)
_emit_syntax_warning(space, w_msg, w_filename, w_lineno, w_offset)
@@ -127,6 +127,6 @@
return name
from pypy.module.unicodedata.interp_ucd import ucd
- w_name = space.wrap(name.decode('utf-8'))
- w_id = space.call_method(ucd, 'normalize', space.wrap('NFKC'), w_name)
- return space.unicode_w(w_id).encode('utf-8')
+ w_name = space.newtext(name)
+ w_id = space.call_method(ucd, 'normalize', space.newtext('NFKC'), w_name)
+ return space.text_w(w_id)
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
@@ -131,7 +131,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 = {
@@ -222,7 +222,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
@@ -130,15 +130,16 @@
def get_value_converter(self, field, value):
if field.type in self.data.simple_types:
return "%s_to_class[%s - 1]().to_object(space)" % (field.type, value)
- elif field.type == "identifier":
- wrapper = "space.wrap(%s.decode('utf-8'))" % (value,)
- if field.opt:
- wrapper += " if %s is not None else space.w_None" % (value,)
- return wrapper
elif field.type in ("object", "singleton", "string", "bytes"):
return value
- elif field.type in ("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,)
allow_none = field.opt
@@ -160,7 +161,7 @@
return "check_string(space, %s)" % (value,)
elif field.type in ("identifier",):
if field.opt:
- return "space.str_or_None_w(%s)" % (value,)
+ return "space.text_or_None_w(%s)" % (value,)
return "space.identifier_w(%s)" % (value,)
elif field.type in ("int",):
return "space.int_w(%s)" % (value,)
@@ -223,7 +224,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("")
@@ -440,7 +441,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")
More information about the pypy-commit
mailing list