public static void register(PyObject search_function) {

codecs.register(search_function);

}

private static String _castString(PyString pystr) {

// Jython used to treat String as equivalent to PyString, or maybe PyUnicode, as

// it made sense. We need to be more careful now! Insert this cast check as necessary

// to ensure the appropriate compliance.

if (pystr == null) {

return null;

}

String s = pystr.toString();

if (pystr instanceof PyUnicode) {

return s;

} else {

// May throw UnicodeEncodeError, per CPython behavior

return codecs.PyUnicode_EncodeASCII(s, s.length(), null);

}

}

public static PyTuple lookup(PyString encoding) {

return codecs.lookup(_castString(encoding));

}

public static PyObject lookup_error(PyString handlerName) {

return codecs.lookup_error(_castString(handlerName));

}

public static void register_error(String name, PyObject errorHandler) {

codecs.register_error(name, errorHandler);

}

/**

public static PyObject decode(PyString bytes) {

return decode(bytes, null, null);

}

/**

public static PyObject decode(PyString bytes, PyString encoding) {

return decode(bytes, encoding, null);

}

/**

public static PyObject decode(PyString bytes, PyString encoding, PyString errors) {

return codecs.decode(bytes, _castString(encoding), _castString(errors));

}

/**

public static PyString encode(PyUnicode unicode) {

return encode(unicode, null, null);

}

/**

public static PyString encode(PyUnicode unicode, PyString encoding) {

return encode(unicode, encoding, null);

}

/**

public static PyString encode(PyUnicode unicode, PyString encoding, PyString errors) {

return Py.newString(codecs.encode(unicode, _castString(encoding), _castString(errors)));

}

/* --- Some codec support methods -------------------------------------------- */

public static PyObject charmap_build(PyUnicode map) {

return EncodingMap.buildEncodingMap(map);

}

/**

enum ByteOrder {

LE, UNDEFINED, BE;

/** Returns the Python equivalent code -1 = LE, 0 = as marked/platform, +1 = BE */

int code() {

return ordinal() - 1;

}

/** Returns equivalent to the Python code -1 = LE, 0 = as marked/platform, +1 = BE */

static ByteOrder fromInt(int byteorder) {

switch (byteorder) {

case -1:

return LE;

case 1:

return BE;

default:

return UNDEFINED;

}

}

}

/**

private static PyTuple decode_tuple(String u, int bytesConsumed) {

return new PyTuple(new PyUnicode(u), Py.newInteger(bytesConsumed));

}

/**

private static PyTuple decode_tuple(String u, int[] consumed, int defConsumed) {

return decode_tuple(u, consumed != null ? consumed[0] : defConsumed);

}

/**

private static PyTuple decode_tuple(String u, int bytesConsumed, ByteOrder order) {

int bo = order.code();

return new PyTuple(new PyUnicode(u), Py.newInteger(bytesConsumed), Py.newInteger(bo));

}

private static PyTuple decode_tuple_str(String s, int len) {

return new PyTuple(new PyString(s), Py.newInteger(len));

}

private static PyTuple encode_tuple(String s, int len) {

return new PyTuple(new PyString(s), Py.newInteger(len));

}

/* --- UTF-8 Codec --------------------------------------------------- */

public static PyTuple utf_8_decode(String str) {

return utf_8_decode(str, null);

}

public static PyTuple utf_8_decode(String str, String errors) {

return utf_8_decode(str, errors, false);

}

public static PyTuple utf_8_decode(String str, String errors, PyObject final_) {

return utf_8_decode(str, errors, final_.__nonzero__());

}

public static PyTuple utf_8_decode(String str, String errors, boolean final_) {

int[] consumed = final_ ? null : new int[1];

return decode_tuple(codecs.PyUnicode_DecodeUTF8Stateful(str, errors, consumed), final_

? str.length() : consumed[0]);

}

public static PyTuple utf_8_encode(String str) {

return utf_8_encode(str, null);

}

public static PyTuple utf_8_encode(String str, String errors) {

int size = str.length();

return encode_tuple(codecs.PyUnicode_EncodeUTF8(str, errors), size);

}

/* --- UTF-7 Codec --------------------------------------------------- */

public static PyTuple utf_7_decode(String bytes) {

return utf_7_decode(bytes, null);

}

public static PyTuple utf_7_decode(String bytes, String errors) {

return utf_7_decode(bytes, null, false);

}

public static PyTuple utf_7_decode(String bytes, String errors, boolean finalFlag) {

int[] consumed = finalFlag ? null : new int[1];

String decoded = codecs.PyUnicode_DecodeUTF7Stateful(bytes, errors, consumed);

return decode_tuple(decoded, consumed, bytes.length());

}

