LCOV - code coverage report
Current view: | top level - Objects/clinic - unicodeobject.c.h (source / functions) |  |  | Hit | Total | Coverage
Test: | CPython 3.12 LCOV report [commit 5e6661bce9] |  | Lines: | 188 | 403 | 46.7 %
Date: | 2023-03-20 08:15:36 |  | Functions: | 18 | 38 | 47.4 %
|  |  | Branches: | 95 | 276 | 34.4 %

               Branch data     Line data    Source code
           1                 :            : /*[clinic input]
           2                 :            : preserve
           3                 :            : [clinic start generated code]*/
           4                 :            :
           5                 :            : #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
           6                 :            : #  include "pycore_gc.h"            // PyGC_Head
           7                 :            : #  include "pycore_runtime.h"       // _Py_ID()
           8                 :            : #endif
           9                 :            :
          10                 :            :
          11                 :            : PyDoc_STRVAR(EncodingMap_size__doc__,
          12                 :            : "size($self, /)\n"
          13                 :            : "--\n"
          14                 :            : "\n"
          15                 :            : "Return the size (in bytes) of this object.");
          16                 :            :
          17                 :            : #define ENCODINGMAP_SIZE_METHODDEF    \
          18                 :            :     {"size", (PyCFunction)EncodingMap_size, METH_NOARGS, EncodingMap_size__doc__},
          19                 :            :
          20                 :            : static PyObject *
          21                 :            : EncodingMap_size_impl(struct encoding_map *self);
          22                 :            :
          23                 :            : static PyObject *
          24                 :          0 : EncodingMap_size(struct encoding_map *self, PyObject *Py_UNUSED(ignored))
          25                 :            : {
          26                 :          0 :     return EncodingMap_size_impl(self);
          27                 :            : }
          28                 :            :
          29                 :            : PyDoc_STRVAR(unicode_title__doc__,
          30                 :            : "title($self, /)\n"
          31                 :            : "--\n"
          32                 :            : "\n"
          33                 :            : "Return a version of the string where each word is titlecased.\n"
          34                 :            : "\n"
          35                 :            : "More specifically, words start with uppercased characters and all remaining\n"
          36                 :            : "cased characters have lower case.");
          37                 :            :
          38                 :            : #define UNICODE_TITLE_METHODDEF    \
          39                 :            :     {"title", (PyCFunction)unicode_title, METH_NOARGS, unicode_title__doc__},
          40                 :            :
          41                 :            : static PyObject *
          42                 :            : unicode_title_impl(PyObject *self);
          43                 :            :
          44                 :            : static PyObject *
          45                 :          0 : unicode_title(PyObject *self, PyObject *Py_UNUSED(ignored))
          46                 :            : {
          47                 :          0 :     return unicode_title_impl(self);
          48                 :            : }
          49                 :            :
          50                 :            : PyDoc_STRVAR(unicode_capitalize__doc__,
          51                 :            : "capitalize($self, /)\n"
          52                 :            : "--\n"
          53                 :            : "\n"
          54                 :            : "Return a capitalized version of the string.\n"
          55                 :            : "\n"
          56                 :            : "More specifically, make the first character have upper case and the rest lower\n"
          57                 :            : "case.");
          58                 :            :
          59                 :            : #define UNICODE_CAPITALIZE_METHODDEF    \
          60                 :            :     {"capitalize", (PyCFunction)unicode_capitalize, METH_NOARGS, unicode_capitalize__doc__},
          61                 :            :
          62                 :            : static PyObject *
          63                 :            : unicode_capitalize_impl(PyObject *self);
          64                 :            :
          65                 :            : static PyObject *
          66                 :          0 : unicode_capitalize(PyObject *self, PyObject *Py_UNUSED(ignored))
          67                 :            : {
          68                 :          0 :     return unicode_capitalize_impl(self);
          69                 :            : }
          70                 :            :
          71                 :            : PyDoc_STRVAR(unicode_casefold__doc__,
          72                 :            : "casefold($self, /)\n"
          73                 :            : "--\n"
          74                 :            : "\n"
          75                 :            : "Return a version of the string suitable for caseless comparisons.");
          76                 :            :
          77                 :            : #define UNICODE_CASEFOLD_METHODDEF    \
          78                 :            :     {"casefold", (PyCFunction)unicode_casefold, METH_NOARGS, unicode_casefold__doc__},
          79                 :            :
          80                 :            : static PyObject *
          81                 :            : unicode_casefold_impl(PyObject *self);
          82                 :            :
          83                 :            : static PyObject *
          84                 :          0 : unicode_casefold(PyObject *self, PyObject *Py_UNUSED(ignored))
          85                 :            : {
          86                 :          0 :     return unicode_casefold_impl(self);
          87                 :            : }
          88                 :            :
          89                 :            : PyDoc_STRVAR(unicode_center__doc__,
          90                 :            : "center($self, width, fillchar=\' \', /)\n"
          91                 :            : "--\n"
          92                 :            : "\n"
          93                 :            : "Return a centered string of length width.\n"
          94                 :            : "\n"
          95                 :            : "Padding is done using the specified fill character (default is a space).");
          96                 :            :
          97                 :            : #define UNICODE_CENTER_METHODDEF    \
          98                 :            :     {"center", _PyCFunction_CAST(unicode_center), METH_FASTCALL, unicode_center__doc__},
          99                 :            :
         100                 :            : static PyObject *
         101                 :            : unicode_center_impl(PyObject *self, Py_ssize_t width, Py_UCS4 fillchar);
         102                 :            :
         103                 :            : static PyObject *
         104                 :          0 : unicode_center(PyObject *self, PyObject *const *args, Py_ssize_t nargs)
         105                 :            : {
         106                 :          0 :     PyObject *return_value = NULL;
         107                 :            :     Py_ssize_t width;
         108                 :          0 :     Py_UCS4 fillchar = ' ';
         109                 :            :
         110   [ #  #  #  #  :          0 :     if (!_PyArg_CheckPositional("center", nargs, 1, 2)) {
                       #  # ]
         111                 :          0 :         goto exit;
         112                 :            :     }
         113                 :            :     {
         114                 :          0 :         Py_ssize_t ival = -1;
         115                 :          0 :         PyObject *iobj = _PyNumber_Index(args[0]);
         116         [ #  # ]:          0 :         if (iobj != NULL) {
         117                 :          0 :             ival = PyLong_AsSsize_t(iobj);
         118                 :          0 :             Py_DECREF(iobj);
         119                 :            :         }
         120   [ #  #  #  # ]:          0 :         if (ival == -1 && PyErr_Occurred()) {
         121                 :          0 :             goto exit;
         122                 :            :         }
         123                 :          0 :         width = ival;
         124                 :            :     }
         125         [ #  # ]:          0 :     if (nargs < 2) {
         126                 :          0 :         goto skip_optional;
         127                 :            :     }
         128         [ #  # ]:          0 :     if (!convert_uc(args[1], &fillchar)) {
         129                 :          0 :         goto exit;
         130                 :            :     }
         131                 :          0 : skip_optional:
         132                 :          0 :     return_value = unicode_center_impl(self, width, fillchar);
         133                 :            :
         134                 :          0 : exit:
         135                 :          0 :     return return_value;
         136                 :            : }
         137                 :            :
         138                 :            : PyDoc_STRVAR(unicode_encode__doc__,
         139                 :            : "encode($self, /, encoding=\'utf-8\', errors=\'strict\')\n"
         140                 :            : "--\n"
         141                 :            : "\n"
         142                 :            : "Encode the string using the codec registered for encoding.\n"
         143                 :            : "\n"
         144                 :            : "  encoding\n"
         145                 :            : "    The encoding in which to encode the string.\n"
         146                 :            : "  errors\n"
         147                 :            : "    The error handling scheme to use for encoding errors.\n"
         148                 :            : "    The default is \'strict\' meaning that encoding errors raise a\n"
         149                 :            : "    UnicodeEncodeError.  Other possible values are \'ignore\', \'replace\' and\n"
         150                 :            : "    \'xmlcharrefreplace\' as well as any other name registered with\n"
         151                 :            : "    codecs.register_error that can handle UnicodeEncodeErrors.");
         152                 :            :
         153                 :            : #define UNICODE_ENCODE_METHODDEF    \
         154                 :            :     {"encode", _PyCFunction_CAST(unicode_encode), METH_FASTCALL|METH_KEYWORDS, unicode_encode__doc__},
         155                 :            :
         156                 :            : static PyObject *
         157                 :            : unicode_encode_impl(PyObject *self, const char *encoding, const char *errors);
         158                 :            :
         159                 :            : static PyObject *
         160                 :       3123 : unicode_encode(PyObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
         161                 :            : {
         162                 :       3123 :     PyObject *return_value = NULL;
         163                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
         164                 :            :
         165                 :            :     #define NUM_KEYWORDS 2
         166                 :            :     static struct {
         167                 :            :         PyGC_Head _this_is_not_used;
         168                 :            :         PyObject_VAR_HEAD
         169                 :            :         PyObject *ob_item[NUM_KEYWORDS];
         170                 :            :     } _kwtuple = {
         171                 :            :         .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
         172                 :            :         .ob_item = { &_Py_ID(encoding), &_Py_ID(errors), },
         173                 :            :     };
         174                 :            :     #undef NUM_KEYWORDS
         175                 :            :     #define KWTUPLE (&_kwtuple.ob_base.ob_base)
         176                 :            :
         177                 :            :     #else  // !Py_BUILD_CORE
         178                 :            :     #  define KWTUPLE NULL
         179                 :            :     #endif  // !Py_BUILD_CORE
         180                 :            :
         181                 :            :     static const char * const _keywords[] = {"encoding", "errors", NULL};
         182                 :            :     static _PyArg_Parser _parser = {
         183                 :            :         .keywords = _keywords,
         184                 :            :         .fname = "encode",
         185                 :            :         .kwtuple = KWTUPLE,
         186                 :            :     };
         187                 :            :     #undef KWTUPLE
         188                 :            :     PyObject *argsbuf[2];
         189         [ -  + ]:       3123 :     Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
         190                 :       3123 :     const char *encoding = NULL;
         191                 :       3123 :     const char *errors = NULL;
         192                 :            :
         193   [ +  -  +  -  :       3123 :     args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 2, 0, argsbuf);
                 +  -  -  + ]
         194         [ -  + ]:       3123 :     if (!args) {
         195                 :          0 :         goto exit;
         196                 :            :     }
         197         [ +  + ]:       3123 :     if (!noptargs) {
         198                 :          1 :         goto skip_optional_pos;
         199                 :            :     }
         200         [ +  - ]:       3122 :     if (args[0]) {
         201         [ -  + ]:       3122 :         if (!PyUnicode_Check(args[0])) {
         202                 :          0 :             _PyArg_BadArgument("encode", "argument 'encoding'", "str", args[0]);
         203                 :          0 :             goto exit;
         204                 :            :         }
         205                 :            :         Py_ssize_t encoding_length;
         206                 :       3122 :         encoding = PyUnicode_AsUTF8AndSize(args[0], &encoding_length);
         207         [ -  + ]:       3122 :         if (encoding == NULL) {
         208                 :          0 :             goto exit;
         209                 :            :         }
         210         [ -  + ]:       3122 :         if (strlen(encoding) != (size_t)encoding_length) {
         211                 :          0 :             PyErr_SetString(PyExc_ValueError, "embedded null character");
         212                 :          0 :             goto exit;
         213                 :            :         }
         214         [ +  + ]:       3122 :         if (!--noptargs) {
         215                 :       2554 :             goto skip_optional_pos;
         216                 :            :         }
         217                 :            :     }
         218         [ -  + ]:        568 :     if (!PyUnicode_Check(args[1])) {
         219                 :          0 :         _PyArg_BadArgument("encode", "argument 'errors'", "str", args[1]);
         220                 :          0 :         goto exit;
         221                 :            :     }
         222                 :            :     Py_ssize_t errors_length;
         223                 :        568 :     errors = PyUnicode_AsUTF8AndSize(args[1], &errors_length);
         224         [ -  + ]:        568 :     if (errors == NULL) {
         225                 :          0 :         goto exit;
         226                 :            :     }
         227         [ -  + ]:        568 :     if (strlen(errors) != (size_t)errors_length) {
         228                 :          0 :         PyErr_SetString(PyExc_ValueError, "embedded null character");
         229                 :          0 :         goto exit;
         230                 :            :     }
         231                 :        568 : skip_optional_pos:
         232                 :       3123 :     return_value = unicode_encode_impl(self, encoding, errors);
         233                 :            :
         234                 :       3123 : exit:
         235                 :       3123 :     return return_value;
         236                 :            : }
         237                 :            :
         238                 :            : PyDoc_STRVAR(unicode_expandtabs__doc__,
         239                 :            : "expandtabs($self, /, tabsize=8)\n"
         240                 :            : "--\n"
         241                 :            : "\n"
         242                 :            : "Return a copy where all tab characters are expanded using spaces.\n"
         243                 :            : "\n"
         244                 :            : "If tabsize is not given, a tab size of 8 characters is assumed.");
         245                 :            :
         246                 :            : #define UNICODE_EXPANDTABS_METHODDEF    \
         247                 :            :     {"expandtabs", _PyCFunction_CAST(unicode_expandtabs), METH_FASTCALL|METH_KEYWORDS, unicode_expandtabs__doc__},
         248                 :            :
         249                 :            : static PyObject *
         250                 :            : unicode_expandtabs_impl(PyObject *self, int tabsize);
         251                 :            :
         252                 :            : static PyObject *
         253                 :          1 : unicode_expandtabs(PyObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
         254                 :            : {
         255                 :          1 :     PyObject *return_value = NULL;
         256                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
         257                 :            :
         258                 :            :     #define NUM_KEYWORDS 1
         259                 :            :     static struct {
         260                 :            :         PyGC_Head _this_is_not_used;
         261                 :            :         PyObject_VAR_HEAD
         262                 :            :         PyObject *ob_item[NUM_KEYWORDS];
         263                 :            :     } _kwtuple = {
         264                 :            :         .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
         265                 :            :         .ob_item = { &_Py_ID(tabsize), },
         266                 :            :     };
         267                 :            :     #undef NUM_KEYWORDS
         268                 :            :     #define KWTUPLE (&_kwtuple.ob_base.ob_base)
         269                 :            :
         270                 :            :     #else  // !Py_BUILD_CORE
         271                 :            :     #  define KWTUPLE NULL
         272                 :            :     #endif  // !Py_BUILD_CORE
         273                 :            :
         274                 :            :     static const char * const _keywords[] = {"tabsize", NULL};
         275                 :            :     static _PyArg_Parser _parser = {
         276                 :            :         .keywords = _keywords,
         277                 :            :         .fname = "expandtabs",
         278                 :            :         .kwtuple = KWTUPLE,
         279                 :            :     };
         280                 :            :     #undef KWTUPLE
         281                 :            :     PyObject *argsbuf[1];
         282         [ -  + ]:          1 :     Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
         283                 :          1 :     int tabsize = 8;
         284                 :            :
         285   [ +  -  +  -  :          1 :     args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf);
                 +  -  -  + ]
         286         [ -  + ]:          1 :     if (!args) {
         287                 :          0 :         goto exit;
         288                 :            :     }
         289         [ +  - ]:          1 :     if (!noptargs) {
         290                 :          1 :         goto skip_optional_pos;
         291                 :            :     }
         292                 :          0 :     tabsize = _PyLong_AsInt(args[0]);
         293   [ #  #  #  # ]:          0 :     if (tabsize == -1 && PyErr_Occurred()) {
         294                 :          0 :         goto exit;
         295                 :            :     }
         296                 :          0 : skip_optional_pos:
         297                 :          1 :     return_value = unicode_expandtabs_impl(self, tabsize);
         298                 :            :
         299                 :          1 : exit:
         300                 :          1 :     return return_value;
         301                 :            : }
         302                 :            :
         303                 :            : PyDoc_STRVAR(unicode_isascii__doc__,
         304                 :            : "isascii($self, /)\n"
         305                 :            : "--\n"
         306                 :            : "\n"
         307                 :            : "Return True if all characters in the string are ASCII, False otherwise.\n"
         308                 :            : "\n"
         309                 :            : "ASCII characters have code points in the range U+0000-U+007F.\n"
         310                 :            : "Empty string is ASCII too.");
         311                 :            :
         312                 :            : #define UNICODE_ISASCII_METHODDEF    \
         313                 :            :     {"isascii", (PyCFunction)unicode_isascii, METH_NOARGS, unicode_isascii__doc__},
         314                 :            :
         315                 :            : static PyObject *
         316                 :            : unicode_isascii_impl(PyObject *self);
         317                 :            :
         318                 :            : static PyObject *
         319                 :        385 : unicode_isascii(PyObject *self, PyObject *Py_UNUSED(ignored))
         320                 :            : {
         321                 :        385 :     return unicode_isascii_impl(self);
         322                 :            : }
         323                 :            :
         324                 :            : PyDoc_STRVAR(unicode_islower__doc__,
         325                 :            : "islower($self, /)\n"
         326                 :            : "--\n"
         327                 :            : "\n"
         328                 :            : "Return True if the string is a lowercase string, False otherwise.\n"
         329                 :            : "\n"
         330                 :            : "A string is lowercase if all cased characters in the string are lowercase and\n"
         331                 :            : "there is at least one cased character in the string.");
         332                 :            :
         333                 :            : #define UNICODE_ISLOWER_METHODDEF    \
         334                 :            :     {"islower", (PyCFunction)unicode_islower, METH_NOARGS, unicode_islower__doc__},
         335                 :            :
         336                 :            : static PyObject *
         337                 :            : unicode_islower_impl(PyObject *self);
         338                 :            :
         339                 :            : static PyObject *
         340                 :          0 : unicode_islower(PyObject *self, PyObject *Py_UNUSED(ignored))
         341                 :            : {
         342                 :          0 :     return unicode_islower_impl(self);
         343                 :            : }
         344                 :            :
         345                 :            : PyDoc_STRVAR(unicode_isupper__doc__,
         346                 :            : "isupper($self, /)\n"
         347                 :            : "--\n"
         348                 :            : "\n"
         349                 :            : "Return True if the string is an uppercase string, False otherwise.\n"
         350                 :            : "\n"
         351                 :            : "A string is uppercase if all cased characters in the string are uppercase and\n"
         352                 :            : "there is at least one cased character in the string.");
         353                 :            :
         354                 :            : #define UNICODE_ISUPPER_METHODDEF    \
         355                 :            :     {"isupper", (PyCFunction)unicode_isupper, METH_NOARGS, unicode_isupper__doc__},
         356                 :            :
         357                 :            : static PyObject *
         358                 :            : unicode_isupper_impl(PyObject *self);
         359                 :            :
         360                 :            : static PyObject *
         361                 :       1844 : unicode_isupper(PyObject *self, PyObject *Py_UNUSED(ignored))
         362                 :            : {
         363                 :       1844 :     return unicode_isupper_impl(self);
         364                 :            : }
         365                 :            :
         366                 :            : PyDoc_STRVAR(unicode_istitle__doc__,
         367                 :            : "istitle($self, /)\n"
         368                 :            : "--\n"
         369                 :            : "\n"
         370                 :            : "Return True if the string is a title-cased string, False otherwise.\n"
         371                 :            : "\n"
         372                 :            : "In a title-cased string, upper- and title-case characters may only\n"
         373                 :            : "follow uncased characters and lowercase characters only cased ones.");
         374                 :            :
         375                 :            : #define UNICODE_ISTITLE_METHODDEF    \
         376                 :            :     {"istitle", (PyCFunction)unicode_istitle, METH_NOARGS, unicode_istitle__doc__},
         377                 :            :
         378                 :            : static PyObject *
         379                 :            : unicode_istitle_impl(PyObject *self);
         380                 :            :
         381                 :            : static PyObject *
         382                 :          0 : unicode_istitle(PyObject *self, PyObject *Py_UNUSED(ignored))
         383                 :            : {
         384                 :          0 :     return unicode_istitle_impl(self);
         385                 :            : }
         386                 :            :
         387                 :            : PyDoc_STRVAR(unicode_isspace__doc__,
         388                 :            : "isspace($self, /)\n"
         389                 :            : "--\n"
         390                 :            : "\n"
         391                 :            : "Return True if the string is a whitespace string, False otherwise.\n"
         392                 :            : "\n"
         393                 :            : "A string is whitespace if all characters in the string are whitespace and there\n"
         394                 :            : "is at least one character in the string.");
         395                 :            :
         396                 :            : #define UNICODE_ISSPACE_METHODDEF    \
         397                 :            :     {"isspace", (PyCFunction)unicode_isspace, METH_NOARGS, unicode_isspace__doc__},
         398                 :            :
         399                 :            : static PyObject *
         400                 :            : unicode_isspace_impl(PyObject *self);
         401                 :            :
         402                 :            : static PyObject *
         403                 :          1 : unicode_isspace(PyObject *self, PyObject *Py_UNUSED(ignored))
         404                 :            : {
         405                 :          1 :     return unicode_isspace_impl(self);
         406                 :            : }
         407                 :            :
         408                 :            : PyDoc_STRVAR(unicode_isalpha__doc__,
         409                 :            : "isalpha($self, /)\n"
         410                 :            : "--\n"
         411                 :            : "\n"
         412                 :            : "Return True if the string is an alphabetic string, False otherwise.\n"
         413                 :            : "\n"
         414                 :            : "A string is alphabetic if all characters in the string are alphabetic and there\n"
         415                 :            : "is at least one character in the string.");
         416                 :            :
         417                 :            : #define UNICODE_ISALPHA_METHODDEF    \
         418                 :            :     {"isalpha", (PyCFunction)unicode_isalpha, METH_NOARGS, unicode_isalpha__doc__},
         419                 :            :
         420                 :            : static PyObject *
         421                 :            : unicode_isalpha_impl(PyObject *self);
         422                 :            :
         423                 :            : static PyObject *
         424                 :          0 : unicode_isalpha(PyObject *self, PyObject *Py_UNUSED(ignored))
         425                 :            : {
         426                 :          0 :     return unicode_isalpha_impl(self);
         427                 :            : }
         428                 :            :
         429                 :            : PyDoc_STRVAR(unicode_isalnum__doc__,
         430                 :            : "isalnum($self, /)\n"
         431                 :            : "--\n"
         432                 :            : "\n"
         433                 :            : "Return True if the string is an alpha-numeric string, False otherwise.\n"
         434                 :            : "\n"
         435                 :            : "A string is alpha-numeric if all characters in the string are alpha-numeric and\n"
         436                 :            : "there is at least one character in the string.");
         437                 :            :
         438                 :            : #define UNICODE_ISALNUM_METHODDEF    \
         439                 :            :     {"isalnum", (PyCFunction)unicode_isalnum, METH_NOARGS, unicode_isalnum__doc__},
         440                 :            :
         441                 :            : static PyObject *
         442                 :            : unicode_isalnum_impl(PyObject *self);
         443                 :            :
         444                 :            : static PyObject *
         445                 :        432 : unicode_isalnum(PyObject *self, PyObject *Py_UNUSED(ignored))
         446                 :            : {
         447                 :        432 :     return unicode_isalnum_impl(self);
         448                 :            : }
         449                 :            :
         450                 :            : PyDoc_STRVAR(unicode_isdecimal__doc__,
         451                 :            : "isdecimal($self, /)\n"
         452                 :            : "--\n"
         453                 :            : "\n"
         454                 :            : "Return True if the string is a decimal string, False otherwise.\n"
         455                 :            : "\n"
         456                 :            : "A string is a decimal string if all characters in the string are decimal and\n"
         457                 :            : "there is at least one character in the string.");
         458                 :            :
         459                 :            : #define UNICODE_ISDECIMAL_METHODDEF    \
         460                 :            :     {"isdecimal", (PyCFunction)unicode_isdecimal, METH_NOARGS, unicode_isdecimal__doc__},
         461                 :            :
         462                 :            : static PyObject *
         463                 :            : unicode_isdecimal_impl(PyObject *self);
         464                 :            :
         465                 :            : static PyObject *
         466                 :          0 : unicode_isdecimal(PyObject *self, PyObject *Py_UNUSED(ignored))
         467                 :            : {
         468                 :          0 :     return unicode_isdecimal_impl(self);
         469                 :            : }
         470                 :            :
         471                 :            : PyDoc_STRVAR(unicode_isdigit__doc__,
         472                 :            : "isdigit($self, /)\n"
         473                 :            : "--\n"
         474                 :            : "\n"
         475                 :            : "Return True if the string is a digit string, False otherwise.\n"
         476                 :            : "\n"
         477                 :            : "A string is a digit string if all characters in the string are digits and there\n"
         478                 :            : "is at least one character in the string.");
         479                 :            :
         480                 :            : #define UNICODE_ISDIGIT_METHODDEF    \
         481                 :            :     {"isdigit", (PyCFunction)unicode_isdigit, METH_NOARGS, unicode_isdigit__doc__},
         482                 :            :
         483                 :            : static PyObject *
         484                 :            : unicode_isdigit_impl(PyObject *self);
         485                 :            :
         486                 :            : static PyObject *
         487                 :          0 : unicode_isdigit(PyObject *self, PyObject *Py_UNUSED(ignored))
         488                 :            : {
         489                 :          0 :     return unicode_isdigit_impl(self);
         490                 :            : }
         491                 :            :
         492                 :            : PyDoc_STRVAR(unicode_isnumeric__doc__,
         493                 :            : "isnumeric($self, /)\n"
         494                 :            : "--\n"
         495                 :            : "\n"
         496                 :            : "Return True if the string is a numeric string, False otherwise.\n"
         497                 :            : "\n"
         498                 :            : "A string is numeric if all characters in the string are numeric and there is at\n"
         499                 :            : "least one character in the string.");
         500                 :            :
         501                 :            : #define UNICODE_ISNUMERIC_METHODDEF    \
         502                 :            :     {"isnumeric", (PyCFunction)unicode_isnumeric, METH_NOARGS, unicode_isnumeric__doc__},
         503                 :            :
         504                 :            : static PyObject *
         505                 :            : unicode_isnumeric_impl(PyObject *self);
         506                 :            :
         507                 :            : static PyObject *
         508                 :          0 : unicode_isnumeric(PyObject *self, PyObject *Py_UNUSED(ignored))
         509                 :            : {
         510                 :          0 :     return unicode_isnumeric_impl(self);
         511                 :            : }
         512                 :            :
         513                 :            : PyDoc_STRVAR(unicode_isidentifier__doc__,
         514                 :            : "isidentifier($self, /)\n"
         515                 :            : "--\n"
         516                 :            : "\n"
         517                 :            : "Return True if the string is a valid Python identifier, False otherwise.\n"
         518                 :            : "\n"
         519                 :            : "Call keyword.iskeyword(s) to test whether string s is a reserved identifier,\n"
         520                 :            : "such as \"def\" or \"class\".");
         521                 :            :
         522                 :            : #define UNICODE_ISIDENTIFIER_METHODDEF    \
         523                 :            :     {"isidentifier", (PyCFunction)unicode_isidentifier, METH_NOARGS, unicode_isidentifier__doc__},
         524                 :            :
         525                 :            : static PyObject *
         526                 :            : unicode_isidentifier_impl(PyObject *self);
         527                 :            :
         528                 :            : static PyObject *
         529                 :        371 : unicode_isidentifier(PyObject *self, PyObject *Py_UNUSED(ignored))
         530                 :            : {
         531                 :        371 :     return unicode_isidentifier_impl(self);
         532                 :            : }
         533                 :            :
         534                 :            : PyDoc_STRVAR(unicode_isprintable__doc__,
         535                 :            : "isprintable($self, /)\n"
         536                 :            : "--\n"
         537                 :            : "\n"
         538                 :            : "Return True if the string is printable, False otherwise.\n"
         539                 :            : "\n"
         540                 :            : "A string is printable if all of its characters are considered printable in\n"
         541                 :            : "repr() or if it is empty.");
         542                 :            :
         543                 :            : #define UNICODE_ISPRINTABLE_METHODDEF    \
         544                 :            :     {"isprintable", (PyCFunction)unicode_isprintable, METH_NOARGS, unicode_isprintable__doc__},
         545                 :            :
         546                 :            : static PyObject *
         547                 :            : unicode_isprintable_impl(PyObject *self);
         548                 :            :
         549                 :            : static PyObject *
         550                 :          0 : unicode_isprintable(PyObject *self, PyObject *Py_UNUSED(ignored))
         551                 :            : {
         552                 :          0 :     return unicode_isprintable_impl(self);
         553                 :            : }
         554                 :            :
         555                 :            : PyDoc_STRVAR(unicode_join__doc__,
         556                 :            : "join($self, iterable, /)\n"
         557                 :            : "--\n"
         558                 :            : "\n"
         559                 :            : "Concatenate any number of strings.\n"
         560                 :            : "\n"
         561                 :            : "The string whose method is called is inserted in between each given string.\n"
         562                 :            : "The result is returned as a new string.\n"
         563                 :            : "\n"
         564                 :            : "Example: \'.\'.join([\'ab\', \'pq\', \'rs\']) -> \'ab.pq.rs\'");
         565                 :            :
         566                 :            : #define UNICODE_JOIN_METHODDEF    \
         567                 :            :     {"join", (PyCFunction)unicode_join, METH_O, unicode_join__doc__},
         568                 :            :
         569                 :            : PyDoc_STRVAR(unicode_ljust__doc__,
         570                 :            : "ljust($self, width, fillchar=\' \', /)\n"
         571                 :            : "--\n"
         572                 :            : "\n"
         573                 :            : "Return a left-justified string of length width.\n"
         574                 :            : "\n"
         575                 :            : "Padding is done using the specified fill character (default is a space).");
         576                 :            :
         577                 :            : #define UNICODE_LJUST_METHODDEF    \
         578                 :            :     {"ljust", _PyCFunction_CAST(unicode_ljust), METH_FASTCALL, unicode_ljust__doc__},
         579                 :            :
         580                 :            : static PyObject *
         581                 :            : unicode_ljust_impl(PyObject *self, Py_ssize_t width, Py_UCS4 fillchar);
         582                 :            :
         583                 :            : static PyObject *
         584                 :          0 : unicode_ljust(PyObject *self, PyObject *const *args, Py_ssize_t nargs)
         585                 :            : {
         586                 :          0 :     PyObject *return_value = NULL;
         587                 :            :     Py_ssize_t width;
         588                 :          0 :     Py_UCS4 fillchar = ' ';
         589                 :            :
         590   [ #  #  #  #  :          0 :     if (!_PyArg_CheckPositional("ljust", nargs, 1, 2)) {
                       #  # ]
         591                 :          0 :         goto exit;
         592                 :            :     }
         593                 :            :     {
         594                 :          0 :         Py_ssize_t ival = -1;
         595                 :          0 :         PyObject *iobj = _PyNumber_Index(args[0]);
         596         [ #  # ]:          0 :         if (iobj != NULL) {
         597                 :          0 :             ival = PyLong_AsSsize_t(iobj);
         598                 :          0 :             Py_DECREF(iobj);
         599                 :            :         }
         600   [ #  #  #  # ]:          0 :         if (ival == -1 && PyErr_Occurred()) {
         601                 :          0 :             goto exit;
         602                 :            :         }
         603                 :          0 :         width = ival;
         604                 :            :     }
         605         [ #  # ]:          0 :     if (nargs < 2) {
         606                 :          0 :         goto skip_optional;
         607                 :            :     }
         608         [ #  # ]:          0 :     if (!convert_uc(args[1], &fillchar)) {
         609                 :          0 :         goto exit;
         610                 :            :     }
         611                 :          0 : skip_optional:
         612                 :          0 :     return_value = unicode_ljust_impl(self, width, fillchar);
         613                 :            :
         614                 :          0 : exit:
         615                 :          0 :     return return_value;
         616                 :            : }
         617                 :            :
         618                 :            : PyDoc_STRVAR(unicode_lower__doc__,
         619                 :            : "lower($self, /)\n"
         620                 :            : "--\n"
         621                 :            : "\n"
         622                 :            : "Return a copy of the string converted to lowercase.");
         623                 :            :
         624                 :            : #define UNICODE_LOWER_METHODDEF    \
         625                 :            :     {"lower", (PyCFunction)unicode_lower, METH_NOARGS, unicode_lower__doc__},
         626                 :            :
         627                 :            : static PyObject *
         628                 :            : unicode_lower_impl(PyObject *self);
         629                 :            :
         630                 :            : static PyObject *
         631                 :        127 : unicode_lower(PyObject *self, PyObject *Py_UNUSED(ignored))
         632                 :            : {
         633                 :        127 :     return unicode_lower_impl(self);
         634                 :            : }
         635                 :            :
         636                 :            : PyDoc_STRVAR(unicode_strip__doc__,
         637                 :            : "strip($self, chars=None, /)\n"
         638                 :            : "--\n"
         639                 :            : "\n"
         640                 :            : "Return a copy of the string with leading and trailing whitespace removed.\n"
         641                 :            : "\n"
         642                 :            : "If chars is given and not None, remove characters in chars instead.");
         643                 :            :
         644                 :            : #define UNICODE_STRIP_METHODDEF    \
         645                 :            :     {"strip", _PyCFunction_CAST(unicode_strip), METH_FASTCALL, unicode_strip__doc__},
         646                 :            :
         647                 :            : static PyObject *
         648                 :            : unicode_strip_impl(PyObject *self, PyObject *chars);
         649                 :            :
         650                 :            : static PyObject *
         651                 :       7279 : unicode_strip(PyObject *self, PyObject *const *args, Py_ssize_t nargs)
         652                 :            : {
         653                 :       7279 :     PyObject *return_value = NULL;
         654                 :       7279 :     PyObject *chars = Py_None;
         655                 :            :
         656   [ +  -  -  +  :       7279 :     if (!_PyArg_CheckPositional("strip", nargs, 0, 1)) {
                       -  - ]
         657                 :          0 :         goto exit;
         658                 :            :     }
         659         [ +  - ]:       7279 :     if (nargs < 1) {
         660                 :       7279 :         goto skip_optional;
         661                 :            :     }
         662                 :          0 :     chars = args[0];
         663                 :       7279 : skip_optional:
         664                 :       7279 :     return_value = unicode_strip_impl(self, chars);
         665                 :            :
         666                 :       7279 : exit:
         667                 :       7279 :     return return_value;
         668                 :            : }
         669                 :            :
         670                 :            : PyDoc_STRVAR(unicode_lstrip__doc__,
         671                 :            : "lstrip($self, chars=None, /)\n"
         672                 :            : "--\n"
         673                 :            : "\n"
         674                 :            : "Return a copy of the string with leading whitespace removed.\n"
         675                 :            : "\n"
         676                 :            : "If chars is given and not None, remove characters in chars instead.");
         677                 :            :
         678                 :            : #define UNICODE_LSTRIP_METHODDEF    \
         679                 :            :     {"lstrip", _PyCFunction_CAST(unicode_lstrip), METH_FASTCALL, unicode_lstrip__doc__},
         680                 :            :
         681                 :            : static PyObject *
         682                 :            : unicode_lstrip_impl(PyObject *self, PyObject *chars);
         683                 :            :
         684                 :            : static PyObject *
         685                 :         82 : unicode_lstrip(PyObject *self, PyObject *const *args, Py_ssize_t nargs)
         686                 :            : {
         687                 :         82 :     PyObject *return_value = NULL;
         688                 :         82 :     PyObject *chars = Py_None;
         689                 :            :
         690   [ +  -  -  +  :         82 :     if (!_PyArg_CheckPositional("lstrip", nargs, 0, 1)) {
                       -  - ]
         691                 :          0 :         goto exit;
         692                 :            :     }
         693         [ +  + ]:         82 :     if (nargs < 1) {
         694                 :         19 :         goto skip_optional;
         695                 :            :     }
         696                 :         63 :     chars = args[0];
         697                 :         82 : skip_optional:
         698                 :         82 :     return_value = unicode_lstrip_impl(self, chars);
         699                 :            :
         700                 :         82 : exit:
         701                 :         82 :     return return_value;
         702                 :            : }
         703                 :            :
         704                 :            : PyDoc_STRVAR(unicode_rstrip__doc__,
         705                 :            : "rstrip($self, chars=None, /)\n"
         706                 :            : "--\n"
         707                 :            : "\n"
         708                 :            : "Return a copy of the string with trailing whitespace removed.\n"
         709                 :            : "\n"
         710                 :            : "If chars is given and not None, remove characters in chars instead.");
         711                 :            :
         712                 :            : #define UNICODE_RSTRIP_METHODDEF    \
         713                 :            :     {"rstrip", _PyCFunction_CAST(unicode_rstrip), METH_FASTCALL, unicode_rstrip__doc__},
         714                 :            :
         715                 :            : static PyObject *
         716                 :            : unicode_rstrip_impl(PyObject *self, PyObject *chars);
         717                 :            :
         718                 :            : static PyObject *
         719                 :      11340 : unicode_rstrip(PyObject *self, PyObject *const *args, Py_ssize_t nargs)
         720                 :            : {
         721                 :      11340 :     PyObject *return_value = NULL;
         722                 :      11340 :     PyObject *chars = Py_None;
         723                 :            :
         724   [ +  -  -  +  :      11340 :     if (!_PyArg_CheckPositional("rstrip", nargs, 0, 1)) {
                       -  - ]
         725                 :          0 :         goto exit;
         726                 :            :     }
         727         [ -  + ]:      11340 :     if (nargs < 1) {
         728                 :          0 :         goto skip_optional;
         729                 :            :     }
         730                 :      11340 :     chars = args[0];
         731                 :      11340 : skip_optional:
         732                 :      11340 :     return_value = unicode_rstrip_impl(self, chars);
         733                 :            :
         734                 :      11340 : exit:
         735                 :      11340 :     return return_value;
         736                 :            : }
         737                 :            :
         738                 :            : PyDoc_STRVAR(unicode_replace__doc__,
         739                 :            : "replace($self, old, new, count=-1, /)\n"
         740                 :            : "--\n"
         741                 :            : "\n"
         742                 :            : "Return a copy with all occurrences of substring old replaced by new.\n"
         743                 :            : "\n"
         744                 :            : "  count\n"
         745                 :            : "    Maximum number of occurrences to replace.\n"
         746                 :            : "    -1 (the default value) means replace all occurrences.\n"
         747                 :            : "\n"
         748                 :            : "If the optional argument count is given, only the first count occurrences are\n"
         749                 :            : "replaced.");
         750                 :            :
         751                 :            : #define UNICODE_REPLACE_METHODDEF    \
         752                 :            :     {"replace", _PyCFunction_CAST(unicode_replace), METH_FASTCALL, unicode_replace__doc__},
         753                 :            :
         754                 :            : static PyObject *
         755                 :            : unicode_replace_impl(PyObject *self, PyObject *old, PyObject *new,
         756                 :            :                      Py_ssize_t count);
         757                 :            :
         758                 :            : static PyObject *
         759                 :       5727 : unicode_replace(PyObject *self, PyObject *const *args, Py_ssize_t nargs)
         760                 :            : {
         761                 :       5727 :     PyObject *return_value = NULL;
         762                 :            :     PyObject *old;
         763                 :            :     PyObject *new;
         764                 :       5727 :     Py_ssize_t count = -1;
         765                 :            :
         766   [ +  -  -  +  :       5727 :     if (!_PyArg_CheckPositional("replace", nargs, 2, 3)) {
                       -  - ]
         767                 :          0 :         goto exit;
         768                 :            :     }
         769         [ -  + ]:       5727 :     if (!PyUnicode_Check(args[0])) {
         770                 :          0 :         _PyArg_BadArgument("replace", "argument 1", "str", args[0]);
         771                 :          0 :         goto exit;
         772                 :            :     }
         773         [ -  + ]:       5727 :     if (PyUnicode_READY(args[0]) == -1) {
         774                 :          0 :         goto exit;
         775                 :            :     }
         776                 :       5727 :     old = args[0];
         777         [ -  + ]:       5727 :     if (!PyUnicode_Check(args[1])) {
         778                 :          0 :         _PyArg_BadArgument("replace", "argument 2", "str", args[1]);
         779                 :          0 :         goto exit;
         780                 :            :     }
         781         [ -  + ]:       5727 :     if (PyUnicode_READY(args[1]) == -1) {
         782                 :          0 :         goto exit;
         783                 :            :     }
         784                 :       5727 :     new = args[1];
         785         [ +  - ]:       5727 :     if (nargs < 3) {
         786                 :       5727 :         goto skip_optional;
         787                 :            :     }
         788                 :            :     {
         789                 :          0 :         Py_ssize_t ival = -1;
         790                 :          0 :         PyObject *iobj = _PyNumber_Index(args[2]);
         791         [ #  # ]:          0 :         if (iobj != NULL) {
         792                 :          0 :             ival = PyLong_AsSsize_t(iobj);
         793                 :          0 :             Py_DECREF(iobj);
         794                 :            :         }
         795   [ #  #  #  # ]:          0 :         if (ival == -1 && PyErr_Occurred()) {
         796                 :          0 :             goto exit;
         797                 :            :         }
         798                 :          0 :         count = ival;
         799                 :            :     }
         800                 :       5727 : skip_optional:
         801                 :       5727 :     return_value = unicode_replace_impl(self, old, new, count);
         802                 :            :
         803                 :       5727 : exit:
         804                 :       5727 :     return return_value;
         805                 :            : }
         806                 :            :
         807                 :            : PyDoc_STRVAR(unicode_removeprefix__doc__,
         808                 :            : "removeprefix($self, prefix, /)\n"
         809                 :            : "--\n"
         810                 :            : "\n"
         811                 :            : "Return a str with the given prefix string removed if present.\n"
         812                 :            : "\n"
         813                 :            : "If the string starts with the prefix string, return string[len(prefix):].\n"
         814                 :            : "Otherwise, return a copy of the original string.");
         815                 :            :
         816                 :            : #define UNICODE_REMOVEPREFIX_METHODDEF    \
         817                 :            :     {"removeprefix", (PyCFunction)unicode_removeprefix, METH_O, unicode_removeprefix__doc__},
         818                 :            :
         819                 :            : static PyObject *
         820                 :            : unicode_removeprefix_impl(PyObject *self, PyObject *prefix);
         821                 :            :
         822                 :            : static PyObject *
         823                 :         80 : unicode_removeprefix(PyObject *self, PyObject *arg)
         824                 :            : {
         825                 :         80 :     PyObject *return_value = NULL;
         826                 :            :     PyObject *prefix;
         827                 :            :
         828         [ -  + ]:         80 :     if (!PyUnicode_Check(arg)) {
         829                 :          0 :         _PyArg_BadArgument("removeprefix", "argument", "str", arg);
         830                 :          0 :         goto exit;
         831                 :            :     }
         832         [ -  + ]:         80 :     if (PyUnicode_READY(arg) == -1) {
         833                 :          0 :         goto exit;
         834                 :            :     }
         835                 :         80 :     prefix = arg;
         836                 :         80 :     return_value = unicode_removeprefix_impl(self, prefix);
         837                 :            :
         838                 :         80 : exit:
         839                 :         80 :     return return_value;
         840                 :            : }
         841                 :            :
         842                 :            : PyDoc_STRVAR(unicode_removesuffix__doc__,
         843                 :            : "removesuffix($self, suffix, /)\n"
         844                 :            : "--\n"
         845                 :            : "\n"
         846                 :            : "Return a str with the given suffix string removed if present.\n"
         847                 :            : "\n"
         848                 :            : "If the string ends with the suffix string and that suffix is not empty,\n"
         849                 :            : "return string[:-len(suffix)]. Otherwise, return a copy of the original\n"
         850                 :            : "string.");
         851                 :            :
         852                 :            : #define UNICODE_REMOVESUFFIX_METHODDEF    \
         853                 :            :     {"removesuffix", (PyCFunction)unicode_removesuffix, METH_O, unicode_removesuffix__doc__},
         854                 :            :
         855                 :            : static PyObject *
         856                 :            : unicode_removesuffix_impl(PyObject *self, PyObject *suffix);
         857                 :            :
         858                 :            : static PyObject *
         859                 :          0 : unicode_removesuffix(PyObject *self, PyObject *arg)
         860                 :            : {
         861                 :          0 :     PyObject *return_value = NULL;
         862                 :            :     PyObject *suffix;
         863                 :            :
         864         [ #  # ]:          0 :     if (!PyUnicode_Check(arg)) {
         865                 :          0 :         _PyArg_BadArgument("removesuffix", "argument", "str", arg);
         866                 :          0 :         goto exit;
         867                 :            :     }
         868         [ #  # ]:          0 :     if (PyUnicode_READY(arg) == -1) {
         869                 :          0 :         goto exit;
         870                 :            :     }
         871                 :          0 :     suffix = arg;
         872                 :          0 :     return_value = unicode_removesuffix_impl(self, suffix);
         873                 :            :
         874                 :          0 : exit:
         875                 :          0 :     return return_value;
         876                 :            : }
         877                 :            :
         878                 :            : PyDoc_STRVAR(unicode_rjust__doc__,
         879                 :            : "rjust($self, width, fillchar=\' \', /)\n"
         880                 :            : "--\n"
         881                 :            : "\n"
         882                 :            : "Return a right-justified string of length width.\n"
         883                 :            : "\n"
         884                 :            : "Padding is done using the specified fill character (default is a space).");
         885                 :            :
         886                 :            : #define UNICODE_RJUST_METHODDEF    \
         887                 :            :     {"rjust", _PyCFunction_CAST(unicode_rjust), METH_FASTCALL, unicode_rjust__doc__},
         888                 :            :
         889                 :            : static PyObject *
         890                 :            : unicode_rjust_impl(PyObject *self, Py_ssize_t width, Py_UCS4 fillchar);
         891                 :            :
         892                 :            : static PyObject *
         893                 :          0 : unicode_rjust(PyObject *self, PyObject *const *args, Py_ssize_t nargs)
         894                 :            : {
         895                 :          0 :     PyObject *return_value = NULL;
         896                 :            :     Py_ssize_t width;
         897                 :          0 :     Py_UCS4 fillchar = ' ';
         898                 :            :
         899   [ #  #  #  #  :          0 :     if (!_PyArg_CheckPositional("rjust", nargs, 1, 2)) {
                       #  # ]
         900                 :          0 :         goto exit;
         901                 :            :     }
         902                 :            :     {
         903                 :          0 :         Py_ssize_t ival = -1;
         904                 :          0 :         PyObject *iobj = _PyNumber_Index(args[0]);
         905         [ #  # ]:          0 :         if (iobj != NULL) {
         906                 :          0 :             ival = PyLong_AsSsize_t(iobj);
         907                 :          0 :             Py_DECREF(iobj);
         908                 :            :         }
         909   [ #  #  #  # ]:          0 :         if (ival == -1 && PyErr_Occurred()) {
         910                 :          0 :             goto exit;
         911                 :            :         }
         912                 :          0 :         width = ival;
         913                 :            :     }
         914         [ #  # ]:          0 :     if (nargs < 2) {
         915                 :          0 :         goto skip_optional;
         916                 :            :     }
         917         [ #  # ]:          0 :     if (!convert_uc(args[1], &fillchar)) {
         918                 :          0 :         goto exit;
         919                 :            :     }
         920                 :          0 : skip_optional:
         921                 :          0 :     return_value = unicode_rjust_impl(self, width, fillchar);
         922                 :            :
         923                 :          0 : exit:
         924                 :          0 :     return return_value;
         925                 :            : }
         926                 :            :
         927                 :            : PyDoc_STRVAR(unicode_split__doc__,
         928                 :            : "split($self, /, sep=None, maxsplit=-1)\n"
         929                 :            : "--\n"
         930                 :            : "\n"
         931                 :            : "Return a list of the substrings in the string, using sep as the separator string.\n"
         932                 :            : "\n"
         933                 :            : "  sep\n"
         934                 :            : "    The separator used to split the string.\n"
         935                 :            : "\n"
         936                 :            : "    When set to None (the default value), will split on any whitespace\n"
         937                 :            : "    character (including \\\\n \\\\r \\\\t \\\\f and spaces) and will discard\n"
         938                 :            : "    empty strings from the result.\n"
         939                 :            : "  maxsplit\n"
         940                 :            : "    Maximum number of splits (starting from the left).\n"
         941                 :            : "    -1 (the default value) means no limit.\n"
         942                 :            : "\n"
         943                 :            : "Note, str.split() is mainly useful for data that has been intentionally\n"
         944                 :            : "delimited.  With natural text that includes punctuation, consider using\n"
         945                 :            : "the regular expression module.");
         946                 :            :
         947                 :            : #define UNICODE_SPLIT_METHODDEF    \
         948                 :            :     {"split", _PyCFunction_CAST(unicode_split), METH_FASTCALL|METH_KEYWORDS, unicode_split__doc__},
         949                 :            :
         950                 :            : static PyObject *
         951                 :            : unicode_split_impl(PyObject *self, PyObject *sep, Py_ssize_t maxsplit);
         952                 :            :
         953                 :            : static PyObject *
         954                 :       8074 : unicode_split(PyObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
         955                 :            : {
         956                 :       8074 :     PyObject *return_value = NULL;
         957                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
         958                 :            :
         959                 :            :     #define NUM_KEYWORDS 2
         960                 :            :     static struct {
         961                 :            :         PyGC_Head _this_is_not_used;
         962                 :            :         PyObject_VAR_HEAD
         963                 :            :         PyObject *ob_item[NUM_KEYWORDS];
         964                 :            :     } _kwtuple = {
         965                 :            :         .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
         966                 :            :         .ob_item = { &_Py_ID(sep), &_Py_ID(maxsplit), },
         967                 :            :     };
         968                 :            :     #undef NUM_KEYWORDS
         969                 :            :     #define KWTUPLE (&_kwtuple.ob_base.ob_base)
         970                 :            :
         971                 :            :     #else  // !Py_BUILD_CORE
         972                 :            :     #  define KWTUPLE NULL
         973                 :            :     #endif  // !Py_BUILD_CORE
         974                 :            :
         975                 :            :     static const char * const _keywords[] = {"sep", "maxsplit", NULL};
         976                 :            :     static _PyArg_Parser _parser = {
         977                 :            :         .keywords = _keywords,
         978                 :            :         .fname = "split",
         979                 :            :         .kwtuple = KWTUPLE,
         980                 :            :     };
         981                 :            :     #undef KWTUPLE
         982                 :            :     PyObject *argsbuf[2];
         983         [ +  + ]:       8074 :     Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
         984                 :       8074 :     PyObject *sep = Py_None;
         985                 :       8074 :     Py_ssize_t maxsplit = -1;
         986                 :            :
         987   [ +  +  +  -  :       8074 :     args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 2, 0, argsbuf);
                 +  -  -  + ]
         988         [ -  + ]:       8074 :     if (!args) {
         989                 :          0 :         goto exit;
         990                 :            :     }
         991         [ +  + ]:       8074 :     if (!noptargs) {
         992                 :       5257 :         goto skip_optional_pos;
         993                 :            :     }
         994         [ +  + ]:       2817 :     if (args[0]) {
         995                 :       2816 :         sep = args[0];
         996         [ +  - ]:       2816 :         if (!--noptargs) {
         997                 :       2816 :             goto skip_optional_pos;
         998                 :            :         }
         999                 :            :     }
        1000                 :            :     {
        1001                 :          1 :         Py_ssize_t ival = -1;
        1002                 :          1 :         PyObject *iobj = _PyNumber_Index(args[1]);
        1003         [ +  - ]:          1 :         if (iobj != NULL) {
        1004                 :          1 :             ival = PyLong_AsSsize_t(iobj);
        1005                 :          1 :             Py_DECREF(iobj);
        1006                 :            :         }
        1007   [ -  +  -  - ]:          1 :         if (ival == -1 && PyErr_Occurred()) {
        1008                 :          0 :             goto exit;
        1009                 :            :         }
        1010                 :          1 :         maxsplit = ival;
        1011                 :            :     }
        1012                 :       8074 : skip_optional_pos:
        1013                 :       8074 :     return_value = unicode_split_impl(self, sep, maxsplit);
        1014                 :            :
        1015                 :       8074 : exit:
        1016                 :       8074 :     return return_value;
        1017                 :            : }
        1018                 :            :
        1019                 :            : PyDoc_STRVAR(unicode_partition__doc__,
        1020                 :            : "partition($self, sep, /)\n"
        1021                 :            : "--\n"
        1022                 :            : "\n"
        1023                 :            : "Partition the string into three parts using the given separator.\n"
        1024                 :            : "\n"
        1025                 :            : "This will search for the separator in the string.  If the separator is found,\n"
        1026                 :            : "returns a 3-tuple containing the part before the separator, the separator\n"
        1027                 :            : "itself, and the part after it.\n"
        1028                 :            : "\n"
        1029                 :            : "If the separator is not found, returns a 3-tuple containing the original string\n"
        1030                 :            : "and two empty strings.");
        1031                 :            :
        1032                 :            : #define UNICODE_PARTITION_METHODDEF    \
        1033                 :            :     {"partition", (PyCFunction)unicode_partition, METH_O, unicode_partition__doc__},
        1034                 :            :
        1035                 :            : PyDoc_STRVAR(unicode_rpartition__doc__,
        1036                 :            : "rpartition($self, sep, /)\n"
        1037                 :            : "--\n"
        1038                 :            : "\n"
        1039                 :            : "Partition the string into three parts using the given separator.\n"
        1040                 :            : "\n"
        1041                 :            : "This will search for the separator in the string, starting at the end. If\n"
        1042                 :            : "the separator is found, returns a 3-tuple containing the part before the\n"
        1043                 :            : "separator, the separator itself, and the part after it.\n"
        1044                 :            : "\n"
        1045                 :            : "If the separator is not found, returns a 3-tuple containing two empty strings\n"
        1046                 :            : "and the original string.");
        1047                 :            :
        1048                 :            : #define UNICODE_RPARTITION_METHODDEF    \
        1049                 :            :     {"rpartition", (PyCFunction)unicode_rpartition, METH_O, unicode_rpartition__doc__},
        1050                 :            :
        1051                 :            : PyDoc_STRVAR(unicode_rsplit__doc__,
        1052                 :            : "rsplit($self, /, sep=None, maxsplit=-1)\n"
        1053                 :            : "--\n"
        1054                 :            : "\n"
        1055                 :            : "Return a list of the substrings in the string, using sep as the separator string.\n"
        1056                 :            : "\n"
        1057                 :            : "  sep\n"
        1058                 :            : "    The separator used to split the string.\n"
        1059                 :            : "\n"
        1060                 :            : "    When set to None (the default value), will split on any whitespace\n"
        1061                 :            : "    character (including \\\\n \\\\r \\\\t \\\\f and spaces) and will discard\n"
        1062                 :            : "    empty strings from the result.\n"
        1063                 :            : "  maxsplit\n"
        1064                 :            : "    Maximum number of splits (starting from the left).\n"
        1065                 :            : "    -1 (the default value) means no limit.\n"
        1066                 :            : "\n"
        1067                 :            : "Splitting starts at the end of the string and works to the front.");
        1068                 :            :
        1069                 :            : #define UNICODE_RSPLIT_METHODDEF    \
        1070                 :            :     {"rsplit", _PyCFunction_CAST(unicode_rsplit), METH_FASTCALL|METH_KEYWORDS, unicode_rsplit__doc__},
        1071                 :            :
        1072                 :            : static PyObject *
        1073                 :            : unicode_rsplit_impl(PyObject *self, PyObject *sep, Py_ssize_t maxsplit);
        1074                 :            :
        1075                 :            : static PyObject *
        1076                 :         23 : unicode_rsplit(PyObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
        1077                 :            : {
        1078                 :         23 :     PyObject *return_value = NULL;
        1079                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
        1080                 :            :
        1081                 :            :     #define NUM_KEYWORDS 2
        1082                 :            :     static struct {
        1083                 :            :         PyGC_Head _this_is_not_used;
        1084                 :            :         PyObject_VAR_HEAD
        1085                 :            :         PyObject *ob_item[NUM_KEYWORDS];
        1086                 :            :     } _kwtuple = {
        1087                 :            :         .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
        1088                 :            :         .ob_item = { &_Py_ID(sep), &_Py_ID(maxsplit), },
        1089                 :            :     };
        1090                 :            :     #undef NUM_KEYWORDS
        1091                 :            :     #define KWTUPLE (&_kwtuple.ob_base.ob_base)
        1092                 :            :
        1093                 :            :     #else  // !Py_BUILD_CORE
        1094                 :            :     #  define KWTUPLE NULL
        1095                 :            :     #endif  // !Py_BUILD_CORE
        1096                 :            :
        1097                 :            :     static const char * const _keywords[] = {"sep", "maxsplit", NULL};
        1098                 :            :     static _PyArg_Parser _parser = {
        1099                 :            :         .keywords = _keywords,
        1100                 :            :         .fname = "rsplit",
        1101                 :            :         .kwtuple = KWTUPLE,
        1102                 :            :     };
        1103                 :            :     #undef KWTUPLE
        1104                 :            :     PyObject *argsbuf[2];
        1105         [ -  + ]:         23 :     Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
        1106                 :         23 :     PyObject *sep = Py_None;
        1107                 :         23 :     Py_ssize_t maxsplit = -1;
        1108                 :            :
        1109   [ +  -  +  -  :         23 :     args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 2, 0, argsbuf);
                 +  -  -  + ]
        1110         [ -  + ]:         23 :     if (!args) {
        1111                 :          0 :         goto exit;
        1112                 :            :     }
        1113         [ -  + ]:         23 :     if (!noptargs) {
        1114                 :          0 :         goto skip_optional_pos;
        1115                 :            :     }
        1116         [ +  - ]:         23 :     if (args[0]) {
        1117                 :         23 :         sep = args[0];
        1118         [ -  + ]:         23 :         if (!--noptargs) {
        1119                 :          0 :             goto skip_optional_pos;
        1120                 :            :         }
        1121                 :            :     }
        1122                 :            :     {
        1123                 :         23 :         Py_ssize_t ival = -1;
        1124                 :         23 :         PyObject *iobj = _PyNumber_Index(args[1]);
        1125         [ +  - ]:         23 :         if (iobj != NULL) {
        1126                 :         23 :             ival = PyLong_AsSsize_t(iobj);
        1127                 :         23 :             Py_DECREF(iobj);
        1128                 :            :         }
        1129   [ -  +  -  - ]:         23 :         if (ival == -1 && PyErr_Occurred()) {
        1130                 :          0 :             goto exit;
        1131                 :            :         }
        1132                 :         23 :         maxsplit = ival;
        1133                 :            :     }
        1134                 :         23 : skip_optional_pos:
        1135                 :         23 :     return_value = unicode_rsplit_impl(self, sep, maxsplit);
        1136                 :            :
        1137                 :         23 : exit:
        1138                 :         23 :     return return_value;
        1139                 :            : }
        1140                 :            :
        1141                 :            : PyDoc_STRVAR(unicode_splitlines__doc__,
        1142                 :            : "splitlines($self, /, keepends=False)\n"
        1143                 :            : "--\n"
        1144                 :            : "\n"
        1145                 :            : "Return a list of the lines in the string, breaking at line boundaries.\n"
        1146                 :            : "\n"
        1147                 :            : "Line breaks are not included in the resulting list unless keepends is given and\n"
        1148                 :            : "true.");
        1149                 :            :
        1150                 :            : #define UNICODE_SPLITLINES_METHODDEF    \
        1151                 :            :     {"splitlines", _PyCFunction_CAST(unicode_splitlines), METH_FASTCALL|METH_KEYWORDS, unicode_splitlines__doc__},
        1152                 :            :
        1153                 :            : static PyObject *
        1154                 :            : unicode_splitlines_impl(PyObject *self, int keepends);
        1155                 :            :
        1156                 :            : static PyObject *
        1157                 :        108 : unicode_splitlines(PyObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
        1158                 :            : {
        1159                 :        108 :     PyObject *return_value = NULL;
        1160                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
        1161                 :            :
        1162                 :            :     #define NUM_KEYWORDS 1
        1163                 :            :     static struct {
        1164                 :            :         PyGC_Head _this_is_not_used;
        1165                 :            :         PyObject_VAR_HEAD
        1166                 :            :         PyObject *ob_item[NUM_KEYWORDS];
        1167                 :            :     } _kwtuple = {
        1168                 :            :         .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
        1169                 :            :         .ob_item = { &_Py_ID(keepends), },
        1170                 :            :     };
        1171                 :            :     #undef NUM_KEYWORDS
        1172                 :            :     #define KWTUPLE (&_kwtuple.ob_base.ob_base)
        1173                 :            :
        1174                 :            :     #else  // !Py_BUILD_CORE
        1175                 :            :     #  define KWTUPLE NULL
        1176                 :            :     #endif  // !Py_BUILD_CORE
        1177                 :            :
        1178                 :            :     static const char * const _keywords[] = {"keepends", NULL};
        1179                 :            :     static _PyArg_Parser _parser = {
        1180                 :            :         .keywords = _keywords,
        1181                 :            :         .fname = "splitlines",
        1182                 :            :         .kwtuple = KWTUPLE,
        1183                 :            :     };
        1184                 :            :     #undef KWTUPLE
        1185                 :            :     PyObject *argsbuf[1];
        1186         [ +  + ]:        108 :     Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
        1187                 :        108 :     int keepends = 0;
        1188                 :            :
        1189   [ +  +  +  -  :        108 :     args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf);
                 +  -  -  + ]
        1190         [ -  + ]:        108 :     if (!args) {
        1191                 :          0 :         goto exit;
        1192                 :            :     }
        1193         [ +  + ]:        108 :     if (!noptargs) {
        1194                 :         23 :         goto skip_optional_pos;
        1195                 :            :     }
        1196                 :         85 :     keepends = PyObject_IsTrue(args[0]);
        1197         [ -  + ]:         85 :     if (keepends < 0) {
        1198                 :          0 :         goto exit;
        1199                 :            :     }
        1200                 :         85 : skip_optional_pos:
        1201                 :        108 :     return_value = unicode_splitlines_impl(self, keepends);
        1202                 :            :
        1203                 :        108 : exit:
        1204                 :        108 :     return return_value;
        1205                 :            : }
        1206                 :            :
        1207                 :            : PyDoc_STRVAR(unicode_swapcase__doc__,
        1208                 :            : "swapcase($self, /)\n"
        1209                 :            : "--\n"
        1210                 :            : "\n"
        1211                 :            : "Convert uppercase characters to lowercase and lowercase characters to uppercase.");
        1212                 :            :
        1213                 :            : #define UNICODE_SWAPCASE_METHODDEF    \
        1214                 :            :     {"swapcase", (PyCFunction)unicode_swapcase, METH_NOARGS, unicode_swapcase__doc__},
        1215                 :            :
        1216                 :            : static PyObject *
        1217                 :            : unicode_swapcase_impl(PyObject *self);
        1218                 :            :
        1219                 :            : static PyObject *
        1220                 :          0 : unicode_swapcase(PyObject *self, PyObject *Py_UNUSED(ignored))
        1221                 :            : {
        1222                 :          0 :     return unicode_swapcase_impl(self);
        1223                 :            : }
        1224                 :            :
        1225                 :            : PyDoc_STRVAR(unicode_maketrans__doc__,
        1226                 :            : "maketrans(x, y=<unrepresentable>, z=<unrepresentable>, /)\n"
        1227                 :            : "--\n"
        1228                 :            : "\n"
        1229                 :            : "Return a translation table usable for str.translate().\n"
        1230                 :            : "\n"
        1231                 :            : "If there is only one argument, it must be a dictionary mapping Unicode\n"
        1232                 :            : "ordinals (integers) or characters to Unicode ordinals, strings or None.\n"
        1233                 :            : "Character keys will be then converted to ordinals.\n"
        1234                 :            : "If there are two arguments, they must be strings of equal length, and\n"
        1235                 :            : "in the resulting dictionary, each character in x will be mapped to the\n"
        1236                 :            : "character at the same position in y. If there is a third argument, it\n"
        1237                 :            : "must be a string, whose characters will be mapped to None in the result.");
        1238                 :            :
        1239                 :            : #define UNICODE_MAKETRANS_METHODDEF    \
        1240                 :            :     {"maketrans", _PyCFunction_CAST(unicode_maketrans), METH_FASTCALL|METH_STATIC, unicode_maketrans__doc__},
        1241                 :            :
        1242                 :            : static PyObject *
        1243                 :            : unicode_maketrans_impl(PyObject *x, PyObject *y, PyObject *z);
        1244                 :            :
        1245                 :            : static PyObject *
        1246                 :          0 : unicode_maketrans(void *null, PyObject *const *args, Py_ssize_t nargs)
        1247                 :            : {
        1248                 :          0 :     PyObject *return_value = NULL;
        1249                 :            :     PyObject *x;
        1250                 :          0 :     PyObject *y = NULL;
        1251                 :          0 :     PyObject *z = NULL;
        1252                 :            :
        1253   [ #  #  #  #  :          0 :     if (!_PyArg_CheckPositional("maketrans", nargs, 1, 3)) {
                       #  # ]
        1254                 :          0 :         goto exit;
        1255                 :            :     }
        1256                 :          0 :     x = args[0];
        1257         [ #  # ]:          0 :     if (nargs < 2) {
        1258                 :          0 :         goto skip_optional;
        1259                 :            :     }
        1260         [ #  # ]:          0 :     if (!PyUnicode_Check(args[1])) {
        1261                 :          0 :         _PyArg_BadArgument("maketrans", "argument 2", "str", args[1]);
        1262                 :          0 :         goto exit;
        1263                 :            :     }
        1264         [ #  # ]:          0 :     if (PyUnicode_READY(args[1]) == -1) {
        1265                 :          0 :         goto exit;
        1266                 :            :     }
        1267                 :          0 :     y = args[1];
        1268         [ #  # ]:          0 :     if (nargs < 3) {
        1269                 :          0 :         goto skip_optional;
        1270                 :            :     }
        1271         [ #  # ]:          0 :     if (!PyUnicode_Check(args[2])) {
        1272                 :          0 :         _PyArg_BadArgument("maketrans", "argument 3", "str", args[2]);
        1273                 :          0 :         goto exit;
        1274                 :            :     }
        1275         [ #  # ]:          0 :     if (PyUnicode_READY(args[2]) == -1) {
        1276                 :          0 :         goto exit;
        1277                 :            :     }
        1278                 :          0 :     z = args[2];
        1279                 :          0 : skip_optional:
        1280                 :          0 :     return_value = unicode_maketrans_impl(x, y, z);
        1281                 :            :
        1282                 :          0 : exit:
        1283                 :          0 :     return return_value;
        1284                 :            : }
        1285                 :            :
        1286                 :            : PyDoc_STRVAR(unicode_translate__doc__,
        1287                 :            : "translate($self, table, /)\n"
        1288                 :            : "--\n"
        1289                 :            : "\n"
        1290                 :            : "Replace each character in the string using the given translation table.\n"
        1291                 :            : "\n"
        1292                 :            : "  table\n"
        1293                 :            : "    Translation table, which must be a mapping of Unicode ordinals to\n"
        1294                 :            : "    Unicode ordinals, strings, or None.\n"
        1295                 :            : "\n"
        1296                 :            : "The table must implement lookup/indexing via __getitem__, for instance a\n"
        1297                 :            : "dictionary or list.  If this operation raises LookupError, the character is\n"
        1298                 :            : "left untouched.  Characters mapped to None are deleted.");
        1299                 :            :
        1300                 :            : #define UNICODE_TRANSLATE_METHODDEF    \
        1301                 :            :     {"translate", (PyCFunction)unicode_translate, METH_O, unicode_translate__doc__},
        1302                 :            :
        1303                 :            : PyDoc_STRVAR(unicode_upper__doc__,
        1304                 :            : "upper($self, /)\n"
        1305                 :            : "--\n"
        1306                 :            : "\n"
        1307                 :            : "Return a copy of the string converted to uppercase.");
        1308                 :            :
        1309                 :            : #define UNICODE_UPPER_METHODDEF    \
        1310                 :            :     {"upper", (PyCFunction)unicode_upper, METH_NOARGS, unicode_upper__doc__},
        1311                 :            :
        1312                 :            : static PyObject *
        1313                 :            : unicode_upper_impl(PyObject *self);
        1314                 :            :
        1315                 :            : static PyObject *
        1316                 :        108 : unicode_upper(PyObject *self, PyObject *Py_UNUSED(ignored))
        1317                 :            : {
        1318                 :        108 :     return unicode_upper_impl(self);
        1319                 :            : }
        1320                 :            :
        1321                 :            : PyDoc_STRVAR(unicode_zfill__doc__,
        1322                 :            : "zfill($self, width, /)\n"
        1323                 :            : "--\n"
        1324                 :            : "\n"
        1325                 :            : "Pad a numeric string with zeros on the left, to fill a field of the given width.\n"
        1326                 :            : "\n"
        1327                 :            : "The string is never truncated.");
        1328                 :            :
        1329                 :            : #define UNICODE_ZFILL_METHODDEF    \
        1330                 :            :     {"zfill", (PyCFunction)unicode_zfill, METH_O, unicode_zfill__doc__},
        1331                 :            :
        1332                 :            : static PyObject *
        1333                 :            : unicode_zfill_impl(PyObject *self, Py_ssize_t width);
        1334                 :            :
        1335                 :            : static PyObject *
        1336                 :          0 : unicode_zfill(PyObject *self, PyObject *arg)
        1337                 :            : {
        1338                 :          0 :     PyObject *return_value = NULL;
        1339                 :            :     Py_ssize_t width;
        1340                 :            :
        1341                 :            :     {
        1342                 :          0 :         Py_ssize_t ival = -1;
        1343                 :          0 :         PyObject *iobj = _PyNumber_Index(arg);
        1344         [ #  # ]:          0 :         if (iobj != NULL) {
        1345                 :          0 :             ival = PyLong_AsSsize_t(iobj);
        1346                 :          0 :             Py_DECREF(iobj);
        1347                 :            :         }
        1348   [ #  #  #  # ]:          0 :         if (ival == -1 && PyErr_Occurred()) {
        1349                 :          0 :             goto exit;
        1350                 :            :         }
        1351                 :          0 :         width = ival;
        1352                 :            :     }
        1353                 :          0 :     return_value = unicode_zfill_impl(self, width);
        1354                 :            :
        1355                 :          0 : exit:
        1356                 :          0 :     return return_value;
        1357                 :            : }
        1358                 :            :
        1359                 :            : PyDoc_STRVAR(unicode___format____doc__,
        1360                 :            : "__format__($self, format_spec, /)\n"
        1361                 :            : "--\n"
        1362                 :            : "\n"
        1363                 :            : "Return a formatted version of the string as described by format_spec.");
        1364                 :            :
        1365                 :            : #define UNICODE___FORMAT___METHODDEF    \
        1366                 :            :     {"__format__", (PyCFunction)unicode___format__, METH_O, unicode___format____doc__},
        1367                 :            :
        1368                 :            : static PyObject *
        1369                 :            : unicode___format___impl(PyObject *self, PyObject *format_spec);
        1370                 :            :
        1371                 :            : static PyObject *
        1372                 :          0 : unicode___format__(PyObject *self, PyObject *arg)
        1373                 :            : {
        1374                 :          0 :     PyObject *return_value = NULL;
        1375                 :            :     PyObject *format_spec;
        1376                 :            :
        1377         [ #  # ]:          0 :     if (!PyUnicode_Check(arg)) {
        1378                 :          0 :         _PyArg_BadArgument("__format__", "argument", "str", arg);
        1379                 :          0 :         goto exit;
        1380                 :            :     }
        1381         [ #  # ]:          0 :     if (PyUnicode_READY(arg) == -1) {
        1382                 :          0 :         goto exit;
        1383                 :            :     }
        1384                 :          0 :     format_spec = arg;
        1385                 :          0 :     return_value = unicode___format___impl(self, format_spec);
        1386                 :            :
        1387                 :          0 : exit:
        1388                 :          0 :     return return_value;
        1389                 :            : }
        1390                 :            :
        1391                 :            : PyDoc_STRVAR(unicode_sizeof__doc__,
        1392                 :            : "__sizeof__($self, /)\n"
        1393                 :            : "--\n"
        1394                 :            : "\n"
        1395                 :            : "Return the size of the string in memory, in bytes.");
        1396                 :            :
        1397                 :            : #define UNICODE_SIZEOF_METHODDEF    \
        1398                 :            :     {"__sizeof__", (PyCFunction)unicode_sizeof, METH_NOARGS, unicode_sizeof__doc__},
        1399                 :            :
        1400                 :            : static PyObject *
        1401                 :            : unicode_sizeof_impl(PyObject *self);
        1402                 :            :
        1403                 :            : static PyObject *
        1404                 :          0 : unicode_sizeof(PyObject *self, PyObject *Py_UNUSED(ignored))
        1405                 :            : {
        1406                 :          0 :     return unicode_sizeof_impl(self);
        1407                 :            : }
        1408                 :            :
        1409                 :            : static PyObject *
        1410                 :            : unicode_new_impl(PyTypeObject *type, PyObject *x, const char *encoding,
        1411                 :            :                  const char *errors);
        1412                 :            :
        1413                 :            : static PyObject *
        1414                 :       2168 : unicode_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
        1415                 :            : {
        1416                 :       2168 :     PyObject *return_value = NULL;
        1417                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
        1418                 :            :
        1419                 :            :     #define NUM_KEYWORDS 3
        1420                 :            :     static struct {
        1421                 :            :         PyGC_Head _this_is_not_used;
        1422                 :            :         PyObject_VAR_HEAD
        1423                 :            :         PyObject *ob_item[NUM_KEYWORDS];
        1424                 :            :     } _kwtuple = {
        1425                 :            :         .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
        1426                 :            :         .ob_item = { &_Py_ID(object), &_Py_ID(encoding), &_Py_ID(errors), },
        1427                 :            :     };
        1428                 :            :     #undef NUM_KEYWORDS
        1429                 :            :     #define KWTUPLE (&_kwtuple.ob_base.ob_base)
        1430                 :            :
        1431                 :            :     #else  // !Py_BUILD_CORE
        1432                 :            :     #  define KWTUPLE NULL
        1433                 :            :     #endif  // !Py_BUILD_CORE
        1434                 :            :
        1435                 :            :     static const char * const _keywords[] = {"object", "encoding", "errors", NULL};
        1436                 :            :     static _PyArg_Parser _parser = {
        1437                 :            :         .keywords = _keywords,
        1438                 :            :         .fname = "str",
        1439                 :            :         .kwtuple = KWTUPLE,
        1440                 :            :     };
        1441                 :            :     #undef KWTUPLE
        1442                 :            :     PyObject *argsbuf[3];
        1443                 :            :     PyObject * const *fastargs;
        1444                 :       2168 :     Py_ssize_t nargs = PyTuple_GET_SIZE(args);
        1445         [ -  + ]:       2168 :     Py_ssize_t noptargs = nargs + (kwargs ? PyDict_GET_SIZE(kwargs) : 0) - 0;
        1446                 :       2168 :     PyObject *x = NULL;
        1447                 :       2168 :     const char *encoding = NULL;
        1448                 :       2168 :     const char *errors = NULL;
        1449                 :            :
        1450   [ +  -  +  -  :       2168 :     fastargs = _PyArg_UnpackKeywords(_PyTuple_CAST(args)->ob_item, nargs, kwargs, NULL, &_parser, 0, 3, 0, argsbuf);
                 +  -  +  - ]
        1451         [ -  + ]:       2168 :     if (!fastargs) {
        1452                 :          0 :         goto exit;
        1453                 :            :     }
        1454         [ -  + ]:       2168 :     if (!noptargs) {
        1455                 :          0 :         goto skip_optional_pos;
        1456                 :            :     }
        1457         [ +  - ]:       2168 :     if (fastargs[0]) {
        1458                 :       2168 :         x = fastargs[0];
        1459         [ +  + ]:       2168 :         if (!--noptargs) {
        1460                 :       2051 :             goto skip_optional_pos;
        1461                 :            :         }
        1462                 :            :     }
        1463         [ +  - ]:        117 :     if (fastargs[1]) {
        1464         [ -  + ]:        117 :         if (!PyUnicode_Check(fastargs[1])) {
        1465                 :          0 :             _PyArg_BadArgument("str", "argument 'encoding'", "str", fastargs[1]);
        1466                 :          0 :             goto exit;
        1467                 :            :         }
        1468                 :            :         Py_ssize_t encoding_length;
        1469                 :        117 :         encoding = PyUnicode_AsUTF8AndSize(fastargs[1], &encoding_length);
        1470         [ -  + ]:        117 :         if (encoding == NULL) {
        1471                 :          0 :             goto exit;
        1472                 :            :         }
        1473         [ -  + ]:        117 :         if (strlen(encoding) != (size_t)encoding_length) {
        1474                 :          0 :             PyErr_SetString(PyExc_ValueError, "embedded null character");
        1475                 :          0 :             goto exit;
        1476                 :            :         }
        1477         [ +  - ]:        117 :         if (!--noptargs) {
        1478                 :        117 :             goto skip_optional_pos;
        1479                 :            :         }
        1480                 :            :     }
        1481         [ #  # ]:          0 :     if (!PyUnicode_Check(fastargs[2])) {
        1482                 :          0 :         _PyArg_BadArgument("str", "argument 'errors'", "str", fastargs[2]);
        1483                 :          0 :         goto exit;
        1484                 :            :     }
        1485                 :            :     Py_ssize_t errors_length;
        1486                 :          0 :     errors = PyUnicode_AsUTF8AndSize(fastargs[2], &errors_length);
        1487         [ #  # ]:          0 :     if (errors == NULL) {
        1488                 :          0 :         goto exit;
        1489                 :            :     }
        1490         [ #  # ]:          0 :     if (strlen(errors) != (size_t)errors_length) {
        1491                 :          0 :         PyErr_SetString(PyExc_ValueError, "embedded null character");
        1492                 :          0 :         goto exit;
        1493                 :            :     }
        1494                 :          0 : skip_optional_pos:
        1495                 :       2168 :     return_value = unicode_new_impl(type, x, encoding, errors);
        1496                 :            :
        1497                 :       2168 : exit:
        1498                 :       2168 :     return return_value;
        1499                 :            : }
        1500                 :            : /*[clinic end generated code: output=05d942840635dadf input=a9049054013a1b77]*/

Generated by: LCOV version 1.14