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#ifndef USE_UNICODE_WCHAR_CACHE
15# define USE_UNICODE_WCHAR_CACHE 1
16#endif /* USE_UNICODE_WCHAR_CACHE */
17
18/* Since splitting on whitespace is an important use case, and
19 whitespace in most situations is solely ASCII whitespace, we
20 optimize for the common case by using a quick look-up table
21 _Py_ascii_whitespace (see below) with an inlined check.
22
23 */
24#define Py_UNICODE_ISSPACE(ch) \
25 ((Py_UCS4)(ch) < 128U ? _Py_ascii_whitespace[(ch)] : _PyUnicode_IsWhitespace(ch))
26
27#define Py_UNICODE_ISLOWER(ch) _PyUnicode_IsLowercase(ch)
28#define Py_UNICODE_ISUPPER(ch) _PyUnicode_IsUppercase(ch)
29#define Py_UNICODE_ISTITLE(ch) _PyUnicode_IsTitlecase(ch)
30#define Py_UNICODE_ISLINEBREAK(ch) _PyUnicode_IsLinebreak(ch)
31
32#define Py_UNICODE_TOLOWER(ch) _PyUnicode_ToLowercase(ch)
33#define Py_UNICODE_TOUPPER(ch) _PyUnicode_ToUppercase(ch)
34#define Py_UNICODE_TOTITLE(ch) _PyUnicode_ToTitlecase(ch)
35
36#define Py_UNICODE_ISDECIMAL(ch) _PyUnicode_IsDecimalDigit(ch)
37#define Py_UNICODE_ISDIGIT(ch) _PyUnicode_IsDigit(ch)
38#define Py_UNICODE_ISNUMERIC(ch) _PyUnicode_IsNumeric(ch)
39#define Py_UNICODE_ISPRINTABLE(ch) _PyUnicode_IsPrintable(ch)
40
41#define Py_UNICODE_TODECIMAL(ch) _PyUnicode_ToDecimalDigit(ch)
42#define Py_UNICODE_TODIGIT(ch) _PyUnicode_ToDigit(ch)
43#define Py_UNICODE_TONUMERIC(ch) _PyUnicode_ToNumeric(ch)
44
45#define Py_UNICODE_ISALPHA(ch) _PyUnicode_IsAlpha(ch)
46
47#define Py_UNICODE_ISALNUM(ch) \
48 (Py_UNICODE_ISALPHA(ch) || \
49 Py_UNICODE_ISDECIMAL(ch) || \
50 Py_UNICODE_ISDIGIT(ch) || \
51 Py_UNICODE_ISNUMERIC(ch))
52
53Py_DEPRECATED(3.3) static inline void
54Py_UNICODE_COPY(Py_UNICODE *target, const Py_UNICODE *source, Py_ssize_t length) {
55 memcpy(dest: target, src: source, n: (size_t)(length) * sizeof(Py_UNICODE));
56}
57
58Py_DEPRECATED(3.3) static inline void
59Py_UNICODE_FILL(Py_UNICODE *target, Py_UNICODE value, Py_ssize_t length) {
60 Py_ssize_t i;
61 for (i = 0; i < length; i++) {
62 target[i] = value;
63 }
64}
65
66/* macros to work with surrogates */
67#define Py_UNICODE_IS_SURROGATE(ch) (0xD800 <= (ch) && (ch) <= 0xDFFF)
68#define Py_UNICODE_IS_HIGH_SURROGATE(ch) (0xD800 <= (ch) && (ch) <= 0xDBFF)
69#define Py_UNICODE_IS_LOW_SURROGATE(ch) (0xDC00 <= (ch) && (ch) <= 0xDFFF)
70/* Join two surrogate characters and return a single Py_UCS4 value. */
71#define Py_UNICODE_JOIN_SURROGATES(high, low) \
72 (((((Py_UCS4)(high) & 0x03FF) << 10) | \
73 ((Py_UCS4)(low) & 0x03FF)) + 0x10000)
74/* high surrogate = top 10 bits added to D800 */
75#define Py_UNICODE_HIGH_SURROGATE(ch) (0xD800 - (0x10000 >> 10) + ((ch) >> 10))
76/* low surrogate = bottom 10 bits added to DC00 */
77#define Py_UNICODE_LOW_SURROGATE(ch) (0xDC00 + ((ch) & 0x3FF))
78
79/* --- Unicode Type ------------------------------------------------------- */
80
81/* ASCII-only strings created through PyUnicode_New use the PyASCIIObject
82 structure. state.ascii and state.compact are set, and the data
83 immediately follow the structure. utf8_length and wstr_length can be found
84 in the length field; the utf8 pointer is equal to the data pointer. */
85typedef struct {
86 /* There are 4 forms of Unicode strings:
87
88 - compact ascii:
89
90 * structure = PyASCIIObject
91 * test: PyUnicode_IS_COMPACT_ASCII(op)
92 * kind = PyUnicode_1BYTE_KIND
93 * compact = 1
94 * ascii = 1
95 * ready = 1
96 * (length is the length of the utf8 and wstr strings)
97 * (data starts just after the structure)
98 * (since ASCII is decoded from UTF-8, the utf8 string are the data)
99
100 - compact:
101
102 * structure = PyCompactUnicodeObject
103 * test: PyUnicode_IS_COMPACT(op) && !PyUnicode_IS_ASCII(op)
104 * kind = PyUnicode_1BYTE_KIND, PyUnicode_2BYTE_KIND or
105 PyUnicode_4BYTE_KIND
106 * compact = 1
107 * ready = 1
108 * ascii = 0
109 * utf8 is not shared with data
110 * utf8_length = 0 if utf8 is NULL
111 * wstr is shared with data and wstr_length=length
112 if kind=PyUnicode_2BYTE_KIND and sizeof(wchar_t)=2
113 or if kind=PyUnicode_4BYTE_KIND and sizeof(wchar_t)=4
114 * wstr_length = 0 if wstr is NULL
115 * (data starts just after the structure)
116
117 - legacy string, not ready:
118
119 * structure = PyUnicodeObject
120 * test: kind == PyUnicode_WCHAR_KIND
121 * length = 0 (use wstr_length)
122 * hash = -1
123 * kind = PyUnicode_WCHAR_KIND
124 * compact = 0
125 * ascii = 0
126 * ready = 0
127 * interned = SSTATE_NOT_INTERNED
128 * wstr is not NULL
129 * data.any is NULL
130 * utf8 is NULL
131 * utf8_length = 0
132
133 - legacy string, ready:
134
135 * structure = PyUnicodeObject structure
136 * test: !PyUnicode_IS_COMPACT(op) && kind != PyUnicode_WCHAR_KIND
137 * kind = PyUnicode_1BYTE_KIND, PyUnicode_2BYTE_KIND or
138 PyUnicode_4BYTE_KIND
139 * compact = 0
140 * ready = 1
141 * data.any is not NULL
142 * utf8 is shared and utf8_length = length with data.any if ascii = 1
143 * utf8_length = 0 if utf8 is NULL
144 * wstr is shared with data.any and wstr_length = length
145 if kind=PyUnicode_2BYTE_KIND and sizeof(wchar_t)=2
146 or if kind=PyUnicode_4BYTE_KIND and sizeof(wchar_4)=4
147 * wstr_length = 0 if wstr is NULL
148
149 Compact strings use only one memory block (structure + characters),
150 whereas legacy strings use one block for the structure and one block
151 for characters.
152
153 Legacy strings are created by PyUnicode_FromUnicode() and
154 PyUnicode_FromStringAndSize(NULL, size) functions. They become ready
155 when PyUnicode_READY() is called.
156
157 See also _PyUnicode_CheckConsistency().
158 */
159 PyObject_HEAD
160 Py_ssize_t length; /* Number of code points in the string */
161 Py_hash_t hash; /* Hash value; -1 if not set */
162 struct {
163 /*
164 SSTATE_NOT_INTERNED (0)
165 SSTATE_INTERNED_MORTAL (1)
166 SSTATE_INTERNED_IMMORTAL (2)
167
168 If interned != SSTATE_NOT_INTERNED, the two references from the
169 dictionary to this object are *not* counted in ob_refcnt.
170 */
171 unsigned int interned:2;
172 /* Character size:
173
174 - PyUnicode_WCHAR_KIND (0):
175
176 * character type = wchar_t (16 or 32 bits, depending on the
177 platform)
178
179 - PyUnicode_1BYTE_KIND (1):
180
181 * character type = Py_UCS1 (8 bits, unsigned)
182 * all characters are in the range U+0000-U+00FF (latin1)
183 * if ascii is set, all characters are in the range U+0000-U+007F
184 (ASCII), otherwise at least one character is in the range
185 U+0080-U+00FF
186
187 - PyUnicode_2BYTE_KIND (2):
188
189 * character type = Py_UCS2 (16 bits, unsigned)
190 * all characters are in the range U+0000-U+FFFF (BMP)
191 * at least one character is in the range U+0100-U+FFFF
192
193 - PyUnicode_4BYTE_KIND (4):
194
195 * character type = Py_UCS4 (32 bits, unsigned)
196 * all characters are in the range U+0000-U+10FFFF
197 * at least one character is in the range U+10000-U+10FFFF
198 */
199 unsigned int kind:3;
200 /* Compact is with respect to the allocation scheme. Compact unicode
201 objects only require one memory block while non-compact objects use
202 one block for the PyUnicodeObject struct and another for its data
203 buffer. */
204 unsigned int compact:1;
205 /* The string only contains characters in the range U+0000-U+007F (ASCII)
206 and the kind is PyUnicode_1BYTE_KIND. If ascii is set and compact is
207 set, use the PyASCIIObject structure. */
208 unsigned int ascii:1;
209 /* The ready flag indicates whether the object layout is initialized
210 completely. This means that this is either a compact object, or
211 the data pointer is filled out. The bit is redundant, and helps
212 to minimize the test in PyUnicode_IS_READY(). */
213 unsigned int ready:1;
214 /* Padding to ensure that PyUnicode_DATA() is always aligned to
215 4 bytes (see issue #19537 on m68k). */
216 unsigned int :24;
217 } state;
218 wchar_t *wstr; /* wchar_t representation (null-terminated) */
219} PyASCIIObject;
220
221/* Non-ASCII strings allocated through PyUnicode_New use the
222 PyCompactUnicodeObject structure. state.compact is set, and the data
223 immediately follow the structure. */
224typedef struct {
225 PyASCIIObject _base;
226 Py_ssize_t utf8_length; /* Number of bytes in utf8, excluding the
227 * terminating \0. */
228 char *utf8; /* UTF-8 representation (null-terminated) */
229 Py_ssize_t wstr_length; /* Number of code points in wstr, possible
230 * surrogates count as two code points. */
231} PyCompactUnicodeObject;
232
233/* Strings allocated through PyUnicode_FromUnicode(NULL, len) use the
234 PyUnicodeObject structure. The actual string data is initially in the wstr
235 block, and copied into the data block using _PyUnicode_Ready. */
236typedef struct {
237 PyCompactUnicodeObject _base;
238 union {
239 void *any;
240 Py_UCS1 *latin1;
241 Py_UCS2 *ucs2;
242 Py_UCS4 *ucs4;
243 } data; /* Canonical, smallest-form Unicode buffer */
244} PyUnicodeObject;
245
246PyAPI_FUNC(int) _PyUnicode_CheckConsistency(
247 PyObject *op,
248 int check_content);
249
250/* Fast access macros */
251
252/* Returns the deprecated Py_UNICODE representation's size in code units
253 (this includes surrogate pairs as 2 units).
254 If the Py_UNICODE representation is not available, it will be computed
255 on request. Use PyUnicode_GET_LENGTH() for the length in code points. */
256
257/* Py_DEPRECATED(3.3) */
258#define PyUnicode_GET_SIZE(op) \
259 (assert(PyUnicode_Check(op)), \
260 (((PyASCIIObject *)(op))->wstr) ? \
261 PyUnicode_WSTR_LENGTH(op) : \
262 ((void)PyUnicode_AsUnicode(_PyObject_CAST(op)),\
263 assert(((PyASCIIObject *)(op))->wstr), \
264 PyUnicode_WSTR_LENGTH(op)))
265
266/* Py_DEPRECATED(3.3) */
267#define PyUnicode_GET_DATA_SIZE(op) \
268 (PyUnicode_GET_SIZE(op) * Py_UNICODE_SIZE)
269
270/* Alias for PyUnicode_AsUnicode(). This will create a wchar_t/Py_UNICODE
271 representation on demand. Using this macro is very inefficient now,
272 try to port your code to use the new PyUnicode_*BYTE_DATA() macros or
273 use PyUnicode_WRITE() and PyUnicode_READ(). */
274
275/* Py_DEPRECATED(3.3) */
276#define PyUnicode_AS_UNICODE(op) \
277 (assert(PyUnicode_Check(op)), \
278 (((PyASCIIObject *)(op))->wstr) ? (((PyASCIIObject *)(op))->wstr) : \
279 PyUnicode_AsUnicode(_PyObject_CAST(op)))
280
281/* Py_DEPRECATED(3.3) */
282#define PyUnicode_AS_DATA(op) \
283 ((const char *)(PyUnicode_AS_UNICODE(op)))
284
285
286/* --- Flexible String Representation Helper Macros (PEP 393) -------------- */
287
288/* Values for PyASCIIObject.state: */
289
290/* Interning state. */
291#define SSTATE_NOT_INTERNED 0
292#define SSTATE_INTERNED_MORTAL 1
293#define SSTATE_INTERNED_IMMORTAL 2
294
295/* Return true if the string contains only ASCII characters, or 0 if not. The
296 string may be compact (PyUnicode_IS_COMPACT_ASCII) or not, but must be
297 ready. */
298#define PyUnicode_IS_ASCII(op) \
299 (assert(PyUnicode_Check(op)), \
300 assert(PyUnicode_IS_READY(op)), \
301 ((PyASCIIObject*)op)->state.ascii)
302
303/* Return true if the string is compact or 0 if not.
304 No type checks or Ready calls are performed. */
305#define PyUnicode_IS_COMPACT(op) \
306 (((PyASCIIObject*)(op))->state.compact)
307
308/* Return true if the string is a compact ASCII string (use PyASCIIObject
309 structure), or 0 if not. No type checks or Ready calls are performed. */
310#define PyUnicode_IS_COMPACT_ASCII(op) \
311 (((PyASCIIObject*)op)->state.ascii && PyUnicode_IS_COMPACT(op))
312
313enum PyUnicode_Kind {
314/* String contains only wstr byte characters. This is only possible
315 when the string was created with a legacy API and _PyUnicode_Ready()
316 has not been called yet. */
317 PyUnicode_WCHAR_KIND = 0,
318/* Return values of the PyUnicode_KIND() macro: */
319 PyUnicode_1BYTE_KIND = 1,
320 PyUnicode_2BYTE_KIND = 2,
321 PyUnicode_4BYTE_KIND = 4
322};
323
324/* Return pointers to the canonical representation cast to unsigned char,
325 Py_UCS2, or Py_UCS4 for direct character access.
326 No checks are performed, use PyUnicode_KIND() before to ensure
327 these will work correctly. */
328
329#define PyUnicode_1BYTE_DATA(op) ((Py_UCS1*)PyUnicode_DATA(op))
330#define PyUnicode_2BYTE_DATA(op) ((Py_UCS2*)PyUnicode_DATA(op))
331#define PyUnicode_4BYTE_DATA(op) ((Py_UCS4*)PyUnicode_DATA(op))
332
333/* Return one of the PyUnicode_*_KIND values defined above. */
334#define PyUnicode_KIND(op) \
335 (assert(PyUnicode_Check(op)), \
336 assert(PyUnicode_IS_READY(op)), \
337 ((PyASCIIObject *)(op))->state.kind)
338
339/* Return a void pointer to the raw unicode buffer. */
340#define _PyUnicode_COMPACT_DATA(op) \
341 (PyUnicode_IS_ASCII(op) ? \
342 ((void*)((PyASCIIObject*)(op) + 1)) : \
343 ((void*)((PyCompactUnicodeObject*)(op) + 1)))
344
345#define _PyUnicode_NONCOMPACT_DATA(op) \
346 (assert(((PyUnicodeObject*)(op))->data.any), \
347 ((((PyUnicodeObject *)(op))->data.any)))
348
349#define PyUnicode_DATA(op) \
350 (assert(PyUnicode_Check(op)), \
351 PyUnicode_IS_COMPACT(op) ? _PyUnicode_COMPACT_DATA(op) : \
352 _PyUnicode_NONCOMPACT_DATA(op))
353
354/* In the access macros below, "kind" may be evaluated more than once.
355 All other macro parameters are evaluated exactly once, so it is safe
356 to put side effects into them (such as increasing the index). */
357
358/* Write into the canonical representation, this macro does not do any sanity
359 checks and is intended for usage in loops. The caller should cache the
360 kind and data pointers obtained from other macro calls.
361 index is the index in the string (starts at 0) and value is the new
362 code point value which should be written to that location. */
363#define PyUnicode_WRITE(kind, data, index, value) \
364 do { \
365 switch ((kind)) { \
366 case PyUnicode_1BYTE_KIND: { \
367 ((Py_UCS1 *)(data))[(index)] = (Py_UCS1)(value); \
368 break; \
369 } \
370 case PyUnicode_2BYTE_KIND: { \
371 ((Py_UCS2 *)(data))[(index)] = (Py_UCS2)(value); \
372 break; \
373 } \
374 default: { \
375 assert((kind) == PyUnicode_4BYTE_KIND); \
376 ((Py_UCS4 *)(data))[(index)] = (Py_UCS4)(value); \
377 } \
378 } \
379 } while (0)
380
381/* Read a code point from the string's canonical representation. No checks
382 or ready calls are performed. */
383#define PyUnicode_READ(kind, data, index) \
384 ((Py_UCS4) \
385 ((kind) == PyUnicode_1BYTE_KIND ? \
386 ((const Py_UCS1 *)(data))[(index)] : \
387 ((kind) == PyUnicode_2BYTE_KIND ? \
388 ((const Py_UCS2 *)(data))[(index)] : \
389 ((const Py_UCS4 *)(data))[(index)] \
390 ) \
391 ))
392
393/* PyUnicode_READ_CHAR() is less efficient than PyUnicode_READ() because it
394 calls PyUnicode_KIND() and might call it twice. For single reads, use
395 PyUnicode_READ_CHAR, for multiple consecutive reads callers should
396 cache kind and use PyUnicode_READ instead. */
397#define PyUnicode_READ_CHAR(unicode, index) \
398 (assert(PyUnicode_Check(unicode)), \
399 assert(PyUnicode_IS_READY(unicode)), \
400 (Py_UCS4) \
401 (PyUnicode_KIND((unicode)) == PyUnicode_1BYTE_KIND ? \
402 ((const Py_UCS1 *)(PyUnicode_DATA((unicode))))[(index)] : \
403 (PyUnicode_KIND((unicode)) == PyUnicode_2BYTE_KIND ? \
404 ((const Py_UCS2 *)(PyUnicode_DATA((unicode))))[(index)] : \
405 ((const Py_UCS4 *)(PyUnicode_DATA((unicode))))[(index)] \
406 ) \
407 ))
408
409/* Returns the length of the unicode string. The caller has to make sure that
410 the string has it's canonical representation set before calling
411 this macro. Call PyUnicode_(FAST_)Ready to ensure that. */
412#define PyUnicode_GET_LENGTH(op) \
413 (assert(PyUnicode_Check(op)), \
414 assert(PyUnicode_IS_READY(op)), \
415 ((PyASCIIObject *)(op))->length)
416
417
418/* Fast check to determine whether an object is ready. Equivalent to
419 PyUnicode_IS_COMPACT(op) || ((PyUnicodeObject*)(op))->data.any */
420
421#define PyUnicode_IS_READY(op) (((PyASCIIObject*)op)->state.ready)
422
423/* PyUnicode_READY() does less work than _PyUnicode_Ready() in the best
424 case. If the canonical representation is not yet set, it will still call
425 _PyUnicode_Ready().
426 Returns 0 on success and -1 on errors. */
427#define PyUnicode_READY(op) \
428 (assert(PyUnicode_Check(op)), \
429 (PyUnicode_IS_READY(op) ? \
430 0 : _PyUnicode_Ready(_PyObject_CAST(op))))
431
432/* Return a maximum character value which is suitable for creating another
433 string based on op. This is always an approximation but more efficient
434 than iterating over the string. */
435#define PyUnicode_MAX_CHAR_VALUE(op) \
436 (assert(PyUnicode_IS_READY(op)), \
437 (PyUnicode_IS_ASCII(op) ? \
438 (0x7f) : \
439 (PyUnicode_KIND(op) == PyUnicode_1BYTE_KIND ? \
440 (0xffU) : \
441 (PyUnicode_KIND(op) == PyUnicode_2BYTE_KIND ? \
442 (0xffffU) : \
443 (0x10ffffU)))))
444
445Py_DEPRECATED(3.3)
446static inline Py_ssize_t _PyUnicode_get_wstr_length(PyObject *op) {
447 return PyUnicode_IS_COMPACT_ASCII(op) ?
448 ((PyASCIIObject*)op)->length :
449 ((PyCompactUnicodeObject*)op)->wstr_length;
450}
451#define PyUnicode_WSTR_LENGTH(op) _PyUnicode_get_wstr_length((PyObject*)op)
452
453/* === Public API ========================================================= */
454
455/* --- Plain Py_UNICODE --------------------------------------------------- */
456
457/* With PEP 393, this is the recommended way to allocate a new unicode object.
458 This function will allocate the object and its buffer in a single memory
459 block. Objects created using this function are not resizable. */
460PyAPI_FUNC(PyObject*) PyUnicode_New(
461 Py_ssize_t size, /* Number of code points in the new string */
462 Py_UCS4 maxchar /* maximum code point value in the string */
463 );
464
465/* Initializes the canonical string representation from the deprecated
466 wstr/Py_UNICODE representation. This function is used to convert Unicode
467 objects which were created using the old API to the new flexible format
468 introduced with PEP 393.
469
470 Don't call this function directly, use the public PyUnicode_READY() macro
471 instead. */
472PyAPI_FUNC(int) _PyUnicode_Ready(
473 PyObject *unicode /* Unicode object */
474 );
475
476/* Get a copy of a Unicode string. */
477PyAPI_FUNC(PyObject*) _PyUnicode_Copy(
478 PyObject *unicode
479 );
480
481/* Copy character from one unicode object into another, this function performs
482 character conversion when necessary and falls back to memcpy() if possible.
483
484 Fail if to is too small (smaller than *how_many* or smaller than
485 len(from)-from_start), or if kind(from[from_start:from_start+how_many]) >
486 kind(to), or if *to* has more than 1 reference.
487
488 Return the number of written character, or return -1 and raise an exception
489 on error.
490
491 Pseudo-code:
492
493 how_many = min(how_many, len(from) - from_start)
494 to[to_start:to_start+how_many] = from[from_start:from_start+how_many]
495 return how_many
496
497 Note: The function doesn't write a terminating null character.
498 */
499PyAPI_FUNC(Py_ssize_t) PyUnicode_CopyCharacters(
500 PyObject *to,
501 Py_ssize_t to_start,
502 PyObject *from,
503 Py_ssize_t from_start,
504 Py_ssize_t how_many
505 );
506
507/* Unsafe version of PyUnicode_CopyCharacters(): don't check arguments and so
508 may crash if parameters are invalid (e.g. if the output string
509 is too short). */
510PyAPI_FUNC(void) _PyUnicode_FastCopyCharacters(
511 PyObject *to,
512 Py_ssize_t to_start,
513 PyObject *from,
514 Py_ssize_t from_start,
515 Py_ssize_t how_many
516 );
517
518/* Fill a string with a character: write fill_char into
519 unicode[start:start+length].
520
521 Fail if fill_char is bigger than the string maximum character, or if the
522 string has more than 1 reference.
523
524 Return the number of written character, or return -1 and raise an exception
525 on error. */
526PyAPI_FUNC(Py_ssize_t) PyUnicode_Fill(
527 PyObject *unicode,
528 Py_ssize_t start,
529 Py_ssize_t length,
530 Py_UCS4 fill_char
531 );
532
533/* Unsafe version of PyUnicode_Fill(): don't check arguments and so may crash
534 if parameters are invalid (e.g. if length is longer than the string). */
535PyAPI_FUNC(void) _PyUnicode_FastFill(
536 PyObject *unicode,
537 Py_ssize_t start,
538 Py_ssize_t length,
539 Py_UCS4 fill_char
540 );
541
542/* Create a Unicode Object from the Py_UNICODE buffer u of the given
543 size.
544
545 u may be NULL which causes the contents to be undefined. It is the
546 user's responsibility to fill in the needed data afterwards. Note
547 that modifying the Unicode object contents after construction is
548 only allowed if u was set to NULL.
549
550 The buffer is copied into the new object. */
551Py_DEPRECATED(3.3) PyAPI_FUNC(PyObject*) PyUnicode_FromUnicode(
552 const Py_UNICODE *u, /* Unicode buffer */
553 Py_ssize_t size /* size of buffer */
554 );
555
556/* Create a new string from a buffer of Py_UCS1, Py_UCS2 or Py_UCS4 characters.
557 Scan the string to find the maximum character. */
558PyAPI_FUNC(PyObject*) PyUnicode_FromKindAndData(
559 int kind,
560 const void *buffer,
561 Py_ssize_t size);
562
563/* Create a new string from a buffer of ASCII characters.
564 WARNING: Don't check if the string contains any non-ASCII character. */
565PyAPI_FUNC(PyObject*) _PyUnicode_FromASCII(
566 const char *buffer,
567 Py_ssize_t size);
568
569/* Compute the maximum character of the substring unicode[start:end].
570 Return 127 for an empty string. */
571PyAPI_FUNC(Py_UCS4) _PyUnicode_FindMaxChar (
572 PyObject *unicode,
573 Py_ssize_t start,
574 Py_ssize_t end);
575
576/* Return a read-only pointer to the Unicode object's internal
577 Py_UNICODE buffer.
578 If the wchar_t/Py_UNICODE representation is not yet available, this
579 function will calculate it. */
580Py_DEPRECATED(3.3) PyAPI_FUNC(Py_UNICODE *) PyUnicode_AsUnicode(
581 PyObject *unicode /* Unicode object */
582 );
583
584/* Similar to PyUnicode_AsUnicode(), but raises a ValueError if the string
585 contains null characters. */
586PyAPI_FUNC(const Py_UNICODE *) _PyUnicode_AsUnicode(
587 PyObject *unicode /* Unicode object */
588 );
589
590/* Return a read-only pointer to the Unicode object's internal
591 Py_UNICODE buffer and save the length at size.
592 If the wchar_t/Py_UNICODE representation is not yet available, this
593 function will calculate it. */
594
595Py_DEPRECATED(3.3) PyAPI_FUNC(Py_UNICODE *) PyUnicode_AsUnicodeAndSize(
596 PyObject *unicode, /* Unicode object */
597 Py_ssize_t *size /* location where to save the length */
598 );
599
600
601/* --- _PyUnicodeWriter API ----------------------------------------------- */
602
603typedef struct {
604 PyObject *buffer;
605 void *data;
606 enum PyUnicode_Kind kind;
607 Py_UCS4 maxchar;
608 Py_ssize_t size;
609 Py_ssize_t pos;
610
611 /* minimum number of allocated characters (default: 0) */
612 Py_ssize_t min_length;
613
614 /* minimum character (default: 127, ASCII) */
615 Py_UCS4 min_char;
616
617 /* If non-zero, overallocate the buffer (default: 0). */
618 unsigned char overallocate;
619
620 /* If readonly is 1, buffer is a shared string (cannot be modified)
621 and size is set to 0. */
622 unsigned char readonly;
623} _PyUnicodeWriter ;
624
625/* Initialize a Unicode writer.
626 *
627 * By default, the minimum buffer size is 0 character and overallocation is
628 * disabled. Set min_length, min_char and overallocate attributes to control
629 * the allocation of the buffer. */
630PyAPI_FUNC(void)
631_PyUnicodeWriter_Init(_PyUnicodeWriter *writer);
632
633/* Prepare the buffer to write 'length' characters
634 with the specified maximum character.
635
636 Return 0 on success, raise an exception and return -1 on error. */
637#define _PyUnicodeWriter_Prepare(WRITER, LENGTH, MAXCHAR) \
638 (((MAXCHAR) <= (WRITER)->maxchar \
639 && (LENGTH) <= (WRITER)->size - (WRITER)->pos) \
640 ? 0 \
641 : (((LENGTH) == 0) \
642 ? 0 \
643 : _PyUnicodeWriter_PrepareInternal((WRITER), (LENGTH), (MAXCHAR))))
644
645/* Don't call this function directly, use the _PyUnicodeWriter_Prepare() macro
646 instead. */
647PyAPI_FUNC(int)
648_PyUnicodeWriter_PrepareInternal(_PyUnicodeWriter *writer,
649 Py_ssize_t length, Py_UCS4 maxchar);
650
651/* Prepare the buffer to have at least the kind KIND.
652 For example, kind=PyUnicode_2BYTE_KIND ensures that the writer will
653 support characters in range U+000-U+FFFF.
654
655 Return 0 on success, raise an exception and return -1 on error. */
656#define _PyUnicodeWriter_PrepareKind(WRITER, KIND) \
657 (assert((KIND) != PyUnicode_WCHAR_KIND), \
658 (KIND) <= (WRITER)->kind \
659 ? 0 \
660 : _PyUnicodeWriter_PrepareKindInternal((WRITER), (KIND)))
661
662/* Don't call this function directly, use the _PyUnicodeWriter_PrepareKind()
663 macro instead. */
664PyAPI_FUNC(int)
665_PyUnicodeWriter_PrepareKindInternal(_PyUnicodeWriter *writer,
666 enum PyUnicode_Kind kind);
667
668/* Append a Unicode character.
669 Return 0 on success, raise an exception and return -1 on error. */
670PyAPI_FUNC(int)
671_PyUnicodeWriter_WriteChar(_PyUnicodeWriter *writer,
672 Py_UCS4 ch
673 );
674
675/* Append a Unicode string.
676 Return 0 on success, raise an exception and return -1 on error. */
677PyAPI_FUNC(int)
678_PyUnicodeWriter_WriteStr(_PyUnicodeWriter *writer,
679 PyObject *str /* Unicode string */
680 );
681
682/* Append a substring of a Unicode string.
683 Return 0 on success, raise an exception and return -1 on error. */
684PyAPI_FUNC(int)
685_PyUnicodeWriter_WriteSubstring(_PyUnicodeWriter *writer,
686 PyObject *str, /* Unicode string */
687 Py_ssize_t start,
688 Py_ssize_t end
689 );
690
691/* Append an ASCII-encoded byte string.
692 Return 0 on success, raise an exception and return -1 on error. */
693PyAPI_FUNC(int)
694_PyUnicodeWriter_WriteASCIIString(_PyUnicodeWriter *writer,
695 const char *str, /* ASCII-encoded byte string */
696 Py_ssize_t len /* number of bytes, or -1 if unknown */
697 );
698
699/* Append a latin1-encoded byte string.
700 Return 0 on success, raise an exception and return -1 on error. */
701PyAPI_FUNC(int)
702_PyUnicodeWriter_WriteLatin1String(_PyUnicodeWriter *writer,
703 const char *str, /* latin1-encoded byte string */
704 Py_ssize_t len /* length in bytes */
705 );
706
707/* Get the value of the writer as a Unicode string. Clear the
708 buffer of the writer. Raise an exception and return NULL
709 on error. */
710PyAPI_FUNC(PyObject *)
711_PyUnicodeWriter_Finish(_PyUnicodeWriter *writer);
712
713/* Deallocate memory of a writer (clear its internal buffer). */
714PyAPI_FUNC(void)
715_PyUnicodeWriter_Dealloc(_PyUnicodeWriter *writer);
716
717
718/* Format the object based on the format_spec, as defined in PEP 3101
719 (Advanced String Formatting). */
720PyAPI_FUNC(int) _PyUnicode_FormatAdvancedWriter(
721 _PyUnicodeWriter *writer,
722 PyObject *obj,
723 PyObject *format_spec,
724 Py_ssize_t start,
725 Py_ssize_t end);
726
727/* --- Manage the default encoding ---------------------------------------- */
728
729/* Returns a pointer to the default encoding (UTF-8) of the
730 Unicode object unicode.
731
732 Like PyUnicode_AsUTF8AndSize(), this also caches the UTF-8 representation
733 in the unicodeobject.
734
735 _PyUnicode_AsString is a #define for PyUnicode_AsUTF8 to
736 support the previous internal function with the same behaviour.
737
738 Use of this API is DEPRECATED since no size information can be
739 extracted from the returned data.
740*/
741
742PyAPI_FUNC(const char *) PyUnicode_AsUTF8(PyObject *unicode);
743
744#define _PyUnicode_AsString PyUnicode_AsUTF8
745
746/* --- Generic Codecs ----------------------------------------------------- */
747
748/* Encodes a Py_UNICODE buffer of the given size and returns a
749 Python string object. */
750Py_DEPRECATED(3.3) PyAPI_FUNC(PyObject*) PyUnicode_Encode(
751 const Py_UNICODE *s, /* Unicode char buffer */
752 Py_ssize_t size, /* number of Py_UNICODE chars to encode */
753 const char *encoding, /* encoding */
754 const char *errors /* error handling */
755 );
756
757/* --- UTF-7 Codecs ------------------------------------------------------- */
758
759Py_DEPRECATED(3.3) PyAPI_FUNC(PyObject*) PyUnicode_EncodeUTF7(
760 const Py_UNICODE *data, /* Unicode char buffer */
761 Py_ssize_t length, /* number of Py_UNICODE chars to encode */
762 int base64SetO, /* Encode RFC2152 Set O characters in base64 */
763 int base64WhiteSpace, /* Encode whitespace (sp, ht, nl, cr) in base64 */
764 const char *errors /* error handling */
765 );
766
767PyAPI_FUNC(PyObject*) _PyUnicode_EncodeUTF7(
768 PyObject *unicode, /* Unicode object */
769 int base64SetO, /* Encode RFC2152 Set O characters in base64 */
770 int base64WhiteSpace, /* Encode whitespace (sp, ht, nl, cr) in base64 */
771 const char *errors /* error handling */
772 );
773
774/* --- UTF-8 Codecs ------------------------------------------------------- */
775
776PyAPI_FUNC(PyObject*) _PyUnicode_AsUTF8String(
777 PyObject *unicode,
778 const char *errors);
779
780Py_DEPRECATED(3.3) PyAPI_FUNC(PyObject*) PyUnicode_EncodeUTF8(
781 const Py_UNICODE *data, /* Unicode char buffer */
782 Py_ssize_t length, /* number of Py_UNICODE chars to encode */
783 const char *errors /* error handling */
784 );
785
786/* --- UTF-32 Codecs ------------------------------------------------------ */
787
788Py_DEPRECATED(3.3) PyAPI_FUNC(PyObject*) PyUnicode_EncodeUTF32(
789 const Py_UNICODE *data, /* Unicode char buffer */
790 Py_ssize_t length, /* number of Py_UNICODE chars to encode */
791 const char *errors, /* error handling */
792 int byteorder /* byteorder to use 0=BOM+native;-1=LE,1=BE */
793 );
794
795PyAPI_FUNC(PyObject*) _PyUnicode_EncodeUTF32(
796 PyObject *object, /* Unicode object */
797 const char *errors, /* error handling */
798 int byteorder /* byteorder to use 0=BOM+native;-1=LE,1=BE */
799 );
800
801/* --- UTF-16 Codecs ------------------------------------------------------ */
802
803/* Returns a Python string object holding the UTF-16 encoded value of
804 the Unicode data.
805
806 If byteorder is not 0, output is written according to the following
807 byte order:
808
809 byteorder == -1: little endian
810 byteorder == 0: native byte order (writes a BOM mark)
811 byteorder == 1: big endian
812
813 If byteorder is 0, the output string will always start with the
814 Unicode BOM mark (U+FEFF). In the other two modes, no BOM mark is
815 prepended.
816
817 Note that Py_UNICODE data is being interpreted as UTF-16 reduced to
818 UCS-2. This trick makes it possible to add full UTF-16 capabilities
819 at a later point without compromising the APIs.
820
821*/
822Py_DEPRECATED(3.3) PyAPI_FUNC(PyObject*) PyUnicode_EncodeUTF16(
823 const Py_UNICODE *data, /* Unicode char buffer */
824 Py_ssize_t length, /* number of Py_UNICODE chars to encode */
825 const char *errors, /* error handling */
826 int byteorder /* byteorder to use 0=BOM+native;-1=LE,1=BE */
827 );
828
829PyAPI_FUNC(PyObject*) _PyUnicode_EncodeUTF16(
830 PyObject* unicode, /* Unicode object */
831 const char *errors, /* error handling */
832 int byteorder /* byteorder to use 0=BOM+native;-1=LE,1=BE */
833 );
834
835/* --- Unicode-Escape Codecs ---------------------------------------------- */
836
837/* Variant of PyUnicode_DecodeUnicodeEscape that supports partial decoding. */
838PyAPI_FUNC(PyObject*) _PyUnicode_DecodeUnicodeEscapeStateful(
839 const char *string, /* Unicode-Escape encoded string */
840 Py_ssize_t length, /* size of string */
841 const char *errors, /* error handling */
842 Py_ssize_t *consumed /* bytes consumed */
843);
844
845/* Helper for PyUnicode_DecodeUnicodeEscape that detects invalid escape
846 chars. */
847PyAPI_FUNC(PyObject*) _PyUnicode_DecodeUnicodeEscapeInternal(
848 const char *string, /* Unicode-Escape encoded string */
849 Py_ssize_t length, /* size of string */
850 const char *errors, /* error handling */
851 Py_ssize_t *consumed, /* bytes consumed */
852 const char **first_invalid_escape /* on return, points to first
853 invalid escaped char in
854 string. */
855);
856
857Py_DEPRECATED(3.3) PyAPI_FUNC(PyObject*) PyUnicode_EncodeUnicodeEscape(
858 const Py_UNICODE *data, /* Unicode char buffer */
859 Py_ssize_t length /* Number of Py_UNICODE chars to encode */
860 );
861
862/* --- Raw-Unicode-Escape Codecs ------------------------------------------ */
863
864Py_DEPRECATED(3.3) PyAPI_FUNC(PyObject*) PyUnicode_EncodeRawUnicodeEscape(
865 const Py_UNICODE *data, /* Unicode char buffer */
866 Py_ssize_t length /* Number of Py_UNICODE chars to encode */
867 );
868
869/* Variant of PyUnicode_DecodeRawUnicodeEscape that supports partial decoding. */
870PyAPI_FUNC(PyObject*) _PyUnicode_DecodeRawUnicodeEscapeStateful(
871 const char *string, /* Unicode-Escape encoded string */
872 Py_ssize_t length, /* size of string */
873 const char *errors, /* error handling */
874 Py_ssize_t *consumed /* bytes consumed */
875);
876
877/* --- Latin-1 Codecs ----------------------------------------------------- */
878
879PyAPI_FUNC(PyObject*) _PyUnicode_AsLatin1String(
880 PyObject* unicode,
881 const char* errors);
882
883Py_DEPRECATED(3.3) PyAPI_FUNC(PyObject*) PyUnicode_EncodeLatin1(
884 const Py_UNICODE *data, /* Unicode char buffer */
885 Py_ssize_t length, /* Number of Py_UNICODE chars to encode */
886 const char *errors /* error handling */
887 );
888
889/* --- ASCII Codecs ------------------------------------------------------- */
890
891PyAPI_FUNC(PyObject*) _PyUnicode_AsASCIIString(
892 PyObject* unicode,
893 const char* errors);
894
895Py_DEPRECATED(3.3) PyAPI_FUNC(PyObject*) PyUnicode_EncodeASCII(
896 const Py_UNICODE *data, /* Unicode char buffer */
897 Py_ssize_t length, /* Number of Py_UNICODE chars to encode */
898 const char *errors /* error handling */
899 );
900
901/* --- Character Map Codecs ----------------------------------------------- */
902
903Py_DEPRECATED(3.3) PyAPI_FUNC(PyObject*) PyUnicode_EncodeCharmap(
904 const Py_UNICODE *data, /* Unicode char buffer */
905 Py_ssize_t length, /* Number of Py_UNICODE chars to encode */
906 PyObject *mapping, /* encoding mapping */
907 const char *errors /* error handling */
908 );
909
910PyAPI_FUNC(PyObject*) _PyUnicode_EncodeCharmap(
911 PyObject *unicode, /* Unicode object */
912 PyObject *mapping, /* encoding mapping */
913 const char *errors /* error handling */
914 );
915
916/* Translate a Py_UNICODE buffer of the given length by applying a
917 character mapping table to it and return the resulting Unicode
918 object.
919
920 The mapping table must map Unicode ordinal integers to Unicode strings,
921 Unicode ordinal integers or None (causing deletion of the character).
922
923 Mapping tables may be dictionaries or sequences. Unmapped character
924 ordinals (ones which cause a LookupError) are left untouched and
925 are copied as-is.
926
927*/
928Py_DEPRECATED(3.3) PyAPI_FUNC(PyObject *) PyUnicode_TranslateCharmap(
929 const Py_UNICODE *data, /* Unicode char buffer */
930 Py_ssize_t length, /* Number of Py_UNICODE chars to encode */
931 PyObject *table, /* Translate table */
932 const char *errors /* error handling */
933 );
934
935/* --- MBCS codecs for Windows -------------------------------------------- */
936
937#ifdef MS_WINDOWS
938Py_DEPRECATED(3.3) PyAPI_FUNC(PyObject*) PyUnicode_EncodeMBCS(
939 const Py_UNICODE *data, /* Unicode char buffer */
940 Py_ssize_t length, /* number of Py_UNICODE chars to encode */
941 const char *errors /* error handling */
942 );
943#endif
944
945/* --- Decimal Encoder ---------------------------------------------------- */
946
947/* Takes a Unicode string holding a decimal value and writes it into
948 an output buffer using standard ASCII digit codes.
949
950 The output buffer has to provide at least length+1 bytes of storage
951 area. The output string is 0-terminated.
952
953 The encoder converts whitespace to ' ', decimal characters to their
954 corresponding ASCII digit and all other Latin-1 characters except
955 \0 as-is. Characters outside this range (Unicode ordinals 1-256)
956 are treated as errors. This includes embedded NULL bytes.
957
958 Error handling is defined by the errors argument:
959
960 NULL or "strict": raise a ValueError
961 "ignore": ignore the wrong characters (these are not copied to the
962 output buffer)
963 "replace": replaces illegal characters with '?'
964
965 Returns 0 on success, -1 on failure.
966
967*/
968
969Py_DEPRECATED(3.3) PyAPI_FUNC(int) PyUnicode_EncodeDecimal(
970 Py_UNICODE *s, /* Unicode buffer */
971 Py_ssize_t length, /* Number of Py_UNICODE chars to encode */
972 char *output, /* Output buffer; must have size >= length */
973 const char *errors /* error handling */
974 );
975
976/* Transforms code points that have decimal digit property to the
977 corresponding ASCII digit code points.
978
979 Returns a new Unicode string on success, NULL on failure.
980*/
981
982Py_DEPRECATED(3.3)
983PyAPI_FUNC(PyObject*) PyUnicode_TransformDecimalToASCII(
984 Py_UNICODE *s, /* Unicode buffer */
985 Py_ssize_t length /* Number of Py_UNICODE chars to transform */
986 );
987
988/* Coverts a Unicode object holding a decimal value to an ASCII string
989 for using in int, float and complex parsers.
990 Transforms code points that have decimal digit property to the
991 corresponding ASCII digit code points. Transforms spaces to ASCII.
992 Transforms code points starting from the first non-ASCII code point that
993 is neither a decimal digit nor a space to the end into '?'. */
994
995PyAPI_FUNC(PyObject*) _PyUnicode_TransformDecimalAndSpaceToASCII(
996 PyObject *unicode /* Unicode object */
997 );
998
999/* --- Methods & Slots ---------------------------------------------------- */
1000
1001PyAPI_FUNC(PyObject *) _PyUnicode_JoinArray(
1002 PyObject *separator,
1003 PyObject *const *items,
1004 Py_ssize_t seqlen
1005 );
1006
1007/* Test whether a unicode is equal to ASCII identifier. Return 1 if true,
1008 0 otherwise. The right argument must be ASCII identifier.
1009 Any error occurs inside will be cleared before return. */
1010PyAPI_FUNC(int) _PyUnicode_EqualToASCIIId(
1011 PyObject *left, /* Left string */
1012 _Py_Identifier *right /* Right identifier */
1013 );
1014
1015/* Test whether a unicode is equal to ASCII string. Return 1 if true,
1016 0 otherwise. The right argument must be ASCII-encoded string.
1017 Any error occurs inside will be cleared before return. */
1018PyAPI_FUNC(int) _PyUnicode_EqualToASCIIString(
1019 PyObject *left,
1020 const char *right /* ASCII-encoded string */
1021 );
1022
1023/* Externally visible for str.strip(unicode) */
1024PyAPI_FUNC(PyObject *) _PyUnicode_XStrip(
1025 PyObject *self,
1026 int striptype,
1027 PyObject *sepobj
1028 );
1029
1030/* Using explicit passed-in values, insert the thousands grouping
1031 into the string pointed to by buffer. For the argument descriptions,
1032 see Objects/stringlib/localeutil.h */
1033PyAPI_FUNC(Py_ssize_t) _PyUnicode_InsertThousandsGrouping(
1034 _PyUnicodeWriter *writer,
1035 Py_ssize_t n_buffer,
1036 PyObject *digits,
1037 Py_ssize_t d_pos,
1038 Py_ssize_t n_digits,
1039 Py_ssize_t min_width,
1040 const char *grouping,
1041 PyObject *thousands_sep,
1042 Py_UCS4 *maxchar);
1043
1044/* === Characters Type APIs =============================================== */
1045
1046/* Helper array used by Py_UNICODE_ISSPACE(). */
1047
1048PyAPI_DATA(const unsigned char) _Py_ascii_whitespace[];
1049
1050/* These should not be used directly. Use the Py_UNICODE_IS* and
1051 Py_UNICODE_TO* macros instead.
1052
1053 These APIs are implemented in Objects/unicodectype.c.
1054
1055*/
1056
1057PyAPI_FUNC(int) _PyUnicode_IsLowercase(
1058 Py_UCS4 ch /* Unicode character */
1059 );
1060
1061PyAPI_FUNC(int) _PyUnicode_IsUppercase(
1062 Py_UCS4 ch /* Unicode character */
1063 );
1064
1065PyAPI_FUNC(int) _PyUnicode_IsTitlecase(
1066 Py_UCS4 ch /* Unicode character */
1067 );
1068
1069PyAPI_FUNC(int) _PyUnicode_IsXidStart(
1070 Py_UCS4 ch /* Unicode character */
1071 );
1072
1073PyAPI_FUNC(int) _PyUnicode_IsXidContinue(
1074 Py_UCS4 ch /* Unicode character */
1075 );
1076
1077PyAPI_FUNC(int) _PyUnicode_IsWhitespace(
1078 const Py_UCS4 ch /* Unicode character */
1079 );
1080
1081PyAPI_FUNC(int) _PyUnicode_IsLinebreak(
1082 const Py_UCS4 ch /* Unicode character */
1083 );
1084
1085/* Py_DEPRECATED(3.3) */ PyAPI_FUNC(Py_UCS4) _PyUnicode_ToLowercase(
1086 Py_UCS4 ch /* Unicode character */
1087 );
1088
1089/* Py_DEPRECATED(3.3) */ PyAPI_FUNC(Py_UCS4) _PyUnicode_ToUppercase(
1090 Py_UCS4 ch /* Unicode character */
1091 );
1092
1093Py_DEPRECATED(3.3) PyAPI_FUNC(Py_UCS4) _PyUnicode_ToTitlecase(
1094 Py_UCS4 ch /* Unicode character */
1095 );
1096
1097PyAPI_FUNC(int) _PyUnicode_ToLowerFull(
1098 Py_UCS4 ch, /* Unicode character */
1099 Py_UCS4 *res
1100 );
1101
1102PyAPI_FUNC(int) _PyUnicode_ToTitleFull(
1103 Py_UCS4 ch, /* Unicode character */
1104 Py_UCS4 *res
1105 );
1106
1107PyAPI_FUNC(int) _PyUnicode_ToUpperFull(
1108 Py_UCS4 ch, /* Unicode character */
1109 Py_UCS4 *res
1110 );
1111
1112PyAPI_FUNC(int) _PyUnicode_ToFoldedFull(
1113 Py_UCS4 ch, /* Unicode character */
1114 Py_UCS4 *res
1115 );
1116
1117PyAPI_FUNC(int) _PyUnicode_IsCaseIgnorable(
1118 Py_UCS4 ch /* Unicode character */
1119 );
1120
1121PyAPI_FUNC(int) _PyUnicode_IsCased(
1122 Py_UCS4 ch /* Unicode character */
1123 );
1124
1125PyAPI_FUNC(int) _PyUnicode_ToDecimalDigit(
1126 Py_UCS4 ch /* Unicode character */
1127 );
1128
1129PyAPI_FUNC(int) _PyUnicode_ToDigit(
1130 Py_UCS4 ch /* Unicode character */
1131 );
1132
1133PyAPI_FUNC(double) _PyUnicode_ToNumeric(
1134 Py_UCS4 ch /* Unicode character */
1135 );
1136
1137PyAPI_FUNC(int) _PyUnicode_IsDecimalDigit(
1138 Py_UCS4 ch /* Unicode character */
1139 );
1140
1141PyAPI_FUNC(int) _PyUnicode_IsDigit(
1142 Py_UCS4 ch /* Unicode character */
1143 );
1144
1145PyAPI_FUNC(int) _PyUnicode_IsNumeric(
1146 Py_UCS4 ch /* Unicode character */
1147 );
1148
1149PyAPI_FUNC(int) _PyUnicode_IsPrintable(
1150 Py_UCS4 ch /* Unicode character */
1151 );
1152
1153PyAPI_FUNC(int) _PyUnicode_IsAlpha(
1154 Py_UCS4 ch /* Unicode character */
1155 );
1156
1157PyAPI_FUNC(PyObject*) _PyUnicode_FormatLong(PyObject *, int, int, int);
1158
1159/* Return an interned Unicode object for an Identifier; may fail if there is no memory.*/
1160PyAPI_FUNC(PyObject*) _PyUnicode_FromId(_Py_Identifier*);
1161
1162/* Fast equality check when the inputs are known to be exact unicode types
1163 and where the hash values are equal (i.e. a very probable match) */
1164PyAPI_FUNC(int) _PyUnicode_EQ(PyObject *, PyObject *);
1165
1166PyAPI_FUNC(int) _PyUnicode_WideCharString_Converter(PyObject *, void *);
1167PyAPI_FUNC(int) _PyUnicode_WideCharString_Opt_Converter(PyObject *, void *);
1168
1169PyAPI_FUNC(Py_ssize_t) _PyUnicode_ScanIdentifier(PyObject *);
1170

source code of include/python3.10/cpython/unicodeobject.h