public static PyTuple utf_7_encode(String str) {

return utf_7_encode(str, null);

}

public static PyTuple utf_7_encode(String str, String errors) {

int size = str.length();

return encode_tuple(codecs.PyUnicode_EncodeUTF7(str, false, false, errors), size);

}

/* --- string-escape Codec -------------------------------------------- */

public static PyTuple escape_decode(String str) {

return escape_decode(str, null);

}

public static PyTuple escape_decode(String str, String errors) {

return decode_tuple_str(PyString.decode_UnicodeEscape(str, 0, str.length(), errors, true),

str.length());

}

public static PyTuple escape_encode(String str) {

return escape_encode(str, null);

}

public static PyTuple escape_encode(String str, String errors) {

return encode_tuple(PyString.encode_UnicodeEscape(str, false), str.length());

}

/* --- Character Mapping Codec --------------------------------------- */

/**

public static PyTuple charmap_decode(String bytes) {

return charmap_decode(bytes, null, null);

}

/**

public static PyTuple charmap_decode(String bytes, String errors) {

return charmap_decode(bytes, errors, null);

}

/**

public static PyTuple charmap_decode(String bytes, String errors, PyObject mapping) {

if (mapping == null || mapping == Py.None) {

// Default to Latin-1

return latin_1_decode(bytes, errors);

} else {

return charmap_decode(bytes, errors, mapping, false);

}

}

/**

public static PyTuple charmap_decode(String bytes, String errors, PyObject mapping,

boolean ignoreUnmapped) {

// XXX bytes: would prefer to accept any object with buffer API

int size = bytes.length();

StringBuilder v = new StringBuilder(size);

for (int i = 0; i < size; i++) {

// Process the i.th input byte

int b = bytes.charAt(i);

if (b > 0xff) {

i = codecs.insertReplacementAndGetResume(v, errors, "charmap", bytes, //

i, i + 1, "ordinal not in range(255)") - 1;

continue;

}

// Map the byte to an output character code (or possibly string)

PyObject w = Py.newInteger(b);

PyObject x = mapping.__finditem__(w);

// Apply to the output

if (x == null) {

// Error case: mapping not found

if (ignoreUnmapped) {

v.appendCodePoint(b);

} else {

i = codecs.insertReplacementAndGetResume(v, errors, "charmap", bytes, //

i, i + 1, "no mapping found") - 1;

}

} else if (x instanceof PyInteger) {

// Mapping was to an int: treat as character code

int value = ((PyInteger)x).getValue();

if (value < 0 || value > PySystemState.maxunicode) {

throw Py.TypeError("character mapping must return "

+ "integer greater than 0 and less than sys.maxunicode");

}

v.appendCodePoint(value);

} else if (x == Py.None) {

i = codecs.insertReplacementAndGetResume(v, errors, "charmap", bytes, //

i, i + 1, "character maps to <undefined>") - 1;

} else if (x instanceof PyString) {

String s = x.toString();

if (s.charAt(0) == 0xfffe) {

// Invalid indicates "undefined" see C-API PyUnicode_DecodeCharmap()

i = codecs.insertReplacementAndGetResume(v, errors, "charmap", bytes, //

i, i + 1, "character maps to <undefined>") - 1;

} else {

v.append(s);

}

} else {

/* wrong return value */

throw Py.TypeError("character mapping must return " + "integer, None or str");

}

}

return decode_tuple(v.toString(), size);

}

// parallel to CPython's PyUnicode_TranslateCharmap

public static PyObject translateCharmap(PyUnicode str, String errors, PyObject mapping) {

StringBuilder buf = new StringBuilder(str.toString().length());

for (Iterator<Integer> iter = str.newSubsequenceIterator(); iter.hasNext();) {

int codePoint = iter.next();

PyObject result = mapping.__finditem__(Py.newInteger(codePoint));

if (result == null) {

// No mapping found means: use 1:1 mapping

buf.appendCodePoint(codePoint);

} else if (result == Py.None) {

// XXX: We don't support the fancier error handling CPython does here of

// capturing regions of chars removed by the None mapping to optionally

// pass to an error handler. Though we don't seem to even use this

// functionality anywhere either

;

} else if (result instanceof PyInteger) {

int value = result.asInt();

if (value < 0 || value > PySystemState.maxunicode) {

throw Py.TypeError(String.format("character mapping must be in range(0x%x)",

PySystemState.maxunicode + 1));

}

buf.appendCodePoint(value);

} else if (result instanceof PyUnicode) {

buf.append(result.toString());

} else {

// wrong return value

throw Py.TypeError("character mapping must return integer, None or unicode");

}

}

return new PyUnicode(buf.toString());

}

