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