fix ya.make

1 files changed, 0 insertions, 1536 deletions

diff --git a/contrib/tools/python3/src/Python/codecs.c b/contrib/tools/python3/src/Python/codecs.c
deleted file mode 100644
index fa329ce243..0000000000
--- a/contrib/tools/python3/src/Python/codecs.c
+++ /dev/null
@@ -1,1536 +0,0 @@
-/* ------------------------------------------------------------------------
-
-   Python Codec Registry and support functions
-
-Written by Marc-Andre Lemburg (mal@lemburg.com).
-
-Copyright (c) Corporation for National Research Initiatives.
-
-   ------------------------------------------------------------------------ */
-
-#include "Python.h"
-#include "pycore_interp.h"        // PyInterpreterState.codec_search_path
-#include "pycore_pystate.h"       // _PyInterpreterState_GET()
-#include "pycore_ucnhash.h"       // _PyUnicode_Name_CAPI
-#include <ctype.h>
-
-const char *Py_hexdigits = "0123456789abcdef";
-
-/* --- Codec Registry ----------------------------------------------------- */
-
-/* Import the standard encodings package which will register the first
-   codec search function.
-
-   This is done in a lazy way so that the Unicode implementation does
-   not downgrade startup time of scripts not needing it.
-
-   ImportErrors are silently ignored by this function. Only one try is
-   made.
-
-*/
-
-static int _PyCodecRegistry_Init(void); /* Forward */
-
-int PyCodec_Register(PyObject *search_function)
-{
-    PyInterpreterState *interp = _PyInterpreterState_GET();
-    if (interp->codec_search_path == NULL && _PyCodecRegistry_Init())
-        goto onError;
-    if (search_function == NULL) {
-        PyErr_BadArgument();
-        goto onError;
-    }
-    if (!PyCallable_Check(search_function)) {
-        PyErr_SetString(PyExc_TypeError, "argument must be callable");
-        goto onError;
-    }
-    return PyList_Append(interp->codec_search_path, search_function);
-
- onError:
-    return -1;
-}
-
-int
-PyCodec_Unregister(PyObject *search_function)
-{
-    PyInterpreterState *interp = PyInterpreterState_Get();
-    PyObject *codec_search_path = interp->codec_search_path;
-    /* Do nothing if codec_search_path is not created yet or was cleared. */
-    if (codec_search_path == NULL) {
-        return 0;
-    }
-
-    assert(PyList_CheckExact(codec_search_path));
-    Py_ssize_t n = PyList_GET_SIZE(codec_search_path);
-    for (Py_ssize_t i = 0; i < n; i++) {
-        PyObject *item = PyList_GET_ITEM(codec_search_path, i);
-        if (item == search_function) {
-            if (interp->codec_search_cache != NULL) {
-                assert(PyDict_CheckExact(interp->codec_search_cache));
-                PyDict_Clear(interp->codec_search_cache);
-            }
-            return PyList_SetSlice(codec_search_path, i, i+1, NULL);
-        }
-    }
-    return 0;
-}
-
-extern int _Py_normalize_encoding(const char *, char *, size_t);
-
-/* Convert a string to a normalized Python string(decoded from UTF-8): all characters are
-   converted to lower case, spaces and hyphens are replaced with underscores. */
-
-static
-PyObject *normalizestring(const char *string)
-{
-    size_t len = strlen(string);
-    char *encoding;
-    PyObject *v;
-
-    if (len > PY_SSIZE_T_MAX) {
-        PyErr_SetString(PyExc_OverflowError, "string is too large");
-        return NULL;
-    }
-
-    encoding = PyMem_Malloc(len + 1);
-    if (encoding == NULL)
-        return PyErr_NoMemory();
-
-    if (!_Py_normalize_encoding(string, encoding, len + 1))
-    {
-        PyErr_SetString(PyExc_RuntimeError, "_Py_normalize_encoding() failed");
-        PyMem_Free(encoding);
-        return NULL;
-    }
-
-    v = PyUnicode_FromString(encoding);
-    PyMem_Free(encoding);
-    return v;
-}
-
-/* Lookup the given encoding and return a tuple providing the codec
-   facilities.
-
-   The encoding string is looked up converted to all lower-case
-   characters. This makes encodings looked up through this mechanism
-   effectively case-insensitive.
-
-   If no codec is found, a LookupError is set and NULL returned.
-
-   As side effect, this tries to load the encodings package, if not
-   yet done. This is part of the lazy load strategy for the encodings
-   package.
-
-*/
-
-PyObject *_PyCodec_Lookup(const char *encoding)
-{
-    if (encoding == NULL) {
-        PyErr_BadArgument();
-        return NULL;
-    }
-
-    PyInterpreterState *interp = _PyInterpreterState_GET();
-    if (interp->codec_search_path == NULL && _PyCodecRegistry_Init()) {
-        return NULL;
-    }
-
-    /* Convert the encoding to a normalized Python string: all
-       characters are converted to lower case, spaces and hyphens are
-       replaced with underscores. */
-    PyObject *v = normalizestring(encoding);
-    if (v == NULL) {
-        return NULL;
-    }
-    PyUnicode_InternInPlace(&v);
-
-    /* First, try to lookup the name in the registry dictionary */
-    PyObject *result = PyDict_GetItemWithError(interp->codec_search_cache, v);
-    if (result != NULL) {
-        Py_INCREF(result);
-        Py_DECREF(v);
-        return result;
-    }
-    else if (PyErr_Occurred()) {
-        goto onError;
-    }
-
-    /* Next, scan the search functions in order of registration */
-    const Py_ssize_t len = PyList_Size(interp->codec_search_path);
-    if (len < 0)
-        goto onError;
-    if (len == 0) {
-        PyErr_SetString(PyExc_LookupError,
-                        "no codec search functions registered: "
-                        "can't find encoding");
-        goto onError;
-    }
-
-    Py_ssize_t i;
-    for (i = 0; i < len; i++) {
-        PyObject *func;
-
-        func = PyList_GetItem(interp->codec_search_path, i);
-        if (func == NULL)
-            goto onError;
-        result = PyObject_CallOneArg(func, v);
-        if (result == NULL)
-            goto onError;
-        if (result == Py_None) {
-            Py_DECREF(result);
-            continue;
-        }
-        if (!PyTuple_Check(result) || PyTuple_GET_SIZE(result) != 4) {
-            PyErr_SetString(PyExc_TypeError,
-                            "codec search functions must return 4-tuples");
-            Py_DECREF(result);
-            goto onError;
-        }
-        break;
-    }
-    if (i == len) {
-        /* XXX Perhaps we should cache misses too ? */
-        PyErr_Format(PyExc_LookupError,
-                     "unknown encoding: %s", encoding);
-        goto onError;
-    }
-
-    /* Cache and return the result */
-    if (PyDict_SetItem(interp->codec_search_cache, v, result) < 0) {
-        Py_DECREF(result);
-        goto onError;
-    }
-    Py_DECREF(v);
-    return result;
-
- onError:
-    Py_DECREF(v);
-    return NULL;
-}
-
-/* Codec registry encoding check API. */
-
-int PyCodec_KnownEncoding(const char *encoding)
-{
-    PyObject *codecs;
-
-    codecs = _PyCodec_Lookup(encoding);
-    if (!codecs) {
-        PyErr_Clear();
-        return 0;
-    }
-    else {
-        Py_DECREF(codecs);
-        return 1;
-    }
-}
-
-static
-PyObject *args_tuple(PyObject *object,
-                     const char *errors)
-{
-    PyObject *args;
-
-    args = PyTuple_New(1 + (errors != NULL));
-    if (args == NULL)
-        return NULL;
-    Py_INCREF(object);
-    PyTuple_SET_ITEM(args,0,object);
-    if (errors) {
-        PyObject *v;
-
-        v = PyUnicode_FromString(errors);
-        if (v == NULL) {
-            Py_DECREF(args);
-            return NULL;
-        }
-        PyTuple_SET_ITEM(args, 1, v);
-    }
-    return args;
-}
-
-/* Helper function to get a codec item */
-
-static
-PyObject *codec_getitem(const char *encoding, int index)
-{
-    PyObject *codecs;
-    PyObject *v;
-
-    codecs = _PyCodec_Lookup(encoding);
-    if (codecs == NULL)
-        return NULL;
-    v = PyTuple_GET_ITEM(codecs, index);
-    Py_DECREF(codecs);
-    Py_INCREF(v);
-    return v;
-}
-
-/* Helper functions to create an incremental codec. */
-static
-PyObject *codec_makeincrementalcodec(PyObject *codec_info,
-                                     const char *errors,
-                                     const char *attrname)
-{
-    PyObject *ret, *inccodec;
-
-    inccodec = PyObject_GetAttrString(codec_info, attrname);
-    if (inccodec == NULL)
-        return NULL;
-    if (errors)
-        ret = PyObject_CallFunction(inccodec, "s", errors);
-    else
-        ret = _PyObject_CallNoArg(inccodec);
-    Py_DECREF(inccodec);
-    return ret;
-}
-
-static
-PyObject *codec_getincrementalcodec(const char *encoding,
-                                    const char *errors,
-                                    const char *attrname)
-{
-    PyObject *codec_info, *ret;
-
-    codec_info = _PyCodec_Lookup(encoding);
-    if (codec_info == NULL)
-        return NULL;
-    ret = codec_makeincrementalcodec(codec_info, errors, attrname);
-    Py_DECREF(codec_info);
-    return ret;
-}
-
-/* Helper function to create a stream codec. */
-
-static
-PyObject *codec_getstreamcodec(const char *encoding,
-                               PyObject *stream,
-                               const char *errors,
-                               const int index)
-{
-    PyObject *codecs, *streamcodec, *codeccls;
-
-    codecs = _PyCodec_Lookup(encoding);
-    if (codecs == NULL)
-        return NULL;
-
-    codeccls = PyTuple_GET_ITEM(codecs, index);
-    if (errors != NULL)
-        streamcodec = PyObject_CallFunction(codeccls, "Os", stream, errors);
-    else
-        streamcodec = PyObject_CallOneArg(codeccls, stream);
-    Py_DECREF(codecs);
-    return streamcodec;
-}
-
-/* Helpers to work with the result of _PyCodec_Lookup
-
- */
-PyObject *_PyCodecInfo_GetIncrementalDecoder(PyObject *codec_info,
-                                             const char *errors)
-{
-    return codec_makeincrementalcodec(codec_info, errors,
-                                      "incrementaldecoder");
-}
-
-PyObject *_PyCodecInfo_GetIncrementalEncoder(PyObject *codec_info,
-                                             const char *errors)
-{
-    return codec_makeincrementalcodec(codec_info, errors,
-                                      "incrementalencoder");
-}
-
-
-/* Convenience APIs to query the Codec registry.
-
-   All APIs return a codec object with incremented refcount.
-
- */
-
-PyObject *PyCodec_Encoder(const char *encoding)
-{
-    return codec_getitem(encoding, 0);
-}
-
-PyObject *PyCodec_Decoder(const char *encoding)
-{
-    return codec_getitem(encoding, 1);
-}
-
-PyObject *PyCodec_IncrementalEncoder(const char *encoding,
-                                     const char *errors)
-{
-    return codec_getincrementalcodec(encoding, errors, "incrementalencoder");
-}
-
-PyObject *PyCodec_IncrementalDecoder(const char *encoding,
-                                     const char *errors)
-{
-    return codec_getincrementalcodec(encoding, errors, "incrementaldecoder");
-}
-
-PyObject *PyCodec_StreamReader(const char *encoding,
-                               PyObject *stream,
-                               const char *errors)
-{
-    return codec_getstreamcodec(encoding, stream, errors, 2);
-}
-
-PyObject *PyCodec_StreamWriter(const char *encoding,
-                               PyObject *stream,
-                               const char *errors)
-{
-    return codec_getstreamcodec(encoding, stream, errors, 3);
-}
-
-/* Helper that tries to ensure the reported exception chain indicates the
- * codec that was invoked to trigger the failure without changing the type
- * of the exception raised.
- */
-static void
-wrap_codec_error(const char *operation,
-                 const char *encoding)
-{
-    /* TrySetFromCause will replace the active exception with a suitably
-     * updated clone if it can, otherwise it will leave the original
-     * exception alone.
-     */
-    _PyErr_TrySetFromCause("%s with '%s' codec failed",
-                           operation, encoding);
-}
-
-/* Encode an object (e.g. a Unicode object) using the given encoding
-   and return the resulting encoded object (usually a Python string).
-
-   errors is passed to the encoder factory as argument if non-NULL. */
-
-static PyObject *
-_PyCodec_EncodeInternal(PyObject *object,
-                        PyObject *encoder,
-                        const char *encoding,
-                        const char *errors)
-{
-    PyObject *args = NULL, *result = NULL;
-    PyObject *v = NULL;
-
-    args = args_tuple(object, errors);
-    if (args == NULL)
-        goto onError;
-
-    result = PyObject_Call(encoder, args, NULL);
-    if (result == NULL) {
-        wrap_codec_error("encoding", encoding);
-        goto onError;
-    }
-
-    if (!PyTuple_Check(result) ||
-        PyTuple_GET_SIZE(result) != 2) {
-        PyErr_SetString(PyExc_TypeError,
-                        "encoder must return a tuple (object, integer)");
-        goto onError;
-    }
-    v = PyTuple_GET_ITEM(result,0);
-    Py_INCREF(v);
-    /* We don't check or use the second (integer) entry. */
-
-    Py_DECREF(args);
-    Py_DECREF(encoder);
-    Py_DECREF(result);
-    return v;
-
- onError:
-    Py_XDECREF(result);
-    Py_XDECREF(args);
-    Py_XDECREF(encoder);
-    return NULL;
-}
-
-/* Decode an object (usually a Python string) using the given encoding
-   and return an equivalent object (e.g. a Unicode object).
-
-   errors is passed to the decoder factory as argument if non-NULL. */
-
-static PyObject *
-_PyCodec_DecodeInternal(PyObject *object,
-                        PyObject *decoder,
-                        const char *encoding,
-                        const char *errors)
-{
-    PyObject *args = NULL, *result = NULL;
-    PyObject *v;
-
-    args = args_tuple(object, errors);
-    if (args == NULL)
-        goto onError;
-
-    result = PyObject_Call(decoder, args, NULL);
-    if (result == NULL) {
-        wrap_codec_error("decoding", encoding);
-        goto onError;
-    }
-    if (!PyTuple_Check(result) ||
-        PyTuple_GET_SIZE(result) != 2) {
-        PyErr_SetString(PyExc_TypeError,
-                        "decoder must return a tuple (object,integer)");
-        goto onError;
-    }
-    v = PyTuple_GET_ITEM(result,0);
-    Py_INCREF(v);
-    /* We don't check or use the second (integer) entry. */
-
-    Py_DECREF(args);
-    Py_DECREF(decoder);
-    Py_DECREF(result);
-    return v;
-
- onError:
-    Py_XDECREF(args);
-    Py_XDECREF(decoder);
-    Py_XDECREF(result);
-    return NULL;
-}
-
-/* Generic encoding/decoding API */
-PyObject *PyCodec_Encode(PyObject *object,
-                         const char *encoding,
-                         const char *errors)
-{
-    PyObject *encoder;
-
-    encoder = PyCodec_Encoder(encoding);
-    if (encoder == NULL)
-        return NULL;
-
-    return _PyCodec_EncodeInternal(object, encoder, encoding, errors);
-}
-
-PyObject *PyCodec_Decode(PyObject *object,
-                         const char *encoding,
-                         const char *errors)
-{
-    PyObject *decoder;
-
-    decoder = PyCodec_Decoder(encoding);
-    if (decoder == NULL)
-        return NULL;
-
-    return _PyCodec_DecodeInternal(object, decoder, encoding, errors);
-}
-
-/* Text encoding/decoding API */
-PyObject * _PyCodec_LookupTextEncoding(const char *encoding,
-                                       const char *alternate_command)
-{
-    _Py_IDENTIFIER(_is_text_encoding);
-    PyObject *codec;
-    PyObject *attr;
-    int is_text_codec;
-
-    codec = _PyCodec_Lookup(encoding);
-    if (codec == NULL)
-        return NULL;
-
-    /* Backwards compatibility: assume any raw tuple describes a text
-     * encoding, and the same for anything lacking the private
-     * attribute.
-     */
-    if (!PyTuple_CheckExact(codec)) {
-        if (_PyObject_LookupAttrId(codec, &PyId__is_text_encoding, &attr) < 0) {
-            Py_DECREF(codec);
-            return NULL;
-        }
-        if (attr != NULL) {
-            is_text_codec = PyObject_IsTrue(attr);
-            Py_DECREF(attr);
-            if (is_text_codec <= 0) {
-                Py_DECREF(codec);
-                if (!is_text_codec)
-                    PyErr_Format(PyExc_LookupError,
-                                 "'%.400s' is not a text encoding; "
-                                 "use %s to handle arbitrary codecs",
-                                 encoding, alternate_command);
-                return NULL;
-            }
-        }
-    }
-
-    /* This appears to be a valid text encoding */
-    return codec;
-}
-
-
-static
-PyObject *codec_getitem_checked(const char *encoding,
-                                const char *alternate_command,
-                                int index)
-{
-    PyObject *codec;
-    PyObject *v;
-
-    codec = _PyCodec_LookupTextEncoding(encoding, alternate_command);
-    if (codec == NULL)
-        return NULL;
-
-    v = PyTuple_GET_ITEM(codec, index);
-    Py_INCREF(v);
-    Py_DECREF(codec);
-    return v;
-}
-
-static PyObject * _PyCodec_TextEncoder(const char *encoding)
-{
-    return codec_getitem_checked(encoding, "codecs.encode()", 0);
-}
-
-static PyObject * _PyCodec_TextDecoder(const char *encoding)
-{
-    return codec_getitem_checked(encoding, "codecs.decode()", 1);
-}
-
-PyObject *_PyCodec_EncodeText(PyObject *object,
-                              const char *encoding,
-                              const char *errors)
-{
-    PyObject *encoder;
-
-    encoder = _PyCodec_TextEncoder(encoding);
-    if (encoder == NULL)
-        return NULL;
-
-    return _PyCodec_EncodeInternal(object, encoder, encoding, errors);
-}
-
-PyObject *_PyCodec_DecodeText(PyObject *object,
-                              const char *encoding,
-                              const char *errors)
-{
-    PyObject *decoder;
-
-    decoder = _PyCodec_TextDecoder(encoding);
-    if (decoder == NULL)
-        return NULL;
-
-    return _PyCodec_DecodeInternal(object, decoder, encoding, errors);
-}
-
-/* Register the error handling callback function error under the name
-   name. This function will be called by the codec when it encounters
-   an unencodable characters/undecodable bytes and doesn't know the
-   callback name, when name is specified as the error parameter
-   in the call to the encode/decode function.
-   Return 0 on success, -1 on error */
-int PyCodec_RegisterError(const char *name, PyObject *error)
-{
-    PyInterpreterState *interp = _PyInterpreterState_GET();
-    if (interp->codec_search_path == NULL && _PyCodecRegistry_Init())
-        return -1;
-    if (!PyCallable_Check(error)) {
-        PyErr_SetString(PyExc_TypeError, "handler must be callable");
-        return -1;
-    }
-    return PyDict_SetItemString(interp->codec_error_registry,
-                                name, error);
-}
-
-/* Lookup the error handling callback function registered under the
-   name error. As a special case NULL can be passed, in which case
-   the error handling callback for strict encoding will be returned. */
-PyObject *PyCodec_LookupError(const char *name)
-{
-    PyObject *handler = NULL;
-
-    PyInterpreterState *interp = _PyInterpreterState_GET();
-    if (interp->codec_search_path == NULL && _PyCodecRegistry_Init())
-        return NULL;
-
-    if (name==NULL)
-        name = "strict";
-    handler = _PyDict_GetItemStringWithError(interp->codec_error_registry, name);
-    if (handler) {
-        Py_INCREF(handler);
-    }
-    else if (!PyErr_Occurred()) {
-        PyErr_Format(PyExc_LookupError, "unknown error handler name '%.400s'", name);
-    }
-    return handler;
-}
-
-static void wrong_exception_type(PyObject *exc)
-{
-    PyErr_Format(PyExc_TypeError,
-                 "don't know how to handle %.200s in error callback",
-                 Py_TYPE(exc)->tp_name);
-}
-
-PyObject *PyCodec_StrictErrors(PyObject *exc)
-{
-    if (PyExceptionInstance_Check(exc))
-        PyErr_SetObject(PyExceptionInstance_Class(exc), exc);
-    else
-        PyErr_SetString(PyExc_TypeError, "codec must pass exception instance");
-    return NULL;
-}
-
-
-PyObject *PyCodec_IgnoreErrors(PyObject *exc)
-{
-    Py_ssize_t end;
-
-    if (PyObject_TypeCheck(exc, (PyTypeObject *)PyExc_UnicodeEncodeError)) {
-        if (PyUnicodeEncodeError_GetEnd(exc, &end))
-            return NULL;
-    }
-    else if (PyObject_TypeCheck(exc, (PyTypeObject *)PyExc_UnicodeDecodeError)) {
-        if (PyUnicodeDecodeError_GetEnd(exc, &end))
-            return NULL;
-    }
-    else if (PyObject_TypeCheck(exc, (PyTypeObject *)PyExc_UnicodeTranslateError)) {
-        if (PyUnicodeTranslateError_GetEnd(exc, &end))
-            return NULL;
-    }
-    else {
-        wrong_exception_type(exc);
-        return NULL;
-    }
-    return Py_BuildValue("(Nn)", PyUnicode_New(0, 0), end);
-}
-
-
-PyObject *PyCodec_ReplaceErrors(PyObject *exc)
-{
-    Py_ssize_t start, end, i, len;
-
-    if (PyObject_TypeCheck(exc, (PyTypeObject *)PyExc_UnicodeEncodeError)) {
-        PyObject *res;
-        Py_UCS1 *outp;
-        if (PyUnicodeEncodeError_GetStart(exc, &start))
-            return NULL;
-        if (PyUnicodeEncodeError_GetEnd(exc, &end))
-            return NULL;
-        len = end - start;
-        res = PyUnicode_New(len, '?');
-        if (res == NULL)
-            return NULL;
-        assert(PyUnicode_KIND(res) == PyUnicode_1BYTE_KIND);
-        outp = PyUnicode_1BYTE_DATA(res);
-        for (i = 0; i < len; ++i)
-            outp[i] = '?';
-        assert(_PyUnicode_CheckConsistency(res, 1));
-        return Py_BuildValue("(Nn)", res, end);
-    }
-    else if (PyObject_TypeCheck(exc, (PyTypeObject *)PyExc_UnicodeDecodeError)) {
-        if (PyUnicodeDecodeError_GetEnd(exc, &end))
-            return NULL;
-        return Py_BuildValue("(Cn)",
-                             (int)Py_UNICODE_REPLACEMENT_CHARACTER,
-                             end);
-    }
-    else if (PyObject_TypeCheck(exc, (PyTypeObject *)PyExc_UnicodeTranslateError)) {
-        PyObject *res;
-        Py_UCS2 *outp;
-        if (PyUnicodeTranslateError_GetStart(exc, &start))
-            return NULL;
-        if (PyUnicodeTranslateError_GetEnd(exc, &end))
-            return NULL;
-        len = end - start;
-        res = PyUnicode_New(len, Py_UNICODE_REPLACEMENT_CHARACTER);
-        if (res == NULL)
-            return NULL;
-        assert(PyUnicode_KIND(res) == PyUnicode_2BYTE_KIND);
-        outp = PyUnicode_2BYTE_DATA(res);
-        for (i = 0; i < len; i++)
-            outp[i] = Py_UNICODE_REPLACEMENT_CHARACTER;
-        assert(_PyUnicode_CheckConsistency(res, 1));
-        return Py_BuildValue("(Nn)", res, end);
-    }
-    else {
-        wrong_exception_type(exc);
-        return NULL;
-    }
-}
-
-PyObject *PyCodec_XMLCharRefReplaceErrors(PyObject *exc)
-{
-    if (PyObject_TypeCheck(exc, (PyTypeObject *)PyExc_UnicodeEncodeError)) {
-        PyObject *restuple;
-        PyObject *object;
-        Py_ssize_t i;
-        Py_ssize_t start;
-        Py_ssize_t end;
-        PyObject *res;
-        Py_UCS1 *outp;
-        Py_ssize_t ressize;
-        Py_UCS4 ch;
-        if (PyUnicodeEncodeError_GetStart(exc, &start))
-            return NULL;
-        if (PyUnicodeEncodeError_GetEnd(exc, &end))
-            return NULL;
-        if (!(object = PyUnicodeEncodeError_GetObject(exc)))
-            return NULL;
-        if (end - start > PY_SSIZE_T_MAX / (2+7+1))
-            end = start + PY_SSIZE_T_MAX / (2+7+1);
-        for (i = start, ressize = 0; i < end; ++i) {
-            /* object is guaranteed to be "ready" */
-            ch = PyUnicode_READ_CHAR(object, i);
-            if (ch<10)
-                ressize += 2+1+1;
-            else if (ch<100)
-                ressize += 2+2+1;
-            else if (ch<1000)
-                ressize += 2+3+1;
-            else if (ch<10000)
-                ressize += 2+4+1;
-            else if (ch<100000)
-                ressize += 2+5+1;
-            else if (ch<1000000)
-                ressize += 2+6+1;
-            else
-                ressize += 2+7+1;
-        }
-        /* allocate replacement */
-        res = PyUnicode_New(ressize, 127);
-        if (res == NULL) {
-            Py_DECREF(object);
-            return NULL;
-        }
-        outp = PyUnicode_1BYTE_DATA(res);
-        /* generate replacement */
-        for (i = start; i < end; ++i) {
-            int digits;
-            int base;
-            ch = PyUnicode_READ_CHAR(object, i);
-            *outp++ = '&';
-            *outp++ = '#';
-            if (ch<10) {
-                digits = 1;
-                base = 1;
-            }
-            else if (ch<100) {
-                digits = 2;
-                base = 10;
-            }
-            else if (ch<1000) {
-                digits = 3;
-                base = 100;
-            }
-            else if (ch<10000) {
-                digits = 4;
-                base = 1000;
-            }
-            else if (ch<100000) {
-                digits = 5;
-                base = 10000;
-            }
-            else if (ch<1000000) {
-                digits = 6;
-                base = 100000;
-            }
-            else {
-                digits = 7;
-                base = 1000000;
-            }
-            while (digits-->0) {
-                *outp++ = '0' + ch/base;
-                ch %= base;
-                base /= 10;
-            }
-            *outp++ = ';';
-        }
-        assert(_PyUnicode_CheckConsistency(res, 1));
-        restuple = Py_BuildValue("(Nn)", res, end);
-        Py_DECREF(object);
-        return restuple;
-    }
-    else {
-        wrong_exception_type(exc);
-        return NULL;
-    }
-}
-
-PyObject *PyCodec_BackslashReplaceErrors(PyObject *exc)
-{
-    PyObject *object;
-    Py_ssize_t i;
-    Py_ssize_t start;
-    Py_ssize_t end;
-    PyObject *res;
-    Py_UCS1 *outp;
-    int ressize;
-    Py_UCS4 c;
-
-    if (PyObject_TypeCheck(exc, (PyTypeObject *)PyExc_UnicodeDecodeError)) {
-        const unsigned char *p;
-        if (PyUnicodeDecodeError_GetStart(exc, &start))
-            return NULL;
-        if (PyUnicodeDecodeError_GetEnd(exc, &end))
-            return NULL;
-        if (!(object = PyUnicodeDecodeError_GetObject(exc)))
-            return NULL;
-        p = (const unsigned char*)PyBytes_AS_STRING(object);
-        res = PyUnicode_New(4 * (end - start), 127);
-        if (res == NULL) {
-            Py_DECREF(object);
-            return NULL;
-        }
-        outp = PyUnicode_1BYTE_DATA(res);
-        for (i = start; i < end; i++, outp += 4) {
-            unsigned char c = p[i];
-            outp[0] = '\\';
-            outp[1] = 'x';
-            outp[2] = Py_hexdigits[(c>>4)&0xf];
-            outp[3] = Py_hexdigits[c&0xf];
-        }
-
-        assert(_PyUnicode_CheckConsistency(res, 1));
-        Py_DECREF(object);
-        return Py_BuildValue("(Nn)", res, end);
-    }
-    if (PyObject_TypeCheck(exc, (PyTypeObject *)PyExc_UnicodeEncodeError)) {
-        if (PyUnicodeEncodeError_GetStart(exc, &start))
-            return NULL;
-        if (PyUnicodeEncodeError_GetEnd(exc, &end))
-            return NULL;
-        if (!(object = PyUnicodeEncodeError_GetObject(exc)))
-            return NULL;
-    }
-    else if (PyObject_TypeCheck(exc, (PyTypeObject *)PyExc_UnicodeTranslateError)) {
-        if (PyUnicodeTranslateError_GetStart(exc, &start))
-            return NULL;
-        if (PyUnicodeTranslateError_GetEnd(exc, &end))
-            return NULL;
-        if (!(object = PyUnicodeTranslateError_GetObject(exc)))
-            return NULL;
-    }
-    else {
-        wrong_exception_type(exc);
-        return NULL;
-    }
-
-    if (end - start > PY_SSIZE_T_MAX / (1+1+8))
-        end = start + PY_SSIZE_T_MAX / (1+1+8);
-    for (i = start, ressize = 0; i < end; ++i) {
-        /* object is guaranteed to be "ready" */
-        c = PyUnicode_READ_CHAR(object, i);
-        if (c >= 0x10000) {
-            ressize += 1+1+8;
-        }
-        else if (c >= 0x100) {
-            ressize += 1+1+4;
-        }
-        else
-            ressize += 1+1+2;
-    }
-    res = PyUnicode_New(ressize, 127);
-    if (res == NULL) {
-        Py_DECREF(object);
-        return NULL;
-    }
-    outp = PyUnicode_1BYTE_DATA(res);
-    for (i = start; i < end; ++i) {
-        c = PyUnicode_READ_CHAR(object, i);
-        *outp++ = '\\';
-        if (c >= 0x00010000) {
-            *outp++ = 'U';
-            *outp++ = Py_hexdigits[(c>>28)&0xf];
-            *outp++ = Py_hexdigits[(c>>24)&0xf];
-            *outp++ = Py_hexdigits[(c>>20)&0xf];
-            *outp++ = Py_hexdigits[(c>>16)&0xf];
-            *outp++ = Py_hexdigits[(c>>12)&0xf];
-            *outp++ = Py_hexdigits[(c>>8)&0xf];
-        }
-        else if (c >= 0x100) {
-            *outp++ = 'u';
-            *outp++ = Py_hexdigits[(c>>12)&0xf];
-            *outp++ = Py_hexdigits[(c>>8)&0xf];
-        }
-        else
-            *outp++ = 'x';
-        *outp++ = Py_hexdigits[(c>>4)&0xf];
-        *outp++ = Py_hexdigits[c&0xf];
-    }
-
-    assert(_PyUnicode_CheckConsistency(res, 1));
-    Py_DECREF(object);
-    return Py_BuildValue("(Nn)", res, end);
-}
-
-static _PyUnicode_Name_CAPI *ucnhash_capi = NULL;
-
-PyObject *PyCodec_NameReplaceErrors(PyObject *exc)
-{
-    if (PyObject_TypeCheck(exc, (PyTypeObject *)PyExc_UnicodeEncodeError)) {
-        PyObject *restuple;
-        PyObject *object;
-        Py_ssize_t i;
-        Py_ssize_t start;
-        Py_ssize_t end;
-        PyObject *res;
-        Py_UCS1 *outp;
-        Py_ssize_t ressize;
-        int replsize;
-        Py_UCS4 c;
-        char buffer[256]; /* NAME_MAXLEN */
-        if (PyUnicodeEncodeError_GetStart(exc, &start))
-            return NULL;
-        if (PyUnicodeEncodeError_GetEnd(exc, &end))
-            return NULL;
-        if (!(object = PyUnicodeEncodeError_GetObject(exc)))
-            return NULL;
-        if (!ucnhash_capi) {
-            /* load the unicode data module */
-            ucnhash_capi = (_PyUnicode_Name_CAPI *)PyCapsule_Import(
-                                            PyUnicodeData_CAPSULE_NAME, 1);
-            if (!ucnhash_capi) {
-                return NULL;
-            }
-        }
-        for (i = start, ressize = 0; i < end; ++i) {
-            /* object is guaranteed to be "ready" */
-            c = PyUnicode_READ_CHAR(object, i);
-            if (ucnhash_capi->getname(c, buffer, sizeof(buffer), 1)) {
-                replsize = 1+1+1+(int)strlen(buffer)+1;
-            }
-            else if (c >= 0x10000) {
-                replsize = 1+1+8;
-            }
-            else if (c >= 0x100) {
-                replsize = 1+1+4;
-            }
-            else
-                replsize = 1+1+2;
-            if (ressize > PY_SSIZE_T_MAX - replsize)
-                break;
-            ressize += replsize;
-        }
-        end = i;
-        res = PyUnicode_New(ressize, 127);
-        if (res==NULL)
-            return NULL;
-        for (i = start, outp = PyUnicode_1BYTE_DATA(res);
-            i < end; ++i) {
-            c = PyUnicode_READ_CHAR(object, i);
-            *outp++ = '\\';
-            if (ucnhash_capi->getname(c, buffer, sizeof(buffer), 1)) {
-                *outp++ = 'N';
-                *outp++ = '{';
-                strcpy((char *)outp, buffer);
-                outp += strlen(buffer);
-                *outp++ = '}';
-                continue;
-            }
-            if (c >= 0x00010000) {
-                *outp++ = 'U';
-                *outp++ = Py_hexdigits[(c>>28)&0xf];
-                *outp++ = Py_hexdigits[(c>>24)&0xf];
-                *outp++ = Py_hexdigits[(c>>20)&0xf];
-                *outp++ = Py_hexdigits[(c>>16)&0xf];
-                *outp++ = Py_hexdigits[(c>>12)&0xf];
-                *outp++ = Py_hexdigits[(c>>8)&0xf];
-            }
-            else if (c >= 0x100) {
-                *outp++ = 'u';
-                *outp++ = Py_hexdigits[(c>>12)&0xf];
-                *outp++ = Py_hexdigits[(c>>8)&0xf];
-            }
-            else
-                *outp++ = 'x';
-            *outp++ = Py_hexdigits[(c>>4)&0xf];
-            *outp++ = Py_hexdigits[c&0xf];
-        }
-
-        assert(outp == PyUnicode_1BYTE_DATA(res) + ressize);
-        assert(_PyUnicode_CheckConsistency(res, 1));
-        restuple = Py_BuildValue("(Nn)", res, end);
-        Py_DECREF(object);
-        return restuple;
-    }
-    else {
-        wrong_exception_type(exc);
-        return NULL;
-    }
-}
-
-#define ENC_UNKNOWN     -1
-#define ENC_UTF8        0
-#define ENC_UTF16BE     1
-#define ENC_UTF16LE     2
-#define ENC_UTF32BE     3
-#define ENC_UTF32LE     4
-
-static int
-get_standard_encoding(const char *encoding, int *bytelength)
-{
-    if (Py_TOLOWER(encoding[0]) == 'u' &&
-        Py_TOLOWER(encoding[1]) == 't' &&
-        Py_TOLOWER(encoding[2]) == 'f') {
-        encoding += 3;
-        if (*encoding == '-' || *encoding == '_' )
-            encoding++;
-        if (encoding[0] == '8' && encoding[1] == '\0') {
-            *bytelength = 3;
-            return ENC_UTF8;
-        }
-        else if (encoding[0] == '1' && encoding[1] == '6') {
-            encoding += 2;
-            *bytelength = 2;
-            if (*encoding == '\0') {
-#ifdef WORDS_BIGENDIAN
-                return ENC_UTF16BE;
-#else
-                return ENC_UTF16LE;
-#endif
-            }
-            if (*encoding == '-' || *encoding == '_' )
-                encoding++;
-            if (Py_TOLOWER(encoding[1]) == 'e' && encoding[2] == '\0') {
-                if (Py_TOLOWER(encoding[0]) == 'b')
-                    return ENC_UTF16BE;
-                if (Py_TOLOWER(encoding[0]) == 'l')
-                    return ENC_UTF16LE;
-            }
-        }
-        else if (encoding[0] == '3' && encoding[1] == '2') {
-            encoding += 2;
-            *bytelength = 4;
-            if (*encoding == '\0') {
-#ifdef WORDS_BIGENDIAN
-                return ENC_UTF32BE;
-#else
-                return ENC_UTF32LE;
-#endif
-            }
-            if (*encoding == '-' || *encoding == '_' )
-                encoding++;
-            if (Py_TOLOWER(encoding[1]) == 'e' && encoding[2] == '\0') {
-                if (Py_TOLOWER(encoding[0]) == 'b')
-                    return ENC_UTF32BE;
-                if (Py_TOLOWER(encoding[0]) == 'l')
-                    return ENC_UTF32LE;
-            }
-        }
-    }
-    else if (strcmp(encoding, "CP_UTF8") == 0) {
-        *bytelength = 3;
-        return ENC_UTF8;
-    }
-    return ENC_UNKNOWN;
-}
-
-/* This handler is declared static until someone demonstrates
-   a need to call it directly. */
-static PyObject *
-PyCodec_SurrogatePassErrors(PyObject *exc)
-{
-    PyObject *restuple;
-    PyObject *object;
-    PyObject *encode;
-    const char *encoding;
-    int code;
-    int bytelength;
-    Py_ssize_t i;
-    Py_ssize_t start;
-    Py_ssize_t end;
-    PyObject *res;
-
-    if (PyObject_TypeCheck(exc, (PyTypeObject *)PyExc_UnicodeEncodeError)) {
-        unsigned char *outp;
-        if (PyUnicodeEncodeError_GetStart(exc, &start))
-            return NULL;
-        if (PyUnicodeEncodeError_GetEnd(exc, &end))
-            return NULL;
-        if (!(object = PyUnicodeEncodeError_GetObject(exc)))
-            return NULL;
-        if (!(encode = PyUnicodeEncodeError_GetEncoding(exc))) {
-            Py_DECREF(object);
-            return NULL;
-        }
-        if (!(encoding = PyUnicode_AsUTF8(encode))) {
-            Py_DECREF(object);
-            Py_DECREF(encode);
-            return NULL;
-        }
-        code = get_standard_encoding(encoding, &bytelength);
-        Py_DECREF(encode);
-        if (code == ENC_UNKNOWN) {
-            /* Not supported, fail with original exception */
-            PyErr_SetObject(PyExceptionInstance_Class(exc), exc);
-            Py_DECREF(object);
-            return NULL;
-        }
-
-        if (end - start > PY_SSIZE_T_MAX / bytelength)
-            end = start + PY_SSIZE_T_MAX / bytelength;
-        res = PyBytes_FromStringAndSize(NULL, bytelength*(end-start));
-        if (!res) {
-            Py_DECREF(object);
-            return NULL;
-        }
-        outp = (unsigned char*)PyBytes_AsString(res);
-        for (i = start; i < end; i++) {
-            /* object is guaranteed to be "ready" */
-            Py_UCS4 ch = PyUnicode_READ_CHAR(object, i);
-            if (!Py_UNICODE_IS_SURROGATE(ch)) {
-                /* Not a surrogate, fail with original exception */
-                PyErr_SetObject(PyExceptionInstance_Class(exc), exc);
-                Py_DECREF(res);
-                Py_DECREF(object);
-                return NULL;
-            }
-            switch (code) {
-            case ENC_UTF8:
-                *outp++ = (unsigned char)(0xe0 | (ch >> 12));
-                *outp++ = (unsigned char)(0x80 | ((ch >> 6) & 0x3f));
-                *outp++ = (unsigned char)(0x80 | (ch & 0x3f));
-                break;
-            case ENC_UTF16LE:
-                *outp++ = (unsigned char) ch;
-                *outp++ = (unsigned char)(ch >> 8);
-                break;
-            case ENC_UTF16BE:
-                *outp++ = (unsigned char)(ch >> 8);
-                *outp++ = (unsigned char) ch;
-                break;
-            case ENC_UTF32LE:
-                *outp++ = (unsigned char) ch;
-                *outp++ = (unsigned char)(ch >> 8);
-                *outp++ = (unsigned char)(ch >> 16);
-                *outp++ = (unsigned char)(ch >> 24);
-                break;
-            case ENC_UTF32BE:
-                *outp++ = (unsigned char)(ch >> 24);
-                *outp++ = (unsigned char)(ch >> 16);
-                *outp++ = (unsigned char)(ch >> 8);
-                *outp++ = (unsigned char) ch;
-                break;
-            }
-        }
-        restuple = Py_BuildValue("(On)", res, end);
-        Py_DECREF(res);
-        Py_DECREF(object);
-        return restuple;
-    }
-    else if (PyObject_TypeCheck(exc, (PyTypeObject *)PyExc_UnicodeDecodeError)) {
-        const unsigned char *p;
-        Py_UCS4 ch = 0;
-        if (PyUnicodeDecodeError_GetStart(exc, &start))
-            return NULL;
-        if (PyUnicodeDecodeError_GetEnd(exc, &end))
-            return NULL;
-        if (!(object = PyUnicodeDecodeError_GetObject(exc)))
-            return NULL;
-        p = (const unsigned char*)PyBytes_AS_STRING(object);
-        if (!(encode = PyUnicodeDecodeError_GetEncoding(exc))) {
-            Py_DECREF(object);
-            return NULL;
-        }
-        if (!(encoding = PyUnicode_AsUTF8(encode))) {
-            Py_DECREF(object);
-            Py_DECREF(encode);
-            return NULL;
-        }
-        code = get_standard_encoding(encoding, &bytelength);
-        Py_DECREF(encode);
-        if (code == ENC_UNKNOWN) {
-            /* Not supported, fail with original exception */
-            PyErr_SetObject(PyExceptionInstance_Class(exc), exc);
-            Py_DECREF(object);
-            return NULL;
-        }
-
-        /* Try decoding a single surrogate character. If
-           there are more, let the codec call us again. */
-        p += start;
-        if (PyBytes_GET_SIZE(object) - start >= bytelength) {
-            switch (code) {
-            case ENC_UTF8:
-                if ((p[0] & 0xf0) == 0xe0 &&
-                    (p[1] & 0xc0) == 0x80 &&
-                    (p[2] & 0xc0) == 0x80) {
-                    /* it's a three-byte code */
-                    ch = ((p[0] & 0x0f) << 12) + ((p[1] & 0x3f) << 6) + (p[2] & 0x3f);
-                }
-                break;
-            case ENC_UTF16LE:
-                ch = p[1] << 8 | p[0];
-                break;
-            case ENC_UTF16BE:
-                ch = p[0] << 8 | p[1];
-                break;
-            case ENC_UTF32LE:
-                ch = (p[3] << 24) | (p[2] << 16) | (p[1] << 8) | p[0];
-                break;
-            case ENC_UTF32BE:
-                ch = (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3];
-                break;
-            }
-        }
-
-        Py_DECREF(object);
-        if (!Py_UNICODE_IS_SURROGATE(ch)) {
-            /* it's not a surrogate - fail */
-            PyErr_SetObject(PyExceptionInstance_Class(exc), exc);
-            return NULL;
-        }
-        res = PyUnicode_FromOrdinal(ch);
-        if (res == NULL)
-            return NULL;
-        return Py_BuildValue("(Nn)", res, start + bytelength);
-    }
-    else {
-        wrong_exception_type(exc);
-        return NULL;
-    }
-}
-
-static PyObject *
-PyCodec_SurrogateEscapeErrors(PyObject *exc)
-{
-    PyObject *restuple;
-    PyObject *object;
-    Py_ssize_t i;
-    Py_ssize_t start;
-    Py_ssize_t end;
-    PyObject *res;
-
-    if (PyObject_TypeCheck(exc, (PyTypeObject *)PyExc_UnicodeEncodeError)) {
-        char *outp;
-        if (PyUnicodeEncodeError_GetStart(exc, &start))
-            return NULL;
-        if (PyUnicodeEncodeError_GetEnd(exc, &end))
-            return NULL;
-        if (!(object = PyUnicodeEncodeError_GetObject(exc)))
-            return NULL;
-        res = PyBytes_FromStringAndSize(NULL, end-start);
-        if (!res) {
-            Py_DECREF(object);
-            return NULL;
-        }
-        outp = PyBytes_AsString(res);
-        for (i = start; i < end; i++) {
-            /* object is guaranteed to be "ready" */
-            Py_UCS4 ch = PyUnicode_READ_CHAR(object, i);
-            if (ch < 0xdc80 || ch > 0xdcff) {
-                /* Not a UTF-8b surrogate, fail with original exception */
-                PyErr_SetObject(PyExceptionInstance_Class(exc), exc);
-                Py_DECREF(res);
-                Py_DECREF(object);
-                return NULL;
-            }
-            *outp++ = ch - 0xdc00;
-        }
-        restuple = Py_BuildValue("(On)", res, end);
-        Py_DECREF(res);
-        Py_DECREF(object);
-        return restuple;
-    }
-    else if (PyObject_TypeCheck(exc, (PyTypeObject *)PyExc_UnicodeDecodeError)) {
-        PyObject *str;
-        const unsigned char *p;
-        Py_UCS2 ch[4]; /* decode up to 4 bad bytes. */
-        int consumed = 0;
-        if (PyUnicodeDecodeError_GetStart(exc, &start))
-            return NULL;
-        if (PyUnicodeDecodeError_GetEnd(exc, &end))
-            return NULL;
-        if (!(object = PyUnicodeDecodeError_GetObject(exc)))
-            return NULL;
-        p = (const unsigned char*)PyBytes_AS_STRING(object);
-        while (consumed < 4 && consumed < end-start) {
-            /* Refuse to escape ASCII bytes. */
-            if (p[start+consumed] < 128)
-                break;
-            ch[consumed] = 0xdc00 + p[start+consumed];
-            consumed++;
-        }
-        Py_DECREF(object);
-        if (!consumed) {
-            /* codec complained about ASCII byte. */
-            PyErr_SetObject(PyExceptionInstance_Class(exc), exc);
-            return NULL;
-        }
-        str = PyUnicode_FromKindAndData(PyUnicode_2BYTE_KIND, ch, consumed);
-        if (str == NULL)
-            return NULL;
-        return Py_BuildValue("(Nn)", str, start+consumed);
-    }
-    else {
-        wrong_exception_type(exc);
-        return NULL;
-    }
-}
-
-
-static PyObject *strict_errors(PyObject *self, PyObject *exc)
-{
-    return PyCodec_StrictErrors(exc);
-}
-
-
-static PyObject *ignore_errors(PyObject *self, PyObject *exc)
-{
-    return PyCodec_IgnoreErrors(exc);
-}
-
-
-static PyObject *replace_errors(PyObject *self, PyObject *exc)
-{
-    return PyCodec_ReplaceErrors(exc);
-}
-
-
-static PyObject *xmlcharrefreplace_errors(PyObject *self, PyObject *exc)
-{
-    return PyCodec_XMLCharRefReplaceErrors(exc);
-}
-
-
-static PyObject *backslashreplace_errors(PyObject *self, PyObject *exc)
-{
-    return PyCodec_BackslashReplaceErrors(exc);
-}
-
-static PyObject *namereplace_errors(PyObject *self, PyObject *exc)
-{
-    return PyCodec_NameReplaceErrors(exc);
-}
-
-static PyObject *surrogatepass_errors(PyObject *self, PyObject *exc)
-{
-    return PyCodec_SurrogatePassErrors(exc);
-}
-
-static PyObject *surrogateescape_errors(PyObject *self, PyObject *exc)
-{
-    return PyCodec_SurrogateEscapeErrors(exc);
-}
-
-static int _PyCodecRegistry_Init(void)
-{
-    static struct {
-        const char *name;
-        PyMethodDef def;
-    } methods[] =
-    {
-        {
-            "strict",
-            {
-                "strict_errors",
-                strict_errors,
-                METH_O,
-                PyDoc_STR("Implements the 'strict' error handling, which "
-                          "raises a UnicodeError on coding errors.")
-            }
-        },
-        {
-            "ignore",
-            {
-                "ignore_errors",
-                ignore_errors,
-                METH_O,
-                PyDoc_STR("Implements the 'ignore' error handling, which "
-                          "ignores malformed data and continues.")
-            }
-        },
-        {
-            "replace",
-            {
-                "replace_errors",
-                replace_errors,
-                METH_O,
-                PyDoc_STR("Implements the 'replace' error handling, which "
-                          "replaces malformed data with a replacement marker.")
-            }
-        },
-        {
-            "xmlcharrefreplace",
-            {
-                "xmlcharrefreplace_errors",
-                xmlcharrefreplace_errors,
-                METH_O,
-                PyDoc_STR("Implements the 'xmlcharrefreplace' error handling, "
-                          "which replaces an unencodable character with the "
-                          "appropriate XML character reference.")
-            }
-        },
-        {
-            "backslashreplace",
-            {
-                "backslashreplace_errors",
-                backslashreplace_errors,
-                METH_O,
-                PyDoc_STR("Implements the 'backslashreplace' error handling, "
-                          "which replaces malformed data with a backslashed "
-                          "escape sequence.")
-            }
-        },
-        {
-            "namereplace",
-            {
-                "namereplace_errors",
-                namereplace_errors,
-                METH_O,
-                PyDoc_STR("Implements the 'namereplace' error handling, "
-                          "which replaces an unencodable character with a "
-                          "\\N{...} escape sequence.")
-            }
-        },
-        {
-            "surrogatepass",
-            {
-                "surrogatepass",
-                surrogatepass_errors,
-                METH_O
-            }
-        },
-        {
-            "surrogateescape",
-            {
-                "surrogateescape",
-                surrogateescape_errors,
-                METH_O
-            }
-        }
-    };
-
-    PyInterpreterState *interp = _PyInterpreterState_GET();
-    PyObject *mod;
-
-    if (interp->codec_search_path != NULL)
-        return 0;
-
-    interp->codec_search_path = PyList_New(0);
-    if (interp->codec_search_path == NULL) {
-        return -1;
-    }
-
-    interp->codec_search_cache = PyDict_New();
-    if (interp->codec_search_cache == NULL) {
-        return -1;
-    }
-
-    interp->codec_error_registry = PyDict_New();
-    if (interp->codec_error_registry == NULL) {
-        return -1;
-    }
-
-    for (size_t i = 0; i < Py_ARRAY_LENGTH(methods); ++i) {
-        PyObject *func = PyCFunction_NewEx(&methods[i].def, NULL, NULL);
-        if (!func) {
-            return -1;
-        }
-
-        int res = PyCodec_RegisterError(methods[i].name, func);
-        Py_DECREF(func);
-        if (res) {
-            return -1;
-        }
-    }
-
-    mod = PyImport_ImportModuleNoBlock("encodings");
-    if (mod == NULL) {
-        return -1;
-    }
-    Py_DECREF(mod);
-    interp->codecs_initialized = 1;
-    return 0;
-}