/**

public static PyTuple charmap_encode(String str) {

return charmap_encode(str, null, null);

}

/**

public static PyTuple charmap_encode(String str, String errors) {

return charmap_encode(str, errors, null);

}

/**

public static PyTuple charmap_encode(String str, String errors, PyObject mapping) {

if (mapping == null || mapping == Py.None) {

// Default to Latin-1

return latin_1_encode(str, errors);

} else {

return charmap_encode_internal(str, errors, mapping, new StringBuilder(str.length()),

true);

}

}

/**

private static PyTuple charmap_encode_internal(String str, String errors, PyObject mapping,

StringBuilder v, boolean letLookupHandleError) {

EncodingMap encodingMap = mapping instanceof EncodingMap ? (EncodingMap)mapping : null;

int size = str.length();

for (int i = 0; i < size; i++) {

// Map the i.th character of str to some value

char ch = str.charAt(i);

PyObject x;

if (encodingMap != null) {

// The mapping given was an EncodingMap [0,256) => on-negative int

int result = encodingMap.lookup(ch);

x = (result == -1) ? null : Py.newInteger(result);

} else {

// The mapping was a map or similar: non-negative int -> object

x = mapping.__finditem__(Py.newInteger(ch));

}

// And map this object to an output character

if (x == null) {

// Error during lookup

if (letLookupHandleError) {

// Some kind of substitute can be placed in the output

i = handleBadMapping(str, errors, mapping, v, size, i);

} else {

// Hard error

throw Py.UnicodeEncodeError("charmap", str, i, i + 1,

"character maps to <undefined>");

}

} else if (x instanceof PyInteger) {

// Look-up had integer result: output as byte value

int value = ((PyInteger)x).getValue();

if (value < 0 || value > 255) {

throw Py.TypeError("character mapping must be in range(256)");

}

v.append((char)value);

} else if (x instanceof PyString && !(x instanceof PyUnicode)) {

// Look-up had str or unicode result: output as Java String

// XXX: (Py3k) Look-up had bytes or str result: output as ... this is a problem

v.append(x.toString());

} else if (x instanceof PyNone) {

i = handleBadMapping(str, errors, mapping, v, size, i);

} else {

/* wrong return value */

throw Py.TypeError("character mapping must return " + "integer, None or str");

}

}

return encode_tuple(v.toString(), size);

}

/**

private static int handleBadMapping(String str, String errors, PyObject mapping,

StringBuilder v, int size, int i) {

// If error policy specified, execute it

if (errors != null) {

if (errors.equals(codecs.IGNORE)) {

return i;

} else if (errors.equals(codecs.REPLACE)) {

String replStr = "?";

charmap_encode_internal(replStr, errors, mapping, v, false);

return i;

} else if (errors.equals(codecs.XMLCHARREFREPLACE)) {

String replStr = codecs.xmlcharrefreplace(i, i + 1, str).toString();

charmap_encode_internal(replStr, errors, mapping, v, false);

return i;

} else if (errors.equals(codecs.BACKSLASHREPLACE)) {

String replStr = codecs.backslashreplace(i, i + 1, str).toString();

charmap_encode_internal(replStr, errors, mapping, v, false);

return i;

}

}

// Default behaviour (error==null or does not match known case)

String msg = "character maps to <undefined>";

PyObject replacement = codecs.encoding_error(errors, "charmap", str, i, i + 1, msg);

String replStr = replacement.__getitem__(0).toString();

charmap_encode_internal(replStr, errors, mapping, v, false);

return codecs.calcNewPosition(size, replacement) - 1;

}

/* --- ascii Codec ---------------------------------------------- */

public static PyTuple ascii_decode(String str) {

return ascii_decode(str, null);

}

public static PyTuple ascii_decode(String str, String errors) {

int size = str.length();

return decode_tuple(codecs.PyUnicode_DecodeASCII(str, size, errors), size);

}

public static PyTuple ascii_encode(String str) {

return ascii_encode(str, null);

}

public static PyTuple ascii_encode(String str, String errors) {

int size = str.length();

return encode_tuple(codecs.PyUnicode_EncodeASCII(str, size, errors), size);

}

/* --- Latin-1 Codec -------------------------------------------- */

public static PyTuple latin_1_decode(String str) {

return latin_1_decode(str, null);

}

public static PyTuple latin_1_decode(String str, String errors) {

int size = str.length();

return decode_tuple(codecs.PyUnicode_DecodeLatin1(str, size, errors), size);

}

