def PyUnicode_DecodeUTF16(space, s, size, llerrors, pbyteorder):
"""Decode length bytes from a UTF-16 encoded buffer string and return the
corresponding Unicode object. errors (if non-NULL) defines the error
handling. It defaults to "strict".
If byteorder is non-NULL, the decoder starts decoding using the given byte
order:
*byteorder == -1: little endian
*byteorder == 0: native order
*byteorder == 1: big endian
If *byteorder is zero, and the first two bytes of the input data are a
byte order mark (BOM), the decoder switches to this byte order and the BOM is
not copied into the resulting Unicode string. If *byteorder is -1 or
1, any byte order mark is copied to the output (where it will result in
either a \ufeff or a \ufffe character).
After completion, *byteorder is set to the current byte order at the end
of input data.
If byteorder is NULL, the codec starts in native order mode.
Return NULL if an exception was raised by the codec."""
string = rffi.charpsize2str(s, size)
if pbyteorder is not None:
llbyteorder = rffi.cast(lltype.Signed, pbyteorder[0])
if llbyteorder < 0:
byteorder = "little"
elif llbyteorder > 0:
byteorder = "big"
else:
byteorder = "native"
else:
byteorder = "native"
if llerrors:
errors = rffi.charp2str(llerrors)
else:
errors = None
result, _, length, byteorder = str_decode_utf_16_helper(
string, errors, final=True, errorhandler=None, byteorder=byteorder)
if pbyteorder is not None:
pbyteorder[0] = rffi.cast(rffi.INT_real, byteorder)
return space.newutf8(result, length)
def utf_16_ex_decode(space, data, errors='strict', byteorder=0, w_final=None):
from pypy.interpreter.unicodehelper import str_decode_utf_16_helper
if errors is None:
errors = 'strict'
final = space.is_true(w_final)
state = space.fromcache(CodecState)
if byteorder == 0:
_byteorder = 'native'
elif byteorder == -1:
_byteorder = 'little'
else:
_byteorder = 'big'
res, lgt, pos, bo = str_decode_utf_16_helper(data, errors, final,
state.decode_error_handler,
_byteorder)
# return result, consumed, byteorder for buffered incremental encoders
return space.newtuple(
[space.newutf8(res, lgt),
space.newint(pos),
space.newint(bo)])
def utf_16_ex_decode(space, data, errors='strict', byteorder=0, w_final=None):
from pypy.interpreter.unicodehelper import str_decode_utf_16_helper
if errors is None:
errors = 'strict'
final = space.is_true(w_final)
state = space.fromcache(CodecState)
if byteorder == 0:
byteorder = 'native'
elif byteorder == -1:
byteorder = 'little'
else:
byteorder = 'big'
consumed = len(data)
if final:
consumed = 0
res, consumed, lgt, byteorder = str_decode_utf_16_helper(
data, errors, final,
state.decode_error_handler, byteorder)
return space.newtuple([space.newutf8(res, lgt),
space.newint(consumed),
space.newint(byteorder)])