def PyUnicode_AsXXXString(space, w_unicode):
"""Encode a Unicode object and return the result as Python
string object. Error handling is "strict". Return NULL if an
exception was raised by the codec."""
if not PyUnicode_Check(space, w_unicode):
PyErr_BadArgument(space)
return unicodetype.encode_object(space, w_unicode, encoding, "strict")
def init__Bytearray(space, w_bytearray, __args__):
# this is on the silly side
w_source, w_encoding, w_errors = __args__.parse_obj(
None, 'bytearray', init_signature, init_defaults)
if w_source is None:
w_source = space.wrap('')
if w_encoding is None:
w_encoding = space.w_None
if w_errors is None:
w_errors = space.w_None
# Unicode argument
if not space.is_w(w_encoding, space.w_None):
from pypy.objspace.std.unicodetype import (
_get_encoding_and_errors, encode_object
)
encoding, errors = _get_encoding_and_errors(space, w_encoding, w_errors)
# if w_source is an integer this correctly raises a TypeError
# the CPython error message is: "encoding or errors without a string argument"
# ours is: "expected unicode, got int object"
w_source = encode_object(space, w_source, encoding, errors)
# Is it an int?
try:
count = space.int_w(w_source)
except OperationError, e:
if not e.match(space, space.w_TypeError):
raise
def PyUnicode_AsUnicodeEscapeString(space, w_unicode):
"""Encode a Unicode object using Unicode-Escape and return the result as Python
string object. Error handling is "strict". Return NULL if an exception was
raised by the codec."""
if not PyUnicode_Check(space, w_unicode):
PyErr_BadArgument(space)
return unicodetype.encode_object(space, w_unicode, 'unicode-escape', 'strict')
def unicode_encode__Unicode_ANY_ANY(space, w_unistr, w_encoding=None, w_errors=None):
from pypy.objspace.std.unicodetype import _get_encoding_and_errors
from pypy.objspace.std.unicodetype import encode_object
encoding, errors = _get_encoding_and_errors(space, w_encoding, w_errors)
w_retval = encode_object(space, w_unistr, encoding, errors)
return w_retval
def unicode_encode__Unicode_ANY_ANY(space, w_unistr,
w_encoding=None,
w_errors=None):
from pypy.objspace.std.unicodetype import getdefaultencoding, \
_get_encoding_and_errors, encode_object
encoding, errors = _get_encoding_and_errors(space, w_encoding, w_errors)
if encoding is None:
encoding = getdefaultencoding(space)
w_retval = encode_object(space, w_unistr, encoding, errors)
return w_retval
def unicode_encode__Unicode_ANY_ANY(space,
w_unistr,
w_encoding=None,
w_errors=None):
from pypy.objspace.std.unicodetype import getdefaultencoding, \
_get_encoding_and_errors, encode_object
encoding, errors = _get_encoding_and_errors(space, w_encoding, w_errors)
if encoding is None:
encoding = getdefaultencoding(space)
w_retval = encode_object(space, w_unistr, encoding, errors)
return w_retval
def PyUnicode_AsEncodedObject(space, w_unicode, llencoding, llerrors):
"""Encode a Unicode object and return the result as Python object.
encoding and errors have the same meaning as the parameters of the same name
in the Unicode encode() method. The codec to be used is looked up using
the Python codec registry. Return NULL if an exception was raised by the
codec."""
if not PyUnicode_Check(space, w_unicode):
PyErr_BadArgument(space)
encoding = errors = None
if llencoding:
encoding = rffi.charp2str(llencoding)
if llerrors:
errors = rffi.charp2str(llerrors)
return unicodetype.encode_object(space, w_unicode, encoding, errors)
def PyUnicode_AsEncodedObject(space, w_unicode, llencoding, llerrors):
"""Encode a Unicode object and return the result as Python object.
encoding and errors have the same meaning as the parameters of the same name
in the Unicode encode() method. The codec to be used is looked up using
the Python codec registry. Return NULL if an exception was raised by the
codec."""
if not PyUnicode_Check(space, w_unicode):
PyErr_BadArgument(space)
encoding = errors = None
if llencoding:
encoding = rffi.charp2str(llencoding)
if llerrors:
errors = rffi.charp2str(llerrors)
return unicodetype.encode_object(space, w_unicode, encoding, errors)
def unicode_call_errorhandler(errors, encoding, reason, input,
startpos, endpos):
w_errorhandler = lookup_error(space, errors)
if decode:
w_cls = space.w_UnicodeDecodeError
else:
w_cls = space.w_UnicodeEncodeError
w_exc = space.call_function(
w_cls,
space.wrap(encoding),
space.wrap(input),
space.wrap(startpos),
space.wrap(endpos),
space.wrap(reason))
w_res = space.call_function(w_errorhandler, w_exc)
if (not space.is_true(space.isinstance(w_res, space.w_tuple))
or space.len_w(w_res) != 2
or not space.is_true(space.isinstance(
space.getitem(w_res, space.wrap(0)),
space.w_unicode))):
if decode:
msg = ("decoding error handler must return "
"(unicode, int) tuple, not %s")
else:
msg = ("encoding error handler must return "
"(unicode, int) tuple, not %s")
raise operationerrfmt(
space.w_TypeError, msg,
space.str_w(space.repr(w_res)))
w_replace, w_newpos = space.fixedview(w_res, 2)
newpos = space.int_w(w_newpos)
if newpos < 0:
newpos = len(input) + newpos
if newpos < 0 or newpos > len(input):
raise operationerrfmt(
space.w_IndexError,
"position %d from error handler out of bounds", newpos)
if decode:
replace = space.unicode_w(w_replace)
return replace, newpos
else:
from pypy.objspace.std.unicodetype import encode_object
w_str = encode_object(space, w_replace, encoding, None)
replace = space.str_w(w_str)
return replace, newpos
def unicode_call_errorhandler(errors, encoding, reason, input,
startpos, endpos):
w_errorhandler = lookup_error(space, errors)
if decode:
w_cls = space.w_UnicodeDecodeError
else:
w_cls = space.w_UnicodeEncodeError
w_exc = space.call_function(
w_cls,
space.wrap(encoding),
space.wrap(input),
space.wrap(startpos),
space.wrap(endpos),
space.wrap(reason))
w_res = space.call_function(w_errorhandler, w_exc)
if (not space.is_true(space.isinstance(w_res, space.w_tuple))
or space.len_w(w_res) != 2
or not space.is_true(space.isinstance(
space.getitem(w_res, space.wrap(0)),
space.w_unicode))):
if decode:
msg = ("decoding error handler must return "
"(unicode, int) tuple, not %s")
else:
msg = ("encoding error handler must return "
"(unicode, int) tuple, not %s")
raise operationerrfmt(
space.w_TypeError, msg,
space.str_w(space.repr(w_res)))
w_replace, w_newpos = space.fixedview(w_res, 2)
newpos = space.int_w(w_newpos)
if newpos < 0:
newpos = len(input) + newpos
if newpos < 0 or newpos > len(input):
raise operationerrfmt(
space.w_IndexError,
"position %d from error handler out of bounds", newpos)
if decode:
replace = space.unicode_w(w_replace)
return replace, newpos
else:
from pypy.objspace.std.unicodetype import encode_object
w_str = encode_object(space, w_replace, encoding, None)
replace = space.str_w(w_str)
return replace, newpos
def encode_unicode(space, w_unistr, encoding, errors):
from pypy.objspace.std.unicodetype import getdefaultencoding, \
_get_encoding_and_errors, encode_object
from pypy.objspace.std.ropeobject import W_RopeObject
if errors is None or errors == "strict":
node = w_unistr._node
if encoding == 'ascii':
result = rope.unicode_encode_ascii(node)
if result is not None:
return W_RopeObject(result)
elif encoding == 'latin-1':
result = rope.unicode_encode_latin1(node)
if result is not None:
return W_RopeObject(result)
elif encoding == "utf-8":
result = rope.unicode_encode_utf8(node)
if result is not None:
return W_RopeObject(result)
return encode_object(space, w_unistr, encoding, errors)
def encode_unicode(space, w_unistr, encoding, errors):
from pypy.objspace.std.unicodetype import getdefaultencoding, \
_get_encoding_and_errors, encode_object
from pypy.objspace.std.ropeobject import W_RopeObject
if errors is None or errors == "strict":
node = w_unistr._node
if encoding == 'ascii':
result = rope.unicode_encode_ascii(node)
if result is not None:
return W_RopeObject(result)
elif encoding == 'latin-1':
result = rope.unicode_encode_latin1(node)
if result is not None:
return W_RopeObject(result)
elif encoding == "utf-8":
result = rope.unicode_encode_utf8(node)
if result is not None:
return W_RopeObject(result)
return encode_object(space, w_unistr, encoding, errors)
def str_encode__Rope_ANY_ANY(space, w_string, w_encoding=None, w_errors=None):
from pypy.objspace.std.unicodetype import _get_encoding_and_errors, \
encode_object
encoding, errors = _get_encoding_and_errors(space, w_encoding, w_errors)
return encode_object(space, w_string, encoding, errors)
def str_encode__String_ANY_ANY(space, w_string, w_encoding=None, w_errors=None):
#import pdb; pdb.set_trace()
from pypy.objspace.std.unicodetype import _get_encoding_and_errors, \
encode_object
encoding, errors = _get_encoding_and_errors(space, w_encoding, w_errors)
return encode_object(space, w_string, encoding, errors)
def str_encode__String_ANY_ANY(space, w_string, w_encoding=None, w_errors=None):
from pypy.objspace.std.unicodetype import _get_encoding_and_errors, \
encode_object
encoding, errors = _get_encoding_and_errors(space, w_encoding, w_errors)
return encode_object(space, w_string, encoding, errors)
def encode(space, w_data, encoding=None, errors='strict'):
from pypy.objspace.std.unicodetype import encode_object
return encode_object(space, w_data, encoding, errors)
def str__Unicode(space, w_uni):
from pypy.objspace.std.unicodetype import encode_object
return encode_object(space, w_uni, None, None)