public static PyTuple latin_1_encode(String str) {

return latin_1_encode(str, null);

}

public static PyTuple latin_1_encode(String str, String errors) {

int size = str.length();

return encode_tuple(codecs.PyUnicode_EncodeLatin1(str, size, errors), size);

}

/* --- UTF-16 Codec ------------------------------------------- */

public static PyTuple utf_16_encode(String str) {

return utf_16_encode(str, null);

}

public static PyTuple utf_16_encode(String str, String errors) {

return encode_tuple(encode_UTF16(str, errors, 0), str.length());

}

public static PyTuple utf_16_encode(String str, String errors, int byteorder) {

return encode_tuple(encode_UTF16(str, errors, byteorder), str.length());

}

public static PyTuple utf_16_le_encode(String str) {

return utf_16_le_encode(str, null);

}

public static PyTuple utf_16_le_encode(String str, String errors) {

return encode_tuple(encode_UTF16(str, errors, -1), str.length());

}

public static PyTuple utf_16_be_encode(String str) {

return utf_16_be_encode(str, null);

}

public static PyTuple utf_16_be_encode(String str, String errors) {

return encode_tuple(encode_UTF16(str, errors, 1), str.length());

}

public static String encode_UTF16(String str, String errors, int byteorder) {

final Charset utf16;

if (byteorder == 0) {

utf16 = Charset.forName("UTF-16");

} else if (byteorder == -1) {

utf16 = Charset.forName("UTF-16LE");

} else {

utf16 = Charset.forName("UTF-16BE");

}

// XXX errors argument ignored: Java's codecs implement "replace"

final ByteBuffer bbuf = utf16.encode(str);

final StringBuilder v = new StringBuilder(bbuf.limit());

while (bbuf.remaining() > 0) {

int val = bbuf.get();

if (val < 0) {

val = 256 + val;

}

v.appendCodePoint(val);

}

return v.toString();

}

public static PyTuple utf_16_decode(String str) {

return utf_16_decode(str, null);

}

public static PyTuple utf_16_decode(String str, String errors) {

return utf_16_decode(str, errors, false);

}

public static PyTuple utf_16_decode(String str, String errors, boolean final_) {

int[] bo = new int[] {0};

int[] consumed = final_ ? null : new int[1];

return decode_tuple(decode_UTF16(str, errors, bo, consumed), final_ ? str.length()

: consumed[0]);

}

public static PyTuple utf_16_le_decode(String str) {

return utf_16_le_decode(str, null);

}

public static PyTuple utf_16_le_decode(String str, String errors) {

return utf_16_le_decode(str, errors, false);

}

public static PyTuple utf_16_le_decode(String str, String errors, boolean final_) {

int[] bo = new int[] {-1};

int[] consumed = final_ ? null : new int[1];

return decode_tuple(decode_UTF16(str, errors, bo, consumed), final_ ? str.length()

: consumed[0]);

}

public static PyTuple utf_16_be_decode(String str) {

return utf_16_be_decode(str, null);

}

public static PyTuple utf_16_be_decode(String str, String errors) {

return utf_16_be_decode(str, errors, false);

}

public static PyTuple utf_16_be_decode(String str, String errors, boolean final_) {

int[] bo = new int[] {1};

int[] consumed = final_ ? null : new int[1];

return decode_tuple(decode_UTF16(str, errors, bo, consumed), final_ ? str.length()

: consumed[0]);

}

public static PyTuple utf_16_ex_decode(String str) {

return utf_16_ex_decode(str, null);

}

public static PyTuple utf_16_ex_decode(String str, String errors) {

return utf_16_ex_decode(str, errors, 0);

}

public static PyTuple utf_16_ex_decode(String str, String errors, int byteorder) {

return utf_16_ex_decode(str, errors, byteorder, false);

}

public static PyTuple

utf_16_ex_decode(String str, String errors, int byteorder, boolean final_) {

int[] bo = new int[] {0};

int[] consumed = final_ ? null : new int[1];

String decoded = decode_UTF16(str, errors, bo, consumed);

return new PyTuple(new PyUnicode(decoded), Py.newInteger(final_ ? str.length()

: consumed[0]), Py.newInteger(bo[0]));

}

private static String decode_UTF16(String str, String errors, int[] byteorder) {

return decode_UTF16(str, errors, byteorder, null);

}

