LCOV - code coverage report
Current view: | top level - Modules - _codecsmodule.c (source / functions) |  |  | Hit | Total | Coverage
Test: | CPython 3.12 LCOV report [commit 5e6661bce9] |  | Lines: | 14 | 165 | 8.5 %
Date: | 2023-03-20 08:15:36 |  | Functions: | 5 | 41 | 12.2 %
|  |  | Branches: | 4 | 66 | 6.1 %

               Branch data     Line data    Source code
           1                 :            : /* ------------------------------------------------------------------------
           2                 :            :
           3                 :            :    _codecs -- Provides access to the codec registry and the builtin
           4                 :            :               codecs.
           5                 :            :
           6                 :            :    This module should never be imported directly. The standard library
           7                 :            :    module "codecs" wraps this builtin module for use within Python.
           8                 :            :
           9                 :            :    The codec registry is accessible via:
          10                 :            :
          11                 :            :      register(search_function) -> None
          12                 :            :
          13                 :            :      lookup(encoding) -> CodecInfo object
          14                 :            :
          15                 :            :    The builtin Unicode codecs use the following interface:
          16                 :            :
          17                 :            :      <encoding>_encode(Unicode_object[,errors='strict']) ->
          18                 :            :         (string object, bytes consumed)
          19                 :            :
          20                 :            :      <encoding>_decode(char_buffer_obj[,errors='strict']) ->
          21                 :            :         (Unicode object, bytes consumed)
          22                 :            :
          23                 :            :    These <encoding>s are available: utf_8, unicode_escape,
          24                 :            :    raw_unicode_escape, latin_1, ascii (7-bit), mbcs (on win32).
          25                 :            :
          26                 :            :
          27                 :            : Written by Marc-Andre Lemburg (mal@lemburg.com).
          28                 :            :
          29                 :            : Copyright (c) Corporation for National Research Initiatives.
          30                 :            :
          31                 :            :    ------------------------------------------------------------------------ */
          32                 :            :
          33                 :            : #define PY_SSIZE_T_CLEAN
          34                 :            : #include "Python.h"
          35                 :            :
          36                 :            : #ifdef MS_WINDOWS
          37                 :            : #include <windows.h>
          38                 :            : #endif
          39                 :            :
          40                 :            : /*[clinic input]
          41                 :            : module _codecs
          42                 :            : [clinic start generated code]*/
          43                 :            : /*[clinic end generated code: output=da39a3ee5e6b4b0d input=e1390e3da3cb9deb]*/
          44                 :            :
          45                 :            : #include "pycore_runtime.h"
          46                 :            : #include "clinic/_codecsmodule.c.h"
          47                 :            :
          48                 :            : /* --- Registry ----------------------------------------------------------- */
          49                 :            :
          50                 :            : /*[clinic input]
          51                 :            : _codecs.register
          52                 :            :     search_function: object
          53                 :            :     /
          54                 :            :
          55                 :            : Register a codec search function.
          56                 :            :
          57                 :            : Search functions are expected to take one argument, the encoding name in
          58                 :            : all lower case letters, and either return None, or a tuple of functions
          59                 :            : (encoder, decoder, stream_reader, stream_writer) (or a CodecInfo object).
          60                 :            : [clinic start generated code]*/
          61                 :            :
          62                 :            : static PyObject *
          63                 :         25 : _codecs_register(PyObject *module, PyObject *search_function)
          64                 :            : /*[clinic end generated code: output=d1bf21e99db7d6d3 input=369578467955cae4]*/
          65                 :            : {
          66         [ -  + ]:         25 :     if (PyCodec_Register(search_function))
          67                 :          0 :         return NULL;
          68                 :            :
          69                 :         25 :     Py_RETURN_NONE;
          70                 :            : }
          71                 :            :
          72                 :            : /*[clinic input]
          73                 :            : _codecs.unregister
          74                 :            :     search_function: object
          75                 :            :     /
          76                 :            :
          77                 :            : Unregister a codec search function and clear the registry's cache.
          78                 :            :
          79                 :            : If the search function is not registered, do nothing.
          80                 :            : [clinic start generated code]*/
          81                 :            :
          82                 :            : static PyObject *
          83                 :          0 : _codecs_unregister(PyObject *module, PyObject *search_function)
          84                 :            : /*[clinic end generated code: output=1f0edee9cf246399 input=dd7c004c652d345e]*/
          85                 :            : {
          86         [ #  # ]:          0 :     if (PyCodec_Unregister(search_function) < 0) {
          87                 :          0 :         return NULL;
          88                 :            :     }
          89                 :            :
          90                 :          0 :     Py_RETURN_NONE;
          91                 :            : }
          92                 :            :
          93                 :            : /*[clinic input]
          94                 :            : _codecs.lookup
          95                 :            :     encoding: str
          96                 :            :     /
          97                 :            :
          98                 :            : Looks up a codec tuple in the Python codec registry and returns a CodecInfo object.
          99                 :            : [clinic start generated code]*/
         100                 :            :
         101                 :            : static PyObject *
         102                 :          0 : _codecs_lookup_impl(PyObject *module, const char *encoding)
         103                 :            : /*[clinic end generated code: output=9f0afa572080c36d input=3c572c0db3febe9c]*/
         104                 :            : {
         105                 :          0 :     return _PyCodec_Lookup(encoding);
         106                 :            : }
         107                 :            :
         108                 :            : /*[clinic input]
         109                 :            : _codecs.encode
         110                 :            :     obj: object
         111                 :            :     encoding: str(c_default="NULL") = "utf-8"
         112                 :            :     errors: str(c_default="NULL") = "strict"
         113                 :            :
         114                 :            : Encodes obj using the codec registered for encoding.
         115                 :            :
         116                 :            : The default encoding is 'utf-8'.  errors may be given to set a
         117                 :            : different error handling scheme.  Default is 'strict' meaning that encoding
         118                 :            : errors raise a ValueError.  Other possible values are 'ignore', 'replace'
         119                 :            : and 'backslashreplace' as well as any other name registered with
         120                 :            : codecs.register_error that can handle ValueErrors.
         121                 :            : [clinic start generated code]*/
         122                 :            :
         123                 :            : static PyObject *
         124                 :          0 : _codecs_encode_impl(PyObject *module, PyObject *obj, const char *encoding,
         125                 :            :                     const char *errors)
         126                 :            : /*[clinic end generated code: output=385148eb9a067c86 input=cd5b685040ff61f0]*/
         127                 :            : {
         128         [ #  # ]:          0 :     if (encoding == NULL)
         129                 :          0 :         encoding = PyUnicode_GetDefaultEncoding();
         130                 :            :
         131                 :            :     /* Encode via the codec registry */
         132                 :          0 :     return PyCodec_Encode(obj, encoding, errors);
         133                 :            : }
         134                 :            :
         135                 :            : /*[clinic input]
         136                 :            : _codecs.decode
         137                 :            :     obj: object
         138                 :            :     encoding: str(c_default="NULL") = "utf-8"
         139                 :            :     errors: str(c_default="NULL") = "strict"
         140                 :            :
         141                 :            : Decodes obj using the codec registered for encoding.
         142                 :            :
         143                 :            : Default encoding is 'utf-8'.  errors may be given to set a
         144                 :            : different error handling scheme.  Default is 'strict' meaning that encoding
         145                 :            : errors raise a ValueError.  Other possible values are 'ignore', 'replace'
         146                 :            : and 'backslashreplace' as well as any other name registered with
         147                 :            : codecs.register_error that can handle ValueErrors.
         148                 :            : [clinic start generated code]*/
         149                 :            :
         150                 :            : static PyObject *
         151                 :          0 : _codecs_decode_impl(PyObject *module, PyObject *obj, const char *encoding,
         152                 :            :                     const char *errors)
         153                 :            : /*[clinic end generated code: output=679882417dc3a0bd input=7702c0cc2fa1add6]*/
         154                 :            : {
         155         [ #  # ]:          0 :     if (encoding == NULL)
         156                 :          0 :         encoding = PyUnicode_GetDefaultEncoding();
         157                 :            :
         158                 :            :     /* Decode via the codec registry */
         159                 :          0 :     return PyCodec_Decode(obj, encoding, errors);
         160                 :            : }
         161                 :            :
         162                 :            : /* --- Helpers ------------------------------------------------------------ */
         163                 :            :
         164                 :            : static
         165                 :       4094 : PyObject *codec_tuple(PyObject *decoded,
         166                 :            :                       Py_ssize_t len)
         167                 :            : {
         168         [ -  + ]:       4094 :     if (decoded == NULL)
         169                 :          0 :         return NULL;
         170                 :       4094 :     return Py_BuildValue("Nn", decoded, len);
         171                 :            : }
         172                 :            :
         173                 :            : /* --- String codecs ------------------------------------------------------ */
         174                 :            : /*[clinic input]
         175                 :            : _codecs.escape_decode
         176                 :            :     data: Py_buffer(accept={str, buffer})
         177                 :            :     errors: str(accept={str, NoneType}) = None
         178                 :            :     /
         179                 :            : [clinic start generated code]*/
         180                 :            :
         181                 :            : static PyObject *
         182                 :          0 : _codecs_escape_decode_impl(PyObject *module, Py_buffer *data,
         183                 :            :                            const char *errors)
         184                 :            : /*[clinic end generated code: output=505200ba8056979a input=77298a561c90bd82]*/
         185                 :            : {
         186                 :          0 :     PyObject *decoded = PyBytes_DecodeEscape(data->buf, data->len,
         187                 :            :                                              errors, 0, NULL);
         188                 :          0 :     return codec_tuple(decoded, data->len);
         189                 :            : }
         190                 :            :
         191                 :            : /*[clinic input]
         192                 :            : _codecs.escape_encode
         193                 :            :     data: object(subclass_of='&PyBytes_Type')
         194                 :            :     errors: str(accept={str, NoneType}) = None
         195                 :            :     /
         196                 :            : [clinic start generated code]*/
         197                 :            :
         198                 :            : static PyObject *
         199                 :          0 : _codecs_escape_encode_impl(PyObject *module, PyObject *data,
         200                 :            :                            const char *errors)
         201                 :            : /*[clinic end generated code: output=4af1d477834bab34 input=8f4b144799a94245]*/
         202                 :            : {
         203                 :            :     Py_ssize_t size;
         204                 :            :     Py_ssize_t newsize;
         205                 :            :     PyObject *v;
         206                 :            :
         207                 :          0 :     size = PyBytes_GET_SIZE(data);
         208         [ #  # ]:          0 :     if (size > PY_SSIZE_T_MAX / 4) {
         209                 :          0 :         PyErr_SetString(PyExc_OverflowError,
         210                 :            :             "string is too large to encode");
         211                 :          0 :             return NULL;
         212                 :            :     }
         213                 :          0 :     newsize = 4*size;
         214                 :          0 :     v = PyBytes_FromStringAndSize(NULL, newsize);
         215                 :            :
         216         [ #  # ]:          0 :     if (v == NULL) {
         217                 :          0 :         return NULL;
         218                 :            :     }
         219                 :            :     else {
         220                 :            :         Py_ssize_t i;
         221                 :            :         char c;
         222                 :          0 :         char *p = PyBytes_AS_STRING(v);
         223                 :            :
         224         [ #  # ]:          0 :         for (i = 0; i < size; i++) {
         225                 :            :             /* There's at least enough room for a hex escape */
         226                 :            :             assert(newsize - (p - PyBytes_AS_STRING(v)) >= 4);
         227                 :          0 :             c = PyBytes_AS_STRING(data)[i];
         228   [ #  #  #  # ]:          0 :             if (c == '\'' || c == '\\')
         229                 :          0 :                 *p++ = '\\', *p++ = c;
         230         [ #  # ]:          0 :             else if (c == '\t')
         231                 :          0 :                 *p++ = '\\', *p++ = 't';
         232         [ #  # ]:          0 :             else if (c == '\n')
         233                 :          0 :                 *p++ = '\\', *p++ = 'n';
         234         [ #  # ]:          0 :             else if (c == '\r')
         235                 :          0 :                 *p++ = '\\', *p++ = 'r';
         236   [ #  #  #  # ]:          0 :             else if (c < ' ' || c >= 0x7f) {
         237                 :          0 :                 *p++ = '\\';
         238                 :          0 :                 *p++ = 'x';
         239                 :          0 :                 *p++ = Py_hexdigits[(c & 0xf0) >> 4];
         240                 :          0 :                 *p++ = Py_hexdigits[c & 0xf];
         241                 :            :             }
         242                 :            :             else
         243                 :          0 :                 *p++ = c;
         244                 :            :         }
         245                 :          0 :         *p = '\0';
         246         [ #  # ]:          0 :         if (_PyBytes_Resize(&v, (p - PyBytes_AS_STRING(v)))) {
         247                 :          0 :             return NULL;
         248                 :            :         }
         249                 :            :     }
         250                 :            :
         251                 :          0 :     return codec_tuple(v, size);
         252                 :            : }
         253                 :            :
         254                 :            : /* --- Decoder ------------------------------------------------------------ */
         255                 :            : /*[clinic input]
         256                 :            : _codecs.utf_7_decode
         257                 :            :     data: Py_buffer
         258                 :            :     errors: str(accept={str, NoneType}) = None
         259                 :            :     final: bool = False
         260                 :            :     /
         261                 :            : [clinic start generated code]*/
         262                 :            :
         263                 :            : static PyObject *
         264                 :          0 : _codecs_utf_7_decode_impl(PyObject *module, Py_buffer *data,
         265                 :            :                           const char *errors, int final)
         266                 :            : /*[clinic end generated code: output=0cd3a944a32a4089 input=dbf8c8998102dc7d]*/
         267                 :            : {
         268                 :          0 :     Py_ssize_t consumed = data->len;
         269         [ #  # ]:          0 :     PyObject *decoded = PyUnicode_DecodeUTF7Stateful(data->buf, data->len,
         270                 :            :                                                      errors,
         271                 :            :                                                      final ? NULL : &consumed);
         272                 :          0 :     return codec_tuple(decoded, consumed);
         273                 :            : }
         274                 :            :
         275                 :            : /*[clinic input]
         276                 :            : _codecs.utf_8_decode
         277                 :            :     data: Py_buffer
         278                 :            :     errors: str(accept={str, NoneType}) = None
         279                 :            :     final: bool = False
         280                 :            :     /
         281                 :            : [clinic start generated code]*/
         282                 :            :
         283                 :            : static PyObject *
         284                 :       4094 : _codecs_utf_8_decode_impl(PyObject *module, Py_buffer *data,
         285                 :            :                           const char *errors, int final)
         286                 :            : /*[clinic end generated code: output=10f74dec8d9bb8bf input=ca06bc8a9c970e25]*/
         287                 :            : {
         288                 :       4094 :     Py_ssize_t consumed = data->len;
         289         [ +  + ]:       4094 :     PyObject *decoded = PyUnicode_DecodeUTF8Stateful(data->buf, data->len,
         290                 :            :                                                      errors,
         291                 :            :                                                      final ? NULL : &consumed);
         292                 :       4094 :     return codec_tuple(decoded, consumed);
         293                 :            : }
         294                 :            :
         295                 :            : /*[clinic input]
         296                 :            : _codecs.utf_16_decode
         297                 :            :     data: Py_buffer
         298                 :            :     errors: str(accept={str, NoneType}) = None
         299                 :            :     final: bool = False
         300                 :            :     /
         301                 :            : [clinic start generated code]*/
         302                 :            :
         303                 :            : static PyObject *
         304                 :          0 : _codecs_utf_16_decode_impl(PyObject *module, Py_buffer *data,
         305                 :            :                            const char *errors, int final)
         306                 :            : /*[clinic end generated code: output=783b442abcbcc2d0 input=5b0f52071ba6cadc]*/
         307                 :            : {
         308                 :          0 :     int byteorder = 0;
         309                 :            :     /* This is overwritten unless final is true. */
         310                 :          0 :     Py_ssize_t consumed = data->len;
         311         [ #  # ]:          0 :     PyObject *decoded = PyUnicode_DecodeUTF16Stateful(data->buf, data->len,
         312                 :            :                                                       errors, &byteorder,
         313                 :            :                                                       final ? NULL : &consumed);
         314                 :          0 :     return codec_tuple(decoded, consumed);
         315                 :            : }
         316                 :            :
         317                 :            : /*[clinic input]
         318                 :            : _codecs.utf_16_le_decode
         319                 :            :     data: Py_buffer
         320                 :            :     errors: str(accept={str, NoneType}) = None
         321                 :            :     final: bool = False
         322                 :            :     /
         323                 :            : [clinic start generated code]*/
         324                 :            :
         325                 :            : static PyObject *
         326                 :          0 : _codecs_utf_16_le_decode_impl(PyObject *module, Py_buffer *data,
         327                 :            :                               const char *errors, int final)
         328                 :            : /*[clinic end generated code: output=899b9e6364379dcd input=115bd8c7b783d0bf]*/
         329                 :            : {
         330                 :          0 :     int byteorder = -1;
         331                 :            :     /* This is overwritten unless final is true. */
         332                 :          0 :     Py_ssize_t consumed = data->len;
         333         [ #  # ]:          0 :     PyObject *decoded = PyUnicode_DecodeUTF16Stateful(data->buf, data->len,
         334                 :            :                                                       errors, &byteorder,
         335                 :            :                                                       final ? NULL : &consumed);
         336                 :          0 :     return codec_tuple(decoded, consumed);
         337                 :            : }
         338                 :            :
         339                 :            : /*[clinic input]
         340                 :            : _codecs.utf_16_be_decode
         341                 :            :     data: Py_buffer
         342                 :            :     errors: str(accept={str, NoneType}) = None
         343                 :            :     final: bool = False
         344                 :            :     /
         345                 :            : [clinic start generated code]*/
         346                 :            :
         347                 :            : static PyObject *
         348                 :          0 : _codecs_utf_16_be_decode_impl(PyObject *module, Py_buffer *data,
         349                 :            :                               const char *errors, int final)
         350                 :            : /*[clinic end generated code: output=49f6465ea07669c8 input=63131422b01f9cb4]*/
         351                 :            : {
         352                 :          0 :     int byteorder = 1;
         353                 :            :     /* This is overwritten unless final is true. */
         354                 :          0 :     Py_ssize_t consumed = data->len;
         355         [ #  # ]:          0 :     PyObject *decoded = PyUnicode_DecodeUTF16Stateful(data->buf, data->len,
         356                 :            :                                                       errors, &byteorder,
         357                 :            :                                                       final ? NULL : &consumed);
         358                 :          0 :     return codec_tuple(decoded, consumed);
         359                 :            : }
         360                 :            :
         361                 :            : /* This non-standard version also provides access to the byteorder
         362                 :            :    parameter of the builtin UTF-16 codec.
         363                 :            :
         364                 :            :    It returns a tuple (unicode, bytesread, byteorder) with byteorder
         365                 :            :    being the value in effect at the end of data.
         366                 :            :
         367                 :            : */
         368                 :            : /*[clinic input]
         369                 :            : _codecs.utf_16_ex_decode
         370                 :            :     data: Py_buffer
         371                 :            :     errors: str(accept={str, NoneType}) = None
         372                 :            :     byteorder: int = 0
         373                 :            :     final: bool = False
         374                 :            :     /
         375                 :            : [clinic start generated code]*/
         376                 :            :
         377                 :            : static PyObject *
         378                 :          0 : _codecs_utf_16_ex_decode_impl(PyObject *module, Py_buffer *data,
         379                 :            :                               const char *errors, int byteorder, int final)
         380                 :            : /*[clinic end generated code: output=0f385f251ecc1988 input=f368a51cf384bf4c]*/
         381                 :            : {
         382                 :            :     /* This is overwritten unless final is true. */
         383                 :          0 :     Py_ssize_t consumed = data->len;
         384                 :            :
         385         [ #  # ]:          0 :     PyObject *decoded = PyUnicode_DecodeUTF16Stateful(data->buf, data->len,
         386                 :            :                                                       errors, &byteorder,
         387                 :            :                                                       final ? NULL : &consumed);
         388         [ #  # ]:          0 :     if (decoded == NULL)
         389                 :          0 :         return NULL;
         390                 :          0 :     return Py_BuildValue("Nni", decoded, consumed, byteorder);
         391                 :            : }
         392                 :            :
         393                 :            : /*[clinic input]
         394                 :            : _codecs.utf_32_decode
         395                 :            :     data: Py_buffer
         396                 :            :     errors: str(accept={str, NoneType}) = None
         397                 :            :     final: bool = False
         398                 :            :     /
         399                 :            : [clinic start generated code]*/
         400                 :            :
         401                 :            : static PyObject *
         402                 :          0 : _codecs_utf_32_decode_impl(PyObject *module, Py_buffer *data,
         403                 :            :                            const char *errors, int final)
         404                 :            : /*[clinic end generated code: output=2fc961807f7b145f input=fcdf3658c5e9b5f3]*/
         405                 :            : {
         406                 :          0 :     int byteorder = 0;
         407                 :            :     /* This is overwritten unless final is true. */
         408                 :          0 :     Py_ssize_t consumed = data->len;
         409         [ #  # ]:          0 :     PyObject *decoded = PyUnicode_DecodeUTF32Stateful(data->buf, data->len,
         410                 :            :                                                       errors, &byteorder,
         411                 :            :                                                       final ? NULL : &consumed);
         412                 :          0 :     return codec_tuple(decoded, consumed);
         413                 :            : }
         414                 :            :
         415                 :            : /*[clinic input]
         416                 :            : _codecs.utf_32_le_decode
         417                 :            :     data: Py_buffer
         418                 :            :     errors: str(accept={str, NoneType}) = None
         419                 :            :     final: bool = False
         420                 :            :     /
         421                 :            : [clinic start generated code]*/
         422                 :            :
         423                 :            : static PyObject *
         424                 :          0 : _codecs_utf_32_le_decode_impl(PyObject *module, Py_buffer *data,
         425                 :            :                               const char *errors, int final)
         426                 :            : /*[clinic end generated code: output=ec8f46b67a94f3e6 input=12220556e885f817]*/
         427                 :            : {
         428                 :          0 :     int byteorder = -1;
         429                 :            :     /* This is overwritten unless final is true. */
         430                 :          0 :     Py_ssize_t consumed = data->len;
         431         [ #  # ]:          0 :     PyObject *decoded = PyUnicode_DecodeUTF32Stateful(data->buf, data->len,
         432                 :            :                                                       errors, &byteorder,
         433                 :            :                                                       final ? NULL : &consumed);
         434                 :          0 :     return codec_tuple(decoded, consumed);
         435                 :            : }
         436                 :            :
         437                 :            : /*[clinic input]
         438                 :            : _codecs.utf_32_be_decode
         439                 :            :     data: Py_buffer
         440                 :            :     errors: str(accept={str, NoneType}) = None
         441                 :            :     final: bool = False
         442                 :            :     /
         443                 :            : [clinic start generated code]*/
         444                 :            :
         445                 :            : static PyObject *
         446                 :          0 : _codecs_utf_32_be_decode_impl(PyObject *module, Py_buffer *data,
         447                 :            :                               const char *errors, int final)
         448                 :            : /*[clinic end generated code: output=ff82bae862c92c4e input=2bc669b4781598db]*/
         449                 :            : {
         450                 :          0 :     int byteorder = 1;
         451                 :            :     /* This is overwritten unless final is true. */
         452                 :          0 :     Py_ssize_t consumed = data->len;
         453         [ #  # ]:          0 :     PyObject *decoded = PyUnicode_DecodeUTF32Stateful(data->buf, data->len,
         454                 :            :                                                       errors, &byteorder,
         455                 :            :                                                       final ? NULL : &consumed);
         456                 :          0 :     return codec_tuple(decoded, consumed);
         457                 :            : }
         458                 :            :
         459                 :            : /* This non-standard version also provides access to the byteorder
         460                 :            :    parameter of the builtin UTF-32 codec.
         461                 :            :
         462                 :            :    It returns a tuple (unicode, bytesread, byteorder) with byteorder
         463                 :            :    being the value in effect at the end of data.
         464                 :            :
         465                 :            : */
         466                 :            : /*[clinic input]
         467                 :            : _codecs.utf_32_ex_decode
         468                 :            :     data: Py_buffer
         469                 :            :     errors: str(accept={str, NoneType}) = None
         470                 :            :     byteorder: int = 0
         471                 :            :     final: bool = False
         472                 :            :     /
         473                 :            : [clinic start generated code]*/
         474                 :            :
         475                 :            : static PyObject *
         476                 :          0 : _codecs_utf_32_ex_decode_impl(PyObject *module, Py_buffer *data,
         477                 :            :                               const char *errors, int byteorder, int final)
         478                 :            : /*[clinic end generated code: output=6bfb177dceaf4848 input=4a2323d0013620df]*/
         479                 :            : {
         480                 :          0 :     Py_ssize_t consumed = data->len;
         481         [ #  # ]:          0 :     PyObject *decoded = PyUnicode_DecodeUTF32Stateful(data->buf, data->len,
         482                 :            :                                                       errors, &byteorder,
         483                 :            :                                                       final ? NULL : &consumed);
         484         [ #  # ]:          0 :     if (decoded == NULL)
         485                 :          0 :         return NULL;
         486                 :          0 :     return Py_BuildValue("Nni", decoded, consumed, byteorder);
         487                 :            : }
         488                 :            :
         489                 :            : /*[clinic input]
         490                 :            : _codecs.unicode_escape_decode
         491                 :            :     data: Py_buffer(accept={str, buffer})
         492                 :            :     errors: str(accept={str, NoneType}) = None
         493                 :            :     final: bool = True
         494                 :            :     /
         495                 :            : [clinic start generated code]*/
         496                 :            :
         497                 :            : static PyObject *
         498                 :          0 : _codecs_unicode_escape_decode_impl(PyObject *module, Py_buffer *data,
         499                 :            :                                    const char *errors, int final)
         500                 :            : /*[clinic end generated code: output=b284f97b12c635ee input=15019f081ffe272b]*/
         501                 :            : {
         502                 :          0 :     Py_ssize_t consumed = data->len;
         503         [ #  # ]:          0 :     PyObject *decoded = _PyUnicode_DecodeUnicodeEscapeStateful(data->buf, data->len,
         504                 :            :                                                                errors,
         505                 :            :                                                                final ? NULL : &consumed);
         506                 :          0 :     return codec_tuple(decoded, consumed);
         507                 :            : }
         508                 :            :
         509                 :            : /*[clinic input]
         510                 :            : _codecs.raw_unicode_escape_decode
         511                 :            :     data: Py_buffer(accept={str, buffer})
         512                 :            :     errors: str(accept={str, NoneType}) = None
         513                 :            :     final: bool = True
         514                 :            :     /
         515                 :            : [clinic start generated code]*/
         516                 :            :
         517                 :            : static PyObject *
         518                 :          0 : _codecs_raw_unicode_escape_decode_impl(PyObject *module, Py_buffer *data,
         519                 :            :                                        const char *errors, int final)
         520                 :            : /*[clinic end generated code: output=11dbd96301e2879e input=b93f823aa8c343ad]*/
         521                 :            : {
         522                 :          0 :     Py_ssize_t consumed = data->len;
         523         [ #  # ]:          0 :     PyObject *decoded = _PyUnicode_DecodeRawUnicodeEscapeStateful(data->buf, data->len,
         524                 :            :                                                                   errors,
         525                 :            :                                                                   final ? NULL : &consumed);
         526                 :          0 :     return codec_tuple(decoded, consumed);
         527                 :            : }
         528                 :            :
         529                 :            : /*[clinic input]
         530                 :            : _codecs.latin_1_decode
         531                 :            :     data: Py_buffer
         532                 :            :     errors: str(accept={str, NoneType}) = None
         533                 :            :     /
         534                 :            : [clinic start generated code]*/
         535                 :            :
         536                 :            : static PyObject *
         537                 :          0 : _codecs_latin_1_decode_impl(PyObject *module, Py_buffer *data,
         538                 :            :                             const char *errors)
         539                 :            : /*[clinic end generated code: output=07f3dfa3f72c7d8f input=76ca58fd6dcd08c7]*/
         540                 :            : {
         541                 :          0 :     PyObject *decoded = PyUnicode_DecodeLatin1(data->buf, data->len, errors);
         542                 :          0 :     return codec_tuple(decoded, data->len);
         543                 :            : }
         544                 :            :
         545                 :            : /*[clinic input]
         546                 :            : _codecs.ascii_decode
         547                 :            :     data: Py_buffer
         548                 :            :     errors: str(accept={str, NoneType}) = None
         549                 :            :     /
         550                 :            : [clinic start generated code]*/
         551                 :            :
         552                 :            : static PyObject *
         553                 :          0 : _codecs_ascii_decode_impl(PyObject *module, Py_buffer *data,
         554                 :            :                           const char *errors)
         555                 :            : /*[clinic end generated code: output=2627d72058d42429 input=e428a267a04b4481]*/
         556                 :            : {
         557                 :          0 :     PyObject *decoded = PyUnicode_DecodeASCII(data->buf, data->len, errors);
         558                 :          0 :     return codec_tuple(decoded, data->len);
         559                 :            : }
         560                 :            :
         561                 :            : /*[clinic input]
         562                 :            : _codecs.charmap_decode
         563                 :            :     data: Py_buffer
         564                 :            :     errors: str(accept={str, NoneType}) = None
         565                 :            :     mapping: object = None
         566                 :            :     /
         567                 :            : [clinic start generated code]*/
         568                 :            :
         569                 :            : static PyObject *
         570                 :          0 : _codecs_charmap_decode_impl(PyObject *module, Py_buffer *data,
         571                 :            :                             const char *errors, PyObject *mapping)
         572                 :            : /*[clinic end generated code: output=2c335b09778cf895 input=15b69df43458eb40]*/
         573                 :            : {
         574                 :            :     PyObject *decoded;
         575                 :            :
         576         [ #  # ]:          0 :     if (mapping == Py_None)
         577                 :          0 :         mapping = NULL;
         578                 :            :
         579                 :          0 :     decoded = PyUnicode_DecodeCharmap(data->buf, data->len, mapping, errors);
         580                 :          0 :     return codec_tuple(decoded, data->len);
         581                 :            : }
         582                 :            :
         583                 :            : #ifdef MS_WINDOWS
         584                 :            :
         585                 :            : /*[clinic input]
         586                 :            : _codecs.mbcs_decode
         587                 :            :     data: Py_buffer
         588                 :            :     errors: str(accept={str, NoneType}) = None
         589                 :            :     final: bool = False
         590                 :            :     /
         591                 :            : [clinic start generated code]*/
         592                 :            :
         593                 :            : static PyObject *
         594                 :            : _codecs_mbcs_decode_impl(PyObject *module, Py_buffer *data,
         595                 :            :                          const char *errors, int final)
         596                 :            : /*[clinic end generated code: output=39b65b8598938c4b input=f144ad1ed6d8f5a6]*/
         597                 :            : {
         598                 :            :     Py_ssize_t consumed = data->len;
         599                 :            :     PyObject *decoded = PyUnicode_DecodeMBCSStateful(data->buf, data->len,
         600                 :            :             errors, final ? NULL : &consumed);
         601                 :            :     return codec_tuple(decoded, consumed);
         602                 :            : }
         603                 :            :
         604                 :            : /*[clinic input]
         605                 :            : _codecs.oem_decode
         606                 :            :     data: Py_buffer
         607                 :            :     errors: str(accept={str, NoneType}) = None
         608                 :            :     final: bool = False
         609                 :            :     /
         610                 :            : [clinic start generated code]*/
         611                 :            :
         612                 :            : static PyObject *
         613                 :            : _codecs_oem_decode_impl(PyObject *module, Py_buffer *data,
         614                 :            :                         const char *errors, int final)
         615                 :            : /*[clinic end generated code: output=da1617612f3fcad8 input=629bf87376d211b4]*/
         616                 :            : {
         617                 :            :     Py_ssize_t consumed = data->len;
         618                 :            :     PyObject *decoded = PyUnicode_DecodeCodePageStateful(CP_OEMCP,
         619                 :            :         data->buf, data->len, errors, final ? NULL : &consumed);
         620                 :            :     return codec_tuple(decoded, consumed);
         621                 :            : }
         622                 :            :
         623                 :            : /*[clinic input]
         624                 :            : _codecs.code_page_decode
         625                 :            :     codepage: int
         626                 :            :     data: Py_buffer
         627                 :            :     errors: str(accept={str, NoneType}) = None
         628                 :            :     final: bool = False
         629                 :            :     /
         630                 :            : [clinic start generated code]*/
         631                 :            :
         632                 :            : static PyObject *
         633                 :            : _codecs_code_page_decode_impl(PyObject *module, int codepage,
         634                 :            :                               Py_buffer *data, const char *errors, int final)
         635                 :            : /*[clinic end generated code: output=53008ea967da3fff input=6a32589b0658c277]*/
         636                 :            : {
         637                 :            :     Py_ssize_t consumed = data->len;
         638                 :            :     PyObject *decoded = PyUnicode_DecodeCodePageStateful(codepage,
         639                 :            :                                                          data->buf, data->len,
         640                 :            :                                                          errors,
         641                 :            :                                                          final ? NULL : &consumed);
         642                 :            :     return codec_tuple(decoded, consumed);
         643                 :            : }
         644                 :            :
         645                 :            : #endif /* MS_WINDOWS */
         646                 :            :
         647                 :            : /* --- Encoder ------------------------------------------------------------ */
         648                 :            :
         649                 :            : /*[clinic input]
         650                 :            : _codecs.readbuffer_encode
         651                 :            :     data: Py_buffer(accept={str, buffer})
         652                 :            :     errors: str(accept={str, NoneType}) = None
         653                 :            :     /
         654                 :            : [clinic start generated code]*/
         655                 :            :
         656                 :            : static PyObject *
         657                 :          0 : _codecs_readbuffer_encode_impl(PyObject *module, Py_buffer *data,
         658                 :            :                                const char *errors)
         659                 :            : /*[clinic end generated code: output=c645ea7cdb3d6e86 input=aa10cfdf252455c5]*/
         660                 :            : {
         661                 :          0 :     PyObject *result = PyBytes_FromStringAndSize(data->buf, data->len);
         662                 :          0 :     return codec_tuple(result, data->len);
         663                 :            : }
         664                 :            :
         665                 :            : /*[clinic input]
         666                 :            : _codecs.utf_7_encode
         667                 :            :     str: unicode
         668                 :            :     errors: str(accept={str, NoneType}) = None
         669                 :            :     /
         670                 :            : [clinic start generated code]*/
         671                 :            :
         672                 :            : static PyObject *
         673                 :          0 : _codecs_utf_7_encode_impl(PyObject *module, PyObject *str,
         674                 :            :                           const char *errors)
         675                 :            : /*[clinic end generated code: output=0feda21ffc921bc8 input=2546dbbb3fa53114]*/
         676                 :            : {
         677                 :          0 :     return codec_tuple(_PyUnicode_EncodeUTF7(str, 0, 0, errors),
         678                 :            :                        PyUnicode_GET_LENGTH(str));
         679                 :            : }
         680                 :            :
         681                 :            : /*[clinic input]
         682                 :            : _codecs.utf_8_encode
         683                 :            :     str: unicode
         684                 :            :     errors: str(accept={str, NoneType}) = None
         685                 :            :     /
         686                 :            : [clinic start generated code]*/
         687                 :            :
         688                 :            : static PyObject *
         689                 :          0 : _codecs_utf_8_encode_impl(PyObject *module, PyObject *str,
         690                 :            :                           const char *errors)
         691                 :            : /*[clinic end generated code: output=02bf47332b9c796c input=a3e71ae01c3f93f3]*/
         692                 :            : {
         693                 :          0 :     return codec_tuple(_PyUnicode_AsUTF8String(str, errors),
         694                 :            :                        PyUnicode_GET_LENGTH(str));
         695                 :            : }
         696                 :            :
         697                 :            : /* This version provides access to the byteorder parameter of the
         698                 :            :    builtin UTF-16 codecs as optional third argument. It defaults to 0
         699                 :            :    which means: use the native byte order and prepend the data with a
         700                 :            :    BOM mark.
         701                 :            :
         702                 :            : */
         703                 :            :
         704                 :            : /*[clinic input]
         705                 :            : _codecs.utf_16_encode
         706                 :            :     str: unicode
         707                 :            :     errors: str(accept={str, NoneType}) = None
         708                 :            :     byteorder: int = 0
         709                 :            :     /
         710                 :            : [clinic start generated code]*/
         711                 :            :
         712                 :            : static PyObject *
         713                 :          0 : _codecs_utf_16_encode_impl(PyObject *module, PyObject *str,
         714                 :            :                            const char *errors, int byteorder)
         715                 :            : /*[clinic end generated code: output=c654e13efa2e64e4 input=68cdc2eb8338555d]*/
         716                 :            : {
         717                 :          0 :     return codec_tuple(_PyUnicode_EncodeUTF16(str, errors, byteorder),
         718                 :            :                        PyUnicode_GET_LENGTH(str));
         719                 :            : }
         720                 :            :
         721                 :            : /*[clinic input]
         722                 :            : _codecs.utf_16_le_encode
         723                 :            :     str: unicode
         724                 :            :     errors: str(accept={str, NoneType}) = None
         725                 :            :     /
         726                 :            : [clinic start generated code]*/
         727                 :            :
         728                 :            : static PyObject *
         729                 :          0 : _codecs_utf_16_le_encode_impl(PyObject *module, PyObject *str,
         730                 :            :                               const char *errors)
         731                 :            : /*[clinic end generated code: output=431b01e55f2d4995 input=83d042706eed6798]*/
         732                 :            : {
         733                 :          0 :     return codec_tuple(_PyUnicode_EncodeUTF16(str, errors, -1),
         734                 :            :                        PyUnicode_GET_LENGTH(str));
         735                 :            : }
         736                 :            :
         737                 :            : /*[clinic input]
         738                 :            : _codecs.utf_16_be_encode
         739                 :            :     str: unicode
         740                 :            :     errors: str(accept={str, NoneType}) = None
         741                 :            :     /
         742                 :            : [clinic start generated code]*/
         743                 :            :
         744                 :            : static PyObject *
         745                 :          0 : _codecs_utf_16_be_encode_impl(PyObject *module, PyObject *str,
         746                 :            :                               const char *errors)
         747                 :            : /*[clinic end generated code: output=96886a6fd54dcae3 input=6f1e9e623b03071b]*/
         748                 :            : {
         749                 :          0 :     return codec_tuple(_PyUnicode_EncodeUTF16(str, errors, +1),
         750                 :            :                        PyUnicode_GET_LENGTH(str));
         751                 :            : }
         752                 :            :
         753                 :            : /* This version provides access to the byteorder parameter of the
         754                 :            :    builtin UTF-32 codecs as optional third argument. It defaults to 0
         755                 :            :    which means: use the native byte order and prepend the data with a
         756                 :            :    BOM mark.
         757                 :            :
         758                 :            : */
         759                 :            :
         760                 :            : /*[clinic input]
         761                 :            : _codecs.utf_32_encode
         762                 :            :     str: unicode
         763                 :            :     errors: str(accept={str, NoneType}) = None
         764                 :            :     byteorder: int = 0
         765                 :            :     /
         766                 :            : [clinic start generated code]*/
         767                 :            :
         768                 :            : static PyObject *
         769                 :          0 : _codecs_utf_32_encode_impl(PyObject *module, PyObject *str,
         770                 :            :                            const char *errors, int byteorder)
         771                 :            : /*[clinic end generated code: output=5c760da0c09a8b83 input=8ec4c64d983bc52b]*/
         772                 :            : {
         773                 :          0 :     return codec_tuple(_PyUnicode_EncodeUTF32(str, errors, byteorder),
         774                 :            :                        PyUnicode_GET_LENGTH(str));
         775                 :            : }
         776                 :            :
         777                 :            : /*[clinic input]
         778                 :            : _codecs.utf_32_le_encode
         779                 :            :     str: unicode
         780                 :            :     errors: str(accept={str, NoneType}) = None
         781                 :            :     /
         782                 :            : [clinic start generated code]*/
         783                 :            :
         784                 :            : static PyObject *
         785                 :          0 : _codecs_utf_32_le_encode_impl(PyObject *module, PyObject *str,
         786                 :            :                               const char *errors)
         787                 :            : /*[clinic end generated code: output=b65cd176de8e36d6 input=f0918d41de3eb1b1]*/
         788                 :            : {
         789                 :          0 :     return codec_tuple(_PyUnicode_EncodeUTF32(str, errors, -1),
         790                 :            :                        PyUnicode_GET_LENGTH(str));
         791                 :            : }
         792                 :            :
         793                 :            : /*[clinic input]
         794                 :            : _codecs.utf_32_be_encode
         795                 :            :     str: unicode
         796                 :            :     errors: str(accept={str, NoneType}) = None
         797                 :            :     /
         798                 :            : [clinic start generated code]*/
         799                 :            :
         800                 :            : static PyObject *
         801                 :          0 : _codecs_utf_32_be_encode_impl(PyObject *module, PyObject *str,
         802                 :            :                               const char *errors)
         803                 :            : /*[clinic end generated code: output=1d9e71a9358709e9 input=967a99a95748b557]*/
         804                 :            : {
         805                 :          0 :     return codec_tuple(_PyUnicode_EncodeUTF32(str, errors, +1),
         806                 :            :                        PyUnicode_GET_LENGTH(str));
         807                 :            : }
         808                 :            :
         809                 :            : /*[clinic input]
         810                 :            : _codecs.unicode_escape_encode
         811                 :            :     str: unicode
         812                 :            :     errors: str(accept={str, NoneType}) = None
         813                 :            :     /
         814                 :            : [clinic start generated code]*/
         815                 :            :
         816                 :            : static PyObject *
         817                 :          0 : _codecs_unicode_escape_encode_impl(PyObject *module, PyObject *str,
         818                 :            :                                    const char *errors)
         819                 :            : /*[clinic end generated code: output=66271b30bc4f7a3c input=8c4de07597054e33]*/
         820                 :            : {
         821                 :          0 :     return codec_tuple(PyUnicode_AsUnicodeEscapeString(str),
         822                 :            :                        PyUnicode_GET_LENGTH(str));
         823                 :            : }
         824                 :            :
         825                 :            : /*[clinic input]
         826                 :            : _codecs.raw_unicode_escape_encode
         827                 :            :     str: unicode
         828                 :            :     errors: str(accept={str, NoneType}) = None
         829                 :            :     /
         830                 :            : [clinic start generated code]*/
         831                 :            :
         832                 :            : static PyObject *
         833                 :          0 : _codecs_raw_unicode_escape_encode_impl(PyObject *module, PyObject *str,
         834                 :            :                                        const char *errors)
         835                 :            : /*[clinic end generated code: output=a66a806ed01c830a input=4aa6f280d78e4574]*/
         836                 :            : {
         837                 :          0 :     return codec_tuple(PyUnicode_AsRawUnicodeEscapeString(str),
         838                 :            :                        PyUnicode_GET_LENGTH(str));
         839                 :            : }
         840                 :            :
         841                 :            : /*[clinic input]
         842                 :            : _codecs.latin_1_encode
         843                 :            :     str: unicode
         844                 :            :     errors: str(accept={str, NoneType}) = None
         845                 :            :     /
         846                 :            : [clinic start generated code]*/
         847                 :            :
         848                 :            : static PyObject *
         849                 :          0 : _codecs_latin_1_encode_impl(PyObject *module, PyObject *str,
         850                 :            :                             const char *errors)
         851                 :            : /*[clinic end generated code: output=2c28c83a27884e08 input=ec3ef74bf85c5c5d]*/
         852                 :            : {
         853                 :          0 :     return codec_tuple(_PyUnicode_AsLatin1String(str, errors),
         854                 :            :                        PyUnicode_GET_LENGTH(str));
         855                 :            : }
         856                 :            :
         857                 :            : /*[clinic input]
         858                 :            : _codecs.ascii_encode
         859                 :            :     str: unicode
         860                 :            :     errors: str(accept={str, NoneType}) = None
         861                 :            :     /
         862                 :            : [clinic start generated code]*/
         863                 :            :
         864                 :            : static PyObject *
         865                 :          0 : _codecs_ascii_encode_impl(PyObject *module, PyObject *str,
         866                 :            :                           const char *errors)
         867                 :            : /*[clinic end generated code: output=b5e035182d33befc input=93e6e602838bd3de]*/
         868                 :            : {
         869                 :          0 :     return codec_tuple(_PyUnicode_AsASCIIString(str, errors),
         870                 :            :                        PyUnicode_GET_LENGTH(str));
         871                 :            : }
         872                 :            :
         873                 :            : /*[clinic input]
         874                 :            : _codecs.charmap_encode
         875                 :            :     str: unicode
         876                 :            :     errors: str(accept={str, NoneType}) = None
         877                 :            :     mapping: object = None
         878                 :            :     /
         879                 :            : [clinic start generated code]*/
         880                 :            :
         881                 :            : static PyObject *
         882                 :          0 : _codecs_charmap_encode_impl(PyObject *module, PyObject *str,
         883                 :            :                             const char *errors, PyObject *mapping)
         884                 :            : /*[clinic end generated code: output=047476f48495a9e9 input=2a98feae73dadce8]*/
         885                 :            : {
         886         [ #  # ]:          0 :     if (mapping == Py_None)
         887                 :          0 :         mapping = NULL;
         888                 :            :
         889                 :          0 :     return codec_tuple(_PyUnicode_EncodeCharmap(str, mapping, errors),
         890                 :            :                        PyUnicode_GET_LENGTH(str));
         891                 :            : }
         892                 :            :
         893                 :            : /*[clinic input]
         894                 :            : _codecs.charmap_build
         895                 :            :     map: unicode
         896                 :            :     /
         897                 :            : [clinic start generated code]*/
         898                 :            :
         899                 :            : static PyObject *
         900                 :          0 : _codecs_charmap_build_impl(PyObject *module, PyObject *map)
         901                 :            : /*[clinic end generated code: output=bb073c27031db9ac input=d91a91d1717dbc6d]*/
         902                 :            : {
         903                 :          0 :     return PyUnicode_BuildEncodingMap(map);
         904                 :            : }
         905                 :            :
         906                 :            : #ifdef MS_WINDOWS
         907                 :            :
         908                 :            : /*[clinic input]
         909                 :            : _codecs.mbcs_encode
         910                 :            :     str: unicode
         911                 :            :     errors: str(accept={str, NoneType}) = None
         912                 :            :     /
         913                 :            : [clinic start generated code]*/
         914                 :            :
         915                 :            : static PyObject *
         916                 :            : _codecs_mbcs_encode_impl(PyObject *module, PyObject *str, const char *errors)
         917                 :            : /*[clinic end generated code: output=76e2e170c966c080 input=2e932fc289ea5a5b]*/
         918                 :            : {
         919                 :            :     return codec_tuple(PyUnicode_EncodeCodePage(CP_ACP, str, errors),
         920                 :            :                        PyUnicode_GET_LENGTH(str));
         921                 :            : }
         922                 :            :
         923                 :            : /*[clinic input]
         924                 :            : _codecs.oem_encode
         925                 :            :     str: unicode
         926                 :            :     errors: str(accept={str, NoneType}) = None
         927                 :            :     /
         928                 :            : [clinic start generated code]*/
         929                 :            :
         930                 :            : static PyObject *
         931                 :            : _codecs_oem_encode_impl(PyObject *module, PyObject *str, const char *errors)
         932                 :            : /*[clinic end generated code: output=65d5982c737de649 input=9eac86dc21eb14f2]*/
         933                 :            : {
         934                 :            :     return codec_tuple(PyUnicode_EncodeCodePage(CP_OEMCP, str, errors),
         935                 :            :         PyUnicode_GET_LENGTH(str));
         936                 :            : }
         937                 :            :
         938                 :            : /*[clinic input]
         939                 :            : _codecs.code_page_encode
         940                 :            :     code_page: int
         941                 :            :     str: unicode
         942                 :            :     errors: str(accept={str, NoneType}) = None
         943                 :            :     /
         944                 :            : [clinic start generated code]*/
         945                 :            :
         946                 :            : static PyObject *
         947                 :            : _codecs_code_page_encode_impl(PyObject *module, int code_page, PyObject *str,
         948                 :            :                               const char *errors)
         949                 :            : /*[clinic end generated code: output=45673f6085657a9e input=7d18a33bc8cd0f94]*/
         950                 :            : {
         951                 :            :     return codec_tuple(PyUnicode_EncodeCodePage(code_page, str, errors),
         952                 :            :                        PyUnicode_GET_LENGTH(str));
         953                 :            : }
         954                 :            :
         955                 :            : #endif /* MS_WINDOWS */
         956                 :            :
         957                 :            : /* --- Error handler registry --------------------------------------------- */
         958                 :            :
         959                 :            : /*[clinic input]
         960                 :            : _codecs.register_error
         961                 :            :     errors: str
         962                 :            :     handler: object
         963                 :            :     /
         964                 :            :
         965                 :            : Register the specified error handler under the name errors.
         966                 :            :
         967                 :            : handler must be a callable object, that will be called with an exception
         968                 :            : instance containing information about the location of the encoding/decoding
         969                 :            : error and must return a (replacement, new position) tuple.
         970                 :            : [clinic start generated code]*/
         971                 :            :
         972                 :            : static PyObject *
         973                 :          0 : _codecs_register_error_impl(PyObject *module, const char *errors,
         974                 :            :                             PyObject *handler)
         975                 :            : /*[clinic end generated code: output=fa2f7d1879b3067d input=5e6709203c2e33fe]*/
         976                 :            : {
         977         [ #  # ]:          0 :     if (PyCodec_RegisterError(errors, handler))
         978                 :          0 :         return NULL;
         979                 :          0 :     Py_RETURN_NONE;
         980                 :            : }
         981                 :            :
         982                 :            : /*[clinic input]
         983                 :            : _codecs.lookup_error
         984                 :            :     name: str
         985                 :            :     /
         986                 :            :
         987                 :            : lookup_error(errors) -> handler
         988                 :            :
         989                 :            : Return the error handler for the specified error handling name or raise a
         990                 :            : LookupError, if no handler exists under this name.
         991                 :            : [clinic start generated code]*/
         992                 :            :
         993                 :            : static PyObject *
         994                 :        150 : _codecs_lookup_error_impl(PyObject *module, const char *name)
         995                 :            : /*[clinic end generated code: output=087f05dc0c9a98cc input=4775dd65e6235aba]*/
         996                 :            : {
         997                 :        150 :     return PyCodec_LookupError(name);
         998                 :            : }
         999                 :            :
        1000                 :            : /* --- Module API --------------------------------------------------------- */
        1001                 :            :
        1002                 :            : static PyMethodDef _codecs_functions[] = {
        1003                 :            :     _CODECS_REGISTER_METHODDEF
        1004                 :            :     _CODECS_UNREGISTER_METHODDEF
        1005                 :            :     _CODECS_LOOKUP_METHODDEF
        1006                 :            :     _CODECS_ENCODE_METHODDEF
        1007                 :            :     _CODECS_DECODE_METHODDEF
        1008                 :            :     _CODECS_ESCAPE_ENCODE_METHODDEF
        1009                 :            :     _CODECS_ESCAPE_DECODE_METHODDEF
        1010                 :            :     _CODECS_UTF_8_ENCODE_METHODDEF
        1011                 :            :     _CODECS_UTF_8_DECODE_METHODDEF
        1012                 :            :     _CODECS_UTF_7_ENCODE_METHODDEF
        1013                 :            :     _CODECS_UTF_7_DECODE_METHODDEF
        1014                 :            :     _CODECS_UTF_16_ENCODE_METHODDEF
        1015                 :            :     _CODECS_UTF_16_LE_ENCODE_METHODDEF
        1016                 :            :     _CODECS_UTF_16_BE_ENCODE_METHODDEF
        1017                 :            :     _CODECS_UTF_16_DECODE_METHODDEF
        1018                 :            :     _CODECS_UTF_16_LE_DECODE_METHODDEF
        1019                 :            :     _CODECS_UTF_16_BE_DECODE_METHODDEF
        1020                 :            :     _CODECS_UTF_16_EX_DECODE_METHODDEF
        1021                 :            :     _CODECS_UTF_32_ENCODE_METHODDEF
        1022                 :            :     _CODECS_UTF_32_LE_ENCODE_METHODDEF
        1023                 :            :     _CODECS_UTF_32_BE_ENCODE_METHODDEF
        1024                 :            :     _CODECS_UTF_32_DECODE_METHODDEF
        1025                 :            :     _CODECS_UTF_32_LE_DECODE_METHODDEF
        1026                 :            :     _CODECS_UTF_32_BE_DECODE_METHODDEF
        1027                 :            :     _CODECS_UTF_32_EX_DECODE_METHODDEF
        1028                 :            :     _CODECS_UNICODE_ESCAPE_ENCODE_METHODDEF
        1029                 :            :     _CODECS_UNICODE_ESCAPE_DECODE_METHODDEF
        1030                 :            :     _CODECS_RAW_UNICODE_ESCAPE_ENCODE_METHODDEF
        1031                 :            :     _CODECS_RAW_UNICODE_ESCAPE_DECODE_METHODDEF
        1032                 :            :     _CODECS_LATIN_1_ENCODE_METHODDEF
        1033                 :            :     _CODECS_LATIN_1_DECODE_METHODDEF
        1034                 :            :     _CODECS_ASCII_ENCODE_METHODDEF
        1035                 :            :     _CODECS_ASCII_DECODE_METHODDEF
        1036                 :            :     _CODECS_CHARMAP_ENCODE_METHODDEF
        1037                 :            :     _CODECS_CHARMAP_DECODE_METHODDEF
        1038                 :            :     _CODECS_CHARMAP_BUILD_METHODDEF
        1039                 :            :     _CODECS_READBUFFER_ENCODE_METHODDEF
        1040                 :            :     _CODECS_MBCS_ENCODE_METHODDEF
        1041                 :            :     _CODECS_MBCS_DECODE_METHODDEF
        1042                 :            :     _CODECS_OEM_ENCODE_METHODDEF
        1043                 :            :     _CODECS_OEM_DECODE_METHODDEF
        1044                 :            :     _CODECS_CODE_PAGE_ENCODE_METHODDEF
        1045                 :            :     _CODECS_CODE_PAGE_DECODE_METHODDEF
        1046                 :            :     _CODECS_REGISTER_ERROR_METHODDEF
        1047                 :            :     _CODECS_LOOKUP_ERROR_METHODDEF
        1048                 :            :     {NULL, NULL}                /* sentinel */
        1049                 :            : };
        1050                 :            :
        1051                 :            : static PyModuleDef_Slot _codecs_slots[] = {
        1052                 :            :     {0, NULL}
        1053                 :            : };
        1054                 :            :
        1055                 :            : static struct PyModuleDef codecsmodule = {
        1056                 :            :         PyModuleDef_HEAD_INIT,
        1057                 :            :         "_codecs",
        1058                 :            :         NULL,
        1059                 :            :         0,
        1060                 :            :         _codecs_functions,
        1061                 :            :         _codecs_slots,
        1062                 :            :         NULL,
        1063                 :            :         NULL,
        1064                 :            :         NULL
        1065                 :            : };
        1066                 :            :
        1067                 :            : PyMODINIT_FUNC
        1068                 :         26 : PyInit__codecs(void)
        1069                 :            : {
        1070                 :         26 :     return PyModuleDef_Init(&codecsmodule);
        1071                 :            : }

Generated by: LCOV version 1.14