LCOV - code coverage report
Current view: top level - Include/cpython - unicodeobject.h (source / functions) Hit Total Coverage
Test: CPython 3.12 LCOV report [commit 5e6661bce9] Lines: 64 81 79.0 %
Date: 2023-03-20 08:15:36 Functions: 17 22 77.3 %
Branches: 37 76 48.7 %

           Branch data     Line data    Source code
       1                 :            : #ifndef Py_CPYTHON_UNICODEOBJECT_H
       2                 :            : #  error "this header file must not be included directly"
       3                 :            : #endif
       4                 :            : 
       5                 :            : /* Py_UNICODE was the native Unicode storage format (code unit) used by
       6                 :            :    Python and represents a single Unicode element in the Unicode type.
       7                 :            :    With PEP 393, Py_UNICODE is deprecated and replaced with a
       8                 :            :    typedef to wchar_t. */
       9                 :            : #define PY_UNICODE_TYPE wchar_t
      10                 :            : /* Py_DEPRECATED(3.3) */ typedef wchar_t Py_UNICODE;
      11                 :            : 
      12                 :            : /* --- Internal Unicode Operations ---------------------------------------- */
      13                 :            : 
      14                 :            : // Static inline functions to work with surrogates
      15                 :     112814 : static inline int Py_UNICODE_IS_SURROGATE(Py_UCS4 ch) {
      16   [ +  +  +  + ]:     112814 :     return (0xD800 <= ch && ch <= 0xDFFF);
      17                 :            : }
      18                 :          0 : static inline int Py_UNICODE_IS_HIGH_SURROGATE(Py_UCS4 ch) {
      19   [ #  #  #  # ]:          0 :     return (0xD800 <= ch && ch <= 0xDBFF);
      20                 :            : }
      21                 :          0 : static inline int Py_UNICODE_IS_LOW_SURROGATE(Py_UCS4 ch) {
      22   [ #  #  #  # ]:          0 :     return (0xDC00 <= ch && ch <= 0xDFFF);
      23                 :            : }
      24                 :            : 
      25                 :            : // Join two surrogate characters and return a single Py_UCS4 value.
      26                 :          0 : static inline Py_UCS4 Py_UNICODE_JOIN_SURROGATES(Py_UCS4 high, Py_UCS4 low)  {
      27                 :            :     assert(Py_UNICODE_IS_HIGH_SURROGATE(high));
      28                 :            :     assert(Py_UNICODE_IS_LOW_SURROGATE(low));
      29                 :          0 :     return 0x10000 + (((high & 0x03FF) << 10) | (low & 0x03FF));
      30                 :            : }
      31                 :            : 
      32                 :            : // High surrogate = top 10 bits added to 0xD800.
      33                 :            : // The character must be in the range [U+10000; U+10ffff].
      34                 :          0 : static inline Py_UCS4 Py_UNICODE_HIGH_SURROGATE(Py_UCS4 ch) {
      35                 :            :     assert(0x10000 <= ch && ch <= 0x10ffff);
      36                 :          0 :     return (0xD800 - (0x10000 >> 10) + (ch >> 10));
      37                 :            : }
      38                 :            : 
      39                 :            : // Low surrogate = bottom 10 bits added to 0xDC00.
      40                 :            : // The character must be in the range [U+10000; U+10ffff].
      41                 :          0 : static inline Py_UCS4 Py_UNICODE_LOW_SURROGATE(Py_UCS4 ch) {
      42                 :            :     assert(0x10000 <= ch && ch <= 0x10ffff);
      43                 :          0 :     return (0xDC00 + (ch & 0x3FF));
      44                 :            : }
      45                 :            : 
      46                 :            : /* --- Unicode Type ------------------------------------------------------- */
      47                 :            : 
      48                 :            : /* ASCII-only strings created through PyUnicode_New use the PyASCIIObject
      49                 :            :    structure. state.ascii and state.compact are set, and the data
      50                 :            :    immediately follow the structure. utf8_length can be found
      51                 :            :    in the length field; the utf8 pointer is equal to the data pointer. */
      52                 :            : typedef struct {
      53                 :            :     /* There are 4 forms of Unicode strings:
      54                 :            : 
      55                 :            :        - compact ascii:
      56                 :            : 
      57                 :            :          * structure = PyASCIIObject
      58                 :            :          * test: PyUnicode_IS_COMPACT_ASCII(op)
      59                 :            :          * kind = PyUnicode_1BYTE_KIND
      60                 :            :          * compact = 1
      61                 :            :          * ascii = 1
      62                 :            :          * (length is the length of the utf8)
      63                 :            :          * (data starts just after the structure)
      64                 :            :          * (since ASCII is decoded from UTF-8, the utf8 string are the data)
      65                 :            : 
      66                 :            :        - compact:
      67                 :            : 
      68                 :            :          * structure = PyCompactUnicodeObject
      69                 :            :          * test: PyUnicode_IS_COMPACT(op) && !PyUnicode_IS_ASCII(op)
      70                 :            :          * kind = PyUnicode_1BYTE_KIND, PyUnicode_2BYTE_KIND or
      71                 :            :            PyUnicode_4BYTE_KIND
      72                 :            :          * compact = 1
      73                 :            :          * ascii = 0
      74                 :            :          * utf8 is not shared with data
      75                 :            :          * utf8_length = 0 if utf8 is NULL
      76                 :            :          * (data starts just after the structure)
      77                 :            : 
      78                 :            :        - legacy string:
      79                 :            : 
      80                 :            :          * structure = PyUnicodeObject structure
      81                 :            :          * test: !PyUnicode_IS_COMPACT(op)
      82                 :            :          * kind = PyUnicode_1BYTE_KIND, PyUnicode_2BYTE_KIND or
      83                 :            :            PyUnicode_4BYTE_KIND
      84                 :            :          * compact = 0
      85                 :            :          * data.any is not NULL
      86                 :            :          * utf8 is shared and utf8_length = length with data.any if ascii = 1
      87                 :            :          * utf8_length = 0 if utf8 is NULL
      88                 :            : 
      89                 :            :        Compact strings use only one memory block (structure + characters),
      90                 :            :        whereas legacy strings use one block for the structure and one block
      91                 :            :        for characters.
      92                 :            : 
      93                 :            :        Legacy strings are created by subclasses of Unicode.
      94                 :            : 
      95                 :            :        See also _PyUnicode_CheckConsistency().
      96                 :            :     */
      97                 :            :     PyObject_HEAD
      98                 :            :     Py_ssize_t length;          /* Number of code points in the string */
      99                 :            :     Py_hash_t hash;             /* Hash value; -1 if not set */
     100                 :            :     struct {
     101                 :            :         /* If interned is set, the two references from the
     102                 :            :            dictionary to this object are *not* counted in ob_refcnt. */
     103                 :            :         unsigned int interned:1;
     104                 :            :         /* Character size:
     105                 :            : 
     106                 :            :            - PyUnicode_1BYTE_KIND (1):
     107                 :            : 
     108                 :            :              * character type = Py_UCS1 (8 bits, unsigned)
     109                 :            :              * all characters are in the range U+0000-U+00FF (latin1)
     110                 :            :              * if ascii is set, all characters are in the range U+0000-U+007F
     111                 :            :                (ASCII), otherwise at least one character is in the range
     112                 :            :                U+0080-U+00FF
     113                 :            : 
     114                 :            :            - PyUnicode_2BYTE_KIND (2):
     115                 :            : 
     116                 :            :              * character type = Py_UCS2 (16 bits, unsigned)
     117                 :            :              * all characters are in the range U+0000-U+FFFF (BMP)
     118                 :            :              * at least one character is in the range U+0100-U+FFFF
     119                 :            : 
     120                 :            :            - PyUnicode_4BYTE_KIND (4):
     121                 :            : 
     122                 :            :              * character type = Py_UCS4 (32 bits, unsigned)
     123                 :            :              * all characters are in the range U+0000-U+10FFFF
     124                 :            :              * at least one character is in the range U+10000-U+10FFFF
     125                 :            :          */
     126                 :            :         unsigned int kind:3;
     127                 :            :         /* Compact is with respect to the allocation scheme. Compact unicode
     128                 :            :            objects only require one memory block while non-compact objects use
     129                 :            :            one block for the PyUnicodeObject struct and another for its data
     130                 :            :            buffer. */
     131                 :            :         unsigned int compact:1;
     132                 :            :         /* The string only contains characters in the range U+0000-U+007F (ASCII)
     133                 :            :            and the kind is PyUnicode_1BYTE_KIND. If ascii is set and compact is
     134                 :            :            set, use the PyASCIIObject structure. */
     135                 :            :         unsigned int ascii:1;
     136                 :            :         /* Padding to ensure that PyUnicode_DATA() is always aligned to
     137                 :            :            4 bytes (see issue #19537 on m68k). */
     138                 :            :         unsigned int :26;
     139                 :            :     } state;
     140                 :            : } PyASCIIObject;
     141                 :            : 
     142                 :            : /* Non-ASCII strings allocated through PyUnicode_New use the
     143                 :            :    PyCompactUnicodeObject structure. state.compact is set, and the data
     144                 :            :    immediately follow the structure. */
     145                 :            : typedef struct {
     146                 :            :     PyASCIIObject _base;
     147                 :            :     Py_ssize_t utf8_length;     /* Number of bytes in utf8, excluding the
     148                 :            :                                  * terminating \0. */
     149                 :            :     char *utf8;                 /* UTF-8 representation (null-terminated) */
     150                 :            : } PyCompactUnicodeObject;
     151                 :            : 
     152                 :            : /* Object format for Unicode subclasses. */
     153                 :            : typedef struct {
     154                 :            :     PyCompactUnicodeObject _base;
     155                 :            :     union {
     156                 :            :         void *any;
     157                 :            :         Py_UCS1 *latin1;
     158                 :            :         Py_UCS2 *ucs2;
     159                 :            :         Py_UCS4 *ucs4;
     160                 :            :     } data;                     /* Canonical, smallest-form Unicode buffer */
     161                 :            : } PyUnicodeObject;
     162                 :            : 
     163                 :            : PyAPI_FUNC(int) _PyUnicode_CheckConsistency(
     164                 :            :     PyObject *op,
     165                 :            :     int check_content);
     166                 :            : 
     167                 :            : 
     168                 :            : #define _PyASCIIObject_CAST(op) \
     169                 :            :     (assert(PyUnicode_Check(op)), \
     170                 :            :      _Py_CAST(PyASCIIObject*, (op)))
     171                 :            : #define _PyCompactUnicodeObject_CAST(op) \
     172                 :            :     (assert(PyUnicode_Check(op)), \
     173                 :            :      _Py_CAST(PyCompactUnicodeObject*, (op)))
     174                 :            : #define _PyUnicodeObject_CAST(op) \
     175                 :            :     (assert(PyUnicode_Check(op)), \
     176                 :            :      _Py_CAST(PyUnicodeObject*, (op)))
     177                 :            : 
     178                 :            : 
     179                 :            : /* --- Flexible String Representation Helper Macros (PEP 393) -------------- */
     180                 :            : 
     181                 :            : /* Values for PyASCIIObject.state: */
     182                 :            : 
     183                 :            : /* Interning state. */
     184                 :            : #define SSTATE_NOT_INTERNED 0
     185                 :            : #define SSTATE_INTERNED_MORTAL 1
     186                 :            : 
     187                 :            : /* Use only if you know it's a string */
     188                 :    8986981 : static inline unsigned int PyUnicode_CHECK_INTERNED(PyObject *op) {
     189                 :    8986981 :     return _PyASCIIObject_CAST(op)->state.interned;
     190                 :            : }
     191                 :            : #define PyUnicode_CHECK_INTERNED(op) PyUnicode_CHECK_INTERNED(_PyObject_CAST(op))
     192                 :            : 
     193                 :            : /* For backward compatibility */
     194                 :    1500720 : static inline unsigned int PyUnicode_IS_READY(PyObject* Py_UNUSED(op)) {
     195                 :    1500720 :     return 1;
     196                 :            : }
     197                 :            : #define PyUnicode_IS_READY(op) PyUnicode_IS_READY(_PyObject_CAST(op))
     198                 :            : 
     199                 :            : /* Return true if the string contains only ASCII characters, or 0 if not. The
     200                 :            :    string may be compact (PyUnicode_IS_COMPACT_ASCII) or not, but must be
     201                 :            :    ready. */
     202                 :   25019819 : static inline unsigned int PyUnicode_IS_ASCII(PyObject *op) {
     203         [ #  # ]:   25019819 :     return _PyASCIIObject_CAST(op)->state.ascii;
     204                 :            : }
     205                 :            : #define PyUnicode_IS_ASCII(op) PyUnicode_IS_ASCII(_PyObject_CAST(op))
     206                 :            : 
     207                 :            : /* Return true if the string is compact or 0 if not.
     208                 :            :    No type checks or Ready calls are performed. */
     209                 :   29563860 : static inline unsigned int PyUnicode_IS_COMPACT(PyObject *op) {
     210         [ #  # ]:   29563860 :     return _PyASCIIObject_CAST(op)->state.compact;
     211                 :            : }
     212                 :            : #define PyUnicode_IS_COMPACT(op) PyUnicode_IS_COMPACT(_PyObject_CAST(op))
     213                 :            : 
     214                 :            : /* Return true if the string is a compact ASCII string (use PyASCIIObject
     215                 :            :    structure), or 0 if not.  No type checks or Ready calls are performed. */
     216                 :    4800553 : static inline int PyUnicode_IS_COMPACT_ASCII(PyObject *op) {
     217   [ +  +  +  + ]:    4800553 :     return (_PyASCIIObject_CAST(op)->state.ascii && PyUnicode_IS_COMPACT(op));
     218                 :            : }
     219                 :            : #define PyUnicode_IS_COMPACT_ASCII(op) PyUnicode_IS_COMPACT_ASCII(_PyObject_CAST(op))
     220                 :            : 
     221                 :            : enum PyUnicode_Kind {
     222                 :            : /* Return values of the PyUnicode_KIND() function: */
     223                 :            :     PyUnicode_1BYTE_KIND = 1,
     224                 :            :     PyUnicode_2BYTE_KIND = 2,
     225                 :            :     PyUnicode_4BYTE_KIND = 4
     226                 :            : };
     227                 :            : 
     228                 :            : // PyUnicode_KIND(): Return one of the PyUnicode_*_KIND values defined above.
     229                 :            : //
     230                 :            : // gh-89653: Converting this macro to a static inline function would introduce
     231                 :            : // new compiler warnings on "kind < PyUnicode_KIND(str)" (compare signed and
     232                 :            : // unsigned numbers) where kind type is an int or on
     233                 :            : // "unsigned int kind = PyUnicode_KIND(str)" (cast signed to unsigned).
     234                 :            : #define PyUnicode_KIND(op) _Py_RVALUE(_PyASCIIObject_CAST(op)->state.kind)
     235                 :            : 
     236                 :            : /* Return a void pointer to the raw unicode buffer. */
     237                 :   20178995 : static inline void* _PyUnicode_COMPACT_DATA(PyObject *op) {
     238         [ +  + ]:   20178995 :     if (PyUnicode_IS_ASCII(op)) {
     239         [ #  # ]:   20153698 :         return _Py_STATIC_CAST(void*, (_PyASCIIObject_CAST(op) + 1));
     240                 :            :     }
     241         [ #  # ]:      25297 :     return _Py_STATIC_CAST(void*, (_PyCompactUnicodeObject_CAST(op) + 1));
     242                 :            : }
     243                 :            : 
     244                 :         28 : static inline void* _PyUnicode_NONCOMPACT_DATA(PyObject *op) {
     245                 :            :     void *data;
     246         [ #  # ]:          0 :     assert(!PyUnicode_IS_COMPACT(op));
     247         [ #  # ]:         28 :     data = _PyUnicodeObject_CAST(op)->data.any;
     248         [ #  # ]:          0 :     assert(data != NULL);
     249                 :         28 :     return data;
     250                 :            : }
     251                 :            : 
     252                 :   20179023 : static inline void* PyUnicode_DATA(PyObject *op) {
     253         [ +  + ]:   20179023 :     if (PyUnicode_IS_COMPACT(op)) {
     254                 :   20178995 :         return _PyUnicode_COMPACT_DATA(op);
     255                 :            :     }
     256                 :         28 :     return _PyUnicode_NONCOMPACT_DATA(op);
     257                 :            : }
     258                 :            : #define PyUnicode_DATA(op) PyUnicode_DATA(_PyObject_CAST(op))
     259                 :            : 
     260                 :            : /* Return pointers to the canonical representation cast to unsigned char,
     261                 :            :    Py_UCS2, or Py_UCS4 for direct character access.
     262                 :            :    No checks are performed, use PyUnicode_KIND() before to ensure
     263                 :            :    these will work correctly. */
     264                 :            : 
     265                 :            : #define PyUnicode_1BYTE_DATA(op) _Py_STATIC_CAST(Py_UCS1*, PyUnicode_DATA(op))
     266                 :            : #define PyUnicode_2BYTE_DATA(op) _Py_STATIC_CAST(Py_UCS2*, PyUnicode_DATA(op))
     267                 :            : #define PyUnicode_4BYTE_DATA(op) _Py_STATIC_CAST(Py_UCS4*, PyUnicode_DATA(op))
     268                 :            : 
     269                 :            : /* Returns the length of the unicode string. */
     270                 :   27393330 : static inline Py_ssize_t PyUnicode_GET_LENGTH(PyObject *op) {
     271         [ #  # ]:   27393330 :     return _PyASCIIObject_CAST(op)->length;
     272                 :            : }
     273                 :            : #define PyUnicode_GET_LENGTH(op) PyUnicode_GET_LENGTH(_PyObject_CAST(op))
     274                 :            : 
     275                 :            : /* Write into the canonical representation, this function does not do any sanity
     276                 :            :    checks and is intended for usage in loops.  The caller should cache the
     277                 :            :    kind and data pointers obtained from other function calls.
     278                 :            :    index is the index in the string (starts at 0) and value is the new
     279                 :            :    code point value which should be written to that location. */
     280                 :     764080 : static inline void PyUnicode_WRITE(int kind, void *data,
     281                 :            :                                    Py_ssize_t index, Py_UCS4 value)
     282                 :            : {
     283                 :            :     assert(index >= 0);
     284         [ +  + ]:     764080 :     if (kind == PyUnicode_1BYTE_KIND) {
     285                 :            :         assert(value <= 0xffU);
     286                 :     755833 :         _Py_STATIC_CAST(Py_UCS1*, data)[index] = _Py_STATIC_CAST(Py_UCS1, value);
     287                 :            :     }
     288         [ +  + ]:       8247 :     else if (kind == PyUnicode_2BYTE_KIND) {
     289                 :            :         assert(value <= 0xffffU);
     290                 :       8202 :         _Py_STATIC_CAST(Py_UCS2*, data)[index] = _Py_STATIC_CAST(Py_UCS2, value);
     291                 :            :     }
     292                 :            :     else {
     293                 :            :         assert(kind == PyUnicode_4BYTE_KIND);
     294                 :            :         assert(value <= 0x10ffffU);
     295                 :         45 :         _Py_STATIC_CAST(Py_UCS4*, data)[index] = value;
     296                 :            :     }
     297                 :     764080 : }
     298                 :            : #define PyUnicode_WRITE(kind, data, index, value) \
     299                 :            :     PyUnicode_WRITE(_Py_STATIC_CAST(int, kind), _Py_CAST(void*, data), \
     300                 :            :                     (index), _Py_STATIC_CAST(Py_UCS4, value))
     301                 :            : 
     302                 :            : /* Read a code point from the string's canonical representation.  No checks
     303                 :            :    or ready calls are performed. */
     304                 :    5933633 : static inline Py_UCS4 PyUnicode_READ(int kind,
     305                 :            :                                      const void *data, Py_ssize_t index)
     306                 :            : {
     307                 :            :     assert(index >= 0);
     308         [ +  + ]:    5933633 :     if (kind == PyUnicode_1BYTE_KIND) {
     309                 :    5844162 :         return _Py_STATIC_CAST(const Py_UCS1*, data)[index];
     310                 :            :     }
     311         [ +  + ]:      89471 :     if (kind == PyUnicode_2BYTE_KIND) {
     312                 :      89464 :         return _Py_STATIC_CAST(const Py_UCS2*, data)[index];
     313                 :            :     }
     314                 :            :     assert(kind == PyUnicode_4BYTE_KIND);
     315                 :          7 :     return _Py_STATIC_CAST(const Py_UCS4*, data)[index];
     316                 :            : }
     317                 :            : #define PyUnicode_READ(kind, data, index) \
     318                 :            :     PyUnicode_READ(_Py_STATIC_CAST(int, kind), \
     319                 :            :                    _Py_STATIC_CAST(const void*, data), \
     320                 :            :                    (index))
     321                 :            : 
     322                 :            : /* PyUnicode_READ_CHAR() is less efficient than PyUnicode_READ() because it
     323                 :            :    calls PyUnicode_KIND() and might call it twice.  For single reads, use
     324                 :            :    PyUnicode_READ_CHAR, for multiple consecutive reads callers should
     325                 :            :    cache kind and use PyUnicode_READ instead. */
     326                 :     564768 : static inline Py_UCS4 PyUnicode_READ_CHAR(PyObject *unicode, Py_ssize_t index)
     327                 :            : {
     328                 :            :     int kind;
     329                 :            : 
     330         [ #  # ]:          0 :     assert(index >= 0);
     331                 :            :     // Tolerate reading the NUL character at str[len(str)]
     332         [ #  # ]:          0 :     assert(index <= PyUnicode_GET_LENGTH(unicode));
     333                 :            : 
     334         [ #  # ]:     564768 :     kind = PyUnicode_KIND(unicode);
     335         [ +  + ]:     564768 :     if (kind == PyUnicode_1BYTE_KIND) {
     336                 :     564680 :         return PyUnicode_1BYTE_DATA(unicode)[index];
     337                 :            :     }
     338         [ +  + ]:         88 :     if (kind == PyUnicode_2BYTE_KIND) {
     339                 :         87 :         return PyUnicode_2BYTE_DATA(unicode)[index];
     340                 :            :     }
     341         [ #  # ]:          0 :     assert(kind == PyUnicode_4BYTE_KIND);
     342                 :          1 :     return PyUnicode_4BYTE_DATA(unicode)[index];
     343                 :            : }
     344                 :            : #define PyUnicode_READ_CHAR(unicode, index) \
     345                 :            :     PyUnicode_READ_CHAR(_PyObject_CAST(unicode), (index))
     346                 :            : 
     347                 :            : /* Return a maximum character value which is suitable for creating another
     348                 :            :    string based on op.  This is always an approximation but more efficient
     349                 :            :    than iterating over the string. */
     350                 :    2534381 : static inline Py_UCS4 PyUnicode_MAX_CHAR_VALUE(PyObject *op)
     351                 :            : {
     352                 :            :     int kind;
     353                 :            : 
     354         [ +  + ]:    2534381 :     if (PyUnicode_IS_ASCII(op)) {
     355                 :    2534039 :         return 0x7fU;
     356                 :            :     }
     357                 :            : 
     358         [ #  # ]:        342 :     kind = PyUnicode_KIND(op);
     359         [ +  + ]:        342 :     if (kind == PyUnicode_1BYTE_KIND) {
     360                 :        134 :        return 0xffU;
     361                 :            :     }
     362         [ +  + ]:        208 :     if (kind == PyUnicode_2BYTE_KIND) {
     363                 :        167 :         return 0xffffU;
     364                 :            :     }
     365         [ #  # ]:          0 :     assert(kind == PyUnicode_4BYTE_KIND);
     366                 :         41 :     return 0x10ffffU;
     367                 :            : }
     368                 :            : #define PyUnicode_MAX_CHAR_VALUE(op) \
     369                 :            :     PyUnicode_MAX_CHAR_VALUE(_PyObject_CAST(op))
     370                 :            : 
     371                 :            : /* === Public API ========================================================= */
     372                 :            : 
     373                 :            : /* --- Plain Py_UNICODE --------------------------------------------------- */
     374                 :            : 
     375                 :            : /* With PEP 393, this is the recommended way to allocate a new unicode object.
     376                 :            :    This function will allocate the object and its buffer in a single memory
     377                 :            :    block.  Objects created using this function are not resizable. */
     378                 :            : PyAPI_FUNC(PyObject*) PyUnicode_New(
     379                 :            :     Py_ssize_t size,            /* Number of code points in the new string */
     380                 :            :     Py_UCS4 maxchar             /* maximum code point value in the string */
     381                 :            :     );
     382                 :            : 
     383                 :            : /* For backward compatibility */
     384                 :    4432370 : static inline int PyUnicode_READY(PyObject* Py_UNUSED(op))
     385                 :            : {
     386                 :    4432370 :     return 0;
     387                 :            : }
     388                 :            : #define PyUnicode_READY(op) PyUnicode_READY(_PyObject_CAST(op))
     389                 :            : 
     390                 :            : /* Get a copy of a Unicode string. */
     391                 :            : PyAPI_FUNC(PyObject*) _PyUnicode_Copy(
     392                 :            :     PyObject *unicode
     393                 :            :     );
     394                 :            : 
     395                 :            : /* Copy character from one unicode object into another, this function performs
     396                 :            :    character conversion when necessary and falls back to memcpy() if possible.
     397                 :            : 
     398                 :            :    Fail if to is too small (smaller than *how_many* or smaller than
     399                 :            :    len(from)-from_start), or if kind(from[from_start:from_start+how_many]) >
     400                 :            :    kind(to), or if *to* has more than 1 reference.
     401                 :            : 
     402                 :            :    Return the number of written character, or return -1 and raise an exception
     403                 :            :    on error.
     404                 :            : 
     405                 :            :    Pseudo-code:
     406                 :            : 
     407                 :            :        how_many = min(how_many, len(from) - from_start)
     408                 :            :        to[to_start:to_start+how_many] = from[from_start:from_start+how_many]
     409                 :            :        return how_many
     410                 :            : 
     411                 :            :    Note: The function doesn't write a terminating null character.
     412                 :            :    */
     413                 :            : PyAPI_FUNC(Py_ssize_t) PyUnicode_CopyCharacters(
     414                 :            :     PyObject *to,
     415                 :            :     Py_ssize_t to_start,
     416                 :            :     PyObject *from,
     417                 :            :     Py_ssize_t from_start,
     418                 :            :     Py_ssize_t how_many
     419                 :            :     );
     420                 :            : 
     421                 :            : /* Unsafe version of PyUnicode_CopyCharacters(): don't check arguments and so
     422                 :            :    may crash if parameters are invalid (e.g. if the output string
     423                 :            :    is too short). */
     424                 :            : PyAPI_FUNC(void) _PyUnicode_FastCopyCharacters(
     425                 :            :     PyObject *to,
     426                 :            :     Py_ssize_t to_start,
     427                 :            :     PyObject *from,
     428                 :            :     Py_ssize_t from_start,
     429                 :            :     Py_ssize_t how_many
     430                 :            :     );
     431                 :            : 
     432                 :            : /* Fill a string with a character: write fill_char into
     433                 :            :    unicode[start:start+length].
     434                 :            : 
     435                 :            :    Fail if fill_char is bigger than the string maximum character, or if the
     436                 :            :    string has more than 1 reference.
     437                 :            : 
     438                 :            :    Return the number of written character, or return -1 and raise an exception
     439                 :            :    on error. */
     440                 :            : PyAPI_FUNC(Py_ssize_t) PyUnicode_Fill(
     441                 :            :     PyObject *unicode,
     442                 :            :     Py_ssize_t start,
     443                 :            :     Py_ssize_t length,
     444                 :            :     Py_UCS4 fill_char
     445                 :            :     );
     446                 :            : 
     447                 :            : /* Unsafe version of PyUnicode_Fill(): don't check arguments and so may crash
     448                 :            :    if parameters are invalid (e.g. if length is longer than the string). */
     449                 :            : PyAPI_FUNC(void) _PyUnicode_FastFill(
     450                 :            :     PyObject *unicode,
     451                 :            :     Py_ssize_t start,
     452                 :            :     Py_ssize_t length,
     453                 :            :     Py_UCS4 fill_char
     454                 :            :     );
     455                 :            : 
     456                 :            : /* Create a new string from a buffer of Py_UCS1, Py_UCS2 or Py_UCS4 characters.
     457                 :            :    Scan the string to find the maximum character. */
     458                 :            : PyAPI_FUNC(PyObject*) PyUnicode_FromKindAndData(
     459                 :            :     int kind,
     460                 :            :     const void *buffer,
     461                 :            :     Py_ssize_t size);
     462                 :            : 
     463                 :            : /* Create a new string from a buffer of ASCII characters.
     464                 :            :    WARNING: Don't check if the string contains any non-ASCII character. */
     465                 :            : PyAPI_FUNC(PyObject*) _PyUnicode_FromASCII(
     466                 :            :     const char *buffer,
     467                 :            :     Py_ssize_t size);
     468                 :            : 
     469                 :            : /* Compute the maximum character of the substring unicode[start:end].
     470                 :            :    Return 127 for an empty string. */
     471                 :            : PyAPI_FUNC(Py_UCS4) _PyUnicode_FindMaxChar (
     472                 :            :     PyObject *unicode,
     473                 :            :     Py_ssize_t start,
     474                 :            :     Py_ssize_t end);
     475                 :            : 
     476                 :            : /* --- _PyUnicodeWriter API ----------------------------------------------- */
     477                 :            : 
     478                 :            : typedef struct {
     479                 :            :     PyObject *buffer;
     480                 :            :     void *data;
     481                 :            :     int kind;
     482                 :            :     Py_UCS4 maxchar;
     483                 :            :     Py_ssize_t size;
     484                 :            :     Py_ssize_t pos;
     485                 :            : 
     486                 :            :     /* minimum number of allocated characters (default: 0) */
     487                 :            :     Py_ssize_t min_length;
     488                 :            : 
     489                 :            :     /* minimum character (default: 127, ASCII) */
     490                 :            :     Py_UCS4 min_char;
     491                 :            : 
     492                 :            :     /* If non-zero, overallocate the buffer (default: 0). */
     493                 :            :     unsigned char overallocate;
     494                 :            : 
     495                 :            :     /* If readonly is 1, buffer is a shared string (cannot be modified)
     496                 :            :        and size is set to 0. */
     497                 :            :     unsigned char readonly;
     498                 :            : } _PyUnicodeWriter ;
     499                 :            : 
     500                 :            : /* Initialize a Unicode writer.
     501                 :            :  *
     502                 :            :  * By default, the minimum buffer size is 0 character and overallocation is
     503                 :            :  * disabled. Set min_length, min_char and overallocate attributes to control
     504                 :            :  * the allocation of the buffer. */
     505                 :            : PyAPI_FUNC(void)
     506                 :            : _PyUnicodeWriter_Init(_PyUnicodeWriter *writer);
     507                 :            : 
     508                 :            : /* Prepare the buffer to write 'length' characters
     509                 :            :    with the specified maximum character.
     510                 :            : 
     511                 :            :    Return 0 on success, raise an exception and return -1 on error. */
     512                 :            : #define _PyUnicodeWriter_Prepare(WRITER, LENGTH, MAXCHAR)             \
     513                 :            :     (((MAXCHAR) <= (WRITER)->maxchar                                  \
     514                 :            :       && (LENGTH) <= (WRITER)->size - (WRITER)->pos)                  \
     515                 :            :      ? 0                                                              \
     516                 :            :      : (((LENGTH) == 0)                                               \
     517                 :            :         ? 0                                                           \
     518                 :            :         : _PyUnicodeWriter_PrepareInternal((WRITER), (LENGTH), (MAXCHAR))))
     519                 :            : 
     520                 :            : /* Don't call this function directly, use the _PyUnicodeWriter_Prepare() macro
     521                 :            :    instead. */
     522                 :            : PyAPI_FUNC(int)
     523                 :            : _PyUnicodeWriter_PrepareInternal(_PyUnicodeWriter *writer,
     524                 :            :                                  Py_ssize_t length, Py_UCS4 maxchar);
     525                 :            : 
     526                 :            : /* Prepare the buffer to have at least the kind KIND.
     527                 :            :    For example, kind=PyUnicode_2BYTE_KIND ensures that the writer will
     528                 :            :    support characters in range U+000-U+FFFF.
     529                 :            : 
     530                 :            :    Return 0 on success, raise an exception and return -1 on error. */
     531                 :            : #define _PyUnicodeWriter_PrepareKind(WRITER, KIND)                    \
     532                 :            :     ((KIND) <= (WRITER)->kind                                         \
     533                 :            :      ? 0                                                              \
     534                 :            :      : _PyUnicodeWriter_PrepareKindInternal((WRITER), (KIND)))
     535                 :            : 
     536                 :            : /* Don't call this function directly, use the _PyUnicodeWriter_PrepareKind()
     537                 :            :    macro instead. */
     538                 :            : PyAPI_FUNC(int)
     539                 :            : _PyUnicodeWriter_PrepareKindInternal(_PyUnicodeWriter *writer,
     540                 :            :                                      int kind);
     541                 :            : 
     542                 :            : /* Append a Unicode character.
     543                 :            :    Return 0 on success, raise an exception and return -1 on error. */
     544                 :            : PyAPI_FUNC(int)
     545                 :            : _PyUnicodeWriter_WriteChar(_PyUnicodeWriter *writer,
     546                 :            :     Py_UCS4 ch
     547                 :            :     );
     548                 :            : 
     549                 :            : /* Append a Unicode string.
     550                 :            :    Return 0 on success, raise an exception and return -1 on error. */
     551                 :            : PyAPI_FUNC(int)
     552                 :            : _PyUnicodeWriter_WriteStr(_PyUnicodeWriter *writer,
     553                 :            :     PyObject *str               /* Unicode string */
     554                 :            :     );
     555                 :            : 
     556                 :            : /* Append a substring of a Unicode string.
     557                 :            :    Return 0 on success, raise an exception and return -1 on error. */
     558                 :            : PyAPI_FUNC(int)
     559                 :            : _PyUnicodeWriter_WriteSubstring(_PyUnicodeWriter *writer,
     560                 :            :     PyObject *str,              /* Unicode string */
     561                 :            :     Py_ssize_t start,
     562                 :            :     Py_ssize_t end
     563                 :            :     );
     564                 :            : 
     565                 :            : /* Append an ASCII-encoded byte string.
     566                 :            :    Return 0 on success, raise an exception and return -1 on error. */
     567                 :            : PyAPI_FUNC(int)
     568                 :            : _PyUnicodeWriter_WriteASCIIString(_PyUnicodeWriter *writer,
     569                 :            :     const char *str,           /* ASCII-encoded byte string */
     570                 :            :     Py_ssize_t len             /* number of bytes, or -1 if unknown */
     571                 :            :     );
     572                 :            : 
     573                 :            : /* Append a latin1-encoded byte string.
     574                 :            :    Return 0 on success, raise an exception and return -1 on error. */
     575                 :            : PyAPI_FUNC(int)
     576                 :            : _PyUnicodeWriter_WriteLatin1String(_PyUnicodeWriter *writer,
     577                 :            :     const char *str,           /* latin1-encoded byte string */
     578                 :            :     Py_ssize_t len             /* length in bytes */
     579                 :            :     );
     580                 :            : 
     581                 :            : /* Get the value of the writer as a Unicode string. Clear the
     582                 :            :    buffer of the writer. Raise an exception and return NULL
     583                 :            :    on error. */
     584                 :            : PyAPI_FUNC(PyObject *)
     585                 :            : _PyUnicodeWriter_Finish(_PyUnicodeWriter *writer);
     586                 :            : 
     587                 :            : /* Deallocate memory of a writer (clear its internal buffer). */
     588                 :            : PyAPI_FUNC(void)
     589                 :            : _PyUnicodeWriter_Dealloc(_PyUnicodeWriter *writer);
     590                 :            : 
     591                 :            : 
     592                 :            : /* Format the object based on the format_spec, as defined in PEP 3101
     593                 :            :    (Advanced String Formatting). */
     594                 :            : PyAPI_FUNC(int) _PyUnicode_FormatAdvancedWriter(
     595                 :            :     _PyUnicodeWriter *writer,
     596                 :            :     PyObject *obj,
     597                 :            :     PyObject *format_spec,
     598                 :            :     Py_ssize_t start,
     599                 :            :     Py_ssize_t end);
     600                 :            : 
     601                 :            : /* --- Manage the default encoding ---------------------------------------- */
     602                 :            : 
     603                 :            : /* Returns a pointer to the default encoding (UTF-8) of the
     604                 :            :    Unicode object unicode.
     605                 :            : 
     606                 :            :    Like PyUnicode_AsUTF8AndSize(), this also caches the UTF-8 representation
     607                 :            :    in the unicodeobject.
     608                 :            : 
     609                 :            :    _PyUnicode_AsString is a #define for PyUnicode_AsUTF8 to
     610                 :            :    support the previous internal function with the same behaviour.
     611                 :            : 
     612                 :            :    Use of this API is DEPRECATED since no size information can be
     613                 :            :    extracted from the returned data.
     614                 :            : */
     615                 :            : 
     616                 :            : PyAPI_FUNC(const char *) PyUnicode_AsUTF8(PyObject *unicode);
     617                 :            : 
     618                 :            : #define _PyUnicode_AsString PyUnicode_AsUTF8
     619                 :            : 
     620                 :            : /* --- UTF-7 Codecs ------------------------------------------------------- */
     621                 :            : 
     622                 :            : PyAPI_FUNC(PyObject*) _PyUnicode_EncodeUTF7(
     623                 :            :     PyObject *unicode,          /* Unicode object */
     624                 :            :     int base64SetO,             /* Encode RFC2152 Set O characters in base64 */
     625                 :            :     int base64WhiteSpace,       /* Encode whitespace (sp, ht, nl, cr) in base64 */
     626                 :            :     const char *errors          /* error handling */
     627                 :            :     );
     628                 :            : 
     629                 :            : /* --- UTF-8 Codecs ------------------------------------------------------- */
     630                 :            : 
     631                 :            : PyAPI_FUNC(PyObject*) _PyUnicode_AsUTF8String(
     632                 :            :     PyObject *unicode,
     633                 :            :     const char *errors);
     634                 :            : 
     635                 :            : /* --- UTF-32 Codecs ------------------------------------------------------ */
     636                 :            : 
     637                 :            : PyAPI_FUNC(PyObject*) _PyUnicode_EncodeUTF32(
     638                 :            :     PyObject *object,           /* Unicode object */
     639                 :            :     const char *errors,         /* error handling */
     640                 :            :     int byteorder               /* byteorder to use 0=BOM+native;-1=LE,1=BE */
     641                 :            :     );
     642                 :            : 
     643                 :            : /* --- UTF-16 Codecs ------------------------------------------------------ */
     644                 :            : 
     645                 :            : /* Returns a Python string object holding the UTF-16 encoded value of
     646                 :            :    the Unicode data.
     647                 :            : 
     648                 :            :    If byteorder is not 0, output is written according to the following
     649                 :            :    byte order:
     650                 :            : 
     651                 :            :    byteorder == -1: little endian
     652                 :            :    byteorder == 0:  native byte order (writes a BOM mark)
     653                 :            :    byteorder == 1:  big endian
     654                 :            : 
     655                 :            :    If byteorder is 0, the output string will always start with the
     656                 :            :    Unicode BOM mark (U+FEFF). In the other two modes, no BOM mark is
     657                 :            :    prepended.
     658                 :            : */
     659                 :            : PyAPI_FUNC(PyObject*) _PyUnicode_EncodeUTF16(
     660                 :            :     PyObject* unicode,          /* Unicode object */
     661                 :            :     const char *errors,         /* error handling */
     662                 :            :     int byteorder               /* byteorder to use 0=BOM+native;-1=LE,1=BE */
     663                 :            :     );
     664                 :            : 
     665                 :            : /* --- Unicode-Escape Codecs ---------------------------------------------- */
     666                 :            : 
     667                 :            : /* Variant of PyUnicode_DecodeUnicodeEscape that supports partial decoding. */
     668                 :            : PyAPI_FUNC(PyObject*) _PyUnicode_DecodeUnicodeEscapeStateful(
     669                 :            :         const char *string,     /* Unicode-Escape encoded string */
     670                 :            :         Py_ssize_t length,      /* size of string */
     671                 :            :         const char *errors,     /* error handling */
     672                 :            :         Py_ssize_t *consumed    /* bytes consumed */
     673                 :            : );
     674                 :            : /* Helper for PyUnicode_DecodeUnicodeEscape that detects invalid escape
     675                 :            :    chars. */
     676                 :            : PyAPI_FUNC(PyObject*) _PyUnicode_DecodeUnicodeEscapeInternal(
     677                 :            :         const char *string,     /* Unicode-Escape encoded string */
     678                 :            :         Py_ssize_t length,      /* size of string */
     679                 :            :         const char *errors,     /* error handling */
     680                 :            :         Py_ssize_t *consumed,   /* bytes consumed */
     681                 :            :         const char **first_invalid_escape  /* on return, points to first
     682                 :            :                                               invalid escaped char in
     683                 :            :                                               string. */
     684                 :            : );
     685                 :            : 
     686                 :            : /* --- Raw-Unicode-Escape Codecs ---------------------------------------------- */
     687                 :            : 
     688                 :            : /* Variant of PyUnicode_DecodeRawUnicodeEscape that supports partial decoding. */
     689                 :            : PyAPI_FUNC(PyObject*) _PyUnicode_DecodeRawUnicodeEscapeStateful(
     690                 :            :         const char *string,     /* Unicode-Escape encoded string */
     691                 :            :         Py_ssize_t length,      /* size of string */
     692                 :            :         const char *errors,     /* error handling */
     693                 :            :         Py_ssize_t *consumed    /* bytes consumed */
     694                 :            : );
     695                 :            : 
     696                 :            : /* --- Latin-1 Codecs ----------------------------------------------------- */
     697                 :            : 
     698                 :            : PyAPI_FUNC(PyObject*) _PyUnicode_AsLatin1String(
     699                 :            :     PyObject* unicode,
     700                 :            :     const char* errors);
     701                 :            : 
     702                 :            : /* --- ASCII Codecs ------------------------------------------------------- */
     703                 :            : 
     704                 :            : PyAPI_FUNC(PyObject*) _PyUnicode_AsASCIIString(
     705                 :            :     PyObject* unicode,
     706                 :            :     const char* errors);
     707                 :            : 
     708                 :            : /* --- Character Map Codecs ----------------------------------------------- */
     709                 :            : 
     710                 :            : /* Translate an Unicode object by applying a character mapping table to
     711                 :            :    it and return the resulting Unicode object.
     712                 :            : 
     713                 :            :    The mapping table must map Unicode ordinal integers to Unicode strings,
     714                 :            :    Unicode ordinal integers or None (causing deletion of the character).
     715                 :            : 
     716                 :            :    Mapping tables may be dictionaries or sequences. Unmapped character
     717                 :            :    ordinals (ones which cause a LookupError) are left untouched and
     718                 :            :    are copied as-is.
     719                 :            : */
     720                 :            : PyAPI_FUNC(PyObject*) _PyUnicode_EncodeCharmap(
     721                 :            :     PyObject *unicode,          /* Unicode object */
     722                 :            :     PyObject *mapping,          /* encoding mapping */
     723                 :            :     const char *errors          /* error handling */
     724                 :            :     );
     725                 :            : 
     726                 :            : /* --- Decimal Encoder ---------------------------------------------------- */
     727                 :            : 
     728                 :            : /* Coverts a Unicode object holding a decimal value to an ASCII string
     729                 :            :    for using in int, float and complex parsers.
     730                 :            :    Transforms code points that have decimal digit property to the
     731                 :            :    corresponding ASCII digit code points.  Transforms spaces to ASCII.
     732                 :            :    Transforms code points starting from the first non-ASCII code point that
     733                 :            :    is neither a decimal digit nor a space to the end into '?'. */
     734                 :            : 
     735                 :            : PyAPI_FUNC(PyObject*) _PyUnicode_TransformDecimalAndSpaceToASCII(
     736                 :            :     PyObject *unicode           /* Unicode object */
     737                 :            :     );
     738                 :            : 
     739                 :            : /* --- Methods & Slots ---------------------------------------------------- */
     740                 :            : 
     741                 :            : PyAPI_FUNC(PyObject *) _PyUnicode_JoinArray(
     742                 :            :     PyObject *separator,
     743                 :            :     PyObject *const *items,
     744                 :            :     Py_ssize_t seqlen
     745                 :            :     );
     746                 :            : 
     747                 :            : /* Test whether a unicode is equal to ASCII identifier.  Return 1 if true,
     748                 :            :    0 otherwise.  The right argument must be ASCII identifier.
     749                 :            :    Any error occurs inside will be cleared before return. */
     750                 :            : PyAPI_FUNC(int) _PyUnicode_EqualToASCIIId(
     751                 :            :     PyObject *left,             /* Left string */
     752                 :            :     _Py_Identifier *right       /* Right identifier */
     753                 :            :     );
     754                 :            : 
     755                 :            : /* Test whether a unicode is equal to ASCII string.  Return 1 if true,
     756                 :            :    0 otherwise.  The right argument must be ASCII-encoded string.
     757                 :            :    Any error occurs inside will be cleared before return. */
     758                 :            : PyAPI_FUNC(int) _PyUnicode_EqualToASCIIString(
     759                 :            :     PyObject *left,
     760                 :            :     const char *right           /* ASCII-encoded string */
     761                 :            :     );
     762                 :            : 
     763                 :            : /* Externally visible for str.strip(unicode) */
     764                 :            : PyAPI_FUNC(PyObject *) _PyUnicode_XStrip(
     765                 :            :     PyObject *self,
     766                 :            :     int striptype,
     767                 :            :     PyObject *sepobj
     768                 :            :     );
     769                 :            : 
     770                 :            : /* Using explicit passed-in values, insert the thousands grouping
     771                 :            :    into the string pointed to by buffer.  For the argument descriptions,
     772                 :            :    see Objects/stringlib/localeutil.h */
     773                 :            : PyAPI_FUNC(Py_ssize_t) _PyUnicode_InsertThousandsGrouping(
     774                 :            :     _PyUnicodeWriter *writer,
     775                 :            :     Py_ssize_t n_buffer,
     776                 :            :     PyObject *digits,
     777                 :            :     Py_ssize_t d_pos,
     778                 :            :     Py_ssize_t n_digits,
     779                 :            :     Py_ssize_t min_width,
     780                 :            :     const char *grouping,
     781                 :            :     PyObject *thousands_sep,
     782                 :            :     Py_UCS4 *maxchar);
     783                 :            : 
     784                 :            : /* === Characters Type APIs =============================================== */
     785                 :            : 
     786                 :            : /* These should not be used directly. Use the Py_UNICODE_IS* and
     787                 :            :    Py_UNICODE_TO* macros instead.
     788                 :            : 
     789                 :            :    These APIs are implemented in Objects/unicodectype.c.
     790                 :            : 
     791                 :            : */
     792                 :            : 
     793                 :            : PyAPI_FUNC(int) _PyUnicode_IsLowercase(
     794                 :            :     Py_UCS4 ch       /* Unicode character */
     795                 :            :     );
     796                 :            : 
     797                 :            : PyAPI_FUNC(int) _PyUnicode_IsUppercase(
     798                 :            :     Py_UCS4 ch       /* Unicode character */
     799                 :            :     );
     800                 :            : 
     801                 :            : PyAPI_FUNC(int) _PyUnicode_IsTitlecase(
     802                 :            :     Py_UCS4 ch       /* Unicode character */
     803                 :            :     );
     804                 :            : 
     805                 :            : PyAPI_FUNC(int) _PyUnicode_IsXidStart(
     806                 :            :     Py_UCS4 ch       /* Unicode character */
     807                 :            :     );
     808                 :            : 
     809                 :            : PyAPI_FUNC(int) _PyUnicode_IsXidContinue(
     810                 :            :     Py_UCS4 ch       /* Unicode character */
     811                 :            :     );
     812                 :            : 
     813                 :            : PyAPI_FUNC(int) _PyUnicode_IsWhitespace(
     814                 :            :     const Py_UCS4 ch         /* Unicode character */
     815                 :            :     );
     816                 :            : 
     817                 :            : PyAPI_FUNC(int) _PyUnicode_IsLinebreak(
     818                 :            :     const Py_UCS4 ch         /* Unicode character */
     819                 :            :     );
     820                 :            : 
     821                 :            : /* Py_DEPRECATED(3.3) */ PyAPI_FUNC(Py_UCS4) _PyUnicode_ToLowercase(
     822                 :            :     Py_UCS4 ch       /* Unicode character */
     823                 :            :     );
     824                 :            : 
     825                 :            : /* Py_DEPRECATED(3.3) */ PyAPI_FUNC(Py_UCS4) _PyUnicode_ToUppercase(
     826                 :            :     Py_UCS4 ch       /* Unicode character */
     827                 :            :     );
     828                 :            : 
     829                 :            : Py_DEPRECATED(3.3) PyAPI_FUNC(Py_UCS4) _PyUnicode_ToTitlecase(
     830                 :            :     Py_UCS4 ch       /* Unicode character */
     831                 :            :     );
     832                 :            : 
     833                 :            : PyAPI_FUNC(int) _PyUnicode_ToLowerFull(
     834                 :            :     Py_UCS4 ch,       /* Unicode character */
     835                 :            :     Py_UCS4 *res
     836                 :            :     );
     837                 :            : 
     838                 :            : PyAPI_FUNC(int) _PyUnicode_ToTitleFull(
     839                 :            :     Py_UCS4 ch,       /* Unicode character */
     840                 :            :     Py_UCS4 *res
     841                 :            :     );
     842                 :            : 
     843                 :            : PyAPI_FUNC(int) _PyUnicode_ToUpperFull(
     844                 :            :     Py_UCS4 ch,       /* Unicode character */
     845                 :            :     Py_UCS4 *res
     846                 :            :     );
     847                 :            : 
     848                 :            : PyAPI_FUNC(int) _PyUnicode_ToFoldedFull(
     849                 :            :     Py_UCS4 ch,       /* Unicode character */
     850                 :            :     Py_UCS4 *res
     851                 :            :     );
     852                 :            : 
     853                 :            : PyAPI_FUNC(int) _PyUnicode_IsCaseIgnorable(
     854                 :            :     Py_UCS4 ch         /* Unicode character */
     855                 :            :     );
     856                 :            : 
     857                 :            : PyAPI_FUNC(int) _PyUnicode_IsCased(
     858                 :            :     Py_UCS4 ch         /* Unicode character */
     859                 :            :     );
     860                 :            : 
     861                 :            : PyAPI_FUNC(int) _PyUnicode_ToDecimalDigit(
     862                 :            :     Py_UCS4 ch       /* Unicode character */
     863                 :            :     );
     864                 :            : 
     865                 :            : PyAPI_FUNC(int) _PyUnicode_ToDigit(
     866                 :            :     Py_UCS4 ch       /* Unicode character */
     867                 :            :     );
     868                 :            : 
     869                 :            : PyAPI_FUNC(double) _PyUnicode_ToNumeric(
     870                 :            :     Py_UCS4 ch       /* Unicode character */
     871                 :            :     );
     872                 :            : 
     873                 :            : PyAPI_FUNC(int) _PyUnicode_IsDecimalDigit(
     874                 :            :     Py_UCS4 ch       /* Unicode character */
     875                 :            :     );
     876                 :            : 
     877                 :            : PyAPI_FUNC(int) _PyUnicode_IsDigit(
     878                 :            :     Py_UCS4 ch       /* Unicode character */
     879                 :            :     );
     880                 :            : 
     881                 :            : PyAPI_FUNC(int) _PyUnicode_IsNumeric(
     882                 :            :     Py_UCS4 ch       /* Unicode character */
     883                 :            :     );
     884                 :            : 
     885                 :            : PyAPI_FUNC(int) _PyUnicode_IsPrintable(
     886                 :            :     Py_UCS4 ch       /* Unicode character */
     887                 :            :     );
     888                 :            : 
     889                 :            : PyAPI_FUNC(int) _PyUnicode_IsAlpha(
     890                 :            :     Py_UCS4 ch       /* Unicode character */
     891                 :            :     );
     892                 :            : 
     893                 :            : // Helper array used by Py_UNICODE_ISSPACE().
     894                 :            : PyAPI_DATA(const unsigned char) _Py_ascii_whitespace[];
     895                 :            : 
     896                 :            : // Since splitting on whitespace is an important use case, and
     897                 :            : // whitespace in most situations is solely ASCII whitespace, we
     898                 :            : // optimize for the common case by using a quick look-up table
     899                 :            : // _Py_ascii_whitespace (see below) with an inlined check.
     900                 :     188085 : static inline int Py_UNICODE_ISSPACE(Py_UCS4 ch) {
     901         [ +  - ]:     188085 :     if (ch < 128) {
     902                 :     188085 :         return _Py_ascii_whitespace[ch];
     903                 :            :     }
     904                 :          0 :     return _PyUnicode_IsWhitespace(ch);
     905                 :            : }
     906                 :            : 
     907                 :            : #define Py_UNICODE_ISLOWER(ch) _PyUnicode_IsLowercase(ch)
     908                 :            : #define Py_UNICODE_ISUPPER(ch) _PyUnicode_IsUppercase(ch)
     909                 :            : #define Py_UNICODE_ISTITLE(ch) _PyUnicode_IsTitlecase(ch)
     910                 :            : #define Py_UNICODE_ISLINEBREAK(ch) _PyUnicode_IsLinebreak(ch)
     911                 :            : 
     912                 :            : #define Py_UNICODE_TOLOWER(ch) _PyUnicode_ToLowercase(ch)
     913                 :            : #define Py_UNICODE_TOUPPER(ch) _PyUnicode_ToUppercase(ch)
     914                 :            : #define Py_UNICODE_TOTITLE(ch) _PyUnicode_ToTitlecase(ch)
     915                 :            : 
     916                 :            : #define Py_UNICODE_ISDECIMAL(ch) _PyUnicode_IsDecimalDigit(ch)
     917                 :            : #define Py_UNICODE_ISDIGIT(ch) _PyUnicode_IsDigit(ch)
     918                 :            : #define Py_UNICODE_ISNUMERIC(ch) _PyUnicode_IsNumeric(ch)
     919                 :            : #define Py_UNICODE_ISPRINTABLE(ch) _PyUnicode_IsPrintable(ch)
     920                 :            : 
     921                 :            : #define Py_UNICODE_TODECIMAL(ch) _PyUnicode_ToDecimalDigit(ch)
     922                 :            : #define Py_UNICODE_TODIGIT(ch) _PyUnicode_ToDigit(ch)
     923                 :            : #define Py_UNICODE_TONUMERIC(ch) _PyUnicode_ToNumeric(ch)
     924                 :            : 
     925                 :            : #define Py_UNICODE_ISALPHA(ch) _PyUnicode_IsAlpha(ch)
     926                 :            : 
     927                 :   67028638 : static inline int Py_UNICODE_ISALNUM(Py_UCS4 ch) {
     928                 :   67028638 :    return (Py_UNICODE_ISALPHA(ch)
     929         [ +  + ]:   38471348 :            || Py_UNICODE_ISDECIMAL(ch)
     930         [ +  - ]:   27352855 :            || Py_UNICODE_ISDIGIT(ch)
     931   [ +  +  -  + ]:  105499986 :            || Py_UNICODE_ISNUMERIC(ch));
     932                 :            : }
     933                 :            : 
     934                 :            : 
     935                 :            : /* === Misc functions ===================================================== */
     936                 :            : 
     937                 :            : PyAPI_FUNC(PyObject*) _PyUnicode_FormatLong(PyObject *, int, int, int);
     938                 :            : 
     939                 :            : /* Return an interned Unicode object for an Identifier; may fail if there is no memory.*/
     940                 :            : PyAPI_FUNC(PyObject*) _PyUnicode_FromId(_Py_Identifier*);
     941                 :            : 
     942                 :            : /* Fast equality check when the inputs are known to be exact unicode types
     943                 :            :    and where the hash values are equal (i.e. a very probable match) */
     944                 :            : PyAPI_FUNC(int) _PyUnicode_EQ(PyObject *, PyObject *);
     945                 :            : 
     946                 :            : /* Equality check. */
     947                 :            : PyAPI_FUNC(int) _PyUnicode_Equal(PyObject *, PyObject *);
     948                 :            : 
     949                 :            : PyAPI_FUNC(int) _PyUnicode_WideCharString_Converter(PyObject *, void *);
     950                 :            : PyAPI_FUNC(int) _PyUnicode_WideCharString_Opt_Converter(PyObject *, void *);
     951                 :            : 
     952                 :            : PyAPI_FUNC(Py_ssize_t) _PyUnicode_ScanIdentifier(PyObject *);

Generated by: LCOV version 1.14