private static String decode_UTF16(String str, String errors, int[] byteorder, int[] consumed) {

int bo = 0;

if (byteorder != null) {

bo = byteorder[0];

}

int size = str.length();

StringBuilder v = new StringBuilder(size / 2);

int i;

for (i = 0; i < size; i += 2) {

char ch1 = str.charAt(i);

if (i + 1 == size) {

if (consumed != null) {

break;

}

i = codecs.insertReplacementAndGetResume(v, errors, "utf-16", str, //

i, i + 1, "truncated data");

continue;

}

char ch2 = str.charAt(i + 1);

if (ch1 == 0xFE && ch2 == 0xFF) {

bo = 1;

continue;

} else if (ch1 == 0xFF && ch2 == 0xFE) {

bo = -1;

continue;

}

int W1;

if (bo == -1) {

W1 = (ch2 << 8 | ch1);

} else {

W1 = (ch1 << 8 | ch2);

}

if (W1 < 0xD800 || W1 > 0xDFFF) {

v.appendCodePoint(W1);

continue;

} else if (W1 >= 0xD800 && W1 <= 0xDBFF && i < size - 1) {

i += 2;

char ch3 = str.charAt(i);

char ch4 = str.charAt(i + 1);

int W2;

if (bo == -1) {

W2 = (ch4 << 8 | ch3);

} else {

W2 = (ch3 << 8 | ch4);

}

if (W2 >= 0xDC00 && W2 <= 0xDFFF) {

int U = (((W1 & 0x3FF) << 10) | (W2 & 0x3FF)) + 0x10000;

v.appendCodePoint(U);

continue;

}

i = codecs.insertReplacementAndGetResume(v, errors, "utf-16", str, //

i, i + 1, "illegal UTF-16 surrogate");

continue;

}

i = codecs.insertReplacementAndGetResume(v, errors, "utf-16", str, //

i, i + 1, "illegal encoding");

}

if (byteorder != null) {

byteorder[0] = bo;

}

if (consumed != null) {

consumed[0] = i;

}

return v.toString();

}

/* --- UTF-32 Codec ------------------------------------------- */

/**

public static PyTuple utf_32_encode(String unicode) {

return utf_32_encode(unicode, null);

}

/**

public static PyTuple utf_32_encode(String unicode, String errors) {

return PyUnicode_EncodeUTF32(unicode, errors, ByteOrder.UNDEFINED);

}

/**

public static PyTuple utf_32_encode(String unicode, String errors, int byteorder) {

ByteOrder order = ByteOrder.fromInt(byteorder);

return PyUnicode_EncodeUTF32(unicode, errors, order);

}

/**

public static PyTuple utf_32_le_encode(String unicode) {

return utf_32_le_encode(unicode, null);

}

/**

public static PyTuple utf_32_le_encode(String unicode, String errors) {

return PyUnicode_EncodeUTF32(unicode, errors, ByteOrder.LE);

}

/**

public static PyTuple utf_32_be_encode(String unicode) {

return utf_32_be_encode(unicode, null);

}

/**

public static PyTuple utf_32_be_encode(String unicode, String errors) {

return PyUnicode_EncodeUTF32(unicode, errors, ByteOrder.BE);

}

/**

private static PyTuple PyUnicode_EncodeUTF32(String unicode, String errors, ByteOrder order) {

// We use a StringBuilder but we are really storing encoded bytes

StringBuilder v = new StringBuilder(4 * (unicode.length() + 1));

int uptr = 0;

// Write a BOM (if required to)

if (order == ByteOrder.UNDEFINED) {

v.append("\u0000\u0000\u00fe\u00ff");

order = ByteOrder.BE;

}

if (order != ByteOrder.LE) {

uptr = PyUnicode_EncodeUTF32BELoop(v, unicode, errors);

} else {

uptr = PyUnicode_EncodeUTF32LELoop(v, unicode, errors);

}

// XXX Issue #2002: should probably report length consumed in Unicode characters

return encode_tuple(v.toString(), uptr);

}

/**

private static int PyUnicode_EncodeUTF32BELoop(StringBuilder v, String unicode, String errors) {

int len = unicode.length();

int uptr = 0;

char[] buf = new char[6]; // first 3 elements always zero

/*

while (uptr < len) {

int ch = unicode.charAt(uptr++);

if ((ch & 0xF800) == 0xD800) {

/*

if ((ch & 0x0400) == 0) {

// Yes, it's a lead surrogate

if (uptr < len) {

// And there is something to follow

int ch2 = unicode.charAt(uptr++);

if ((ch2 & 0xFC00) == 0xDC00) {

// And it is a trail surrogate, so we can get on with the encoding

ch = ((ch & 0x3ff) << 10) + (ch2 & 0x3ff) + 0x10000;

buf[3] = (char)((ch >> 16) & 0xff);

buf[4] = (char)((ch >> 8) & 0xff);