Branch data Line data Source code
1 : : /*
2 : :
3 : : Unicode implementation based on original code by Fredrik Lundh,
4 : : modified by Marc-Andre Lemburg <mal@lemburg.com>.
5 : :
6 : : Major speed upgrades to the method implementations at the Reykjavik
7 : : NeedForSpeed sprint, by Fredrik Lundh and Andrew Dalke.
8 : :
9 : : Copyright (c) Corporation for National Research Initiatives.
10 : :
11 : : --------------------------------------------------------------------
12 : : The original string type implementation is:
13 : :
14 : : Copyright (c) 1999 by Secret Labs AB
15 : : Copyright (c) 1999 by Fredrik Lundh
16 : :
17 : : By obtaining, using, and/or copying this software and/or its
18 : : associated documentation, you agree that you have read, understood,
19 : : and will comply with the following terms and conditions:
20 : :
21 : : Permission to use, copy, modify, and distribute this software and its
22 : : associated documentation for any purpose and without fee is hereby
23 : : granted, provided that the above copyright notice appears in all
24 : : copies, and that both that copyright notice and this permission notice
25 : : appear in supporting documentation, and that the name of Secret Labs
26 : : AB or the author not be used in advertising or publicity pertaining to
27 : : distribution of the software without specific, written prior
28 : : permission.
29 : :
30 : : SECRET LABS AB AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO
31 : : THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
32 : : FITNESS. IN NO EVENT SHALL SECRET LABS AB OR THE AUTHOR BE LIABLE FOR
33 : : ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
34 : : WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
35 : : ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
36 : : OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
37 : : --------------------------------------------------------------------
38 : :
39 : : */
40 : :
41 : : #define PY_SSIZE_T_CLEAN
42 : : #include "Python.h"
43 : : #include "pycore_abstract.h" // _PyIndex_Check()
44 : : #include "pycore_atomic_funcs.h" // _Py_atomic_size_get()
45 : : #include "pycore_bytesobject.h" // _PyBytes_Repeat()
46 : : #include "pycore_bytes_methods.h" // _Py_bytes_lower()
47 : : #include "pycore_format.h" // F_LJUST
48 : : #include "pycore_initconfig.h" // _PyStatus_OK()
49 : : #include "pycore_interp.h" // PyInterpreterState.fs_codec
50 : : #include "pycore_long.h" // _PyLong_FormatWriter()
51 : : #include "pycore_object.h" // _PyObject_GC_TRACK(), _Py_FatalRefcountError()
52 : : #include "pycore_pathconfig.h" // _Py_DumpPathConfig()
53 : : #include "pycore_pylifecycle.h" // _Py_SetFileSystemEncoding()
54 : : #include "pycore_pystate.h" // _PyInterpreterState_GET()
55 : : #include "pycore_runtime_init.h" // _PyUnicode_InitStaticStrings()
56 : : #include "pycore_ucnhash.h" // _PyUnicode_Name_CAPI
57 : : #include "pycore_unicodeobject.h" // struct _Py_unicode_state
58 : : #include "stringlib/eq.h" // unicode_eq()
59 : :
60 : : #ifdef MS_WINDOWS
61 : : #include <windows.h>
62 : : #endif
63 : :
64 : : #ifdef HAVE_NON_UNICODE_WCHAR_T_REPRESENTATION
65 : : # include "pycore_fileutils.h" // _Py_LocaleUsesNonUnicodeWchar()
66 : : #endif
67 : :
68 : : /* Uncomment to display statistics on interned strings at exit
69 : : in _PyUnicode_ClearInterned(). */
70 : : /* #define INTERNED_STATS 1 */
71 : :
72 : :
73 : : /*[clinic input]
74 : : class str "PyObject *" "&PyUnicode_Type"
75 : : [clinic start generated code]*/
76 : : /*[clinic end generated code: output=da39a3ee5e6b4b0d input=4884c934de622cf6]*/
77 : :
78 : : /*[python input]
79 : : class Py_UCS4_converter(CConverter):
80 : : type = 'Py_UCS4'
81 : : converter = 'convert_uc'
82 : :
83 : : def converter_init(self):
84 : : if self.default is not unspecified:
85 : : self.c_default = ascii(self.default)
86 : : if len(self.c_default) > 4 or self.c_default[0] != "'":
87 : : self.c_default = hex(ord(self.default))
88 : :
89 : : [python start generated code]*/
90 : : /*[python end generated code: output=da39a3ee5e6b4b0d input=88f5dd06cd8e7a61]*/
91 : :
92 : : /* --- Globals ------------------------------------------------------------
93 : :
94 : : NOTE: In the interpreter's initialization phase, some globals are currently
95 : : initialized dynamically as needed. In the process Unicode objects may
96 : : be created before the Unicode type is ready.
97 : :
98 : : */
99 : :
100 : :
101 : : #ifdef __cplusplus
102 : : extern "C" {
103 : : #endif
104 : :
105 : : // Maximum code point of Unicode 6.0: 0x10ffff (1,114,111).
106 : : // The value must be the same in fileutils.c.
107 : : #define MAX_UNICODE 0x10ffff
108 : :
109 : : #ifdef Py_DEBUG
110 : : # define _PyUnicode_CHECK(op) _PyUnicode_CheckConsistency(op, 0)
111 : : #else
112 : : # define _PyUnicode_CHECK(op) PyUnicode_Check(op)
113 : : #endif
114 : :
115 : : #define _PyUnicode_UTF8(op) \
116 : : (_PyCompactUnicodeObject_CAST(op)->utf8)
117 : : #define PyUnicode_UTF8(op) \
118 : : (assert(_PyUnicode_CHECK(op)), \
119 : : PyUnicode_IS_COMPACT_ASCII(op) ? \
120 : : ((char*)(_PyASCIIObject_CAST(op) + 1)) : \
121 : : _PyUnicode_UTF8(op))
122 : : #define _PyUnicode_UTF8_LENGTH(op) \
123 : : (_PyCompactUnicodeObject_CAST(op)->utf8_length)
124 : : #define PyUnicode_UTF8_LENGTH(op) \
125 : : (assert(_PyUnicode_CHECK(op)), \
126 : : PyUnicode_IS_COMPACT_ASCII(op) ? \
127 : : _PyASCIIObject_CAST(op)->length : \
128 : : _PyUnicode_UTF8_LENGTH(op))
129 : :
130 : : #define _PyUnicode_LENGTH(op) \
131 : : (_PyASCIIObject_CAST(op)->length)
132 : : #define _PyUnicode_STATE(op) \
133 : : (_PyASCIIObject_CAST(op)->state)
134 : : #define _PyUnicode_HASH(op) \
135 : : (_PyASCIIObject_CAST(op)->hash)
136 : : #define _PyUnicode_KIND(op) \
137 : : (assert(_PyUnicode_CHECK(op)), \
138 : : _PyASCIIObject_CAST(op)->state.kind)
139 : : #define _PyUnicode_GET_LENGTH(op) \
140 : : (assert(_PyUnicode_CHECK(op)), \
141 : : _PyASCIIObject_CAST(op)->length)
142 : : #define _PyUnicode_DATA_ANY(op) \
143 : : (_PyUnicodeObject_CAST(op)->data.any)
144 : :
145 : : #define _PyUnicode_SHARE_UTF8(op) \
146 : : (assert(_PyUnicode_CHECK(op)), \
147 : : assert(!PyUnicode_IS_COMPACT_ASCII(op)), \
148 : : (_PyUnicode_UTF8(op) == PyUnicode_DATA(op)))
149 : :
150 : : /* true if the Unicode object has an allocated UTF-8 memory block
151 : : (not shared with other data) */
152 : : #define _PyUnicode_HAS_UTF8_MEMORY(op) \
153 : : ((!PyUnicode_IS_COMPACT_ASCII(op) \
154 : : && _PyUnicode_UTF8(op) \
155 : : && _PyUnicode_UTF8(op) != PyUnicode_DATA(op)))
156 : :
157 : : /* Generic helper macro to convert characters of different types.
158 : : from_type and to_type have to be valid type names, begin and end
159 : : are pointers to the source characters which should be of type
160 : : "from_type *". to is a pointer of type "to_type *" and points to the
161 : : buffer where the result characters are written to. */
162 : : #define _PyUnicode_CONVERT_BYTES(from_type, to_type, begin, end, to) \
163 : : do { \
164 : : to_type *_to = (to_type *)(to); \
165 : : const from_type *_iter = (const from_type *)(begin);\
166 : : const from_type *_end = (const from_type *)(end);\
167 : : Py_ssize_t n = (_end) - (_iter); \
168 : : const from_type *_unrolled_end = \
169 : : _iter + _Py_SIZE_ROUND_DOWN(n, 4); \
170 : : while (_iter < (_unrolled_end)) { \
171 : : _to[0] = (to_type) _iter[0]; \
172 : : _to[1] = (to_type) _iter[1]; \
173 : : _to[2] = (to_type) _iter[2]; \
174 : : _to[3] = (to_type) _iter[3]; \
175 : : _iter += 4; _to += 4; \
176 : : } \
177 : : while (_iter < (_end)) \
178 : : *_to++ = (to_type) *_iter++; \
179 : : } while (0)
180 : :
181 : : #define LATIN1(ch) \
182 : : (ch < 128 \
183 : : ? (PyObject*)&_Py_SINGLETON(strings).ascii[ch] \
184 : : : (PyObject*)&_Py_SINGLETON(strings).latin1[ch - 128])
185 : :
186 : : #ifdef MS_WINDOWS
187 : : /* On Windows, overallocate by 50% is the best factor */
188 : : # define OVERALLOCATE_FACTOR 2
189 : : #else
190 : : /* On Linux, overallocate by 25% is the best factor */
191 : : # define OVERALLOCATE_FACTOR 4
192 : : #endif
193 : :
194 : : /* This dictionary holds all interned unicode strings. Note that references
195 : : to strings in this dictionary are *not* counted in the string's ob_refcnt.
196 : : When the interned string reaches a refcnt of 0 the string deallocation
197 : : function will delete the reference from this dictionary.
198 : :
199 : : Another way to look at this is that to say that the actual reference
200 : : count of a string is: s->ob_refcnt + (s->state ? 2 : 0)
201 : : */
202 : : static PyObject *interned = NULL;
203 : :
204 : : /* Forward declaration */
205 : : static inline int
206 : : _PyUnicodeWriter_WriteCharInline(_PyUnicodeWriter *writer, Py_UCS4 ch);
207 : : static inline void
208 : : _PyUnicodeWriter_InitWithBuffer(_PyUnicodeWriter *writer, PyObject *buffer);
209 : : static PyObject *
210 : : unicode_encode_utf8(PyObject *unicode, _Py_error_handler error_handler,
211 : : const char *errors);
212 : : static PyObject *
213 : : unicode_decode_utf8(const char *s, Py_ssize_t size,
214 : : _Py_error_handler error_handler, const char *errors,
215 : : Py_ssize_t *consumed);
216 : : #ifdef Py_DEBUG
217 : : static inline int unicode_is_finalizing(void);
218 : : static int unicode_is_singleton(PyObject *unicode);
219 : : #endif
220 : :
221 : :
222 : : // Return a borrowed reference to the empty string singleton.
223 : 39473325 : static inline PyObject* unicode_get_empty(void)
224 : : {
225 : : _Py_DECLARE_STR(empty, "");
226 : 39473325 : return &_Py_STR(empty);
227 : : }
228 : :
229 : :
230 : : // Return a strong reference to the empty string singleton.
231 : 5926674 : static inline PyObject* unicode_new_empty(void)
232 : : {
233 : 5926674 : PyObject *empty = unicode_get_empty();
234 : 5926674 : Py_INCREF(empty);
235 : 5926674 : return empty;
236 : : }
237 : :
238 : : #define _Py_RETURN_UNICODE_EMPTY() \
239 : : do { \
240 : : return unicode_new_empty(); \
241 : : } while (0)
242 : :
243 : : static inline void
244 : 421019 : unicode_fill(int kind, void *data, Py_UCS4 value,
245 : : Py_ssize_t start, Py_ssize_t length)
246 : : {
247 : : assert(0 <= start);
248 [ + + + - ]: 421019 : switch (kind) {
249 : 420530 : case PyUnicode_1BYTE_KIND: {
250 : : assert(value <= 0xff);
251 : 420530 : Py_UCS1 ch = (unsigned char)value;
252 : 420530 : Py_UCS1 *to = (Py_UCS1 *)data + start;
253 : 420530 : memset(to, ch, length);
254 : 420530 : break;
255 : : }
256 : 461 : case PyUnicode_2BYTE_KIND: {
257 : : assert(value <= 0xffff);
258 : 461 : Py_UCS2 ch = (Py_UCS2)value;
259 : 461 : Py_UCS2 *to = (Py_UCS2 *)data + start;
260 : 461 : const Py_UCS2 *end = to + length;
261 [ + + ]: 10753 : for (; to < end; ++to) *to = ch;
262 : 461 : break;
263 : : }
264 : 28 : case PyUnicode_4BYTE_KIND: {
265 : : assert(value <= MAX_UNICODE);
266 : 28 : Py_UCS4 ch = value;
267 : 28 : Py_UCS4 * to = (Py_UCS4 *)data + start;
268 : 28 : const Py_UCS4 *end = to + length;
269 [ + + ]: 113 : for (; to < end; ++to) *to = ch;
270 : 28 : break;
271 : : }
272 : 0 : default: Py_UNREACHABLE();
273 : : }
274 : 421019 : }
275 : :
276 : :
277 : : /* Fast detection of the most frequent whitespace characters */
278 : : const unsigned char _Py_ascii_whitespace[] = {
279 : : 0, 0, 0, 0, 0, 0, 0, 0,
280 : : /* case 0x0009: * CHARACTER TABULATION */
281 : : /* case 0x000A: * LINE FEED */
282 : : /* case 0x000B: * LINE TABULATION */
283 : : /* case 0x000C: * FORM FEED */
284 : : /* case 0x000D: * CARRIAGE RETURN */
285 : : 0, 1, 1, 1, 1, 1, 0, 0,
286 : : 0, 0, 0, 0, 0, 0, 0, 0,
287 : : /* case 0x001C: * FILE SEPARATOR */
288 : : /* case 0x001D: * GROUP SEPARATOR */
289 : : /* case 0x001E: * RECORD SEPARATOR */
290 : : /* case 0x001F: * UNIT SEPARATOR */
291 : : 0, 0, 0, 0, 1, 1, 1, 1,
292 : : /* case 0x0020: * SPACE */
293 : : 1, 0, 0, 0, 0, 0, 0, 0,
294 : : 0, 0, 0, 0, 0, 0, 0, 0,
295 : : 0, 0, 0, 0, 0, 0, 0, 0,
296 : : 0, 0, 0, 0, 0, 0, 0, 0,
297 : :
298 : : 0, 0, 0, 0, 0, 0, 0, 0,
299 : : 0, 0, 0, 0, 0, 0, 0, 0,
300 : : 0, 0, 0, 0, 0, 0, 0, 0,
301 : : 0, 0, 0, 0, 0, 0, 0, 0,
302 : : 0, 0, 0, 0, 0, 0, 0, 0,
303 : : 0, 0, 0, 0, 0, 0, 0, 0,
304 : : 0, 0, 0, 0, 0, 0, 0, 0,
305 : : 0, 0, 0, 0, 0, 0, 0, 0
306 : : };
307 : :
308 : : /* forward */
309 : : static PyObject* get_latin1_char(unsigned char ch);
310 : : static int unicode_modifiable(PyObject *unicode);
311 : :
312 : :
313 : : static PyObject *
314 : : _PyUnicode_FromUCS1(const Py_UCS1 *s, Py_ssize_t size);
315 : : static PyObject *
316 : : _PyUnicode_FromUCS2(const Py_UCS2 *s, Py_ssize_t size);
317 : : static PyObject *
318 : : _PyUnicode_FromUCS4(const Py_UCS4 *s, Py_ssize_t size);
319 : :
320 : : static PyObject *
321 : : unicode_encode_call_errorhandler(const char *errors,
322 : : PyObject **errorHandler,const char *encoding, const char *reason,
323 : : PyObject *unicode, PyObject **exceptionObject,
324 : : Py_ssize_t startpos, Py_ssize_t endpos, Py_ssize_t *newpos);
325 : :
326 : : static void
327 : : raise_encode_exception(PyObject **exceptionObject,
328 : : const char *encoding,
329 : : PyObject *unicode,
330 : : Py_ssize_t startpos, Py_ssize_t endpos,
331 : : const char *reason);
332 : :
333 : : /* Same for linebreaks */
334 : : static const unsigned char ascii_linebreak[] = {
335 : : 0, 0, 0, 0, 0, 0, 0, 0,
336 : : /* 0x000A, * LINE FEED */
337 : : /* 0x000B, * LINE TABULATION */
338 : : /* 0x000C, * FORM FEED */
339 : : /* 0x000D, * CARRIAGE RETURN */
340 : : 0, 0, 1, 1, 1, 1, 0, 0,
341 : : 0, 0, 0, 0, 0, 0, 0, 0,
342 : : /* 0x001C, * FILE SEPARATOR */
343 : : /* 0x001D, * GROUP SEPARATOR */
344 : : /* 0x001E, * RECORD SEPARATOR */
345 : : 0, 0, 0, 0, 1, 1, 1, 0,
346 : : 0, 0, 0, 0, 0, 0, 0, 0,
347 : : 0, 0, 0, 0, 0, 0, 0, 0,
348 : : 0, 0, 0, 0, 0, 0, 0, 0,
349 : : 0, 0, 0, 0, 0, 0, 0, 0,
350 : :
351 : : 0, 0, 0, 0, 0, 0, 0, 0,
352 : : 0, 0, 0, 0, 0, 0, 0, 0,
353 : : 0, 0, 0, 0, 0, 0, 0, 0,
354 : : 0, 0, 0, 0, 0, 0, 0, 0,
355 : : 0, 0, 0, 0, 0, 0, 0, 0,
356 : : 0, 0, 0, 0, 0, 0, 0, 0,
357 : : 0, 0, 0, 0, 0, 0, 0, 0,
358 : : 0, 0, 0, 0, 0, 0, 0, 0
359 : : };
360 : :
361 : : static int convert_uc(PyObject *obj, void *addr);
362 : :
363 : : struct encoding_map;
364 : : #include "clinic/unicodeobject.c.h"
365 : :
366 : : _Py_error_handler
367 : 403545 : _Py_GetErrorHandler(const char *errors)
368 : : {
369 [ + + + + ]: 403545 : if (errors == NULL || strcmp(errors, "strict") == 0) {
370 : 27557 : return _Py_ERROR_STRICT;
371 : : }
372 [ + + ]: 375988 : if (strcmp(errors, "surrogateescape") == 0) {
373 : 366824 : return _Py_ERROR_SURROGATEESCAPE;
374 : : }
375 [ + + ]: 9164 : if (strcmp(errors, "replace") == 0) {
376 : 821 : return _Py_ERROR_REPLACE;
377 : : }
378 [ + + ]: 8343 : if (strcmp(errors, "ignore") == 0) {
379 : 613 : return _Py_ERROR_IGNORE;
380 : : }
381 [ + + ]: 7730 : if (strcmp(errors, "backslashreplace") == 0) {
382 : 3883 : return _Py_ERROR_BACKSLASHREPLACE;
383 : : }
384 [ + + ]: 3847 : if (strcmp(errors, "surrogatepass") == 0) {
385 : 3503 : return _Py_ERROR_SURROGATEPASS;
386 : : }
387 [ + + ]: 344 : if (strcmp(errors, "xmlcharrefreplace") == 0) {
388 : 190 : return _Py_ERROR_XMLCHARREFREPLACE;
389 : : }
390 : 154 : return _Py_ERROR_OTHER;
391 : : }
392 : :
393 : :
394 : : static _Py_error_handler
395 : 1102304 : get_error_handler_wide(const wchar_t *errors)
396 : : {
397 [ + - - + ]: 1102304 : if (errors == NULL || wcscmp(errors, L"strict") == 0) {
398 : 0 : return _Py_ERROR_STRICT;
399 : : }
400 [ + - ]: 1102304 : if (wcscmp(errors, L"surrogateescape") == 0) {
401 : 1102304 : return _Py_ERROR_SURROGATEESCAPE;
402 : : }
403 [ # # ]: 0 : if (wcscmp(errors, L"replace") == 0) {
404 : 0 : return _Py_ERROR_REPLACE;
405 : : }
406 [ # # ]: 0 : if (wcscmp(errors, L"ignore") == 0) {
407 : 0 : return _Py_ERROR_IGNORE;
408 : : }
409 [ # # ]: 0 : if (wcscmp(errors, L"backslashreplace") == 0) {
410 : 0 : return _Py_ERROR_BACKSLASHREPLACE;
411 : : }
412 [ # # ]: 0 : if (wcscmp(errors, L"surrogatepass") == 0) {
413 : 0 : return _Py_ERROR_SURROGATEPASS;
414 : : }
415 [ # # ]: 0 : if (wcscmp(errors, L"xmlcharrefreplace") == 0) {
416 : 0 : return _Py_ERROR_XMLCHARREFREPLACE;
417 : : }
418 : 0 : return _Py_ERROR_OTHER;
419 : : }
420 : :
421 : :
422 : : static inline int
423 : 13606943 : unicode_check_encoding_errors(const char *encoding, const char *errors)
424 : : {
425 [ + + + + ]: 13606943 : if (encoding == NULL && errors == NULL) {
426 : 98630 : return 0;
427 : : }
428 : :
429 : 13508313 : PyInterpreterState *interp = _PyInterpreterState_GET();
430 : : #ifndef Py_DEBUG
431 : : /* In release mode, only check in development mode (-X dev) */
432 [ + + ]: 13508313 : if (!_PyInterpreterState_GetConfig(interp)->dev_mode) {
433 : 13507278 : return 0;
434 : : }
435 : : #else
436 : : /* Always check in debug mode */
437 : : #endif
438 : :
439 : : /* Avoid calling _PyCodec_Lookup() and PyCodec_LookupError() before the
440 : : codec registry is ready: before_PyUnicode_InitEncodings() is called. */
441 [ - + ]: 1035 : if (!interp->unicode.fs_codec.encoding) {
442 : 0 : return 0;
443 : : }
444 : :
445 : : /* Disable checks during Python finalization. For example, it allows to
446 : : call _PyObject_Dump() during finalization for debugging purpose. */
447 [ - + ]: 1035 : if (interp->finalizing) {
448 : 0 : return 0;
449 : : }
450 : :
451 [ + + ]: 1035 : if (encoding != NULL
452 : : // Fast path for the most common built-in encodings. Even if the codec
453 : : // is cached, _PyCodec_Lookup() decodes the bytes string from UTF-8 to
454 : : // create a temporary Unicode string (the key in the cache).
455 [ + + ]: 1031 : && strcmp(encoding, "utf-8") != 0
456 [ + + ]: 431 : && strcmp(encoding, "utf8") != 0
457 [ + + ]: 421 : && strcmp(encoding, "ascii") != 0)
458 : : {
459 : 113 : PyObject *handler = _PyCodec_Lookup(encoding);
460 [ + + ]: 113 : if (handler == NULL) {
461 : 10 : return -1;
462 : : }
463 : 103 : Py_DECREF(handler);
464 : : }
465 : :
466 [ + + ]: 1025 : if (errors != NULL
467 : : // Fast path for the most common built-in error handlers.
468 [ + - ]: 546 : && strcmp(errors, "strict") != 0
469 [ + - ]: 546 : && strcmp(errors, "ignore") != 0
470 [ + - ]: 546 : && strcmp(errors, "replace") != 0
471 [ + + ]: 546 : && strcmp(errors, "surrogateescape") != 0
472 [ + + ]: 30 : && strcmp(errors, "surrogatepass") != 0)
473 : : {
474 : 28 : PyObject *handler = PyCodec_LookupError(errors);
475 [ + - ]: 28 : if (handler == NULL) {
476 : 28 : return -1;
477 : : }
478 : 0 : Py_DECREF(handler);
479 : : }
480 : 997 : return 0;
481 : : }
482 : :
483 : :
484 : : int
485 : 0 : _PyUnicode_CheckConsistency(PyObject *op, int check_content)
486 : : {
487 : : #define CHECK(expr) \
488 : : do { if (!(expr)) { _PyObject_ASSERT_FAILED_MSG(op, Py_STRINGIFY(expr)); } } while (0)
489 : :
490 : : assert(op != NULL);
491 [ # # ]: 0 : CHECK(PyUnicode_Check(op));
492 : :
493 : 0 : PyASCIIObject *ascii = _PyASCIIObject_CAST(op);
494 : 0 : int kind = ascii->state.kind;
495 : :
496 [ # # # # ]: 0 : if (ascii->state.ascii == 1 && ascii->state.compact == 1) {
497 [ # # ]: 0 : CHECK(kind == PyUnicode_1BYTE_KIND);
498 : : }
499 : : else {
500 : 0 : PyCompactUnicodeObject *compact = _PyCompactUnicodeObject_CAST(op);
501 : : void *data;
502 : :
503 [ # # ]: 0 : if (ascii->state.compact == 1) {
504 : 0 : data = compact + 1;
505 [ # # # # : 0 : CHECK(kind == PyUnicode_1BYTE_KIND
# # ]
506 : : || kind == PyUnicode_2BYTE_KIND
507 : : || kind == PyUnicode_4BYTE_KIND);
508 [ # # ]: 0 : CHECK(ascii->state.ascii == 0);
509 [ # # ]: 0 : CHECK(compact->utf8 != data);
510 : : }
511 : : else {
512 : 0 : PyUnicodeObject *unicode = _PyUnicodeObject_CAST(op);
513 : :
514 : 0 : data = unicode->data.any;
515 [ # # # # : 0 : CHECK(kind == PyUnicode_1BYTE_KIND
# # ]
516 : : || kind == PyUnicode_2BYTE_KIND
517 : : || kind == PyUnicode_4BYTE_KIND);
518 [ # # ]: 0 : CHECK(ascii->state.compact == 0);
519 [ # # ]: 0 : CHECK(data != NULL);
520 [ # # ]: 0 : if (ascii->state.ascii) {
521 [ # # ]: 0 : CHECK(compact->utf8 == data);
522 [ # # ]: 0 : CHECK(compact->utf8_length == ascii->length);
523 : : }
524 : : else {
525 [ # # ]: 0 : CHECK(compact->utf8 != data);
526 : : }
527 : : }
528 : :
529 [ # # ]: 0 : if (compact->utf8 == NULL)
530 [ # # ]: 0 : CHECK(compact->utf8_length == 0);
531 : : }
532 : :
533 : : /* check that the best kind is used: O(n) operation */
534 [ # # ]: 0 : if (check_content) {
535 : : Py_ssize_t i;
536 : 0 : Py_UCS4 maxchar = 0;
537 : : const void *data;
538 : : Py_UCS4 ch;
539 : :
540 : 0 : data = PyUnicode_DATA(ascii);
541 [ # # ]: 0 : for (i=0; i < ascii->length; i++)
542 : : {
543 : 0 : ch = PyUnicode_READ(kind, data, i);
544 [ # # ]: 0 : if (ch > maxchar)
545 : 0 : maxchar = ch;
546 : : }
547 [ # # ]: 0 : if (kind == PyUnicode_1BYTE_KIND) {
548 [ # # ]: 0 : if (ascii->state.ascii == 0) {
549 [ # # ]: 0 : CHECK(maxchar >= 128);
550 [ # # ]: 0 : CHECK(maxchar <= 255);
551 : : }
552 : : else
553 [ # # ]: 0 : CHECK(maxchar < 128);
554 : : }
555 [ # # ]: 0 : else if (kind == PyUnicode_2BYTE_KIND) {
556 [ # # ]: 0 : CHECK(maxchar >= 0x100);
557 [ # # ]: 0 : CHECK(maxchar <= 0xFFFF);
558 : : }
559 : : else {
560 [ # # ]: 0 : CHECK(maxchar >= 0x10000);
561 [ # # ]: 0 : CHECK(maxchar <= MAX_UNICODE);
562 : : }
563 [ # # ]: 0 : CHECK(PyUnicode_READ(kind, data, ascii->length) == 0);
564 : : }
565 : 0 : return 1;
566 : :
567 : : #undef CHECK
568 : : }
569 : :
570 : : static PyObject*
571 : 12619516 : unicode_result(PyObject *unicode)
572 : : {
573 : : assert(_PyUnicode_CHECK(unicode));
574 : :
575 : 12619516 : Py_ssize_t length = PyUnicode_GET_LENGTH(unicode);
576 [ + + ]: 12619516 : if (length == 0) {
577 : 2 : PyObject *empty = unicode_get_empty();
578 [ - + ]: 2 : if (unicode != empty) {
579 : 0 : Py_DECREF(unicode);
580 : 0 : Py_INCREF(empty);
581 : : }
582 : 2 : return empty;
583 : : }
584 : :
585 [ + + ]: 12619514 : if (length == 1) {
586 : 949913 : int kind = PyUnicode_KIND(unicode);
587 [ + + ]: 949913 : if (kind == PyUnicode_1BYTE_KIND) {
588 : 249452 : const Py_UCS1 *data = PyUnicode_1BYTE_DATA(unicode);
589 : 249452 : Py_UCS1 ch = data[0];
590 [ + + ]: 249452 : PyObject *latin1_char = LATIN1(ch);
591 [ + + ]: 249452 : if (unicode != latin1_char) {
592 : 244772 : Py_INCREF(latin1_char);
593 : 244772 : Py_DECREF(unicode);
594 : : }
595 : 249452 : return latin1_char;
596 : : }
597 : : }
598 : :
599 : : assert(_PyUnicode_CheckConsistency(unicode, 1));
600 : 12370062 : return unicode;
601 : : }
602 : :
603 : : static PyObject*
604 : 17767903 : unicode_result_unchanged(PyObject *unicode)
605 : : {
606 [ + + ]: 17767903 : if (PyUnicode_CheckExact(unicode)) {
607 : 17706339 : Py_INCREF(unicode);
608 : 17706339 : return unicode;
609 : : }
610 : : else
611 : : /* Subtype -- return genuine unicode string with the same value. */
612 : 61564 : return _PyUnicode_Copy(unicode);
613 : : }
614 : :
615 : : /* Implementation of the "backslashreplace" error handler for 8-bit encodings:
616 : : ASCII, Latin1, UTF-8, etc. */
617 : : static char*
618 : 8395 : backslashreplace(_PyBytesWriter *writer, char *str,
619 : : PyObject *unicode, Py_ssize_t collstart, Py_ssize_t collend)
620 : : {
621 : : Py_ssize_t size, i;
622 : : Py_UCS4 ch;
623 : : int kind;
624 : : const void *data;
625 : :
626 : 8395 : kind = PyUnicode_KIND(unicode);
627 : 8395 : data = PyUnicode_DATA(unicode);
628 : :
629 : 8395 : size = 0;
630 : : /* determine replacement size */
631 [ + + ]: 32655 : for (i = collstart; i < collend; ++i) {
632 : : Py_ssize_t incr;
633 : :
634 : 24260 : ch = PyUnicode_READ(kind, data, i);
635 [ + + ]: 24260 : if (ch < 0x100)
636 : 4789 : incr = 2+2;
637 [ + + ]: 19471 : else if (ch < 0x10000)
638 : 19176 : incr = 2+4;
639 : : else {
640 : : assert(ch <= MAX_UNICODE);
641 : 295 : incr = 2+8;
642 : : }
643 [ - + ]: 24260 : if (size > PY_SSIZE_T_MAX - incr) {
644 : 0 : PyErr_SetString(PyExc_OverflowError,
645 : : "encoded result is too long for a Python string");
646 : 0 : return NULL;
647 : : }
648 : 24260 : size += incr;
649 : : }
650 : :
651 : 8395 : str = _PyBytesWriter_Prepare(writer, str, size);
652 [ - + ]: 8395 : if (str == NULL)
653 : 0 : return NULL;
654 : :
655 : : /* generate replacement */
656 [ + + ]: 32655 : for (i = collstart; i < collend; ++i) {
657 : 24260 : ch = PyUnicode_READ(kind, data, i);
658 : 24260 : *str++ = '\\';
659 [ + + ]: 24260 : if (ch >= 0x00010000) {
660 : 295 : *str++ = 'U';
661 : 295 : *str++ = Py_hexdigits[(ch>>28)&0xf];
662 : 295 : *str++ = Py_hexdigits[(ch>>24)&0xf];
663 : 295 : *str++ = Py_hexdigits[(ch>>20)&0xf];
664 : 295 : *str++ = Py_hexdigits[(ch>>16)&0xf];
665 : 295 : *str++ = Py_hexdigits[(ch>>12)&0xf];
666 : 295 : *str++ = Py_hexdigits[(ch>>8)&0xf];
667 : : }
668 [ + + ]: 23965 : else if (ch >= 0x100) {
669 : 19176 : *str++ = 'u';
670 : 19176 : *str++ = Py_hexdigits[(ch>>12)&0xf];
671 : 19176 : *str++ = Py_hexdigits[(ch>>8)&0xf];
672 : : }
673 : : else
674 : 4789 : *str++ = 'x';
675 : 24260 : *str++ = Py_hexdigits[(ch>>4)&0xf];
676 : 24260 : *str++ = Py_hexdigits[ch&0xf];
677 : : }
678 : 8395 : return str;
679 : : }
680 : :
681 : : /* Implementation of the "xmlcharrefreplace" error handler for 8-bit encodings:
682 : : ASCII, Latin1, UTF-8, etc. */
683 : : static char*
684 : 1242 : xmlcharrefreplace(_PyBytesWriter *writer, char *str,
685 : : PyObject *unicode, Py_ssize_t collstart, Py_ssize_t collend)
686 : : {
687 : : Py_ssize_t size, i;
688 : : Py_UCS4 ch;
689 : : int kind;
690 : : const void *data;
691 : :
692 : 1242 : kind = PyUnicode_KIND(unicode);
693 : 1242 : data = PyUnicode_DATA(unicode);
694 : :
695 : 1242 : size = 0;
696 : : /* determine replacement size */
697 [ + + ]: 5557 : for (i = collstart; i < collend; ++i) {
698 : : Py_ssize_t incr;
699 : :
700 : 4315 : ch = PyUnicode_READ(kind, data, i);
701 [ - + ]: 4315 : if (ch < 10)
702 : 0 : incr = 2+1+1;
703 [ - + ]: 4315 : else if (ch < 100)
704 : 0 : incr = 2+2+1;
705 [ + + ]: 4315 : else if (ch < 1000)
706 : 1066 : incr = 2+3+1;
707 [ + + ]: 3249 : else if (ch < 10000)
708 : 193 : incr = 2+4+1;
709 [ + + ]: 3056 : else if (ch < 100000)
710 : 3053 : incr = 2+5+1;
711 [ + + ]: 3 : else if (ch < 1000000)
712 : 2 : incr = 2+6+1;
713 : : else {
714 : : assert(ch <= MAX_UNICODE);
715 : 1 : incr = 2+7+1;
716 : : }
717 [ - + ]: 4315 : if (size > PY_SSIZE_T_MAX - incr) {
718 : 0 : PyErr_SetString(PyExc_OverflowError,
719 : : "encoded result is too long for a Python string");
720 : 0 : return NULL;
721 : : }
722 : 4315 : size += incr;
723 : : }
724 : :
725 : 1242 : str = _PyBytesWriter_Prepare(writer, str, size);
726 [ - + ]: 1242 : if (str == NULL)
727 : 0 : return NULL;
728 : :
729 : : /* generate replacement */
730 [ + + ]: 5557 : for (i = collstart; i < collend; ++i) {
731 : 4315 : size = sprintf(str, "&#%d;", PyUnicode_READ(kind, data, i));
732 [ - + ]: 4315 : if (size < 0) {
733 : 0 : return NULL;
734 : : }
735 : 4315 : str += size;
736 : : }
737 : 1242 : return str;
738 : : }
739 : :
740 : : /* --- Bloom Filters ----------------------------------------------------- */
741 : :
742 : : /* stuff to implement simple "bloom filters" for Unicode characters.
743 : : to keep things simple, we use a single bitmask, using the least 5
744 : : bits from each unicode characters as the bit index. */
745 : :
746 : : /* the linebreak mask is set up by _PyUnicode_Init() below */
747 : :
748 : : #if LONG_BIT >= 128
749 : : #define BLOOM_WIDTH 128
750 : : #elif LONG_BIT >= 64
751 : : #define BLOOM_WIDTH 64
752 : : #elif LONG_BIT >= 32
753 : : #define BLOOM_WIDTH 32
754 : : #else
755 : : #error "LONG_BIT is smaller than 32"
756 : : #endif
757 : :
758 : : #define BLOOM_MASK unsigned long
759 : :
760 : : static BLOOM_MASK bloom_linebreak = ~(BLOOM_MASK)0;
761 : :
762 : : #define BLOOM(mask, ch) ((mask & (1UL << ((ch) & (BLOOM_WIDTH - 1)))))
763 : :
764 : : #define BLOOM_LINEBREAK(ch) \
765 : : ((ch) < 128U ? ascii_linebreak[(ch)] : \
766 : : (BLOOM(bloom_linebreak, (ch)) && Py_UNICODE_ISLINEBREAK(ch)))
767 : :
768 : : static inline BLOOM_MASK
769 : 5541440 : make_bloom_mask(int kind, const void* ptr, Py_ssize_t len)
770 : : {
771 : : #define BLOOM_UPDATE(TYPE, MASK, PTR, LEN) \
772 : : do { \
773 : : TYPE *data = (TYPE *)PTR; \
774 : : TYPE *end = data + LEN; \
775 : : Py_UCS4 ch; \
776 : : for (; data != end; data++) { \
777 : : ch = *data; \
778 : : MASK |= (1UL << (ch & (BLOOM_WIDTH - 1))); \
779 : : } \
780 : : break; \
781 : : } while (0)
782 : :
783 : : /* calculate simple bloom-style bitmask for a given unicode string */
784 : :
785 : : BLOOM_MASK mask;
786 : :
787 : 5541440 : mask = 0;
788 [ + + - - ]: 5541440 : switch (kind) {
789 : 5538473 : case PyUnicode_1BYTE_KIND:
790 [ + + ]: 11473202 : BLOOM_UPDATE(Py_UCS1, mask, ptr, len);
791 : 5538473 : break;
792 : 2967 : case PyUnicode_2BYTE_KIND:
793 [ + + ]: 26703 : BLOOM_UPDATE(Py_UCS2, mask, ptr, len);
794 : 2967 : break;
795 : 0 : case PyUnicode_4BYTE_KIND:
796 [ # # ]: 0 : BLOOM_UPDATE(Py_UCS4, mask, ptr, len);
797 : 0 : break;
798 : 0 : default:
799 : 0 : Py_UNREACHABLE();
800 : : }
801 : 5541440 : return mask;
802 : :
803 : : #undef BLOOM_UPDATE
804 : : }
805 : :
806 : : static int
807 : 66698811 : ensure_unicode(PyObject *obj)
808 : : {
809 [ + + ]: 66698811 : if (!PyUnicode_Check(obj)) {
810 : 15 : PyErr_Format(PyExc_TypeError,
811 : : "must be str, not %.100s",
812 : 15 : Py_TYPE(obj)->tp_name);
813 : 15 : return -1;
814 : : }
815 : 66698796 : return 0;
816 : : }
817 : :
818 : : /* Compilation of templated routines */
819 : :
820 : : #define STRINGLIB_GET_EMPTY() unicode_get_empty()
821 : :
822 : : #include "stringlib/asciilib.h"
823 : : #include "stringlib/fastsearch.h"
824 : : #include "stringlib/partition.h"
825 : : #include "stringlib/split.h"
826 : : #include "stringlib/count.h"
827 : : #include "stringlib/find.h"
828 : : #include "stringlib/find_max_char.h"
829 : : #include "stringlib/undef.h"
830 : :
831 : : #include "stringlib/ucs1lib.h"
832 : : #include "stringlib/fastsearch.h"
833 : : #include "stringlib/partition.h"
834 : : #include "stringlib/split.h"
835 : : #include "stringlib/count.h"
836 : : #include "stringlib/find.h"
837 : : #include "stringlib/replace.h"
838 : : #include "stringlib/find_max_char.h"
839 : : #include "stringlib/undef.h"
840 : :
841 : : #include "stringlib/ucs2lib.h"
842 : : #include "stringlib/fastsearch.h"
843 : : #include "stringlib/partition.h"
844 : : #include "stringlib/split.h"
845 : : #include "stringlib/count.h"
846 : : #include "stringlib/find.h"
847 : : #include "stringlib/replace.h"
848 : : #include "stringlib/find_max_char.h"
849 : : #include "stringlib/undef.h"
850 : :
851 : : #include "stringlib/ucs4lib.h"
852 : : #include "stringlib/fastsearch.h"
853 : : #include "stringlib/partition.h"
854 : : #include "stringlib/split.h"
855 : : #include "stringlib/count.h"
856 : : #include "stringlib/find.h"
857 : : #include "stringlib/replace.h"
858 : : #include "stringlib/find_max_char.h"
859 : : #include "stringlib/undef.h"
860 : :
861 : : #undef STRINGLIB_GET_EMPTY
862 : :
863 : : /* --- Unicode Object ----------------------------------------------------- */
864 : :
865 : : static inline Py_ssize_t
866 : 34756728 : findchar(const void *s, int kind,
867 : : Py_ssize_t size, Py_UCS4 ch,
868 : : int direction)
869 : : {
870 [ + + + - ]: 34756728 : switch (kind) {
871 : 33615512 : case PyUnicode_1BYTE_KIND:
872 [ + + ]: 33615512 : if ((Py_UCS1) ch != ch)
873 : 2 : return -1;
874 [ + + ]: 33615510 : if (direction > 0)
875 : 32453167 : return ucs1lib_find_char((const Py_UCS1 *) s, size, (Py_UCS1) ch);
876 : : else
877 : 1162343 : return ucs1lib_rfind_char((const Py_UCS1 *) s, size, (Py_UCS1) ch);
878 : 90068 : case PyUnicode_2BYTE_KIND:
879 [ - + ]: 90068 : if ((Py_UCS2) ch != ch)
880 : 0 : return -1;
881 [ + + ]: 90068 : if (direction > 0)
882 : 89733 : return ucs2lib_find_char((const Py_UCS2 *) s, size, (Py_UCS2) ch);
883 : : else
884 : 335 : return ucs2lib_rfind_char((const Py_UCS2 *) s, size, (Py_UCS2) ch);
885 : 1051148 : case PyUnicode_4BYTE_KIND:
886 [ + + ]: 1051148 : if (direction > 0)
887 : 1051139 : return ucs4lib_find_char((const Py_UCS4 *) s, size, ch);
888 : : else
889 : 9 : return ucs4lib_rfind_char((const Py_UCS4 *) s, size, ch);
890 : 0 : default:
891 : 0 : Py_UNREACHABLE();
892 : : }
893 : : }
894 : :
895 : : #ifdef Py_DEBUG
896 : : /* Fill the data of a Unicode string with invalid characters to detect bugs
897 : : earlier.
898 : :
899 : : _PyUnicode_CheckConsistency(str, 1) detects invalid characters, at least for
900 : : ASCII and UCS-4 strings. U+00FF is invalid in ASCII and U+FFFFFFFF is an
901 : : invalid character in Unicode 6.0. */
902 : : static void
903 : : unicode_fill_invalid(PyObject *unicode, Py_ssize_t old_length)
904 : : {
905 : : int kind = PyUnicode_KIND(unicode);
906 : : Py_UCS1 *data = PyUnicode_1BYTE_DATA(unicode);
907 : : Py_ssize_t length = _PyUnicode_LENGTH(unicode);
908 : : if (length <= old_length)
909 : : return;
910 : : memset(data + old_length * kind, 0xff, (length - old_length) * kind);
911 : : }
912 : : #endif
913 : :
914 : : static PyObject*
915 : 11572188 : resize_compact(PyObject *unicode, Py_ssize_t length)
916 : : {
917 : : Py_ssize_t char_size;
918 : : Py_ssize_t struct_size;
919 : : Py_ssize_t new_size;
920 : : PyObject *new_unicode;
921 : : #ifdef Py_DEBUG
922 : : Py_ssize_t old_length = _PyUnicode_LENGTH(unicode);
923 : : #endif
924 : :
925 : : assert(unicode_modifiable(unicode));
926 : : assert(PyUnicode_IS_COMPACT(unicode));
927 : :
928 : 11572188 : char_size = PyUnicode_KIND(unicode);
929 [ + + ]: 11572188 : if (PyUnicode_IS_ASCII(unicode))
930 : 10657204 : struct_size = sizeof(PyASCIIObject);
931 : : else
932 : 914984 : struct_size = sizeof(PyCompactUnicodeObject);
933 : :
934 [ - + ]: 11572188 : if (length > ((PY_SSIZE_T_MAX - struct_size) / char_size - 1)) {
935 : : PyErr_NoMemory();
936 : 0 : return NULL;
937 : : }
938 : 11572188 : new_size = (struct_size + (length + 1) * char_size);
939 : :
940 [ + + + + : 11572188 : if (_PyUnicode_HAS_UTF8_MEMORY(unicode)) {
+ - ]
941 : 11 : PyObject_Free(_PyUnicode_UTF8(unicode));
942 : 11 : _PyUnicode_UTF8(unicode) = NULL;
943 : 11 : _PyUnicode_UTF8_LENGTH(unicode) = 0;
944 : : }
945 : : #ifdef Py_REF_DEBUG
946 : : _Py_RefTotal--;
947 : : #endif
948 : : #ifdef Py_TRACE_REFS
949 : : _Py_ForgetReference(unicode);
950 : : #endif
951 : :
952 : 11572188 : new_unicode = (PyObject *)PyObject_Realloc(unicode, new_size);
953 [ - + ]: 11572188 : if (new_unicode == NULL) {
954 : 0 : _Py_NewReference(unicode);
955 : : PyErr_NoMemory();
956 : 0 : return NULL;
957 : : }
958 : 11572188 : unicode = new_unicode;
959 : 11572188 : _Py_NewReference(unicode);
960 : :
961 : 11572188 : _PyUnicode_LENGTH(unicode) = length;
962 : : #ifdef Py_DEBUG
963 : : unicode_fill_invalid(unicode, old_length);
964 : : #endif
965 : 11572188 : PyUnicode_WRITE(PyUnicode_KIND(unicode), PyUnicode_DATA(unicode),
966 : : length, 0);
967 : : assert(_PyUnicode_CheckConsistency(unicode, 0));
968 : 11572188 : return unicode;
969 : : }
970 : :
971 : : static int
972 : 0 : resize_inplace(PyObject *unicode, Py_ssize_t length)
973 : : {
974 : : assert(!PyUnicode_IS_COMPACT(unicode));
975 : : assert(Py_REFCNT(unicode) == 1);
976 : :
977 : : Py_ssize_t new_size;
978 : : Py_ssize_t char_size;
979 : : int share_utf8;
980 : : void *data;
981 : : #ifdef Py_DEBUG
982 : : Py_ssize_t old_length = _PyUnicode_LENGTH(unicode);
983 : : #endif
984 : :
985 : 0 : data = _PyUnicode_DATA_ANY(unicode);
986 : 0 : char_size = PyUnicode_KIND(unicode);
987 : 0 : share_utf8 = _PyUnicode_SHARE_UTF8(unicode);
988 : :
989 [ # # ]: 0 : if (length > (PY_SSIZE_T_MAX / char_size - 1)) {
990 : : PyErr_NoMemory();
991 : 0 : return -1;
992 : : }
993 : 0 : new_size = (length + 1) * char_size;
994 : :
995 [ # # # # : 0 : if (!share_utf8 && _PyUnicode_HAS_UTF8_MEMORY(unicode))
# # # # ]
996 : : {
997 : 0 : PyObject_Free(_PyUnicode_UTF8(unicode));
998 : 0 : _PyUnicode_UTF8(unicode) = NULL;
999 : 0 : _PyUnicode_UTF8_LENGTH(unicode) = 0;
1000 : : }
1001 : :
1002 : 0 : data = (PyObject *)PyObject_Realloc(data, new_size);
1003 [ # # ]: 0 : if (data == NULL) {
1004 : : PyErr_NoMemory();
1005 : 0 : return -1;
1006 : : }
1007 : 0 : _PyUnicode_DATA_ANY(unicode) = data;
1008 [ # # ]: 0 : if (share_utf8) {
1009 : 0 : _PyUnicode_UTF8(unicode) = data;
1010 : 0 : _PyUnicode_UTF8_LENGTH(unicode) = length;
1011 : : }
1012 : 0 : _PyUnicode_LENGTH(unicode) = length;
1013 : 0 : PyUnicode_WRITE(PyUnicode_KIND(unicode), data, length, 0);
1014 : : #ifdef Py_DEBUG
1015 : : unicode_fill_invalid(unicode, old_length);
1016 : : #endif
1017 : :
1018 : : /* check for integer overflow */
1019 [ # # ]: 0 : if (length > PY_SSIZE_T_MAX / (Py_ssize_t)sizeof(wchar_t) - 1) {
1020 : : PyErr_NoMemory();
1021 : 0 : return -1;
1022 : : }
1023 : : assert(_PyUnicode_CheckConsistency(unicode, 0));
1024 : 0 : return 0;
1025 : : }
1026 : :
1027 : : static PyObject*
1028 : 0 : resize_copy(PyObject *unicode, Py_ssize_t length)
1029 : : {
1030 : : Py_ssize_t copy_length;
1031 : : PyObject *copy;
1032 : :
1033 : 0 : copy = PyUnicode_New(length, PyUnicode_MAX_CHAR_VALUE(unicode));
1034 [ # # ]: 0 : if (copy == NULL)
1035 : 0 : return NULL;
1036 : :
1037 [ # # ]: 0 : copy_length = Py_MIN(length, PyUnicode_GET_LENGTH(unicode));
1038 : 0 : _PyUnicode_FastCopyCharacters(copy, 0, unicode, 0, copy_length);
1039 : 0 : return copy;
1040 : : }
1041 : :
1042 : : static const char*
1043 : 12 : unicode_kind_name(PyObject *unicode)
1044 : : {
1045 : : /* don't check consistency: unicode_kind_name() is called from
1046 : : _PyUnicode_Dump() */
1047 [ - + ]: 12 : if (!PyUnicode_IS_COMPACT(unicode))
1048 : : {
1049 [ # # # # ]: 0 : switch (PyUnicode_KIND(unicode))
1050 : : {
1051 : 0 : case PyUnicode_1BYTE_KIND:
1052 [ # # ]: 0 : if (PyUnicode_IS_ASCII(unicode))
1053 : 0 : return "legacy ascii";
1054 : : else
1055 : 0 : return "legacy latin1";
1056 : 0 : case PyUnicode_2BYTE_KIND:
1057 : 0 : return "legacy UCS2";
1058 : 0 : case PyUnicode_4BYTE_KIND:
1059 : 0 : return "legacy UCS4";
1060 : 0 : default:
1061 : 0 : return "<legacy invalid kind>";
1062 : : }
1063 : : }
1064 [ + + + - ]: 12 : switch (PyUnicode_KIND(unicode)) {
1065 : 6 : case PyUnicode_1BYTE_KIND:
1066 [ + + ]: 6 : if (PyUnicode_IS_ASCII(unicode))
1067 : 3 : return "ascii";
1068 : : else
1069 : 3 : return "latin1";
1070 : 3 : case PyUnicode_2BYTE_KIND:
1071 : 3 : return "UCS2";
1072 : 3 : case PyUnicode_4BYTE_KIND:
1073 : 3 : return "UCS4";
1074 : 0 : default:
1075 : 0 : return "<invalid compact kind>";
1076 : : }
1077 : : }
1078 : :
1079 : : #ifdef Py_DEBUG
1080 : : /* Functions wrapping macros for use in debugger */
1081 : : const char *_PyUnicode_utf8(void *unicode_raw){
1082 : : PyObject *unicode = _PyObject_CAST(unicode_raw);
1083 : : return PyUnicode_UTF8(unicode);
1084 : : }
1085 : :
1086 : : const void *_PyUnicode_compact_data(void *unicode_raw) {
1087 : : PyObject *unicode = _PyObject_CAST(unicode_raw);
1088 : : return _PyUnicode_COMPACT_DATA(unicode);
1089 : : }
1090 : : const void *_PyUnicode_data(void *unicode_raw) {
1091 : : PyObject *unicode = _PyObject_CAST(unicode_raw);
1092 : : printf("obj %p\n", (void*)unicode);
1093 : : printf("compact %d\n", PyUnicode_IS_COMPACT(unicode));
1094 : : printf("compact ascii %d\n", PyUnicode_IS_COMPACT_ASCII(unicode));
1095 : : printf("ascii op %p\n", (void*)(_PyASCIIObject_CAST(unicode) + 1));
1096 : : printf("compact op %p\n", (void*)(_PyCompactUnicodeObject_CAST(unicode) + 1));
1097 : : printf("compact data %p\n", _PyUnicode_COMPACT_DATA(unicode));
1098 : : return PyUnicode_DATA(unicode);
1099 : : }
1100 : :
1101 : : void
1102 : : _PyUnicode_Dump(PyObject *op)
1103 : : {
1104 : : PyASCIIObject *ascii = _PyASCIIObject_CAST(op);
1105 : : PyCompactUnicodeObject *compact = _PyCompactUnicodeObject_CAST(op);
1106 : : PyUnicodeObject *unicode = _PyUnicodeObject_CAST(op);
1107 : : const void *data;
1108 : :
1109 : : if (ascii->state.compact)
1110 : : {
1111 : : if (ascii->state.ascii)
1112 : : data = (ascii + 1);
1113 : : else
1114 : : data = (compact + 1);
1115 : : }
1116 : : else
1117 : : data = unicode->data.any;
1118 : : printf("%s: len=%zu, ", unicode_kind_name(op), ascii->length);
1119 : :
1120 : : if (!ascii->state.ascii) {
1121 : : printf("utf8=%p (%zu)", (void *)compact->utf8, compact->utf8_length);
1122 : : }
1123 : : printf(", data=%p\n", data);
1124 : : }
1125 : : #endif
1126 : :
1127 : :
1128 : : PyObject *
1129 : 233123496 : PyUnicode_New(Py_ssize_t size, Py_UCS4 maxchar)
1130 : : {
1131 : : /* Optimization for empty strings */
1132 [ + + ]: 233123496 : if (size == 0) {
1133 : 1021397 : return unicode_new_empty();
1134 : : }
1135 : :
1136 : : PyObject *obj;
1137 : : PyCompactUnicodeObject *unicode;
1138 : : void *data;
1139 : : int kind;
1140 : : int is_ascii;
1141 : : Py_ssize_t char_size;
1142 : : Py_ssize_t struct_size;
1143 : :
1144 : 232102099 : is_ascii = 0;
1145 : 232102099 : struct_size = sizeof(PyCompactUnicodeObject);
1146 [ + + ]: 232102099 : if (maxchar < 128) {
1147 : 189155398 : kind = PyUnicode_1BYTE_KIND;
1148 : 189155398 : char_size = 1;
1149 : 189155398 : is_ascii = 1;
1150 : 189155398 : struct_size = sizeof(PyASCIIObject);
1151 : : }
1152 [ + + ]: 42946701 : else if (maxchar < 256) {
1153 : 520541 : kind = PyUnicode_1BYTE_KIND;
1154 : 520541 : char_size = 1;
1155 : : }
1156 [ + + ]: 42426160 : else if (maxchar < 65536) {
1157 : 4561801 : kind = PyUnicode_2BYTE_KIND;
1158 : 4561801 : char_size = 2;
1159 : : }
1160 : : else {
1161 [ - + ]: 37864359 : if (maxchar > MAX_UNICODE) {
1162 : 0 : PyErr_SetString(PyExc_SystemError,
1163 : : "invalid maximum character passed to PyUnicode_New");
1164 : 0 : return NULL;
1165 : : }
1166 : 37864359 : kind = PyUnicode_4BYTE_KIND;
1167 : 37864359 : char_size = 4;
1168 : : }
1169 : :
1170 : : /* Ensure we won't overflow the size. */
1171 [ - + ]: 232102099 : if (size < 0) {
1172 : 0 : PyErr_SetString(PyExc_SystemError,
1173 : : "Negative size passed to PyUnicode_New");
1174 : 0 : return NULL;
1175 : : }
1176 [ + + ]: 232102099 : if (size > ((PY_SSIZE_T_MAX - struct_size) / char_size - 1))
1177 : : return PyErr_NoMemory();
1178 : :
1179 : : /* Duplicated allocation code from _PyObject_New() instead of a call to
1180 : : * PyObject_New() so we are able to allocate space for the object and
1181 : : * it's data buffer.
1182 : : */
1183 : 232102091 : obj = (PyObject *) PyObject_Malloc(struct_size + (size + 1) * char_size);
1184 [ + + ]: 232102091 : if (obj == NULL) {
1185 : : return PyErr_NoMemory();
1186 : : }
1187 : 232101810 : _PyObject_Init(obj, &PyUnicode_Type);
1188 : :
1189 : 232101810 : unicode = (PyCompactUnicodeObject *)obj;
1190 [ + + ]: 232101810 : if (is_ascii)
1191 : 189155115 : data = ((PyASCIIObject*)obj) + 1;
1192 : : else
1193 : 42946695 : data = unicode + 1;
1194 : 232101810 : _PyUnicode_LENGTH(unicode) = size;
1195 : 232101810 : _PyUnicode_HASH(unicode) = -1;
1196 : 232101810 : _PyUnicode_STATE(unicode).interned = 0;
1197 : 232101810 : _PyUnicode_STATE(unicode).kind = kind;
1198 : 232101810 : _PyUnicode_STATE(unicode).compact = 1;
1199 : 232101810 : _PyUnicode_STATE(unicode).ascii = is_ascii;
1200 [ + + ]: 232101810 : if (is_ascii) {
1201 : 189155115 : ((char*)data)[size] = 0;
1202 : : }
1203 [ + + ]: 42946695 : else if (kind == PyUnicode_1BYTE_KIND) {
1204 : 520539 : ((char*)data)[size] = 0;
1205 : 520539 : unicode->utf8 = NULL;
1206 : 520539 : unicode->utf8_length = 0;
1207 : : }
1208 : : else {
1209 : 42426156 : unicode->utf8 = NULL;
1210 : 42426156 : unicode->utf8_length = 0;
1211 [ + + ]: 42426156 : if (kind == PyUnicode_2BYTE_KIND)
1212 : 4561799 : ((Py_UCS2*)data)[size] = 0;
1213 : : else /* kind == PyUnicode_4BYTE_KIND */
1214 : 37864357 : ((Py_UCS4*)data)[size] = 0;
1215 : : }
1216 : : #ifdef Py_DEBUG
1217 : : unicode_fill_invalid((PyObject*)unicode, 0);
1218 : : #endif
1219 : : assert(_PyUnicode_CheckConsistency((PyObject*)unicode, 0));
1220 : 232101810 : return obj;
1221 : : }
1222 : :
1223 : : #if SIZEOF_WCHAR_T == 2
1224 : : /* Helper function to convert a 16-bits wchar_t representation to UCS4, this
1225 : : will decode surrogate pairs, the other conversions are implemented as macros
1226 : : for efficiency.
1227 : :
1228 : : This function assumes that unicode can hold one more code point than wstr
1229 : : characters for a terminating null character. */
1230 : : static void
1231 : : unicode_convert_wchar_to_ucs4(const wchar_t *begin, const wchar_t *end,
1232 : : PyObject *unicode)
1233 : : {
1234 : : const wchar_t *iter;
1235 : : Py_UCS4 *ucs4_out;
1236 : :
1237 : : assert(unicode != NULL);
1238 : : assert(_PyUnicode_CHECK(unicode));
1239 : : assert(_PyUnicode_KIND(unicode) == PyUnicode_4BYTE_KIND);
1240 : : ucs4_out = PyUnicode_4BYTE_DATA(unicode);
1241 : :
1242 : : for (iter = begin; iter < end; ) {
1243 : : assert(ucs4_out < (PyUnicode_4BYTE_DATA(unicode) +
1244 : : _PyUnicode_GET_LENGTH(unicode)));
1245 : : if (Py_UNICODE_IS_HIGH_SURROGATE(iter[0])
1246 : : && (iter+1) < end
1247 : : && Py_UNICODE_IS_LOW_SURROGATE(iter[1]))
1248 : : {
1249 : : *ucs4_out++ = Py_UNICODE_JOIN_SURROGATES(iter[0], iter[1]);
1250 : : iter += 2;
1251 : : }
1252 : : else {
1253 : : *ucs4_out++ = *iter;
1254 : : iter++;
1255 : : }
1256 : : }
1257 : : assert(ucs4_out == (PyUnicode_4BYTE_DATA(unicode) +
1258 : : _PyUnicode_GET_LENGTH(unicode)));
1259 : :
1260 : : }
1261 : : #endif
1262 : :
1263 : : static int
1264 : 29148 : unicode_check_modifiable(PyObject *unicode)
1265 : : {
1266 [ - + ]: 29148 : if (!unicode_modifiable(unicode)) {
1267 : 0 : PyErr_SetString(PyExc_SystemError,
1268 : : "Cannot modify a string currently used");
1269 : 0 : return -1;
1270 : : }
1271 : 29148 : return 0;
1272 : : }
1273 : :
1274 : : static int
1275 : 114913186 : _copy_characters(PyObject *to, Py_ssize_t to_start,
1276 : : PyObject *from, Py_ssize_t from_start,
1277 : : Py_ssize_t how_many, int check_maxchar)
1278 : : {
1279 : : int from_kind, to_kind;
1280 : : const void *from_data;
1281 : : void *to_data;
1282 : :
1283 : : assert(0 <= how_many);
1284 : : assert(0 <= from_start);
1285 : : assert(0 <= to_start);
1286 : : assert(PyUnicode_Check(from));
1287 : : assert(from_start + how_many <= PyUnicode_GET_LENGTH(from));
1288 : :
1289 : : assert(PyUnicode_Check(to));
1290 : : assert(to_start + how_many <= PyUnicode_GET_LENGTH(to));
1291 : :
1292 [ + + ]: 114913186 : if (how_many == 0)
1293 : 428420 : return 0;
1294 : :
1295 : 114484766 : from_kind = PyUnicode_KIND(from);
1296 : 114484766 : from_data = PyUnicode_DATA(from);
1297 : 114484766 : to_kind = PyUnicode_KIND(to);
1298 : 114484766 : to_data = PyUnicode_DATA(to);
1299 : :
1300 : : #ifdef Py_DEBUG
1301 : : if (!check_maxchar
1302 : : && PyUnicode_MAX_CHAR_VALUE(from) > PyUnicode_MAX_CHAR_VALUE(to))
1303 : : {
1304 : : Py_UCS4 to_maxchar = PyUnicode_MAX_CHAR_VALUE(to);
1305 : : Py_UCS4 ch;
1306 : : Py_ssize_t i;
1307 : : for (i=0; i < how_many; i++) {
1308 : : ch = PyUnicode_READ(from_kind, from_data, from_start + i);
1309 : : assert(ch <= to_maxchar);
1310 : : }
1311 : : }
1312 : : #endif
1313 : :
1314 [ + + ]: 114484766 : if (from_kind == to_kind) {
1315 [ + + ]: 77088740 : if (check_maxchar
1316 [ + + + + ]: 21481 : && !PyUnicode_IS_ASCII(from) && PyUnicode_IS_ASCII(to))
1317 : : {
1318 : : /* Writing Latin-1 characters into an ASCII string requires to
1319 : : check that all written characters are pure ASCII */
1320 : : Py_UCS4 max_char;
1321 : 1 : max_char = ucs1lib_find_max_char(from_data,
1322 : : (const Py_UCS1*)from_data + how_many);
1323 [ + - ]: 1 : if (max_char >= 128)
1324 : 1 : return -1;
1325 : : }
1326 : 77088739 : memcpy((char*)to_data + to_kind * to_start,
1327 : 77088739 : (const char*)from_data + from_kind * from_start,
1328 : 77088739 : to_kind * how_many);
1329 : : }
1330 [ + + ]: 37396026 : else if (from_kind == PyUnicode_1BYTE_KIND
1331 [ + + ]: 37321825 : && to_kind == PyUnicode_2BYTE_KIND)
1332 : : {
1333 [ + + + + ]: 13421122 : _PyUnicode_CONVERT_BYTES(
1334 : : Py_UCS1, Py_UCS2,
1335 : : PyUnicode_1BYTE_DATA(from) + from_start,
1336 : : PyUnicode_1BYTE_DATA(from) + from_start + how_many,
1337 : : PyUnicode_2BYTE_DATA(to) + to_start
1338 : : );
1339 : : }
1340 [ + + ]: 33374423 : else if (from_kind == PyUnicode_1BYTE_KIND
1341 [ + - ]: 33300222 : && to_kind == PyUnicode_4BYTE_KIND)
1342 : : {
1343 [ + + + + ]: 93697765 : _PyUnicode_CONVERT_BYTES(
1344 : : Py_UCS1, Py_UCS4,
1345 : : PyUnicode_1BYTE_DATA(from) + from_start,
1346 : : PyUnicode_1BYTE_DATA(from) + from_start + how_many,
1347 : : PyUnicode_4BYTE_DATA(to) + to_start
1348 : : );
1349 : : }
1350 [ + + ]: 74201 : else if (from_kind == PyUnicode_2BYTE_KIND
1351 [ + + ]: 74190 : && to_kind == PyUnicode_4BYTE_KIND)
1352 : : {
1353 [ + + + + ]: 307387 : _PyUnicode_CONVERT_BYTES(
1354 : : Py_UCS2, Py_UCS4,
1355 : : PyUnicode_2BYTE_DATA(from) + from_start,
1356 : : PyUnicode_2BYTE_DATA(from) + from_start + how_many,
1357 : : PyUnicode_4BYTE_DATA(to) + to_start
1358 : : );
1359 : : }
1360 : : else {
1361 : : assert (PyUnicode_MAX_CHAR_VALUE(from) > PyUnicode_MAX_CHAR_VALUE(to));
1362 : :
1363 [ + + ]: 141 : if (!check_maxchar) {
1364 [ + + ]: 136 : if (from_kind == PyUnicode_2BYTE_KIND
1365 [ + - ]: 128 : && to_kind == PyUnicode_1BYTE_KIND)
1366 : : {
1367 [ + + + + ]: 280 : _PyUnicode_CONVERT_BYTES(
1368 : : Py_UCS2, Py_UCS1,
1369 : : PyUnicode_2BYTE_DATA(from) + from_start,
1370 : : PyUnicode_2BYTE_DATA(from) + from_start + how_many,
1371 : : PyUnicode_1BYTE_DATA(to) + to_start
1372 : : );
1373 : : }
1374 [ + - ]: 8 : else if (from_kind == PyUnicode_4BYTE_KIND
1375 [ + + ]: 8 : && to_kind == PyUnicode_1BYTE_KIND)
1376 : : {
1377 [ + + + + ]: 16 : _PyUnicode_CONVERT_BYTES(
1378 : : Py_UCS4, Py_UCS1,
1379 : : PyUnicode_4BYTE_DATA(from) + from_start,
1380 : : PyUnicode_4BYTE_DATA(from) + from_start + how_many,
1381 : : PyUnicode_1BYTE_DATA(to) + to_start
1382 : : );
1383 : : }
1384 [ + - ]: 6 : else if (from_kind == PyUnicode_4BYTE_KIND
1385 [ + - ]: 6 : && to_kind == PyUnicode_2BYTE_KIND)
1386 : : {
1387 [ + + + + ]: 48 : _PyUnicode_CONVERT_BYTES(
1388 : : Py_UCS4, Py_UCS2,
1389 : : PyUnicode_4BYTE_DATA(from) + from_start,
1390 : : PyUnicode_4BYTE_DATA(from) + from_start + how_many,
1391 : : PyUnicode_2BYTE_DATA(to) + to_start
1392 : : );
1393 : : }
1394 : : else {
1395 : 0 : Py_UNREACHABLE();
1396 : : }
1397 : : }
1398 : : else {
1399 : 5 : const Py_UCS4 to_maxchar = PyUnicode_MAX_CHAR_VALUE(to);
1400 : : Py_UCS4 ch;
1401 : : Py_ssize_t i;
1402 : :
1403 [ + - ]: 5 : for (i=0; i < how_many; i++) {
1404 : 5 : ch = PyUnicode_READ(from_kind, from_data, from_start + i);
1405 [ + - ]: 5 : if (ch > to_maxchar)
1406 : 5 : return -1;
1407 : 0 : PyUnicode_WRITE(to_kind, to_data, to_start + i, ch);
1408 : : }
1409 : : }
1410 : : }
1411 : 114484760 : return 0;
1412 : : }
1413 : :
1414 : : void
1415 : 114891700 : _PyUnicode_FastCopyCharacters(
1416 : : PyObject *to, Py_ssize_t to_start,
1417 : : PyObject *from, Py_ssize_t from_start, Py_ssize_t how_many)
1418 : : {
1419 : 114891700 : (void)_copy_characters(to, to_start, from, from_start, how_many, 0);
1420 : 114891700 : }
1421 : :
1422 : : Py_ssize_t
1423 : 21493 : PyUnicode_CopyCharacters(PyObject *to, Py_ssize_t to_start,
1424 : : PyObject *from, Py_ssize_t from_start,
1425 : : Py_ssize_t how_many)
1426 : : {
1427 : : int err;
1428 : :
1429 [ + + - + ]: 21493 : if (!PyUnicode_Check(from) || !PyUnicode_Check(to)) {
1430 : 1 : PyErr_BadInternalCall();
1431 : 1 : return -1;
1432 : : }
1433 : :
1434 [ + + ]: 21492 : if ((size_t)from_start > (size_t)PyUnicode_GET_LENGTH(from)) {
1435 : 2 : PyErr_SetString(PyExc_IndexError, "string index out of range");
1436 : 2 : return -1;
1437 : : }
1438 [ + + ]: 21490 : if ((size_t)to_start > (size_t)PyUnicode_GET_LENGTH(to)) {
1439 : 2 : PyErr_SetString(PyExc_IndexError, "string index out of range");
1440 : 2 : return -1;
1441 : : }
1442 [ + + ]: 21488 : if (how_many < 0) {
1443 : 1 : PyErr_SetString(PyExc_SystemError, "how_many cannot be negative");
1444 : 1 : return -1;
1445 : : }
1446 [ + - ]: 21487 : how_many = Py_MIN(PyUnicode_GET_LENGTH(from)-from_start, how_many);
1447 [ + + ]: 21487 : if (to_start + how_many > PyUnicode_GET_LENGTH(to)) {
1448 : 1 : PyErr_Format(PyExc_SystemError,
1449 : : "Cannot write %zi characters at %zi "
1450 : : "in a string of %zi characters",
1451 : : how_many, to_start, PyUnicode_GET_LENGTH(to));
1452 : 1 : return -1;
1453 : : }
1454 : :
1455 [ - + ]: 21486 : if (how_many == 0)
1456 : 0 : return 0;
1457 : :
1458 [ - + ]: 21486 : if (unicode_check_modifiable(to))
1459 : 0 : return -1;
1460 : :
1461 : 21486 : err = _copy_characters(to, to_start, from, from_start, how_many, 1);
1462 [ + + ]: 21486 : if (err) {
1463 : 6 : PyErr_Format(PyExc_SystemError,
1464 : : "Cannot copy %s characters "
1465 : : "into a string of %s characters",
1466 : : unicode_kind_name(from),
1467 : : unicode_kind_name(to));
1468 : 6 : return -1;
1469 : : }
1470 : 21480 : return how_many;
1471 : : }
1472 : :
1473 : : /* Find the maximum code point and count the number of surrogate pairs so a
1474 : : correct string length can be computed before converting a string to UCS4.
1475 : : This function counts single surrogates as a character and not as a pair.
1476 : :
1477 : : Return 0 on success, or -1 on error. */
1478 : : static int
1479 : 1766722 : find_maxchar_surrogates(const wchar_t *begin, const wchar_t *end,
1480 : : Py_UCS4 *maxchar, Py_ssize_t *num_surrogates)
1481 : : {
1482 : : const wchar_t *iter;
1483 : : Py_UCS4 ch;
1484 : :
1485 : : assert(num_surrogates != NULL && maxchar != NULL);
1486 : 1766722 : *num_surrogates = 0;
1487 : 1766722 : *maxchar = 0;
1488 : :
1489 [ + + ]: 38258377 : for (iter = begin; iter < end; ) {
1490 : : #if SIZEOF_WCHAR_T == 2
1491 : : if (Py_UNICODE_IS_HIGH_SURROGATE(iter[0])
1492 : : && (iter+1) < end
1493 : : && Py_UNICODE_IS_LOW_SURROGATE(iter[1]))
1494 : : {
1495 : : ch = Py_UNICODE_JOIN_SURROGATES(iter[0], iter[1]);
1496 : : ++(*num_surrogates);
1497 : : iter += 2;
1498 : : }
1499 : : else
1500 : : #endif
1501 : : {
1502 : 36491658 : ch = *iter;
1503 : 36491658 : iter++;
1504 : : }
1505 [ + + ]: 36491658 : if (ch > *maxchar) {
1506 : 6508227 : *maxchar = ch;
1507 [ + + ]: 6508227 : if (*maxchar > MAX_UNICODE) {
1508 : 3 : PyErr_Format(PyExc_ValueError,
1509 : : "character U+%x is not in range [U+0000; U+%x]",
1510 : : ch, MAX_UNICODE);
1511 : 3 : return -1;
1512 : : }
1513 : : }
1514 : : }
1515 : 1766719 : return 0;
1516 : : }
1517 : :
1518 : : static void
1519 : 231652374 : unicode_dealloc(PyObject *unicode)
1520 : : {
1521 : : #ifdef Py_DEBUG
1522 : : if (!unicode_is_finalizing() && unicode_is_singleton(unicode)) {
1523 : : _Py_FatalRefcountError("deallocating an Unicode singleton");
1524 : : }
1525 : : #endif
1526 : :
1527 [ + + ]: 231652374 : if (PyUnicode_CHECK_INTERNED(unicode)) {
1528 : : /* Revive the dead object temporarily. PyDict_DelItem() removes two
1529 : : references (key and value) which were ignored by
1530 : : PyUnicode_InternInPlace(). Use refcnt=3 rather than refcnt=2
1531 : : to prevent calling unicode_dealloc() again. Adjust refcnt after
1532 : : PyDict_DelItem(). */
1533 : : assert(Py_REFCNT(unicode) == 0);
1534 : 19260634 : Py_SET_REFCNT(unicode, 3);
1535 [ - + ]: 19260634 : if (PyDict_DelItem(interned, unicode) != 0) {
1536 : 0 : _PyErr_WriteUnraisableMsg("deletion of interned string failed",
1537 : : NULL);
1538 : : }
1539 : : assert(Py_REFCNT(unicode) == 1);
1540 : 19260634 : Py_SET_REFCNT(unicode, 0);
1541 : : }
1542 : :
1543 [ + + + + : 231652374 : if (_PyUnicode_HAS_UTF8_MEMORY(unicode)) {
+ + ]
1544 : 4182 : PyObject_Free(_PyUnicode_UTF8(unicode));
1545 : : }
1546 [ + + + - ]: 231652374 : if (!PyUnicode_IS_COMPACT(unicode) && _PyUnicode_DATA_ANY(unicode)) {
1547 : 128369 : PyObject_Free(_PyUnicode_DATA_ANY(unicode));
1548 : : }
1549 : :
1550 : 231652374 : Py_TYPE(unicode)->tp_free(unicode);
1551 : 231652374 : }
1552 : :
1553 : : #ifdef Py_DEBUG
1554 : : static int
1555 : : unicode_is_singleton(PyObject *unicode)
1556 : : {
1557 : : if (unicode == &_Py_STR(empty)) {
1558 : : return 1;
1559 : : }
1560 : :
1561 : : PyASCIIObject *ascii = _PyASCIIObject_CAST(unicode);
1562 : : if (ascii->length == 1) {
1563 : : Py_UCS4 ch = PyUnicode_READ_CHAR(unicode, 0);
1564 : : if (ch < 256 && LATIN1(ch) == unicode) {
1565 : : return 1;
1566 : : }
1567 : : }
1568 : : return 0;
1569 : : }
1570 : : #endif
1571 : :
1572 : : static int
1573 : 5038400 : unicode_modifiable(PyObject *unicode)
1574 : : {
1575 : : assert(_PyUnicode_CHECK(unicode));
1576 [ + + ]: 5038400 : if (Py_REFCNT(unicode) != 1)
1577 : 2199218 : return 0;
1578 [ + + ]: 2839182 : if (_PyUnicode_HASH(unicode) != -1)
1579 : 233 : return 0;
1580 [ - + ]: 2838949 : if (PyUnicode_CHECK_INTERNED(unicode))
1581 : 0 : return 0;
1582 [ - + ]: 2838949 : if (!PyUnicode_CheckExact(unicode))
1583 : 0 : return 0;
1584 : : #ifdef Py_DEBUG
1585 : : /* singleton refcount is greater than 1 */
1586 : : assert(!unicode_is_singleton(unicode));
1587 : : #endif
1588 : 2838949 : return 1;
1589 : : }
1590 : :
1591 : : static int
1592 : 1404430 : unicode_resize(PyObject **p_unicode, Py_ssize_t length)
1593 : : {
1594 : : PyObject *unicode;
1595 : : Py_ssize_t old_length;
1596 : :
1597 : : assert(p_unicode != NULL);
1598 : 1404430 : unicode = *p_unicode;
1599 : :
1600 : : assert(unicode != NULL);
1601 : : assert(PyUnicode_Check(unicode));
1602 : : assert(0 <= length);
1603 : :
1604 : 1404430 : old_length = PyUnicode_GET_LENGTH(unicode);
1605 [ - + ]: 1404430 : if (old_length == length)
1606 : 0 : return 0;
1607 : :
1608 [ - + ]: 1404430 : if (length == 0) {
1609 : 0 : PyObject *empty = unicode_new_empty();
1610 : 0 : Py_SETREF(*p_unicode, empty);
1611 : 0 : return 0;
1612 : : }
1613 : :
1614 [ - + ]: 1404430 : if (!unicode_modifiable(unicode)) {
1615 : 0 : PyObject *copy = resize_copy(unicode, length);
1616 [ # # ]: 0 : if (copy == NULL)
1617 : 0 : return -1;
1618 : 0 : Py_SETREF(*p_unicode, copy);
1619 : 0 : return 0;
1620 : : }
1621 : :
1622 [ + - ]: 1404430 : if (PyUnicode_IS_COMPACT(unicode)) {
1623 : 1404430 : PyObject *new_unicode = resize_compact(unicode, length);
1624 [ - + ]: 1404430 : if (new_unicode == NULL)
1625 : 0 : return -1;
1626 : 1404430 : *p_unicode = new_unicode;
1627 : 1404430 : return 0;
1628 : : }
1629 : 0 : return resize_inplace(unicode, length);
1630 : : }
1631 : :
1632 : : int
1633 : 0 : PyUnicode_Resize(PyObject **p_unicode, Py_ssize_t length)
1634 : : {
1635 : : PyObject *unicode;
1636 [ # # ]: 0 : if (p_unicode == NULL) {
1637 : 0 : PyErr_BadInternalCall();
1638 : 0 : return -1;
1639 : : }
1640 : 0 : unicode = *p_unicode;
1641 [ # # # # : 0 : if (unicode == NULL || !PyUnicode_Check(unicode) || length < 0)
# # ]
1642 : : {
1643 : 0 : PyErr_BadInternalCall();
1644 : 0 : return -1;
1645 : : }
1646 : 0 : return unicode_resize(p_unicode, length);
1647 : : }
1648 : :
1649 : : /* Copy an ASCII or latin1 char* string into a Python Unicode string.
1650 : :
1651 : : WARNING: The function doesn't copy the terminating null character and
1652 : : doesn't check the maximum character (may write a latin1 character in an
1653 : : ASCII string). */
1654 : : static void
1655 : 3 : unicode_write_cstr(PyObject *unicode, Py_ssize_t index,
1656 : : const char *str, Py_ssize_t len)
1657 : : {
1658 : 3 : int kind = PyUnicode_KIND(unicode);
1659 : 3 : const void *data = PyUnicode_DATA(unicode);
1660 : 3 : const char *end = str + len;
1661 : :
1662 : : assert(index + len <= PyUnicode_GET_LENGTH(unicode));
1663 [ + - - - ]: 3 : switch (kind) {
1664 : 3 : case PyUnicode_1BYTE_KIND: {
1665 : : #ifdef Py_DEBUG
1666 : : if (PyUnicode_IS_ASCII(unicode)) {
1667 : : Py_UCS4 maxchar = ucs1lib_find_max_char(
1668 : : (const Py_UCS1*)str,
1669 : : (const Py_UCS1*)str + len);
1670 : : assert(maxchar < 128);
1671 : : }
1672 : : #endif
1673 : 3 : memcpy((char *) data + index, str, len);
1674 : 3 : break;
1675 : : }
1676 : 0 : case PyUnicode_2BYTE_KIND: {
1677 : 0 : Py_UCS2 *start = (Py_UCS2 *)data + index;
1678 : 0 : Py_UCS2 *ucs2 = start;
1679 : :
1680 [ # # ]: 0 : for (; str < end; ++ucs2, ++str)
1681 : 0 : *ucs2 = (Py_UCS2)*str;
1682 : :
1683 : : assert((ucs2 - start) <= PyUnicode_GET_LENGTH(unicode));
1684 : 0 : break;
1685 : : }
1686 : 0 : case PyUnicode_4BYTE_KIND: {
1687 : 0 : Py_UCS4 *start = (Py_UCS4 *)data + index;
1688 : 0 : Py_UCS4 *ucs4 = start;
1689 : :
1690 [ # # ]: 0 : for (; str < end; ++ucs4, ++str)
1691 : 0 : *ucs4 = (Py_UCS4)*str;
1692 : :
1693 : : assert((ucs4 - start) <= PyUnicode_GET_LENGTH(unicode));
1694 : 0 : break;
1695 : : }
1696 : 0 : default:
1697 : 0 : Py_UNREACHABLE();
1698 : : }
1699 : 3 : }
1700 : :
1701 : : static PyObject*
1702 : 79614945 : get_latin1_char(Py_UCS1 ch)
1703 : : {
1704 [ + + ]: 79614945 : return Py_NewRef(LATIN1(ch));
1705 : : }
1706 : :
1707 : : static PyObject*
1708 : 68598047 : unicode_char(Py_UCS4 ch)
1709 : : {
1710 : : PyObject *unicode;
1711 : :
1712 : : assert(ch <= MAX_UNICODE);
1713 : :
1714 [ + + ]: 68598047 : if (ch < 256) {
1715 : 56536766 : return get_latin1_char(ch);
1716 : : }
1717 : :
1718 : 12061281 : unicode = PyUnicode_New(1, ch);
1719 [ - + ]: 12061281 : if (unicode == NULL)
1720 : 0 : return NULL;
1721 : :
1722 : : assert(PyUnicode_KIND(unicode) != PyUnicode_1BYTE_KIND);
1723 [ + + ]: 12061281 : if (PyUnicode_KIND(unicode) == PyUnicode_2BYTE_KIND) {
1724 : 1558368 : PyUnicode_2BYTE_DATA(unicode)[0] = (Py_UCS2)ch;
1725 : : } else {
1726 : : assert(PyUnicode_KIND(unicode) == PyUnicode_4BYTE_KIND);
1727 : 10502913 : PyUnicode_4BYTE_DATA(unicode)[0] = ch;
1728 : : }
1729 : : assert(_PyUnicode_CheckConsistency(unicode, 1));
1730 : 12061281 : return unicode;
1731 : : }
1732 : :
1733 : : PyObject *
1734 : 1787547 : PyUnicode_FromWideChar(const wchar_t *u, Py_ssize_t size)
1735 : : {
1736 : : PyObject *unicode;
1737 : 1787547 : Py_UCS4 maxchar = 0;
1738 : : Py_ssize_t num_surrogates;
1739 : :
1740 [ - + - - ]: 1787547 : if (u == NULL && size != 0) {
1741 : 0 : PyErr_BadInternalCall();
1742 : 0 : return NULL;
1743 : : }
1744 : :
1745 [ + + ]: 1787547 : if (size == -1) {
1746 : 346665 : size = wcslen(u);
1747 : : }
1748 : :
1749 : : /* If the Unicode data is known at construction time, we can apply
1750 : : some optimizations which share commonly used objects. */
1751 : :
1752 : : /* Optimization for empty strings */
1753 [ + + ]: 1787547 : if (size == 0)
1754 : 5729 : _Py_RETURN_UNICODE_EMPTY();
1755 : :
1756 : : #ifdef HAVE_NON_UNICODE_WCHAR_T_REPRESENTATION
1757 : : /* Oracle Solaris uses non-Unicode internal wchar_t form for
1758 : : non-Unicode locales and hence needs conversion to UCS-4 first. */
1759 : : if (_Py_LocaleUsesNonUnicodeWchar()) {
1760 : : wchar_t* converted = _Py_DecodeNonUnicodeWchar(u, size);
1761 : : if (!converted) {
1762 : : return NULL;
1763 : : }
1764 : : PyObject *unicode = _PyUnicode_FromUCS4(converted, size);
1765 : : PyMem_Free(converted);
1766 : : return unicode;
1767 : : }
1768 : : #endif
1769 : :
1770 : : /* Single character Unicode objects in the Latin-1 range are
1771 : : shared when using this constructor */
1772 [ + + + + ]: 1781818 : if (size == 1 && (Py_UCS4)*u < 256)
1773 : 15096 : return get_latin1_char((unsigned char)*u);
1774 : :
1775 : : /* If not empty and not single character, copy the Unicode data
1776 : : into the new object */
1777 [ + + ]: 1766722 : if (find_maxchar_surrogates(u, u + size,
1778 : : &maxchar, &num_surrogates) == -1)
1779 : 3 : return NULL;
1780 : :
1781 : 1766719 : unicode = PyUnicode_New(size - num_surrogates, maxchar);
1782 [ - + ]: 1766719 : if (!unicode)
1783 : 0 : return NULL;
1784 : :
1785 [ + + + - ]: 1766719 : switch (PyUnicode_KIND(unicode)) {
1786 : 1766495 : case PyUnicode_1BYTE_KIND:
1787 [ + + + + ]: 12659961 : _PyUnicode_CONVERT_BYTES(Py_UNICODE, unsigned char,
1788 : : u, u + size, PyUnicode_1BYTE_DATA(unicode));
1789 : 1766495 : break;
1790 : 182 : case PyUnicode_2BYTE_KIND:
1791 : : #if Py_UNICODE_SIZE == 2
1792 : : memcpy(PyUnicode_2BYTE_DATA(unicode), u, size * 2);
1793 : : #else
1794 [ + + + + ]: 2175 : _PyUnicode_CONVERT_BYTES(Py_UNICODE, Py_UCS2,
1795 : : u, u + size, PyUnicode_2BYTE_DATA(unicode));
1796 : : #endif
1797 : 182 : break;
1798 : 42 : case PyUnicode_4BYTE_KIND:
1799 : : #if SIZEOF_WCHAR_T == 2
1800 : : /* This is the only case which has to process surrogates, thus
1801 : : a simple copy loop is not enough and we need a function. */
1802 : : unicode_convert_wchar_to_ucs4(u, u + size, unicode);
1803 : : #else
1804 : : assert(num_surrogates == 0);
1805 : 42 : memcpy(PyUnicode_4BYTE_DATA(unicode), u, size * 4);
1806 : : #endif
1807 : 42 : break;
1808 : 0 : default:
1809 : 0 : Py_UNREACHABLE();
1810 : : }
1811 : :
1812 : 1766719 : return unicode_result(unicode);
1813 : : }
1814 : :
1815 : : PyObject *
1816 : 4968821 : PyUnicode_FromStringAndSize(const char *u, Py_ssize_t size)
1817 : : {
1818 [ - + ]: 4968821 : if (size < 0) {
1819 : 0 : PyErr_SetString(PyExc_SystemError,
1820 : : "Negative size passed to PyUnicode_FromStringAndSize");
1821 : 0 : return NULL;
1822 : : }
1823 [ + + ]: 4968821 : if (u != NULL) {
1824 : 4862369 : return PyUnicode_DecodeUTF8Stateful(u, size, NULL, NULL);
1825 : : }
1826 [ - + ]: 106452 : if (size > 0) {
1827 : 0 : PyErr_SetString(PyExc_SystemError,
1828 : : "NULL string with positive size with NULL passed to PyUnicode_FromStringAndSize");
1829 : 0 : return NULL;
1830 : : }
1831 : 106452 : return unicode_new_empty();
1832 : : }
1833 : :
1834 : : PyObject *
1835 : 41735676 : PyUnicode_FromString(const char *u)
1836 : : {
1837 : 41735676 : size_t size = strlen(u);
1838 [ - + ]: 41735676 : if (size > PY_SSIZE_T_MAX) {
1839 : 0 : PyErr_SetString(PyExc_OverflowError, "input too long");
1840 : 0 : return NULL;
1841 : : }
1842 : 41735676 : return PyUnicode_DecodeUTF8Stateful(u, (Py_ssize_t)size, NULL, NULL);
1843 : : }
1844 : :
1845 : :
1846 : : PyObject *
1847 : 148991 : _PyUnicode_FromId(_Py_Identifier *id)
1848 : : {
1849 : 148991 : PyInterpreterState *interp = _PyInterpreterState_GET();
1850 : 148991 : struct _Py_unicode_ids *ids = &interp->unicode.ids;
1851 : :
1852 : 148991 : Py_ssize_t index = _Py_atomic_size_get(&id->index);
1853 [ + + ]: 148991 : if (index < 0) {
1854 : 6681 : struct _Py_unicode_runtime_ids *rt_ids = &interp->runtime->unicode_ids;
1855 : :
1856 : 6681 : PyThread_acquire_lock(rt_ids->lock, WAIT_LOCK);
1857 : : // Check again to detect concurrent access. Another thread can have
1858 : : // initialized the index while this thread waited for the lock.
1859 : 6681 : index = _Py_atomic_size_get(&id->index);
1860 [ + - ]: 6681 : if (index < 0) {
1861 : : assert(rt_ids->next_index < PY_SSIZE_T_MAX);
1862 : 6681 : index = rt_ids->next_index;
1863 : 6681 : rt_ids->next_index++;
1864 : 6681 : _Py_atomic_size_set(&id->index, index);
1865 : : }
1866 : 6681 : PyThread_release_lock(rt_ids->lock);
1867 : : }
1868 : : assert(index >= 0);
1869 : :
1870 : : PyObject *obj;
1871 [ + + ]: 148991 : if (index < ids->size) {
1872 : 148134 : obj = ids->array[index];
1873 [ + + ]: 148134 : if (obj) {
1874 : : // Return a borrowed reference
1875 : 142308 : return obj;
1876 : : }
1877 : : }
1878 : :
1879 : 6683 : obj = PyUnicode_DecodeUTF8Stateful(id->string, strlen(id->string),
1880 : : NULL, NULL);
1881 [ - + ]: 6683 : if (!obj) {
1882 : 0 : return NULL;
1883 : : }
1884 : 6683 : PyUnicode_InternInPlace(&obj);
1885 : :
1886 [ + + ]: 6683 : if (index >= ids->size) {
1887 : : // Overallocate to reduce the number of realloc
1888 : 857 : Py_ssize_t new_size = Py_MAX(index * 2, 16);
1889 : 857 : Py_ssize_t item_size = sizeof(ids->array[0]);
1890 : 857 : PyObject **new_array = PyMem_Realloc(ids->array, new_size * item_size);
1891 [ - + ]: 857 : if (new_array == NULL) {
1892 : : PyErr_NoMemory();
1893 : 0 : return NULL;
1894 : : }
1895 : 857 : memset(&new_array[ids->size], 0, (new_size - ids->size) * item_size);
1896 : 857 : ids->array = new_array;
1897 : 857 : ids->size = new_size;
1898 : : }
1899 : :
1900 : : // The array stores a strong reference
1901 : 6683 : ids->array[index] = obj;
1902 : :
1903 : : // Return a borrowed reference
1904 : 6683 : return obj;
1905 : : }
1906 : :
1907 : :
1908 : : static void
1909 : 3125 : unicode_clear_identifiers(struct _Py_unicode_state *state)
1910 : : {
1911 : 3125 : struct _Py_unicode_ids *ids = &state->ids;
1912 [ + + ]: 16837 : for (Py_ssize_t i=0; i < ids->size; i++) {
1913 : 13712 : Py_XDECREF(ids->array[i]);
1914 : : }
1915 : 3125 : ids->size = 0;
1916 : 3125 : PyMem_Free(ids->array);
1917 : 3125 : ids->array = NULL;
1918 : : // Don't reset _PyRuntime next_index: _Py_Identifier.id remains valid
1919 : : // after Py_Finalize().
1920 : 3125 : }
1921 : :
1922 : :
1923 : : /* Internal function, doesn't check maximum character */
1924 : :
1925 : : PyObject*
1926 : 31903300 : _PyUnicode_FromASCII(const char *buffer, Py_ssize_t size)
1927 : : {
1928 : 31903300 : const unsigned char *s = (const unsigned char *)buffer;
1929 : : PyObject *unicode;
1930 [ + + ]: 31903300 : if (size == 1) {
1931 : : #ifdef Py_DEBUG
1932 : : assert((unsigned char)s[0] < 128);
1933 : : #endif
1934 : 6975571 : return get_latin1_char(s[0]);
1935 : : }
1936 : 24927729 : unicode = PyUnicode_New(size, 127);
1937 [ - + ]: 24927729 : if (!unicode)
1938 : 0 : return NULL;
1939 : 24927729 : memcpy(PyUnicode_1BYTE_DATA(unicode), s, size);
1940 : : assert(_PyUnicode_CheckConsistency(unicode, 1));
1941 : 24927729 : return unicode;
1942 : : }
1943 : :
1944 : : static Py_UCS4
1945 : 9 : kind_maxchar_limit(int kind)
1946 : : {
1947 [ - + - - ]: 9 : switch (kind) {
1948 : 0 : case PyUnicode_1BYTE_KIND:
1949 : 0 : return 0x80;
1950 : 9 : case PyUnicode_2BYTE_KIND:
1951 : 9 : return 0x100;
1952 : 0 : case PyUnicode_4BYTE_KIND:
1953 : 0 : return 0x10000;
1954 : 0 : default:
1955 : 0 : Py_UNREACHABLE();
1956 : : }
1957 : : }
1958 : :
1959 : : static PyObject*
1960 : 50066464 : _PyUnicode_FromUCS1(const Py_UCS1* u, Py_ssize_t size)
1961 : : {
1962 : : PyObject *res;
1963 : : unsigned char max_char;
1964 : :
1965 [ + + ]: 50066464 : if (size == 0) {
1966 : 106064 : _Py_RETURN_UNICODE_EMPTY();
1967 : : }
1968 : : assert(size > 0);
1969 [ + + ]: 49960400 : if (size == 1) {
1970 : 6459878 : return get_latin1_char(u[0]);
1971 : : }
1972 : :
1973 : 43500522 : max_char = ucs1lib_find_max_char(u, u + size);
1974 : 43500522 : res = PyUnicode_New(size, max_char);
1975 [ - + ]: 43500522 : if (!res)
1976 : 0 : return NULL;
1977 : 43500522 : memcpy(PyUnicode_1BYTE_DATA(res), u, size);
1978 : : assert(_PyUnicode_CheckConsistency(res, 1));
1979 : 43500522 : return res;
1980 : : }
1981 : :
1982 : : static PyObject*
1983 : 316186 : _PyUnicode_FromUCS2(const Py_UCS2 *u, Py_ssize_t size)
1984 : : {
1985 : : PyObject *res;
1986 : : Py_UCS2 max_char;
1987 : :
1988 [ + + ]: 316186 : if (size == 0)
1989 : 8034 : _Py_RETURN_UNICODE_EMPTY();
1990 : : assert(size > 0);
1991 [ + + ]: 308152 : if (size == 1)
1992 : 25435 : return unicode_char(u[0]);
1993 : :
1994 : 282717 : max_char = ucs2lib_find_max_char(u, u + size);
1995 : 282717 : res = PyUnicode_New(size, max_char);
1996 [ - + ]: 282717 : if (!res)
1997 : 0 : return NULL;
1998 [ + + ]: 282717 : if (max_char >= 256)
1999 : 131994 : memcpy(PyUnicode_2BYTE_DATA(res), u, sizeof(Py_UCS2)*size);
2000 : : else {
2001 [ + + + + ]: 1600772 : _PyUnicode_CONVERT_BYTES(
2002 : : Py_UCS2, Py_UCS1, u, u + size, PyUnicode_1BYTE_DATA(res));
2003 : : }
2004 : : assert(_PyUnicode_CheckConsistency(res, 1));
2005 : 282717 : return res;
2006 : : }
2007 : :
2008 : : static PyObject*
2009 : 405853 : _PyUnicode_FromUCS4(const Py_UCS4 *u, Py_ssize_t size)
2010 : : {
2011 : : PyObject *res;
2012 : : Py_UCS4 max_char;
2013 : :
2014 [ + + ]: 405853 : if (size == 0)
2015 : 7430 : _Py_RETURN_UNICODE_EMPTY();
2016 : : assert(size > 0);
2017 [ + + ]: 398423 : if (size == 1)
2018 : 100584 : return unicode_char(u[0]);
2019 : :
2020 : 297839 : max_char = ucs4lib_find_max_char(u, u + size);
2021 : 297839 : res = PyUnicode_New(size, max_char);
2022 [ - + ]: 297839 : if (!res)
2023 : 0 : return NULL;
2024 [ + + ]: 297839 : if (max_char < 256)
2025 [ + + + + ]: 21808525 : _PyUnicode_CONVERT_BYTES(Py_UCS4, Py_UCS1, u, u + size,
2026 : : PyUnicode_1BYTE_DATA(res));
2027 [ + + ]: 164243 : else if (max_char < 0x10000)
2028 [ + + + + ]: 635805 : _PyUnicode_CONVERT_BYTES(Py_UCS4, Py_UCS2, u, u + size,
2029 : : PyUnicode_2BYTE_DATA(res));
2030 : : else
2031 : 12276 : memcpy(PyUnicode_4BYTE_DATA(res), u, sizeof(Py_UCS4)*size);
2032 : : assert(_PyUnicode_CheckConsistency(res, 1));
2033 : 297839 : return res;
2034 : : }
2035 : :
2036 : : PyObject*
2037 : 45582217 : PyUnicode_FromKindAndData(int kind, const void *buffer, Py_ssize_t size)
2038 : : {
2039 [ - + ]: 45582217 : if (size < 0) {
2040 : 0 : PyErr_SetString(PyExc_ValueError, "size must be positive");
2041 : 0 : return NULL;
2042 : : }
2043 [ + + + - ]: 45582217 : switch (kind) {
2044 : 45026129 : case PyUnicode_1BYTE_KIND:
2045 : 45026129 : return _PyUnicode_FromUCS1(buffer, size);
2046 : 156641 : case PyUnicode_2BYTE_KIND:
2047 : 156641 : return _PyUnicode_FromUCS2(buffer, size);
2048 : 399447 : case PyUnicode_4BYTE_KIND:
2049 : 399447 : return _PyUnicode_FromUCS4(buffer, size);
2050 : 0 : default:
2051 : 0 : PyErr_SetString(PyExc_SystemError, "invalid kind");
2052 : 0 : return NULL;
2053 : : }
2054 : : }
2055 : :
2056 : : Py_UCS4
2057 : 1035405 : _PyUnicode_FindMaxChar(PyObject *unicode, Py_ssize_t start, Py_ssize_t end)
2058 : : {
2059 : : int kind;
2060 : : const void *startptr, *endptr;
2061 : :
2062 : : assert(0 <= start);
2063 : : assert(end <= PyUnicode_GET_LENGTH(unicode));
2064 : : assert(start <= end);
2065 : :
2066 [ + + + + ]: 1035405 : if (start == 0 && end == PyUnicode_GET_LENGTH(unicode))
2067 : 197960 : return PyUnicode_MAX_CHAR_VALUE(unicode);
2068 : :
2069 [ + + ]: 837445 : if (start == end)
2070 : 3074 : return 127;
2071 : :
2072 [ + + ]: 834371 : if (PyUnicode_IS_ASCII(unicode))
2073 : 833944 : return 127;
2074 : :
2075 : 427 : kind = PyUnicode_KIND(unicode);
2076 : 427 : startptr = PyUnicode_DATA(unicode);
2077 : 427 : endptr = (char *)startptr + end * kind;
2078 : 427 : startptr = (char *)startptr + start * kind;
2079 [ + + - - ]: 427 : switch(kind) {
2080 : 33 : case PyUnicode_1BYTE_KIND:
2081 : 33 : return ucs1lib_find_max_char(startptr, endptr);
2082 : 394 : case PyUnicode_2BYTE_KIND:
2083 : 394 : return ucs2lib_find_max_char(startptr, endptr);
2084 : 0 : case PyUnicode_4BYTE_KIND:
2085 : 0 : return ucs4lib_find_max_char(startptr, endptr);
2086 : 0 : default:
2087 : 0 : Py_UNREACHABLE();
2088 : : }
2089 : : }
2090 : :
2091 : : /* Ensure that a string uses the most efficient storage, if it is not the
2092 : : case: create a new string with of the right kind. Write NULL into *p_unicode
2093 : : on error. */
2094 : : static void
2095 : 141 : unicode_adjust_maxchar(PyObject **p_unicode)
2096 : : {
2097 : : PyObject *unicode, *copy;
2098 : : Py_UCS4 max_char;
2099 : : Py_ssize_t len;
2100 : : int kind;
2101 : :
2102 : : assert(p_unicode != NULL);
2103 : 141 : unicode = *p_unicode;
2104 [ - + ]: 141 : if (PyUnicode_IS_ASCII(unicode))
2105 : 0 : return;
2106 : :
2107 : 141 : len = PyUnicode_GET_LENGTH(unicode);
2108 : 141 : kind = PyUnicode_KIND(unicode);
2109 [ + + ]: 141 : if (kind == PyUnicode_1BYTE_KIND) {
2110 : 3 : const Py_UCS1 *u = PyUnicode_1BYTE_DATA(unicode);
2111 : 3 : max_char = ucs1lib_find_max_char(u, u + len);
2112 [ - + ]: 3 : if (max_char >= 128)
2113 : 0 : return;
2114 : : }
2115 [ + + ]: 138 : else if (kind == PyUnicode_2BYTE_KIND) {
2116 : 126 : const Py_UCS2 *u = PyUnicode_2BYTE_DATA(unicode);
2117 : 126 : max_char = ucs2lib_find_max_char(u, u + len);
2118 [ + + ]: 126 : if (max_char >= 256)
2119 : 2 : return;
2120 : : }
2121 [ + - ]: 12 : else if (kind == PyUnicode_4BYTE_KIND) {
2122 : 12 : const Py_UCS4 *u = PyUnicode_4BYTE_DATA(unicode);
2123 : 12 : max_char = ucs4lib_find_max_char(u, u + len);
2124 [ + + ]: 12 : if (max_char >= 0x10000)
2125 : 4 : return;
2126 : : }
2127 : : else
2128 : 0 : Py_UNREACHABLE();
2129 : :
2130 : 135 : copy = PyUnicode_New(len, max_char);
2131 [ + - ]: 135 : if (copy != NULL)
2132 : 135 : _PyUnicode_FastCopyCharacters(copy, 0, unicode, 0, len);
2133 : 135 : Py_DECREF(unicode);
2134 : 135 : *p_unicode = copy;
2135 : : }
2136 : :
2137 : : PyObject*
2138 : 61705 : _PyUnicode_Copy(PyObject *unicode)
2139 : : {
2140 : : Py_ssize_t length;
2141 : : PyObject *copy;
2142 : :
2143 [ - + ]: 61705 : if (!PyUnicode_Check(unicode)) {
2144 : 0 : PyErr_BadInternalCall();
2145 : 0 : return NULL;
2146 : : }
2147 : :
2148 : 61705 : length = PyUnicode_GET_LENGTH(unicode);
2149 : 61705 : copy = PyUnicode_New(length, PyUnicode_MAX_CHAR_VALUE(unicode));
2150 [ - + ]: 61705 : if (!copy)
2151 : 0 : return NULL;
2152 : : assert(PyUnicode_KIND(copy) == PyUnicode_KIND(unicode));
2153 : :
2154 : 61705 : memcpy(PyUnicode_DATA(copy), PyUnicode_DATA(unicode),
2155 : 61705 : length * PyUnicode_KIND(unicode));
2156 : : assert(_PyUnicode_CheckConsistency(copy, 1));
2157 : 61705 : return copy;
2158 : : }
2159 : :
2160 : :
2161 : : /* Widen Unicode objects to larger buffers. Don't write terminating null
2162 : : character. Return NULL on error. */
2163 : :
2164 : : static void*
2165 : 34651 : unicode_askind(int skind, void const *data, Py_ssize_t len, int kind)
2166 : : {
2167 : : void *result;
2168 : :
2169 : : assert(skind < kind);
2170 [ + + - ]: 34651 : switch (kind) {
2171 : 31331 : case PyUnicode_2BYTE_KIND:
2172 [ + - ]: 31331 : result = PyMem_New(Py_UCS2, len);
2173 [ - + ]: 31331 : if (!result)
2174 : : return PyErr_NoMemory();
2175 : : assert(skind == PyUnicode_1BYTE_KIND);
2176 [ + + + + ]: 65043 : _PyUnicode_CONVERT_BYTES(
2177 : : Py_UCS1, Py_UCS2,
2178 : : (const Py_UCS1 *)data,
2179 : : ((const Py_UCS1 *)data) + len,
2180 : : result);
2181 : 31331 : return result;
2182 : 3320 : case PyUnicode_4BYTE_KIND:
2183 [ + - ]: 3320 : result = PyMem_New(Py_UCS4, len);
2184 [ - + ]: 3320 : if (!result)
2185 : : return PyErr_NoMemory();
2186 [ + + ]: 3320 : if (skind == PyUnicode_2BYTE_KIND) {
2187 [ + + + + ]: 124 : _PyUnicode_CONVERT_BYTES(
2188 : : Py_UCS2, Py_UCS4,
2189 : : (const Py_UCS2 *)data,
2190 : : ((const Py_UCS2 *)data) + len,
2191 : : result);
2192 : : }
2193 : : else {
2194 : : assert(skind == PyUnicode_1BYTE_KIND);
2195 [ + + + + ]: 6631 : _PyUnicode_CONVERT_BYTES(
2196 : : Py_UCS1, Py_UCS4,
2197 : : (const Py_UCS1 *)data,
2198 : : ((const Py_UCS1 *)data) + len,
2199 : : result);
2200 : : }
2201 : 3320 : return result;
2202 : 0 : default:
2203 : 0 : Py_UNREACHABLE();
2204 : : return NULL;
2205 : : }
2206 : : }
2207 : :
2208 : : static Py_UCS4*
2209 : 103122 : as_ucs4(PyObject *string, Py_UCS4 *target, Py_ssize_t targetsize,
2210 : : int copy_null)
2211 : : {
2212 : : int kind;
2213 : : const void *data;
2214 : : Py_ssize_t len, targetlen;
2215 : 103122 : kind = PyUnicode_KIND(string);
2216 : 103122 : data = PyUnicode_DATA(string);
2217 : 103122 : len = PyUnicode_GET_LENGTH(string);
2218 : 103122 : targetlen = len;
2219 [ + + ]: 103122 : if (copy_null)
2220 : 70 : targetlen++;
2221 [ + + ]: 103122 : if (!target) {
2222 [ + - ]: 46 : target = PyMem_New(Py_UCS4, targetlen);
2223 [ - + ]: 46 : if (!target) {
2224 : : PyErr_NoMemory();
2225 : 0 : return NULL;
2226 : : }
2227 : : }
2228 : : else {
2229 [ + + ]: 103076 : if (targetsize < targetlen) {
2230 : 12 : PyErr_Format(PyExc_SystemError,
2231 : : "string is longer than the buffer");
2232 [ + + + - ]: 12 : if (copy_null && 0 < targetsize)
2233 : 6 : target[0] = 0;
2234 : 12 : return NULL;
2235 : : }
2236 : : }
2237 [ + + ]: 103110 : if (kind == PyUnicode_1BYTE_KIND) {
2238 : 102863 : const Py_UCS1 *start = (const Py_UCS1 *) data;
2239 [ + + + + ]: 24203176 : _PyUnicode_CONVERT_BYTES(Py_UCS1, Py_UCS4, start, start + len, target);
2240 : : }
2241 [ + + ]: 247 : else if (kind == PyUnicode_2BYTE_KIND) {
2242 : 206 : const Py_UCS2 *start = (const Py_UCS2 *) data;
2243 [ + + + + ]: 587204 : _PyUnicode_CONVERT_BYTES(Py_UCS2, Py_UCS4, start, start + len, target);
2244 : : }
2245 [ + - ]: 41 : else if (kind == PyUnicode_4BYTE_KIND) {
2246 : 41 : memcpy(target, data, len * sizeof(Py_UCS4));
2247 : : }
2248 : : else {
2249 : 0 : Py_UNREACHABLE();
2250 : : }
2251 [ + + ]: 103110 : if (copy_null)
2252 : 64 : target[len] = 0;
2253 : 103110 : return target;
2254 : : }
2255 : :
2256 : : Py_UCS4*
2257 : 103076 : PyUnicode_AsUCS4(PyObject *string, Py_UCS4 *target, Py_ssize_t targetsize,
2258 : : int copy_null)
2259 : : {
2260 [ + - - + ]: 103076 : if (target == NULL || targetsize < 0) {
2261 : 0 : PyErr_BadInternalCall();
2262 : 0 : return NULL;
2263 : : }
2264 : 103076 : return as_ucs4(string, target, targetsize, copy_null);
2265 : : }
2266 : :
2267 : : Py_UCS4*
2268 : 46 : PyUnicode_AsUCS4Copy(PyObject *string)
2269 : : {
2270 : 46 : return as_ucs4(string, NULL, 0, 1);
2271 : : }
2272 : :
2273 : : /* maximum number of characters required for output of %lld or %p.
2274 : : We need at most ceil(log10(256)*SIZEOF_LONG_LONG) digits,
2275 : : plus 1 for the sign. 53/22 is an upper bound for log10(256). */
2276 : : #define MAX_LONG_LONG_CHARS (2 + (SIZEOF_LONG_LONG*53-1) / 22)
2277 : :
2278 : : static int
2279 : 13184839 : unicode_fromformat_write_str(_PyUnicodeWriter *writer, PyObject *str,
2280 : : Py_ssize_t width, Py_ssize_t precision)
2281 : : {
2282 : : Py_ssize_t length, fill, arglen;
2283 : : Py_UCS4 maxchar;
2284 : :
2285 : 13184839 : length = PyUnicode_GET_LENGTH(str);
2286 [ + + + + ]: 13184839 : if ((precision == -1 || precision >= length)
2287 [ + + ]: 13184796 : && width <= length)
2288 : 13184787 : return _PyUnicodeWriter_WriteStr(writer, str);
2289 : :
2290 [ + + ]: 52 : if (precision != -1)
2291 : 43 : length = Py_MIN(precision, length);
2292 : :
2293 : 52 : arglen = Py_MAX(length, width);
2294 [ + + ]: 52 : if (PyUnicode_MAX_CHAR_VALUE(str) > writer->maxchar)
2295 : 5 : maxchar = _PyUnicode_FindMaxChar(str, 0, length);
2296 : : else
2297 : 47 : maxchar = writer->maxchar;
2298 : :
2299 [ + + + + : 52 : if (_PyUnicodeWriter_Prepare(writer, arglen, maxchar) == -1)
+ - - + ]
2300 : 0 : return -1;
2301 : :
2302 [ + + ]: 52 : if (width > length) {
2303 : 14 : fill = width - length;
2304 [ - + ]: 14 : if (PyUnicode_Fill(writer->buffer, writer->pos, fill, ' ') == -1)
2305 : 0 : return -1;
2306 : 14 : writer->pos += fill;
2307 : : }
2308 : :
2309 : 52 : _PyUnicode_FastCopyCharacters(writer->buffer, writer->pos,
2310 : : str, 0, length);
2311 : 52 : writer->pos += length;
2312 : 52 : return 0;
2313 : : }
2314 : :
2315 : : static int
2316 : 4908654 : unicode_fromformat_write_cstr(_PyUnicodeWriter *writer, const char *str,
2317 : : Py_ssize_t width, Py_ssize_t precision)
2318 : : {
2319 : : /* UTF-8 */
2320 : : Py_ssize_t length;
2321 : : PyObject *unicode;
2322 : : int res;
2323 : :
2324 [ + + ]: 4908654 : if (precision == -1) {
2325 : 214876 : length = strlen(str);
2326 : : }
2327 : : else {
2328 : 4693778 : length = 0;
2329 [ + + + + ]: 39998151 : while (length < precision && str[length]) {
2330 : 35304373 : length++;
2331 : : }
2332 : : }
2333 : 4908654 : unicode = PyUnicode_DecodeUTF8Stateful(str, length, "replace", NULL);
2334 [ + + ]: 4908654 : if (unicode == NULL)
2335 : 32 : return -1;
2336 : :
2337 : 4908622 : res = unicode_fromformat_write_str(writer, unicode, width, -1);
2338 : 4908622 : Py_DECREF(unicode);
2339 : 4908622 : return res;
2340 : : }
2341 : :
2342 : : static const char*
2343 : 13361517 : unicode_fromformat_arg(_PyUnicodeWriter *writer,
2344 : : const char *f, va_list *vargs)
2345 : : {
2346 : : const char *p;
2347 : : Py_ssize_t len;
2348 : : int zeropad;
2349 : : Py_ssize_t width;
2350 : : Py_ssize_t precision;
2351 : : int longflag;
2352 : : int longlongflag;
2353 : : int size_tflag;
2354 : : Py_ssize_t fill;
2355 : :
2356 : 13361517 : p = f;
2357 : 13361517 : f++;
2358 : 13361517 : zeropad = 0;
2359 [ + + ]: 13361517 : if (*f == '0') {
2360 : 10190 : zeropad = 1;
2361 : 10190 : f++;
2362 : : }
2363 : :
2364 : : /* parse the width.precision part, e.g. "%2.5s" => width=2, precision=5 */
2365 : 13361517 : width = -1;
2366 [ + + ]: 13361517 : if (Py_ISDIGIT((unsigned)*f)) {
2367 : 11439 : width = *f - '0';
2368 : 11439 : f++;
2369 [ + + ]: 11454 : while (Py_ISDIGIT((unsigned)*f)) {
2370 [ - + ]: 15 : if (width > (PY_SSIZE_T_MAX - ((int)*f - '0')) / 10) {
2371 : 0 : PyErr_SetString(PyExc_ValueError,
2372 : : "width too big");
2373 : 0 : return NULL;
2374 : : }
2375 : 15 : width = (width * 10) + (*f - '0');
2376 : 15 : f++;
2377 : : }
2378 : : }
2379 : 13361517 : precision = -1;
2380 [ + + ]: 13361517 : if (*f == '.') {
2381 : 4700582 : f++;
2382 [ + + ]: 4700582 : if (Py_ISDIGIT((unsigned)*f)) {
2383 : 4700581 : precision = (*f - '0');
2384 : 4700581 : f++;
2385 [ + + ]: 10650388 : while (Py_ISDIGIT((unsigned)*f)) {
2386 [ - + ]: 5949807 : if (precision > (PY_SSIZE_T_MAX - ((int)*f - '0')) / 10) {
2387 : 0 : PyErr_SetString(PyExc_ValueError,
2388 : : "precision too big");
2389 : 0 : return NULL;
2390 : : }
2391 : 5949807 : precision = (precision * 10) + (*f - '0');
2392 : 5949807 : f++;
2393 : : }
2394 : : }
2395 [ + + ]: 4700582 : if (*f == '%') {
2396 : : /* "%.3%s" => f points to "3" */
2397 : 1 : f--;
2398 : : }
2399 : : }
2400 [ + + ]: 13361517 : if (*f == '\0') {
2401 : : /* bogus format "%.123" => go backward, f points to "3" */
2402 : 1 : f--;
2403 : : }
2404 : :
2405 : : /* Handle %ld, %lu, %lld and %llu. */
2406 : 13361517 : longflag = 0;
2407 : 13361517 : longlongflag = 0;
2408 : 13361517 : size_tflag = 0;
2409 [ + + ]: 13361517 : if (*f == 'l') {
2410 [ + + + + : 8184 : if (f[1] == 'd' || f[1] == 'u' || f[1] == 'i') {
+ + ]
2411 : 8081 : longflag = 1;
2412 : 8081 : ++f;
2413 : : }
2414 [ + - ]: 103 : else if (f[1] == 'l' &&
2415 [ + + + + : 103 : (f[2] == 'd' || f[2] == 'u' || f[2] == 'i')) {
+ - ]
2416 : 103 : longlongflag = 1;
2417 : 103 : f += 2;
2418 : : }
2419 : : }
2420 : : /* handle the size_t flag. */
2421 [ + + + + : 13353333 : else if (*f == 'z' && (f[1] == 'd' || f[1] == 'u' || f[1] == 'i')) {
+ + + - ]
2422 : 32060 : size_tflag = 1;
2423 : 32060 : ++f;
2424 : : }
2425 : :
2426 [ + + ]: 13361517 : if (f[1] == '\0')
2427 : 185978 : writer->overallocate = 0;
2428 : :
2429 [ + + + + : 13361517 : switch (*f) {
+ + + + +
+ + ]
2430 : 31296 : case 'c':
2431 : : {
2432 : 31296 : int ordinal = va_arg(*vargs, int);
2433 [ + - + + ]: 31296 : if (ordinal < 0 || ordinal > MAX_UNICODE) {
2434 : 1 : PyErr_SetString(PyExc_OverflowError,
2435 : : "character argument not in range(0x110000)");
2436 : 1 : return NULL;
2437 : : }
2438 [ - + ]: 31295 : if (_PyUnicodeWriter_WriteCharInline(writer, ordinal) < 0)
2439 : 0 : return NULL;
2440 : 31295 : break;
2441 : : }
2442 : :
2443 : 115798 : case 'i':
2444 : : case 'd':
2445 : : case 'u':
2446 : : case 'x':
2447 : : {
2448 : : /* used by sprintf */
2449 : : char buffer[MAX_LONG_LONG_CHARS];
2450 : : Py_ssize_t arglen;
2451 : :
2452 [ + + ]: 115798 : if (*f == 'u') {
2453 [ + + ]: 6776 : if (longflag) {
2454 : 6118 : len = sprintf(buffer, "%lu", va_arg(*vargs, unsigned long));
2455 : : }
2456 [ + + ]: 658 : else if (longlongflag) {
2457 : 6 : len = sprintf(buffer, "%llu", va_arg(*vargs, unsigned long long));
2458 : : }
2459 [ + + ]: 652 : else if (size_tflag) {
2460 : 148 : len = sprintf(buffer, "%zu", va_arg(*vargs, size_t));
2461 : : }
2462 : : else {
2463 : 504 : len = sprintf(buffer, "%u", va_arg(*vargs, unsigned int));
2464 : : }
2465 : : }
2466 [ + + ]: 109022 : else if (*f == 'x') {
2467 : 130 : len = sprintf(buffer, "%x", va_arg(*vargs, int));
2468 : : }
2469 : : else {
2470 [ + + ]: 108892 : if (longflag) {
2471 : 1963 : len = sprintf(buffer, "%li", va_arg(*vargs, long));
2472 : : }
2473 [ + + ]: 106929 : else if (longlongflag) {
2474 : 97 : len = sprintf(buffer, "%lli", va_arg(*vargs, long long));
2475 : : }
2476 [ + + ]: 106832 : else if (size_tflag) {
2477 : 31912 : len = sprintf(buffer, "%zi", va_arg(*vargs, Py_ssize_t));
2478 : : }
2479 : : else {
2480 : 74920 : len = sprintf(buffer, "%i", va_arg(*vargs, int));
2481 : : }
2482 : : }
2483 : : assert(len >= 0);
2484 : :
2485 [ + + ]: 115798 : if (precision < len)
2486 : 112134 : precision = len;
2487 : :
2488 : 115798 : arglen = Py_MAX(precision, width);
2489 [ + + + + : 115798 : if (_PyUnicodeWriter_Prepare(writer, arglen, 127) == -1)
+ - - + ]
2490 : 0 : return NULL;
2491 : :
2492 [ + + ]: 115798 : if (width > precision) {
2493 : : Py_UCS4 fillchar;
2494 : 6484 : fill = width - precision;
2495 [ + + ]: 6484 : fillchar = zeropad?'0':' ';
2496 [ - + ]: 6484 : if (PyUnicode_Fill(writer->buffer, writer->pos, fill, fillchar) == -1)
2497 : 0 : return NULL;
2498 : 6484 : writer->pos += fill;
2499 : : }
2500 [ + + ]: 115798 : if (precision > len) {
2501 : 1099 : fill = precision - len;
2502 [ - + ]: 1099 : if (PyUnicode_Fill(writer->buffer, writer->pos, fill, '0') == -1)
2503 : 0 : return NULL;
2504 : 1099 : writer->pos += fill;
2505 : : }
2506 : :
2507 [ - + ]: 115798 : if (_PyUnicodeWriter_WriteASCIIString(writer, buffer, len) < 0)
2508 : 0 : return NULL;
2509 : 115798 : break;
2510 : : }
2511 : :
2512 : 28913 : case 'p':
2513 : : {
2514 : : char number[MAX_LONG_LONG_CHARS];
2515 : :
2516 : 28913 : len = sprintf(number, "%p", va_arg(*vargs, void*));
2517 : : assert(len >= 0);
2518 : :
2519 : : /* %p is ill-defined: ensure leading 0x. */
2520 [ - + ]: 28913 : if (number[1] == 'X')
2521 : 0 : number[1] = 'x';
2522 [ - + ]: 28913 : else if (number[1] != 'x') {
2523 : 0 : memmove(number + 2, number,
2524 : 0 : strlen(number) + 1);
2525 : 0 : number[0] = '0';
2526 : 0 : number[1] = 'x';
2527 : 0 : len += 2;
2528 : : }
2529 : :
2530 [ - + ]: 28913 : if (_PyUnicodeWriter_WriteASCIIString(writer, number, len) < 0)
2531 : 0 : return NULL;
2532 : 28913 : break;
2533 : : }
2534 : :
2535 : 4908646 : case 's':
2536 : : {
2537 : : /* UTF-8 */
2538 : 4908646 : const char *s = va_arg(*vargs, const char*);
2539 [ + + ]: 4908646 : if (unicode_fromformat_write_cstr(writer, s, width, precision) < 0)
2540 : 32 : return NULL;
2541 : 4908614 : break;
2542 : : }
2543 : :
2544 : 8138960 : case 'U':
2545 : : {
2546 : 8138960 : PyObject *obj = va_arg(*vargs, PyObject *);
2547 : : assert(obj && _PyUnicode_CHECK(obj));
2548 : :
2549 [ - + ]: 8138960 : if (unicode_fromformat_write_str(writer, obj, width, precision) == -1)
2550 : 0 : return NULL;
2551 : 8138960 : break;
2552 : : }
2553 : :
2554 : 2125 : case 'V':
2555 : : {
2556 : 2125 : PyObject *obj = va_arg(*vargs, PyObject *);
2557 : 2125 : const char *str = va_arg(*vargs, const char *);
2558 [ + + ]: 2125 : if (obj) {
2559 : : assert(_PyUnicode_CHECK(obj));
2560 [ - + ]: 2117 : if (unicode_fromformat_write_str(writer, obj, width, precision) == -1)
2561 : 0 : return NULL;
2562 : : }
2563 : : else {
2564 : : assert(str != NULL);
2565 [ - + ]: 8 : if (unicode_fromformat_write_cstr(writer, str, width, precision) < 0)
2566 : 0 : return NULL;
2567 : : }
2568 : 2125 : break;
2569 : : }
2570 : :
2571 : 12237 : case 'S':
2572 : : {
2573 : 12237 : PyObject *obj = va_arg(*vargs, PyObject *);
2574 : : PyObject *str;
2575 : : assert(obj);
2576 : 12237 : str = PyObject_Str(obj);
2577 [ + + ]: 12237 : if (!str)
2578 : 2 : return NULL;
2579 [ - + ]: 12235 : if (unicode_fromformat_write_str(writer, str, width, precision) == -1) {
2580 : 0 : Py_DECREF(str);
2581 : 0 : return NULL;
2582 : : }
2583 : 12235 : Py_DECREF(str);
2584 : 12235 : break;
2585 : : }
2586 : :
2587 : 123400 : case 'R':
2588 : : {
2589 : 123400 : PyObject *obj = va_arg(*vargs, PyObject *);
2590 : : PyObject *repr;
2591 : : assert(obj);
2592 : 123400 : repr = PyObject_Repr(obj);
2593 [ + + ]: 123400 : if (!repr)
2594 : 501 : return NULL;
2595 [ - + ]: 122899 : if (unicode_fromformat_write_str(writer, repr, width, precision) == -1) {
2596 : 0 : Py_DECREF(repr);
2597 : 0 : return NULL;
2598 : : }
2599 : 122899 : Py_DECREF(repr);
2600 : 122899 : break;
2601 : : }
2602 : :
2603 : 6 : case 'A':
2604 : : {
2605 : 6 : PyObject *obj = va_arg(*vargs, PyObject *);
2606 : : PyObject *ascii;
2607 : : assert(obj);
2608 : 6 : ascii = PyObject_ASCII(obj);
2609 [ - + ]: 6 : if (!ascii)
2610 : 0 : return NULL;
2611 [ - + ]: 6 : if (unicode_fromformat_write_str(writer, ascii, width, precision) == -1) {
2612 : 0 : Py_DECREF(ascii);
2613 : 0 : return NULL;
2614 : : }
2615 : 6 : Py_DECREF(ascii);
2616 : 6 : break;
2617 : : }
2618 : :
2619 : 133 : case '%':
2620 [ - + ]: 133 : if (_PyUnicodeWriter_WriteCharInline(writer, '%') < 0)
2621 : 0 : return NULL;
2622 : 133 : break;
2623 : :
2624 : 3 : default:
2625 : : /* if we stumble upon an unknown formatting code, copy the rest
2626 : : of the format string to the output string. (we cannot just
2627 : : skip the code, since there's no way to know what's in the
2628 : : argument list) */
2629 : 3 : len = strlen(p);
2630 [ - + ]: 3 : if (_PyUnicodeWriter_WriteLatin1String(writer, p, len) == -1)
2631 : 0 : return NULL;
2632 : 3 : f = p+len;
2633 : 3 : return f;
2634 : : }
2635 : :
2636 : 13360978 : f++;
2637 : 13360978 : return f;
2638 : : }
2639 : :
2640 : : PyObject *
2641 : 7330931 : PyUnicode_FromFormatV(const char *format, va_list vargs)
2642 : : {
2643 : : va_list vargs2;
2644 : : const char *f;
2645 : : _PyUnicodeWriter writer;
2646 : :
2647 : 7330931 : _PyUnicodeWriter_Init(&writer);
2648 : 7330931 : writer.min_length = strlen(format) + 100;
2649 : 7330931 : writer.overallocate = 1;
2650 : :
2651 : : // Copy varags to be able to pass a reference to a subfunction.
2652 : 7330931 : va_copy(vargs2, vargs);
2653 : :
2654 [ + + ]: 40912410 : for (f = format; *f; ) {
2655 [ + + ]: 33582018 : if (*f == '%') {
2656 : 13361517 : f = unicode_fromformat_arg(&writer, f, &vargs2);
2657 [ + + ]: 13361517 : if (f == NULL)
2658 : 536 : goto fail;
2659 : : }
2660 : : else {
2661 : : const char *p;
2662 : : Py_ssize_t len;
2663 : :
2664 : 20220501 : p = f;
2665 : : do
2666 : : {
2667 [ + + ]: 220759050 : if ((unsigned char)*p > 127) {
2668 : 1 : PyErr_Format(PyExc_ValueError,
2669 : : "PyUnicode_FromFormatV() expects an ASCII-encoded format "
2670 : : "string, got a non-ASCII byte: 0x%02x",
2671 : 1 : (unsigned char)*p);
2672 : 1 : goto fail;
2673 : : }
2674 : 220759049 : p++;
2675 : : }
2676 [ + + + + ]: 220759049 : while (*p != '\0' && *p != '%');
2677 : 20220500 : len = p - f;
2678 : :
2679 [ + + ]: 20220500 : if (*p == '\0')
2680 : 7144424 : writer.overallocate = 0;
2681 : :
2682 [ + + ]: 20220500 : if (_PyUnicodeWriter_WriteASCIIString(&writer, f, len) < 0)
2683 : 2 : goto fail;
2684 : :
2685 : 20220498 : f = p;
2686 : : }
2687 : : }
2688 : 7330392 : va_end(vargs2);
2689 : 7330392 : return _PyUnicodeWriter_Finish(&writer);
2690 : :
2691 : 539 : fail:
2692 : 539 : va_end(vargs2);
2693 : 539 : _PyUnicodeWriter_Dealloc(&writer);
2694 : 539 : return NULL;
2695 : : }
2696 : :
2697 : : PyObject *
2698 : 563601 : PyUnicode_FromFormat(const char *format, ...)
2699 : : {
2700 : : PyObject* ret;
2701 : : va_list vargs;
2702 : :
2703 : 563601 : va_start(vargs, format);
2704 : 563601 : ret = PyUnicode_FromFormatV(format, vargs);
2705 : 563601 : va_end(vargs);
2706 : 563601 : return ret;
2707 : : }
2708 : :
2709 : : static Py_ssize_t
2710 : 439986 : unicode_get_widechar_size(PyObject *unicode)
2711 : : {
2712 : : Py_ssize_t res;
2713 : :
2714 : : assert(unicode != NULL);
2715 : : assert(_PyUnicode_CHECK(unicode));
2716 : :
2717 : 439986 : res = _PyUnicode_LENGTH(unicode);
2718 : : #if SIZEOF_WCHAR_T == 2
2719 : : if (PyUnicode_KIND(unicode) == PyUnicode_4BYTE_KIND) {
2720 : : const Py_UCS4 *s = PyUnicode_4BYTE_DATA(unicode);
2721 : : const Py_UCS4 *end = s + res;
2722 : : for (; s < end; ++s) {
2723 : : if (*s > 0xFFFF) {
2724 : : ++res;
2725 : : }
2726 : : }
2727 : : }
2728 : : #endif
2729 : 439986 : return res;
2730 : : }
2731 : :
2732 : : static void
2733 : 429970 : unicode_copy_as_widechar(PyObject *unicode, wchar_t *w, Py_ssize_t size)
2734 : : {
2735 : : assert(unicode != NULL);
2736 : : assert(_PyUnicode_CHECK(unicode));
2737 : :
2738 [ + + ]: 429970 : if (PyUnicode_KIND(unicode) == sizeof(wchar_t)) {
2739 : 39 : memcpy(w, PyUnicode_DATA(unicode), size * sizeof(wchar_t));
2740 : 39 : return;
2741 : : }
2742 : :
2743 [ + + ]: 429931 : if (PyUnicode_KIND(unicode) == PyUnicode_1BYTE_KIND) {
2744 : 423515 : const Py_UCS1 *s = PyUnicode_1BYTE_DATA(unicode);
2745 [ + + ]: 20598319 : for (; size--; ++s, ++w) {
2746 : 20174804 : *w = *s;
2747 : : }
2748 : : }
2749 : : else {
2750 : : #if SIZEOF_WCHAR_T == 4
2751 : : assert(PyUnicode_KIND(unicode) == PyUnicode_2BYTE_KIND);
2752 : 6416 : const Py_UCS2 *s = PyUnicode_2BYTE_DATA(unicode);
2753 [ + + ]: 24974 : for (; size--; ++s, ++w) {
2754 : 18558 : *w = *s;
2755 : : }
2756 : : #else
2757 : : assert(PyUnicode_KIND(unicode) == PyUnicode_4BYTE_KIND);
2758 : : const Py_UCS4 *s = PyUnicode_4BYTE_DATA(unicode);
2759 : : for (; size--; ++s, ++w) {
2760 : : Py_UCS4 ch = *s;
2761 : : if (ch > 0xFFFF) {
2762 : : assert(ch <= MAX_UNICODE);
2763 : : /* encode surrogate pair in this case */
2764 : : *w++ = Py_UNICODE_HIGH_SURROGATE(ch);
2765 : : if (!size--)
2766 : : break;
2767 : : *w = Py_UNICODE_LOW_SURROGATE(ch);
2768 : : }
2769 : : else {
2770 : : *w = ch;
2771 : : }
2772 : : }
2773 : : #endif
2774 : : }
2775 : : }
2776 : :
2777 : : #ifdef HAVE_WCHAR_H
2778 : :
2779 : : /* Convert a Unicode object to a wide character string.
2780 : :
2781 : : - If w is NULL: return the number of wide characters (including the null
2782 : : character) required to convert the unicode object. Ignore size argument.
2783 : :
2784 : : - Otherwise: return the number of wide characters (excluding the null
2785 : : character) written into w. Write at most size wide characters (including
2786 : : the null character). */
2787 : : Py_ssize_t
2788 : 20079 : PyUnicode_AsWideChar(PyObject *unicode,
2789 : : wchar_t *w,
2790 : : Py_ssize_t size)
2791 : : {
2792 : : Py_ssize_t res;
2793 : :
2794 [ - + ]: 20079 : if (unicode == NULL) {
2795 : 0 : PyErr_BadInternalCall();
2796 : 0 : return -1;
2797 : : }
2798 [ - + ]: 20079 : if (!PyUnicode_Check(unicode)) {
2799 : 0 : PyErr_BadArgument();
2800 : 0 : return -1;
2801 : : }
2802 : :
2803 : 20079 : res = unicode_get_widechar_size(unicode);
2804 [ + + ]: 20079 : if (w == NULL) {
2805 : 10016 : return res + 1;
2806 : : }
2807 : :
2808 [ + + ]: 10063 : if (size > res) {
2809 : 62 : size = res + 1;
2810 : : }
2811 : : else {
2812 : 10001 : res = size;
2813 : : }
2814 : 10063 : unicode_copy_as_widechar(unicode, w, size);
2815 : :
2816 : : #ifdef HAVE_NON_UNICODE_WCHAR_T_REPRESENTATION
2817 : : /* Oracle Solaris uses non-Unicode internal wchar_t form for
2818 : : non-Unicode locales and hence needs conversion first. */
2819 : : if (_Py_LocaleUsesNonUnicodeWchar()) {
2820 : : if (_Py_EncodeNonUnicodeWchar_InPlace(w, size) < 0) {
2821 : : return -1;
2822 : : }
2823 : : }
2824 : : #endif
2825 : :
2826 : 10063 : return res;
2827 : : }
2828 : :
2829 : : wchar_t*
2830 : 419907 : PyUnicode_AsWideCharString(PyObject *unicode,
2831 : : Py_ssize_t *size)
2832 : : {
2833 : : wchar_t *buffer;
2834 : : Py_ssize_t buflen;
2835 : :
2836 [ - + ]: 419907 : if (unicode == NULL) {
2837 : 0 : PyErr_BadInternalCall();
2838 : 0 : return NULL;
2839 : : }
2840 [ - + ]: 419907 : if (!PyUnicode_Check(unicode)) {
2841 : 0 : PyErr_BadArgument();
2842 : 0 : return NULL;
2843 : : }
2844 : :
2845 : 419907 : buflen = unicode_get_widechar_size(unicode);
2846 [ + - ]: 419907 : buffer = (wchar_t *) PyMem_NEW(wchar_t, (buflen + 1));
2847 [ - + ]: 419907 : if (buffer == NULL) {
2848 : : PyErr_NoMemory();
2849 : 0 : return NULL;
2850 : : }
2851 : 419907 : unicode_copy_as_widechar(unicode, buffer, buflen + 1);
2852 : :
2853 : : #ifdef HAVE_NON_UNICODE_WCHAR_T_REPRESENTATION
2854 : : /* Oracle Solaris uses non-Unicode internal wchar_t form for
2855 : : non-Unicode locales and hence needs conversion first. */
2856 : : if (_Py_LocaleUsesNonUnicodeWchar()) {
2857 : : if (_Py_EncodeNonUnicodeWchar_InPlace(buffer, (buflen + 1)) < 0) {
2858 : : return NULL;
2859 : : }
2860 : : }
2861 : : #endif
2862 : :
2863 [ + + ]: 419907 : if (size != NULL) {
2864 : 285648 : *size = buflen;
2865 : : }
2866 [ + + ]: 134259 : else if (wcslen(buffer) != (size_t)buflen) {
2867 : 9 : PyMem_Free(buffer);
2868 : 9 : PyErr_SetString(PyExc_ValueError,
2869 : : "embedded null character");
2870 : 9 : return NULL;
2871 : : }
2872 : 419898 : return buffer;
2873 : : }
2874 : :
2875 : : #endif /* HAVE_WCHAR_H */
2876 : :
2877 : : int
2878 : 0 : _PyUnicode_WideCharString_Converter(PyObject *obj, void *ptr)
2879 : : {
2880 : 0 : wchar_t **p = (wchar_t **)ptr;
2881 [ # # ]: 0 : if (obj == NULL) {
2882 : 0 : PyMem_Free(*p);
2883 : 0 : *p = NULL;
2884 : 0 : return 1;
2885 : : }
2886 [ # # ]: 0 : if (PyUnicode_Check(obj)) {
2887 : 0 : *p = PyUnicode_AsWideCharString(obj, NULL);
2888 [ # # ]: 0 : if (*p == NULL) {
2889 : 0 : return 0;
2890 : : }
2891 : 0 : return Py_CLEANUP_SUPPORTED;
2892 : : }
2893 : 0 : PyErr_Format(PyExc_TypeError,
2894 : : "argument must be str, not %.50s",
2895 : 0 : Py_TYPE(obj)->tp_name);
2896 : 0 : return 0;
2897 : : }
2898 : :
2899 : : int
2900 : 0 : _PyUnicode_WideCharString_Opt_Converter(PyObject *obj, void *ptr)
2901 : : {
2902 : 0 : wchar_t **p = (wchar_t **)ptr;
2903 [ # # ]: 0 : if (obj == NULL) {
2904 : 0 : PyMem_Free(*p);
2905 : 0 : *p = NULL;
2906 : 0 : return 1;
2907 : : }
2908 [ # # ]: 0 : if (obj == Py_None) {
2909 : 0 : *p = NULL;
2910 : 0 : return 1;
2911 : : }
2912 [ # # ]: 0 : if (PyUnicode_Check(obj)) {
2913 : 0 : *p = PyUnicode_AsWideCharString(obj, NULL);
2914 [ # # ]: 0 : if (*p == NULL) {
2915 : 0 : return 0;
2916 : : }
2917 : 0 : return Py_CLEANUP_SUPPORTED;
2918 : : }
2919 : 0 : PyErr_Format(PyExc_TypeError,
2920 : : "argument must be str or None, not %.50s",
2921 : 0 : Py_TYPE(obj)->tp_name);
2922 : 0 : return 0;
2923 : : }
2924 : :
2925 : : PyObject *
2926 : 12696835 : PyUnicode_FromOrdinal(int ordinal)
2927 : : {
2928 [ + + + + ]: 12696835 : if (ordinal < 0 || ordinal > MAX_UNICODE) {
2929 : 6 : PyErr_SetString(PyExc_ValueError,
2930 : : "chr() arg not in range(0x110000)");
2931 : 6 : return NULL;
2932 : : }
2933 : :
2934 : 12696829 : return unicode_char((Py_UCS4)ordinal);
2935 : : }
2936 : :
2937 : : PyObject *
2938 : 1219618 : PyUnicode_FromObject(PyObject *obj)
2939 : : {
2940 : : /* XXX Perhaps we should make this API an alias of
2941 : : PyObject_Str() instead ?! */
2942 [ + + ]: 1219618 : if (PyUnicode_CheckExact(obj)) {
2943 : 1219610 : Py_INCREF(obj);
2944 : 1219610 : return obj;
2945 : : }
2946 [ + - ]: 8 : if (PyUnicode_Check(obj)) {
2947 : : /* For a Unicode subtype that's not a Unicode object,
2948 : : return a true Unicode object with the same data. */
2949 : 8 : return _PyUnicode_Copy(obj);
2950 : : }
2951 : 0 : PyErr_Format(PyExc_TypeError,
2952 : : "Can't convert '%.100s' object to str implicitly",
2953 : 0 : Py_TYPE(obj)->tp_name);
2954 : 0 : return NULL;
2955 : : }
2956 : :
2957 : : PyObject *
2958 : 8302555 : PyUnicode_FromEncodedObject(PyObject *obj,
2959 : : const char *encoding,
2960 : : const char *errors)
2961 : : {
2962 : : Py_buffer buffer;
2963 : : PyObject *v;
2964 : :
2965 [ - + ]: 8302555 : if (obj == NULL) {
2966 : 0 : PyErr_BadInternalCall();
2967 : 0 : return NULL;
2968 : : }
2969 : :
2970 : : /* Decoding bytes objects is the most common case and should be fast */
2971 [ + + ]: 8302555 : if (PyBytes_Check(obj)) {
2972 [ + + ]: 7750313 : if (PyBytes_GET_SIZE(obj) == 0) {
2973 [ + + ]: 78862 : if (unicode_check_encoding_errors(encoding, errors) < 0) {
2974 : 6 : return NULL;
2975 : : }
2976 : 78856 : _Py_RETURN_UNICODE_EMPTY();
2977 : : }
2978 : 15342902 : return PyUnicode_Decode(
2979 : 7671451 : PyBytes_AS_STRING(obj), PyBytes_GET_SIZE(obj),
2980 : : encoding, errors);
2981 : : }
2982 : :
2983 [ + + ]: 552242 : if (PyUnicode_Check(obj)) {
2984 : 1 : PyErr_SetString(PyExc_TypeError,
2985 : : "decoding str is not supported");
2986 : 1 : return NULL;
2987 : : }
2988 : :
2989 : : /* Retrieve a bytes buffer view through the PEP 3118 buffer interface */
2990 [ - + ]: 552241 : if (PyObject_GetBuffer(obj, &buffer, PyBUF_SIMPLE) < 0) {
2991 : 0 : PyErr_Format(PyExc_TypeError,
2992 : : "decoding to str: need a bytes-like object, %.80s found",
2993 : 0 : Py_TYPE(obj)->tp_name);
2994 : 0 : return NULL;
2995 : : }
2996 : :
2997 [ + + ]: 552241 : if (buffer.len == 0) {
2998 : 2073 : PyBuffer_Release(&buffer);
2999 [ + + ]: 2073 : if (unicode_check_encoding_errors(encoding, errors) < 0) {
3000 : 1 : return NULL;
3001 : : }
3002 : 2072 : _Py_RETURN_UNICODE_EMPTY();
3003 : : }
3004 : :
3005 : 550168 : v = PyUnicode_Decode((char*) buffer.buf, buffer.len, encoding, errors);
3006 : 550168 : PyBuffer_Release(&buffer);
3007 : 550168 : return v;
3008 : : }
3009 : :
3010 : : /* Normalize an encoding name: similar to encodings.normalize_encoding(), but
3011 : : also convert to lowercase. Return 1 on success, or 0 on error (encoding is
3012 : : longer than lower_len-1). */
3013 : : int
3014 : 15010024 : _Py_normalize_encoding(const char *encoding,
3015 : : char *lower,
3016 : : size_t lower_len)
3017 : : {
3018 : : const char *e;
3019 : : char *l;
3020 : : char *l_end;
3021 : : int punct;
3022 : :
3023 : : assert(encoding != NULL);
3024 : :
3025 : 15010024 : e = encoding;
3026 : 15010024 : l = lower;
3027 : 15010024 : l_end = &lower[lower_len - 1];
3028 : 15010024 : punct = 0;
3029 : 98414721 : while (1) {
3030 : 113424745 : char c = *e;
3031 [ + + ]: 113424745 : if (c == 0) {
3032 : 13864723 : break;
3033 : : }
3034 : :
3035 [ + + + + ]: 99560022 : if (Py_ISALNUM(c) || c == '.') {
3036 [ + + + + ]: 85152828 : if (punct && l != lower) {
3037 [ + + ]: 14407089 : if (l == l_end) {
3038 : 51 : return 0;
3039 : : }
3040 : 14407038 : *l++ = '_';
3041 : : }
3042 : 85152777 : punct = 0;
3043 : :
3044 [ + + ]: 85152777 : if (l == l_end) {
3045 : 1145250 : return 0;
3046 : : }
3047 : 84007527 : *l++ = Py_TOLOWER(c);
3048 : : }
3049 : : else {
3050 : 14407194 : punct = 1;
3051 : : }
3052 : :
3053 : 98414721 : e++;
3054 : : }
3055 : 13864723 : *l = '\0';
3056 : 13864723 : return 1;
3057 : : }
3058 : :
3059 : : PyObject *
3060 : 8227874 : PyUnicode_Decode(const char *s,
3061 : : Py_ssize_t size,
3062 : : const char *encoding,
3063 : : const char *errors)
3064 : : {
3065 : 8227874 : PyObject *buffer = NULL, *unicode;
3066 : : Py_buffer info;
3067 : : char buflower[11]; /* strlen("iso-8859-1\0") == 11, longest shortcut */
3068 : :
3069 [ + + ]: 8227874 : if (unicode_check_encoding_errors(encoding, errors) < 0) {
3070 : 5 : return NULL;
3071 : : }
3072 : :
3073 [ + + ]: 8227869 : if (size == 0) {
3074 : 4 : _Py_RETURN_UNICODE_EMPTY();
3075 : : }
3076 : :
3077 [ + + ]: 8227865 : if (encoding == NULL) {
3078 : 5047 : return PyUnicode_DecodeUTF8Stateful(s, size, errors, NULL);
3079 : : }
3080 : :
3081 : : /* Shortcuts for common default encodings */
3082 [ + + ]: 8222818 : if (_Py_normalize_encoding(encoding, buflower, sizeof(buflower))) {
3083 : 8163255 : char *lower = buflower;
3084 : :
3085 : : /* Fast paths */
3086 [ + + + + : 8163255 : if (lower[0] == 'u' && lower[1] == 't' && lower[2] == 'f') {
+ - ]
3087 : 2385645 : lower += 3;
3088 [ + + ]: 2385645 : if (*lower == '_') {
3089 : : /* Match "utf8" and "utf_8" */
3090 : 2384879 : lower++;
3091 : : }
3092 : :
3093 [ + + + + ]: 2385645 : if (lower[0] == '8' && lower[1] == 0) {
3094 : 2381126 : return PyUnicode_DecodeUTF8Stateful(s, size, errors, NULL);
3095 : : }
3096 [ + + + - : 4519 : else if (lower[0] == '1' && lower[1] == '6' && lower[2] == 0) {
+ + ]
3097 : 1063 : return PyUnicode_DecodeUTF16(s, size, errors, 0);
3098 : : }
3099 [ + + + - : 3456 : else if (lower[0] == '3' && lower[1] == '2' && lower[2] == 0) {
+ + ]
3100 : 33 : return PyUnicode_DecodeUTF32(s, size, errors, 0);
3101 : : }
3102 : : }
3103 : : else {
3104 [ + + ]: 5777610 : if (strcmp(lower, "ascii") == 0
3105 [ + + ]: 5079428 : || strcmp(lower, "us_ascii") == 0) {
3106 : 698321 : return PyUnicode_DecodeASCII(s, size, errors);
3107 : : }
3108 : : #ifdef MS_WINDOWS
3109 : : else if (strcmp(lower, "mbcs") == 0) {
3110 : : return PyUnicode_DecodeMBCS(s, size, errors);
3111 : : }
3112 : : #endif
3113 [ + + ]: 5079289 : else if (strcmp(lower, "latin1") == 0
3114 [ + + ]: 5068648 : || strcmp(lower, "latin_1") == 0
3115 [ + + ]: 205913 : || strcmp(lower, "iso_8859_1") == 0
3116 [ + + ]: 203893 : || strcmp(lower, "iso8859_1") == 0) {
3117 : 4896918 : return PyUnicode_DecodeLatin1(s, size, errors);
3118 : : }
3119 : : }
3120 : : }
3121 : :
3122 : : /* Decode via the codec registry */
3123 : 245357 : buffer = NULL;
3124 [ - + ]: 245357 : if (PyBuffer_FillInfo(&info, NULL, (void *)s, size, 1, PyBUF_FULL_RO) < 0)
3125 : 0 : goto onError;
3126 : 245357 : buffer = PyMemoryView_FromBuffer(&info);
3127 [ - + ]: 245357 : if (buffer == NULL)
3128 : 0 : goto onError;
3129 : 245357 : unicode = _PyCodec_DecodeText(buffer, encoding, errors);
3130 [ + + ]: 245357 : if (unicode == NULL)
3131 : 99 : goto onError;
3132 [ + + ]: 245258 : if (!PyUnicode_Check(unicode)) {
3133 : 2 : PyErr_Format(PyExc_TypeError,
3134 : : "'%.400s' decoder returned '%.400s' instead of 'str'; "
3135 : : "use codecs.decode() to decode to arbitrary types",
3136 : : encoding,
3137 : 2 : Py_TYPE(unicode)->tp_name);
3138 : 2 : Py_DECREF(unicode);
3139 : 2 : goto onError;
3140 : : }
3141 : 245256 : Py_DECREF(buffer);
3142 : 245256 : return unicode_result(unicode);
3143 : :
3144 : 101 : onError:
3145 : 101 : Py_XDECREF(buffer);
3146 : 101 : return NULL;
3147 : : }
3148 : :
3149 : : PyObject *
3150 : 0 : PyUnicode_AsDecodedObject(PyObject *unicode,
3151 : : const char *encoding,
3152 : : const char *errors)
3153 : : {
3154 [ # # ]: 0 : if (!PyUnicode_Check(unicode)) {
3155 : 0 : PyErr_BadArgument();
3156 : 0 : return NULL;
3157 : : }
3158 : :
3159 [ # # ]: 0 : if (PyErr_WarnEx(PyExc_DeprecationWarning,
3160 : : "PyUnicode_AsDecodedObject() is deprecated; "
3161 : : "use PyCodec_Decode() to decode from str", 1) < 0)
3162 : 0 : return NULL;
3163 : :
3164 [ # # ]: 0 : if (encoding == NULL)
3165 : 0 : encoding = PyUnicode_GetDefaultEncoding();
3166 : :
3167 : : /* Decode via the codec registry */
3168 : 0 : return PyCodec_Decode(unicode, encoding, errors);
3169 : : }
3170 : :
3171 : : PyObject *
3172 : 0 : PyUnicode_AsDecodedUnicode(PyObject *unicode,
3173 : : const char *encoding,
3174 : : const char *errors)
3175 : : {
3176 : : PyObject *v;
3177 : :
3178 [ # # ]: 0 : if (!PyUnicode_Check(unicode)) {
3179 : 0 : PyErr_BadArgument();
3180 : 0 : goto onError;
3181 : : }
3182 : :
3183 [ # # ]: 0 : if (PyErr_WarnEx(PyExc_DeprecationWarning,
3184 : : "PyUnicode_AsDecodedUnicode() is deprecated; "
3185 : : "use PyCodec_Decode() to decode from str to str", 1) < 0)
3186 : 0 : return NULL;
3187 : :
3188 [ # # ]: 0 : if (encoding == NULL)
3189 : 0 : encoding = PyUnicode_GetDefaultEncoding();
3190 : :
3191 : : /* Decode via the codec registry */
3192 : 0 : v = PyCodec_Decode(unicode, encoding, errors);
3193 [ # # ]: 0 : if (v == NULL)
3194 : 0 : goto onError;
3195 [ # # ]: 0 : if (!PyUnicode_Check(v)) {
3196 : 0 : PyErr_Format(PyExc_TypeError,
3197 : : "'%.400s' decoder returned '%.400s' instead of 'str'; "
3198 : : "use codecs.decode() to decode to arbitrary types",
3199 : : encoding,
3200 : 0 : Py_TYPE(unicode)->tp_name);
3201 : 0 : Py_DECREF(v);
3202 : 0 : goto onError;
3203 : : }
3204 : 0 : return unicode_result(v);
3205 : :
3206 : 0 : onError:
3207 : 0 : return NULL;
3208 : : }
3209 : :
3210 : : PyObject *
3211 : 0 : PyUnicode_AsEncodedObject(PyObject *unicode,
3212 : : const char *encoding,
3213 : : const char *errors)
3214 : : {
3215 : : PyObject *v;
3216 : :
3217 [ # # ]: 0 : if (!PyUnicode_Check(unicode)) {
3218 : 0 : PyErr_BadArgument();
3219 : 0 : goto onError;
3220 : : }
3221 : :
3222 [ # # ]: 0 : if (PyErr_WarnEx(PyExc_DeprecationWarning,
3223 : : "PyUnicode_AsEncodedObject() is deprecated; "
3224 : : "use PyUnicode_AsEncodedString() to encode from str to bytes "
3225 : : "or PyCodec_Encode() for generic encoding", 1) < 0)
3226 : 0 : return NULL;
3227 : :
3228 [ # # ]: 0 : if (encoding == NULL)
3229 : 0 : encoding = PyUnicode_GetDefaultEncoding();
3230 : :
3231 : : /* Encode via the codec registry */
3232 : 0 : v = PyCodec_Encode(unicode, encoding, errors);
3233 [ # # ]: 0 : if (v == NULL)
3234 : 0 : goto onError;
3235 : 0 : return v;
3236 : :
3237 : 0 : onError:
3238 : 0 : return NULL;
3239 : : }
3240 : :
3241 : :
3242 : : static PyObject *
3243 : 77368 : unicode_encode_locale(PyObject *unicode, _Py_error_handler error_handler,
3244 : : int current_locale)
3245 : : {
3246 : : Py_ssize_t wlen;
3247 : 77368 : wchar_t *wstr = PyUnicode_AsWideCharString(unicode, &wlen);
3248 [ - + ]: 77368 : if (wstr == NULL) {
3249 : 0 : return NULL;
3250 : : }
3251 : :
3252 [ - + ]: 77368 : if ((size_t)wlen != wcslen(wstr)) {
3253 : 0 : PyErr_SetString(PyExc_ValueError, "embedded null character");
3254 : 0 : PyMem_Free(wstr);
3255 : 0 : return NULL;
3256 : : }
3257 : :
3258 : : char *str;
3259 : : size_t error_pos;
3260 : : const char *reason;
3261 : 77368 : int res = _Py_EncodeLocaleEx(wstr, &str, &error_pos, &reason,
3262 : : current_locale, error_handler);
3263 : 77368 : PyMem_Free(wstr);
3264 : :
3265 [ - + ]: 77368 : if (res != 0) {
3266 [ # # ]: 0 : if (res == -2) {
3267 : : PyObject *exc;
3268 : 0 : exc = PyObject_CallFunction(PyExc_UnicodeEncodeError, "sOnns",
3269 : : "locale", unicode,
3270 : : (Py_ssize_t)error_pos,
3271 : 0 : (Py_ssize_t)(error_pos+1),
3272 : : reason);
3273 [ # # ]: 0 : if (exc != NULL) {
3274 : 0 : PyCodec_StrictErrors(exc);
3275 : 0 : Py_DECREF(exc);
3276 : : }
3277 : : }
3278 [ # # ]: 0 : else if (res == -3) {
3279 : 0 : PyErr_SetString(PyExc_ValueError, "unsupported error handler");
3280 : : }
3281 : : else {
3282 : : PyErr_NoMemory();
3283 : : }
3284 : 0 : return NULL;
3285 : : }
3286 : :
3287 : 77368 : PyObject *bytes = PyBytes_FromString(str);
3288 : 77368 : PyMem_RawFree(str);
3289 : 77368 : return bytes;
3290 : : }
3291 : :
3292 : : PyObject *
3293 : 1401 : PyUnicode_EncodeLocale(PyObject *unicode, const char *errors)
3294 : : {
3295 : 1401 : _Py_error_handler error_handler = _Py_GetErrorHandler(errors);
3296 : 1401 : return unicode_encode_locale(unicode, error_handler, 1);
3297 : : }
3298 : :
3299 : : PyObject *
3300 : 2133877 : PyUnicode_EncodeFSDefault(PyObject *unicode)
3301 : : {
3302 : 2133877 : PyInterpreterState *interp = _PyInterpreterState_GET();
3303 : 2133877 : struct _Py_unicode_fs_codec *fs_codec = &interp->unicode.fs_codec;
3304 [ + + ]: 2133877 : if (fs_codec->utf8) {
3305 : 2054477 : return unicode_encode_utf8(unicode,
3306 : : fs_codec->error_handler,
3307 : 2054477 : fs_codec->errors);
3308 : : }
3309 : : #ifndef _Py_FORCE_UTF8_FS_ENCODING
3310 [ + + ]: 79400 : else if (fs_codec->encoding) {
3311 : 3433 : return PyUnicode_AsEncodedString(unicode,
3312 : 3433 : fs_codec->encoding,
3313 : 3433 : fs_codec->errors);
3314 : : }
3315 : : #endif
3316 : : else {
3317 : : /* Before _PyUnicode_InitEncodings() is called, the Python codec
3318 : : machinery is not ready and so cannot be used:
3319 : : use wcstombs() in this case. */
3320 : 75967 : const PyConfig *config = _PyInterpreterState_GetConfig(interp);
3321 : 75967 : const wchar_t *filesystem_errors = config->filesystem_errors;
3322 : : assert(filesystem_errors != NULL);
3323 : 75967 : _Py_error_handler errors = get_error_handler_wide(filesystem_errors);
3324 : : assert(errors != _Py_ERROR_UNKNOWN);
3325 : : #ifdef _Py_FORCE_UTF8_FS_ENCODING
3326 : : return unicode_encode_utf8(unicode, errors, NULL);
3327 : : #else
3328 : 75967 : return unicode_encode_locale(unicode, errors, 0);
3329 : : #endif
3330 : : }
3331 : : }
3332 : :
3333 : : PyObject *
3334 : 5298134 : PyUnicode_AsEncodedString(PyObject *unicode,
3335 : : const char *encoding,
3336 : : const char *errors)
3337 : : {
3338 : : PyObject *v;
3339 : : char buflower[11]; /* strlen("iso_8859_1\0") == 11, longest shortcut */
3340 : :
3341 [ - + ]: 5298134 : if (!PyUnicode_Check(unicode)) {
3342 : 0 : PyErr_BadArgument();
3343 : 0 : return NULL;
3344 : : }
3345 : :
3346 [ + + ]: 5298134 : if (unicode_check_encoding_errors(encoding, errors) < 0) {
3347 : 26 : return NULL;
3348 : : }
3349 : :
3350 [ + + ]: 5298108 : if (encoding == NULL) {
3351 : 93551 : return _PyUnicode_AsUTF8String(unicode, errors);
3352 : : }
3353 : :
3354 : : /* Shortcuts for common default encodings */
3355 [ + + ]: 5204557 : if (_Py_normalize_encoding(encoding, buflower, sizeof(buflower))) {
3356 : 4118819 : char *lower = buflower;
3357 : :
3358 : : /* Fast paths */
3359 [ + + + + : 4118819 : if (lower[0] == 'u' && lower[1] == 't' && lower[2] == 'f') {
+ - ]
3360 : 2523417 : lower += 3;
3361 [ + + ]: 2523417 : if (*lower == '_') {
3362 : : /* Match "utf8" and "utf_8" */
3363 : 2465360 : lower++;
3364 : : }
3365 : :
3366 [ + + + + ]: 2523417 : if (lower[0] == '8' && lower[1] == 0) {
3367 : 2513302 : return _PyUnicode_AsUTF8String(unicode, errors);
3368 : : }
3369 [ + + + - : 10115 : else if (lower[0] == '1' && lower[1] == '6' && lower[2] == 0) {
+ + ]
3370 : 1816 : return _PyUnicode_EncodeUTF16(unicode, errors, 0);
3371 : : }
3372 [ + + + - : 8299 : else if (lower[0] == '3' && lower[1] == '2' && lower[2] == 0) {
+ + ]
3373 : 767 : return _PyUnicode_EncodeUTF32(unicode, errors, 0);
3374 : : }
3375 : : }
3376 : : else {
3377 [ + + ]: 1595402 : if (strcmp(lower, "ascii") == 0
3378 [ + + ]: 187655 : || strcmp(lower, "us_ascii") == 0) {
3379 : 1414771 : return _PyUnicode_AsASCIIString(unicode, errors);
3380 : : }
3381 : : #ifdef MS_WINDOWS
3382 : : else if (strcmp(lower, "mbcs") == 0) {
3383 : : return PyUnicode_EncodeCodePage(CP_ACP, unicode, errors);
3384 : : }
3385 : : #endif
3386 [ + + ]: 180631 : else if (strcmp(lower, "latin1") == 0 ||
3387 [ + + ]: 179731 : strcmp(lower, "latin_1") == 0 ||
3388 [ + + ]: 168795 : strcmp(lower, "iso_8859_1") == 0 ||
3389 [ + + ]: 166649 : strcmp(lower, "iso8859_1") == 0) {
3390 : 14028 : return _PyUnicode_AsLatin1String(unicode, errors);
3391 : : }
3392 : : }
3393 : : }
3394 : :
3395 : : /* Encode via the codec registry */
3396 : 1259873 : v = _PyCodec_EncodeText(unicode, encoding, errors);
3397 [ + + ]: 1259873 : if (v == NULL)
3398 : 60 : return NULL;
3399 : :
3400 : : /* The normal path */
3401 [ + + ]: 1259813 : if (PyBytes_Check(v))
3402 : 1259811 : return v;
3403 : :
3404 : : /* If the codec returns a buffer, raise a warning and convert to bytes */
3405 [ - + ]: 2 : if (PyByteArray_Check(v)) {
3406 : : int error;
3407 : : PyObject *b;
3408 : :
3409 : 0 : error = PyErr_WarnFormat(PyExc_RuntimeWarning, 1,
3410 : : "encoder %s returned bytearray instead of bytes; "
3411 : : "use codecs.encode() to encode to arbitrary types",
3412 : : encoding);
3413 [ # # ]: 0 : if (error) {
3414 : 0 : Py_DECREF(v);
3415 : 0 : return NULL;
3416 : : }
3417 : :
3418 : 0 : b = PyBytes_FromStringAndSize(PyByteArray_AS_STRING(v),
3419 : : PyByteArray_GET_SIZE(v));
3420 : 0 : Py_DECREF(v);
3421 : 0 : return b;
3422 : : }
3423 : :
3424 : 2 : PyErr_Format(PyExc_TypeError,
3425 : : "'%.400s' encoder returned '%.400s' instead of 'bytes'; "
3426 : : "use codecs.encode() to encode to arbitrary types",
3427 : : encoding,
3428 : 2 : Py_TYPE(v)->tp_name);
3429 : 2 : Py_DECREF(v);
3430 : 2 : return NULL;
3431 : : }
3432 : :
3433 : : PyObject *
3434 : 0 : PyUnicode_AsEncodedUnicode(PyObject *unicode,
3435 : : const char *encoding,
3436 : : const char *errors)
3437 : : {
3438 : : PyObject *v;
3439 : :
3440 [ # # ]: 0 : if (!PyUnicode_Check(unicode)) {
3441 : 0 : PyErr_BadArgument();
3442 : 0 : goto onError;
3443 : : }
3444 : :
3445 [ # # ]: 0 : if (PyErr_WarnEx(PyExc_DeprecationWarning,
3446 : : "PyUnicode_AsEncodedUnicode() is deprecated; "
3447 : : "use PyCodec_Encode() to encode from str to str", 1) < 0)
3448 : 0 : return NULL;
3449 : :
3450 [ # # ]: 0 : if (encoding == NULL)
3451 : 0 : encoding = PyUnicode_GetDefaultEncoding();
3452 : :
3453 : : /* Encode via the codec registry */
3454 : 0 : v = PyCodec_Encode(unicode, encoding, errors);
3455 [ # # ]: 0 : if (v == NULL)
3456 : 0 : goto onError;
3457 [ # # ]: 0 : if (!PyUnicode_Check(v)) {
3458 : 0 : PyErr_Format(PyExc_TypeError,
3459 : : "'%.400s' encoder returned '%.400s' instead of 'str'; "
3460 : : "use codecs.encode() to encode to arbitrary types",
3461 : : encoding,
3462 : 0 : Py_TYPE(v)->tp_name);
3463 : 0 : Py_DECREF(v);
3464 : 0 : goto onError;
3465 : : }
3466 : 0 : return v;
3467 : :
3468 : 0 : onError:
3469 : 0 : return NULL;
3470 : : }
3471 : :
3472 : : static PyObject*
3473 : 1400963 : unicode_decode_locale(const char *str, Py_ssize_t len,
3474 : : _Py_error_handler errors, int current_locale)
3475 : : {
3476 [ + - - + ]: 1400963 : if (str[len] != '\0' || (size_t)len != strlen(str)) {
3477 : 0 : PyErr_SetString(PyExc_ValueError, "embedded null byte");
3478 : 0 : return NULL;
3479 : : }
3480 : :
3481 : : wchar_t *wstr;
3482 : : size_t wlen;
3483 : : const char *reason;
3484 : 1400963 : int res = _Py_DecodeLocaleEx(str, &wstr, &wlen, &reason,
3485 : : current_locale, errors);
3486 [ - + ]: 1400963 : if (res != 0) {
3487 [ # # ]: 0 : if (res == -2) {
3488 : : PyObject *exc;
3489 : 0 : exc = PyObject_CallFunction(PyExc_UnicodeDecodeError, "sy#nns",
3490 : : "locale", str, len,
3491 : : (Py_ssize_t)wlen,
3492 : 0 : (Py_ssize_t)(wlen + 1),
3493 : : reason);
3494 [ # # ]: 0 : if (exc != NULL) {
3495 : 0 : PyCodec_StrictErrors(exc);
3496 : 0 : Py_DECREF(exc);
3497 : : }
3498 : : }
3499 [ # # ]: 0 : else if (res == -3) {
3500 : 0 : PyErr_SetString(PyExc_ValueError, "unsupported error handler");
3501 : : }
3502 : : else {
3503 : : PyErr_NoMemory();
3504 : : }
3505 : 0 : return NULL;
3506 : : }
3507 : :
3508 : 1400963 : PyObject *unicode = PyUnicode_FromWideChar(wstr, wlen);
3509 : 1400963 : PyMem_RawFree(wstr);
3510 : 1400963 : return unicode;
3511 : : }
3512 : :
3513 : : PyObject*
3514 : 0 : PyUnicode_DecodeLocaleAndSize(const char *str, Py_ssize_t len,
3515 : : const char *errors)
3516 : : {
3517 : 0 : _Py_error_handler error_handler = _Py_GetErrorHandler(errors);
3518 : 0 : return unicode_decode_locale(str, len, error_handler, 1);
3519 : : }
3520 : :
3521 : : PyObject*
3522 : 377760 : PyUnicode_DecodeLocale(const char *str, const char *errors)
3523 : : {
3524 : 377760 : Py_ssize_t size = (Py_ssize_t)strlen(str);
3525 : 377760 : _Py_error_handler error_handler = _Py_GetErrorHandler(errors);
3526 : 377760 : return unicode_decode_locale(str, size, error_handler, 1);
3527 : : }
3528 : :
3529 : :
3530 : : PyObject*
3531 : 111117 : PyUnicode_DecodeFSDefault(const char *s) {
3532 : 111117 : Py_ssize_t size = (Py_ssize_t)strlen(s);
3533 : 111117 : return PyUnicode_DecodeFSDefaultAndSize(s, size);
3534 : : }
3535 : :
3536 : : PyObject*
3537 : 2458127 : PyUnicode_DecodeFSDefaultAndSize(const char *s, Py_ssize_t size)
3538 : : {
3539 : 2458127 : PyInterpreterState *interp = _PyInterpreterState_GET();
3540 : 2458127 : struct _Py_unicode_fs_codec *fs_codec = &interp->unicode.fs_codec;
3541 [ + + ]: 2458127 : if (fs_codec->utf8) {
3542 : 1429462 : return unicode_decode_utf8(s, size,
3543 : : fs_codec->error_handler,
3544 : 1429462 : fs_codec->errors,
3545 : : NULL);
3546 : : }
3547 : : #ifndef _Py_FORCE_UTF8_FS_ENCODING
3548 [ + + ]: 1028665 : else if (fs_codec->encoding) {
3549 : 5462 : return PyUnicode_Decode(s, size,
3550 : 5462 : fs_codec->encoding,
3551 : 5462 : fs_codec->errors);
3552 : : }
3553 : : #endif
3554 : : else {
3555 : : /* Before _PyUnicode_InitEncodings() is called, the Python codec
3556 : : machinery is not ready and so cannot be used:
3557 : : use mbstowcs() in this case. */
3558 : 1023203 : const PyConfig *config = _PyInterpreterState_GetConfig(interp);
3559 : 1023203 : const wchar_t *filesystem_errors = config->filesystem_errors;
3560 : : assert(filesystem_errors != NULL);
3561 : 1023203 : _Py_error_handler errors = get_error_handler_wide(filesystem_errors);
3562 : : assert(errors != _Py_ERROR_UNKNOWN);
3563 : : #ifdef _Py_FORCE_UTF8_FS_ENCODING
3564 : : return unicode_decode_utf8(s, size, errors, NULL, NULL);
3565 : : #else
3566 : 1023203 : return unicode_decode_locale(s, size, errors, 0);
3567 : : #endif
3568 : : }
3569 : : }
3570 : :
3571 : :
3572 : : int
3573 : 2157342 : PyUnicode_FSConverter(PyObject* arg, void* addr)
3574 : : {
3575 : 2157342 : PyObject *path = NULL;
3576 : 2157342 : PyObject *output = NULL;
3577 : : Py_ssize_t size;
3578 : : const char *data;
3579 [ + + ]: 2157342 : if (arg == NULL) {
3580 : 1 : Py_DECREF(*(PyObject**)addr);
3581 : 1 : *(PyObject**)addr = NULL;
3582 : 1 : return 1;
3583 : : }
3584 : 2157341 : path = PyOS_FSPath(arg);
3585 [ + + ]: 2157341 : if (path == NULL) {
3586 : 11 : return 0;
3587 : : }
3588 [ + + ]: 2157330 : if (PyBytes_Check(path)) {
3589 : 54298 : output = path;
3590 : : }
3591 : : else { // PyOS_FSPath() guarantees its returned value is bytes or str.
3592 : 2103032 : output = PyUnicode_EncodeFSDefault(path);
3593 : 2103032 : Py_DECREF(path);
3594 [ + + ]: 2103032 : if (!output) {
3595 : 53 : return 0;
3596 : : }
3597 : : assert(PyBytes_Check(output));
3598 : : }
3599 : :
3600 : 2157277 : size = PyBytes_GET_SIZE(output);
3601 : 2157277 : data = PyBytes_AS_STRING(output);
3602 [ + + ]: 2157277 : if ((size_t)size != strlen(data)) {
3603 : 70 : PyErr_SetString(PyExc_ValueError, "embedded null byte");
3604 : 70 : Py_DECREF(output);
3605 : 70 : return 0;
3606 : : }
3607 : 2157207 : *(PyObject**)addr = output;
3608 : 2157207 : return Py_CLEANUP_SUPPORTED;
3609 : : }
3610 : :
3611 : :
3612 : : int
3613 : 30319 : PyUnicode_FSDecoder(PyObject* arg, void* addr)
3614 : : {
3615 : 30319 : int is_buffer = 0;
3616 : 30319 : PyObject *path = NULL;
3617 : 30319 : PyObject *output = NULL;
3618 [ - + ]: 30319 : if (arg == NULL) {
3619 : 0 : Py_DECREF(*(PyObject**)addr);
3620 : 0 : *(PyObject**)addr = NULL;
3621 : 0 : return 1;
3622 : : }
3623 : :
3624 : 30319 : is_buffer = PyObject_CheckBuffer(arg);
3625 [ + + ]: 30319 : if (!is_buffer) {
3626 : 30313 : path = PyOS_FSPath(arg);
3627 [ + + ]: 30313 : if (path == NULL) {
3628 : 2 : return 0;
3629 : : }
3630 : : }
3631 : : else {
3632 : 6 : path = arg;
3633 : 6 : Py_INCREF(arg);
3634 : : }
3635 : :
3636 [ + + ]: 30317 : if (PyUnicode_Check(path)) {
3637 : 30311 : output = path;
3638 : : }
3639 [ + + + - ]: 12 : else if (PyBytes_Check(path) || is_buffer) {
3640 : 6 : PyObject *path_bytes = NULL;
3641 : :
3642 [ + + - + ]: 10 : if (!PyBytes_Check(path) &&
3643 : 4 : PyErr_WarnFormat(PyExc_DeprecationWarning, 1,
3644 : : "path should be string, bytes, or os.PathLike, not %.200s",
3645 : 4 : Py_TYPE(arg)->tp_name)) {
3646 : 0 : Py_DECREF(path);
3647 : 0 : return 0;
3648 : : }
3649 : 6 : path_bytes = PyBytes_FromObject(path);
3650 : 6 : Py_DECREF(path);
3651 [ - + ]: 6 : if (!path_bytes) {
3652 : 0 : return 0;
3653 : : }
3654 : 6 : output = PyUnicode_DecodeFSDefaultAndSize(PyBytes_AS_STRING(path_bytes),
3655 : : PyBytes_GET_SIZE(path_bytes));
3656 : 6 : Py_DECREF(path_bytes);
3657 [ - + ]: 6 : if (!output) {
3658 : 0 : return 0;
3659 : : }
3660 : : }
3661 : : else {
3662 : 0 : PyErr_Format(PyExc_TypeError,
3663 : : "path should be string, bytes, or os.PathLike, not %.200s",
3664 : 0 : Py_TYPE(arg)->tp_name);
3665 : 0 : Py_DECREF(path);
3666 : 0 : return 0;
3667 : : }
3668 [ - + ]: 30317 : if (findchar(PyUnicode_DATA(output), PyUnicode_KIND(output),
3669 : : PyUnicode_GET_LENGTH(output), 0, 1) >= 0) {
3670 : 0 : PyErr_SetString(PyExc_ValueError, "embedded null character");
3671 : 0 : Py_DECREF(output);
3672 : 0 : return 0;
3673 : : }
3674 : 30317 : *(PyObject**)addr = output;
3675 : 30317 : return Py_CLEANUP_SUPPORTED;
3676 : : }
3677 : :
3678 : :
3679 : : static int unicode_fill_utf8(PyObject *unicode);
3680 : :
3681 : : const char *
3682 : 25515468 : PyUnicode_AsUTF8AndSize(PyObject *unicode, Py_ssize_t *psize)
3683 : : {
3684 [ - + ]: 25515468 : if (!PyUnicode_Check(unicode)) {
3685 : 0 : PyErr_BadArgument();
3686 : 0 : return NULL;
3687 : : }
3688 : :
3689 [ + + + + ]: 25515468 : if (PyUnicode_UTF8(unicode) == NULL) {
3690 [ + + ]: 4537 : if (unicode_fill_utf8(unicode) == -1) {
3691 : 70 : return NULL;
3692 : : }
3693 : : }
3694 : :
3695 [ + + ]: 25515398 : if (psize)
3696 [ + + ]: 23847452 : *psize = PyUnicode_UTF8_LENGTH(unicode);
3697 [ + + ]: 25515398 : return PyUnicode_UTF8(unicode);
3698 : : }
3699 : :
3700 : : const char *
3701 : 1667951 : PyUnicode_AsUTF8(PyObject *unicode)
3702 : : {
3703 : 1667951 : return PyUnicode_AsUTF8AndSize(unicode, NULL);
3704 : : }
3705 : :
3706 : : /*
3707 : : PyUnicode_GetSize() has been deprecated since Python 3.3
3708 : : because it returned length of Py_UNICODE.
3709 : :
3710 : : But this function is part of stable abi, because it don't
3711 : : include Py_UNICODE in signature and it was not excluded from
3712 : : stable abi in PEP 384.
3713 : : */
3714 : : PyAPI_FUNC(Py_ssize_t)
3715 : 0 : PyUnicode_GetSize(PyObject *unicode)
3716 : : {
3717 : 0 : PyErr_SetString(PyExc_RuntimeError,
3718 : : "PyUnicode_GetSize has been removed.");
3719 : 0 : return -1;
3720 : : }
3721 : :
3722 : : Py_ssize_t
3723 : 43871 : PyUnicode_GetLength(PyObject *unicode)
3724 : : {
3725 [ - + ]: 43871 : if (!PyUnicode_Check(unicode)) {
3726 : 0 : PyErr_BadArgument();
3727 : 0 : return -1;
3728 : : }
3729 : 43871 : return PyUnicode_GET_LENGTH(unicode);
3730 : : }
3731 : :
3732 : : Py_UCS4
3733 : 21 : PyUnicode_ReadChar(PyObject *unicode, Py_ssize_t index)
3734 : : {
3735 : : const void *data;
3736 : : int kind;
3737 : :
3738 [ - + ]: 21 : if (!PyUnicode_Check(unicode)) {
3739 : 0 : PyErr_BadArgument();
3740 : 0 : return (Py_UCS4)-1;
3741 : : }
3742 [ + - - + ]: 21 : if (index < 0 || index >= PyUnicode_GET_LENGTH(unicode)) {
3743 : 0 : PyErr_SetString(PyExc_IndexError, "string index out of range");
3744 : 0 : return (Py_UCS4)-1;
3745 : : }
3746 : 21 : data = PyUnicode_DATA(unicode);
3747 : 21 : kind = PyUnicode_KIND(unicode);
3748 : 21 : return PyUnicode_READ(kind, data, index);
3749 : : }
3750 : :
3751 : : int
3752 : 12 : PyUnicode_WriteChar(PyObject *unicode, Py_ssize_t index, Py_UCS4 ch)
3753 : : {
3754 [ + - - + ]: 12 : if (!PyUnicode_Check(unicode) || !PyUnicode_IS_COMPACT(unicode)) {
3755 : 0 : PyErr_BadArgument();
3756 : 0 : return -1;
3757 : : }
3758 [ + - - + ]: 12 : if (index < 0 || index >= PyUnicode_GET_LENGTH(unicode)) {
3759 : 0 : PyErr_SetString(PyExc_IndexError, "string index out of range");
3760 : 0 : return -1;
3761 : : }
3762 [ - + ]: 12 : if (unicode_check_modifiable(unicode))
3763 : 0 : return -1;
3764 [ - + ]: 12 : if (ch > PyUnicode_MAX_CHAR_VALUE(unicode)) {
3765 : 0 : PyErr_SetString(PyExc_ValueError, "character out of range");
3766 : 0 : return -1;
3767 : : }
3768 : 12 : PyUnicode_WRITE(PyUnicode_KIND(unicode), PyUnicode_DATA(unicode),
3769 : : index, ch);
3770 : 12 : return 0;
3771 : : }
3772 : :
3773 : : const char *
3774 : 2094 : PyUnicode_GetDefaultEncoding(void)
3775 : : {
3776 : 2094 : return "utf-8";
3777 : : }
3778 : :
3779 : : /* create or adjust a UnicodeDecodeError */
3780 : : static void
3781 : 7248 : make_decode_exception(PyObject **exceptionObject,
3782 : : const char *encoding,
3783 : : const char *input, Py_ssize_t length,
3784 : : Py_ssize_t startpos, Py_ssize_t endpos,
3785 : : const char *reason)
3786 : : {
3787 [ + + ]: 7248 : if (*exceptionObject == NULL) {
3788 : 5586 : *exceptionObject = PyUnicodeDecodeError_Create(
3789 : : encoding, input, length, startpos, endpos, reason);
3790 : : }
3791 : : else {
3792 [ - + ]: 1662 : if (PyUnicodeDecodeError_SetStart(*exceptionObject, startpos))
3793 : 0 : goto onError;
3794 [ - + ]: 1662 : if (PyUnicodeDecodeError_SetEnd(*exceptionObject, endpos))
3795 : 0 : goto onError;
3796 [ - + ]: 1662 : if (PyUnicodeDecodeError_SetReason(*exceptionObject, reason))
3797 : 0 : goto onError;
3798 : : }
3799 : 7248 : return;
3800 : :
3801 : 0 : onError:
3802 [ # # ]: 0 : Py_CLEAR(*exceptionObject);
3803 : : }
3804 : :
3805 : : #ifdef MS_WINDOWS
3806 : : static int
3807 : : widechar_resize(wchar_t **buf, Py_ssize_t *size, Py_ssize_t newsize)
3808 : : {
3809 : : if (newsize > *size) {
3810 : : wchar_t *newbuf = *buf;
3811 : : if (PyMem_Resize(newbuf, wchar_t, newsize) == NULL) {
3812 : : PyErr_NoMemory();
3813 : : return -1;
3814 : : }
3815 : : *buf = newbuf;
3816 : : }
3817 : : *size = newsize;
3818 : : return 0;
3819 : : }
3820 : :
3821 : : /* error handling callback helper:
3822 : : build arguments, call the callback and check the arguments,
3823 : : if no exception occurred, copy the replacement to the output
3824 : : and adjust various state variables.
3825 : : return 0 on success, -1 on error
3826 : : */
3827 : :
3828 : : static int
3829 : : unicode_decode_call_errorhandler_wchar(
3830 : : const char *errors, PyObject **errorHandler,
3831 : : const char *encoding, const char *reason,
3832 : : const char **input, const char **inend, Py_ssize_t *startinpos,
3833 : : Py_ssize_t *endinpos, PyObject **exceptionObject, const char **inptr,
3834 : : wchar_t **buf, Py_ssize_t *bufsize, Py_ssize_t *outpos)
3835 : : {
3836 : : static const char *argparse = "Un;decoding error handler must return (str, int) tuple";
3837 : :
3838 : : PyObject *restuple = NULL;
3839 : : PyObject *repunicode = NULL;
3840 : : Py_ssize_t outsize;
3841 : : Py_ssize_t insize;
3842 : : Py_ssize_t requiredsize;
3843 : : Py_ssize_t newpos;
3844 : : PyObject *inputobj = NULL;
3845 : : Py_ssize_t repwlen;
3846 : :
3847 : : if (*errorHandler == NULL) {
3848 : : *errorHandler = PyCodec_LookupError(errors);
3849 : : if (*errorHandler == NULL)
3850 : : goto onError;
3851 : : }
3852 : :
3853 : : make_decode_exception(exceptionObject,
3854 : : encoding,
3855 : : *input, *inend - *input,
3856 : : *startinpos, *endinpos,
3857 : : reason);
3858 : : if (*exceptionObject == NULL)
3859 : : goto onError;
3860 : :
3861 : : restuple = PyObject_CallOneArg(*errorHandler, *exceptionObject);
3862 : : if (restuple == NULL)
3863 : : goto onError;
3864 : : if (!PyTuple_Check(restuple)) {
3865 : : PyErr_SetString(PyExc_TypeError, &argparse[3]);
3866 : : goto onError;
3867 : : }
3868 : : if (!PyArg_ParseTuple(restuple, argparse, &repunicode, &newpos))
3869 : : goto onError;
3870 : :
3871 : : /* Copy back the bytes variables, which might have been modified by the
3872 : : callback */
3873 : : inputobj = PyUnicodeDecodeError_GetObject(*exceptionObject);
3874 : : if (!inputobj)
3875 : : goto onError;
3876 : : *input = PyBytes_AS_STRING(inputobj);
3877 : : insize = PyBytes_GET_SIZE(inputobj);
3878 : : *inend = *input + insize;
3879 : : /* we can DECREF safely, as the exception has another reference,
3880 : : so the object won't go away. */
3881 : : Py_DECREF(inputobj);
3882 : :
3883 : : if (newpos<0)
3884 : : newpos = insize+newpos;
3885 : : if (newpos<0 || newpos>insize) {
3886 : : PyErr_Format(PyExc_IndexError, "position %zd from error handler out of bounds", newpos);
3887 : : goto onError;
3888 : : }
3889 : :
3890 : : repwlen = PyUnicode_AsWideChar(repunicode, NULL, 0);
3891 : : if (repwlen < 0)
3892 : : goto onError;
3893 : : repwlen--;
3894 : : /* need more space? (at least enough for what we
3895 : : have+the replacement+the rest of the string (starting
3896 : : at the new input position), so we won't have to check space
3897 : : when there are no errors in the rest of the string) */
3898 : : requiredsize = *outpos;
3899 : : if (requiredsize > PY_SSIZE_T_MAX - repwlen)
3900 : : goto overflow;
3901 : : requiredsize += repwlen;
3902 : : if (requiredsize > PY_SSIZE_T_MAX - (insize - newpos))
3903 : : goto overflow;
3904 : : requiredsize += insize - newpos;
3905 : : outsize = *bufsize;
3906 : : if (requiredsize > outsize) {
3907 : : if (outsize <= PY_SSIZE_T_MAX/2 && requiredsize < 2*outsize)
3908 : : requiredsize = 2*outsize;
3909 : : if (widechar_resize(buf, bufsize, requiredsize) < 0) {
3910 : : goto onError;
3911 : : }
3912 : : }
3913 : : PyUnicode_AsWideChar(repunicode, *buf + *outpos, repwlen);
3914 : : *outpos += repwlen;
3915 : : *endinpos = newpos;
3916 : : *inptr = *input + newpos;
3917 : :
3918 : : /* we made it! */
3919 : : Py_DECREF(restuple);
3920 : : return 0;
3921 : :
3922 : : overflow:
3923 : : PyErr_SetString(PyExc_OverflowError,
3924 : : "decoded result is too long for a Python string");
3925 : :
3926 : : onError:
3927 : : Py_XDECREF(restuple);
3928 : : return -1;
3929 : : }
3930 : : #endif /* MS_WINDOWS */
3931 : :
3932 : : static int
3933 : 7249 : unicode_decode_call_errorhandler_writer(
3934 : : const char *errors, PyObject **errorHandler,
3935 : : const char *encoding, const char *reason,
3936 : : const char **input, const char **inend, Py_ssize_t *startinpos,
3937 : : Py_ssize_t *endinpos, PyObject **exceptionObject, const char **inptr,
3938 : : _PyUnicodeWriter *writer /* PyObject **output, Py_ssize_t *outpos */)
3939 : : {
3940 : : static const char *argparse = "Un;decoding error handler must return (str, int) tuple";
3941 : :
3942 : 7249 : PyObject *restuple = NULL;
3943 : 7249 : PyObject *repunicode = NULL;
3944 : : Py_ssize_t insize;
3945 : : Py_ssize_t newpos;
3946 : : Py_ssize_t replen;
3947 : : Py_ssize_t remain;
3948 : 7249 : PyObject *inputobj = NULL;
3949 : 7249 : int need_to_grow = 0;
3950 : : const char *new_inptr;
3951 : :
3952 [ + + ]: 7249 : if (*errorHandler == NULL) {
3953 : 5587 : *errorHandler = PyCodec_LookupError(errors);
3954 [ + + ]: 5587 : if (*errorHandler == NULL)
3955 : 1 : goto onError;
3956 : : }
3957 : :
3958 : 7248 : make_decode_exception(exceptionObject,
3959 : : encoding,
3960 : 7248 : *input, *inend - *input,
3961 : : *startinpos, *endinpos,
3962 : : reason);
3963 [ - + ]: 7248 : if (*exceptionObject == NULL)
3964 : 0 : goto onError;
3965 : :
3966 : 7248 : restuple = PyObject_CallOneArg(*errorHandler, *exceptionObject);
3967 [ + + ]: 7248 : if (restuple == NULL)
3968 : 4019 : goto onError;
3969 [ + + ]: 3229 : if (!PyTuple_Check(restuple)) {
3970 : 12 : PyErr_SetString(PyExc_TypeError, &argparse[3]);
3971 : 12 : goto onError;
3972 : : }
3973 [ + + ]: 3217 : if (!PyArg_ParseTuple(restuple, argparse, &repunicode, &newpos))
3974 : 22 : goto onError;
3975 : :
3976 : : /* Copy back the bytes variables, which might have been modified by the
3977 : : callback */
3978 : 3195 : inputobj = PyUnicodeDecodeError_GetObject(*exceptionObject);
3979 [ + + ]: 3195 : if (!inputobj)
3980 : 7 : goto onError;
3981 : 3188 : remain = *inend - *input - *endinpos;
3982 : 3188 : *input = PyBytes_AS_STRING(inputobj);
3983 : 3188 : insize = PyBytes_GET_SIZE(inputobj);
3984 : 3188 : *inend = *input + insize;
3985 : : /* we can DECREF safely, as the exception has another reference,
3986 : : so the object won't go away. */
3987 : 3188 : Py_DECREF(inputobj);
3988 : :
3989 [ + + ]: 3188 : if (newpos<0)
3990 : 3 : newpos = insize+newpos;
3991 [ + + + + ]: 3188 : if (newpos<0 || newpos>insize) {
3992 : 2 : PyErr_Format(PyExc_IndexError, "position %zd from error handler out of bounds", newpos);
3993 : 2 : goto onError;
3994 : : }
3995 : :
3996 : 3186 : replen = PyUnicode_GET_LENGTH(repunicode);
3997 [ + + ]: 3186 : if (replen > 1) {
3998 : 71 : writer->min_length += replen - 1;
3999 : 71 : need_to_grow = 1;
4000 : : }
4001 : 3186 : new_inptr = *input + newpos;
4002 [ + + ]: 3186 : if (*inend - new_inptr > remain) {
4003 : : /* We don't know the decoding algorithm here so we make the worst
4004 : : assumption that one byte decodes to one unicode character.
4005 : : If unfortunately one byte could decode to more unicode characters,
4006 : : the decoder may write out-of-bound then. Is it possible for the
4007 : : algorithms using this function? */
4008 : 267 : writer->min_length += *inend - new_inptr - remain;
4009 : 267 : need_to_grow = 1;
4010 : : }
4011 [ + + ]: 3186 : if (need_to_grow) {
4012 : 337 : writer->overallocate = 1;
4013 [ + + + + ]: 477 : if (_PyUnicodeWriter_Prepare(writer, writer->min_length - writer->pos,
4014 [ + - - + ]: 280 : PyUnicode_MAX_CHAR_VALUE(repunicode)) == -1)
4015 : 0 : goto onError;
4016 : : }
4017 [ - + ]: 3186 : if (_PyUnicodeWriter_WriteStr(writer, repunicode) == -1)
4018 : 0 : goto onError;
4019 : :
4020 : 3186 : *endinpos = newpos;
4021 : 3186 : *inptr = new_inptr;
4022 : :
4023 : : /* we made it! */
4024 : 3186 : Py_DECREF(restuple);
4025 : 3186 : return 0;
4026 : :
4027 : 4063 : onError:
4028 : 4063 : Py_XDECREF(restuple);
4029 : 4063 : return -1;
4030 : : }
4031 : :
4032 : : /* --- UTF-7 Codec -------------------------------------------------------- */
4033 : :
4034 : : /* See RFC2152 for details. We encode conservatively and decode liberally. */
4035 : :
4036 : : /* Three simple macros defining base-64. */
4037 : :
4038 : : /* Is c a base-64 character? */
4039 : :
4040 : : #define IS_BASE64(c) \
4041 : : (((c) >= 'A' && (c) <= 'Z') || \
4042 : : ((c) >= 'a' && (c) <= 'z') || \
4043 : : ((c) >= '0' && (c) <= '9') || \
4044 : : (c) == '+' || (c) == '/')
4045 : :
4046 : : /* given that c is a base-64 character, what is its base-64 value? */
4047 : :
4048 : : #define FROM_BASE64(c) \
4049 : : (((c) >= 'A' && (c) <= 'Z') ? (c) - 'A' : \
4050 : : ((c) >= 'a' && (c) <= 'z') ? (c) - 'a' + 26 : \
4051 : : ((c) >= '0' && (c) <= '9') ? (c) - '0' + 52 : \
4052 : : (c) == '+' ? 62 : 63)
4053 : :
4054 : : /* What is the base-64 character of the bottom 6 bits of n? */
4055 : :
4056 : : #define TO_BASE64(n) \
4057 : : ("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"[(n) & 0x3f])
4058 : :
4059 : : /* DECODE_DIRECT: this byte encountered in a UTF-7 string should be
4060 : : * decoded as itself. We are permissive on decoding; the only ASCII
4061 : : * byte not decoding to itself is the + which begins a base64
4062 : : * string. */
4063 : :
4064 : : #define DECODE_DIRECT(c) \
4065 : : ((c) <= 127 && (c) != '+')
4066 : :
4067 : : /* The UTF-7 encoder treats ASCII characters differently according to
4068 : : * whether they are Set D, Set O, Whitespace, or special (i.e. none of
4069 : : * the above). See RFC2152. This array identifies these different
4070 : : * sets:
4071 : : * 0 : "Set D"
4072 : : * alphanumeric and '(),-./:?
4073 : : * 1 : "Set O"
4074 : : * !"#$%&*;<=>@[]^_`{|}
4075 : : * 2 : "whitespace"
4076 : : * ht nl cr sp
4077 : : * 3 : special (must be base64 encoded)
4078 : : * everything else (i.e. +\~ and non-printing codes 0-8 11-12 14-31 127)
4079 : : */
4080 : :
4081 : : static
4082 : : char utf7_category[128] = {
4083 : : /* nul soh stx etx eot enq ack bel bs ht nl vt np cr so si */
4084 : : 3, 3, 3, 3, 3, 3, 3, 3, 3, 2, 2, 3, 3, 2, 3, 3,
4085 : : /* dle dc1 dc2 dc3 dc4 nak syn etb can em sub esc fs gs rs us */
4086 : : 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
4087 : : /* sp ! " # $ % & ' ( ) * + , - . / */
4088 : : 2, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 3, 0, 0, 0, 0,
4089 : : /* 0 1 2 3 4 5 6 7 8 9 : ; < = > ? */
4090 : : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0,
4091 : : /* @ A B C D E F G H I J K L M N O */
4092 : : 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4093 : : /* P Q R S T U V W X Y Z [ \ ] ^ _ */
4094 : : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 3, 1, 1, 1,
4095 : : /* ` a b c d e f g h i j k l m n o */
4096 : : 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4097 : : /* p q r s t u v w x y z { | } ~ del */
4098 : : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 3, 3,
4099 : : };
4100 : :
4101 : : /* ENCODE_DIRECT: this character should be encoded as itself. The
4102 : : * answer depends on whether we are encoding set O as itself, and also
4103 : : * on whether we are encoding whitespace as itself. RFC2152 makes it
4104 : : * clear that the answers to these questions vary between
4105 : : * applications, so this code needs to be flexible. */
4106 : :
4107 : : #define ENCODE_DIRECT(c, directO, directWS) \
4108 : : ((c) < 128 && (c) > 0 && \
4109 : : ((utf7_category[(c)] == 0) || \
4110 : : (directWS && (utf7_category[(c)] == 2)) || \
4111 : : (directO && (utf7_category[(c)] == 1))))
4112 : :
4113 : : PyObject *
4114 : 0 : PyUnicode_DecodeUTF7(const char *s,
4115 : : Py_ssize_t size,
4116 : : const char *errors)
4117 : : {
4118 : 0 : return PyUnicode_DecodeUTF7Stateful(s, size, errors, NULL);
4119 : : }
4120 : :
4121 : : /* The decoder. The only state we preserve is our read position,
4122 : : * i.e. how many characters we have consumed. So if we end in the
4123 : : * middle of a shift sequence we have to back off the read position
4124 : : * and the output to the beginning of the sequence, otherwise we lose
4125 : : * all the shift state (seen bits, number of bits seen, high
4126 : : * surrogate). */
4127 : :
4128 : : PyObject *
4129 : 5662 : PyUnicode_DecodeUTF7Stateful(const char *s,
4130 : : Py_ssize_t size,
4131 : : const char *errors,
4132 : : Py_ssize_t *consumed)
4133 : : {
4134 : 5662 : const char *starts = s;
4135 : : Py_ssize_t startinpos;
4136 : : Py_ssize_t endinpos;
4137 : : const char *e;
4138 : : _PyUnicodeWriter writer;
4139 : 5662 : const char *errmsg = "";
4140 : 5662 : int inShift = 0;
4141 : : Py_ssize_t shiftOutStart;
4142 : 5662 : unsigned int base64bits = 0;
4143 : 5662 : unsigned long base64buffer = 0;
4144 : 5662 : Py_UCS4 surrogate = 0;
4145 : 5662 : PyObject *errorHandler = NULL;
4146 : 5662 : PyObject *exc = NULL;
4147 : :
4148 [ + + ]: 5662 : if (size == 0) {
4149 [ + + ]: 18 : if (consumed)
4150 : 8 : *consumed = 0;
4151 : 18 : _Py_RETURN_UNICODE_EMPTY();
4152 : : }
4153 : :
4154 : : /* Start off assuming it's all ASCII. Widen later as necessary. */
4155 : 5644 : _PyUnicodeWriter_Init(&writer);
4156 : 5644 : writer.min_length = size;
4157 : :
4158 : 5644 : shiftOutStart = 0;
4159 : 5644 : e = s + size;
4160 : :
4161 [ + + ]: 356931 : while (s < e) {
4162 : : Py_UCS4 ch;
4163 : 351314 : restart:
4164 : 351314 : ch = (unsigned char) *s;
4165 : :
4166 [ + + ]: 351314 : if (inShift) { /* in a base-64 section */
4167 [ + + + + : 53274 : if (IS_BASE64(ch)) { /* consume a base-64 character */
+ + + + +
+ + + + +
+ + ]
4168 [ + + + + : 50649 : base64buffer = (base64buffer << 6) | FROM_BASE64(ch);
+ + + - +
+ + - +
+ ]
4169 : 50649 : base64bits += 6;
4170 : 50649 : s++;
4171 [ + + ]: 50649 : if (base64bits >= 16) {
4172 : : /* we have enough bits for a UTF-16 value */
4173 : 18553 : Py_UCS4 outCh = (Py_UCS4)(base64buffer >> (base64bits-16));
4174 : 18553 : base64bits -= 16;
4175 : 18553 : base64buffer &= (1 << base64bits) - 1; /* clear high bits */
4176 : : assert(outCh <= 0xffff);
4177 [ + + ]: 18553 : if (surrogate) {
4178 : : /* expecting a second surrogate */
4179 [ + + ]: 17 : if (Py_UNICODE_IS_LOW_SURROGATE(outCh)) {
4180 : 16 : Py_UCS4 ch2 = Py_UNICODE_JOIN_SURROGATES(surrogate, outCh);
4181 [ - + ]: 16 : if (_PyUnicodeWriter_WriteCharInline(&writer, ch2) < 0)
4182 : 0 : goto onError;
4183 : 16 : surrogate = 0;
4184 : 16 : continue;
4185 : : }
4186 : : else {
4187 [ - + ]: 1 : if (_PyUnicodeWriter_WriteCharInline(&writer, surrogate) < 0)
4188 : 0 : goto onError;
4189 : 1 : surrogate = 0;
4190 : : }
4191 : : }
4192 [ + + ]: 18537 : if (Py_UNICODE_IS_HIGH_SURROGATE(outCh)) {
4193 : : /* first surrogate */
4194 : 52 : surrogate = outCh;
4195 : : }
4196 : : else {
4197 [ - + ]: 18485 : if (_PyUnicodeWriter_WriteCharInline(&writer, outCh) < 0)
4198 : 0 : goto onError;
4199 : : }
4200 : : }
4201 : : }
4202 : : else { /* now leaving a base-64 section */
4203 : 2625 : inShift = 0;
4204 [ + + ]: 2625 : if (base64bits > 0) { /* left-over bits */
4205 [ + + ]: 2615 : if (base64bits >= 6) {
4206 : : /* We've seen at least one base-64 character */
4207 : 28 : s++;
4208 : 28 : errmsg = "partial character in shift sequence";
4209 : 28 : goto utf7Error;
4210 : : }
4211 : : else {
4212 : : /* Some bits remain; they should be zero */
4213 [ + + ]: 2587 : if (base64buffer != 0) {
4214 : 8 : s++;
4215 : 8 : errmsg = "non-zero padding bits in shift sequence";
4216 : 8 : goto utf7Error;
4217 : : }
4218 : : }
4219 : : }
4220 [ + + + + : 2589 : if (surrogate && DECODE_DIRECT(ch)) {
+ - ]
4221 [ - + ]: 9 : if (_PyUnicodeWriter_WriteCharInline(&writer, surrogate) < 0)
4222 : 0 : goto onError;
4223 : : }
4224 : 2589 : surrogate = 0;
4225 [ + + ]: 2589 : if (ch == '-') {
4226 : : /* '-' is absorbed; other terminating
4227 : : characters are preserved */
4228 : 2578 : s++;
4229 : : }
4230 : : }
4231 : : }
4232 [ + + ]: 298040 : else if ( ch == '+' ) {
4233 : 2899 : startinpos = s-starts;
4234 : 2899 : s++; /* consume '+' */
4235 [ + + + + ]: 2899 : if (s < e && *s == '-') { /* '+-' encodes '+' */
4236 : 7 : s++;
4237 [ - + ]: 7 : if (_PyUnicodeWriter_WriteCharInline(&writer, '+') < 0)
4238 : 0 : goto onError;
4239 : : }
4240 [ + + + + : 2892 : else if (s < e && !IS_BASE64(*s)) {
+ + + + -
+ + + + +
+ + + + ]
4241 : 6 : s++;
4242 : 6 : errmsg = "ill-formed sequence";
4243 : 6 : goto utf7Error;
4244 : : }
4245 : : else { /* begin base64-encoded section */
4246 : 2886 : inShift = 1;
4247 : 2886 : surrogate = 0;
4248 : 2886 : shiftOutStart = writer.pos;
4249 : 2886 : base64bits = 0;
4250 : 2886 : base64buffer = 0;
4251 : : }
4252 : : }
4253 [ + + + - ]: 295141 : else if (DECODE_DIRECT(ch)) { /* character decodes as itself */
4254 : 294871 : s++;
4255 [ - + ]: 294871 : if (_PyUnicodeWriter_WriteCharInline(&writer, ch) < 0)
4256 : 0 : goto onError;
4257 : : }
4258 : : else {
4259 : 270 : startinpos = s-starts;
4260 : 270 : s++;
4261 : 270 : errmsg = "unexpected special character";
4262 : 270 : goto utf7Error;
4263 : : }
4264 : 350986 : continue;
4265 : 312 : utf7Error:
4266 : 312 : endinpos = s-starts;
4267 [ + + ]: 312 : if (unicode_decode_call_errorhandler_writer(
4268 : : errors, &errorHandler,
4269 : : "utf7", errmsg,
4270 : : &starts, &e, &startinpos, &endinpos, &exc, &s,
4271 : : &writer))
4272 : 27 : goto onError;
4273 : : }
4274 : :
4275 : : /* end of string */
4276 : :
4277 [ + + + + ]: 5617 : if (inShift && !consumed) { /* in shift sequence, no more to follow */
4278 : : /* if we're in an inconsistent state, that's an error */
4279 : 15 : inShift = 0;
4280 [ + + + + ]: 15 : if (surrogate ||
4281 [ + + ]: 7 : (base64bits >= 6) ||
4282 [ + + ]: 6 : (base64bits > 0 && base64buffer != 0)) {
4283 : 12 : endinpos = size;
4284 [ + + ]: 12 : if (unicode_decode_call_errorhandler_writer(
4285 : : errors, &errorHandler,
4286 : : "utf7", "unterminated shift sequence",
4287 : : &starts, &e, &startinpos, &endinpos, &exc, &s,
4288 : : &writer))
4289 : 5 : goto onError;
4290 [ - + ]: 7 : if (s < e)
4291 : 0 : goto restart;
4292 : : }
4293 : : }
4294 : :
4295 : : /* return state */
4296 [ + + ]: 5612 : if (consumed) {
4297 [ + + ]: 4429 : if (inShift) {
4298 : 246 : *consumed = startinpos;
4299 [ + + + + ]: 246 : if (writer.pos != shiftOutStart && writer.maxchar > 127) {
4300 : 72 : PyObject *result = PyUnicode_FromKindAndData(
4301 : 72 : writer.kind, writer.data, shiftOutStart);
4302 : 72 : Py_XDECREF(errorHandler);
4303 : 72 : Py_XDECREF(exc);
4304 : 72 : _PyUnicodeWriter_Dealloc(&writer);
4305 : 72 : return result;
4306 : : }
4307 : 174 : writer.pos = shiftOutStart; /* back off output */
4308 : : }
4309 : : else {
4310 : 4183 : *consumed = s-starts;
4311 : : }
4312 : : }
4313 : :
4314 : 5540 : Py_XDECREF(errorHandler);
4315 : 5540 : Py_XDECREF(exc);
4316 : 5540 : return _PyUnicodeWriter_Finish(&writer);
4317 : :
4318 : 32 : onError:
4319 : 32 : Py_XDECREF(errorHandler);
4320 : 32 : Py_XDECREF(exc);
4321 : 32 : _PyUnicodeWriter_Dealloc(&writer);
4322 : 32 : return NULL;
4323 : : }
4324 : :
4325 : :
4326 : : PyObject *
4327 : 1907 : _PyUnicode_EncodeUTF7(PyObject *str,
4328 : : int base64SetO,
4329 : : int base64WhiteSpace,
4330 : : const char *errors)
4331 : : {
4332 : : int kind;
4333 : : const void *data;
4334 : : Py_ssize_t len;
4335 : : PyObject *v;
4336 : 1907 : int inShift = 0;
4337 : : Py_ssize_t i;
4338 : 1907 : unsigned int base64bits = 0;
4339 : 1907 : unsigned long base64buffer = 0;
4340 : : char * out;
4341 : : const char * start;
4342 : :
4343 : 1907 : kind = PyUnicode_KIND(str);
4344 : 1907 : data = PyUnicode_DATA(str);
4345 : 1907 : len = PyUnicode_GET_LENGTH(str);
4346 : :
4347 [ + + ]: 1907 : if (len == 0)
4348 : 20 : return PyBytes_FromStringAndSize(NULL, 0);
4349 : :
4350 : : /* It might be possible to tighten this worst case */
4351 [ - + ]: 1887 : if (len > PY_SSIZE_T_MAX / 8)
4352 : : return PyErr_NoMemory();
4353 : 1887 : v = PyBytes_FromStringAndSize(NULL, len * 8);
4354 [ - + ]: 1887 : if (v == NULL)
4355 : 0 : return NULL;
4356 : :
4357 : 1887 : start = out = PyBytes_AS_STRING(v);
4358 [ + + ]: 351497 : for (i = 0; i < len; ++i) {
4359 : 349610 : Py_UCS4 ch = PyUnicode_READ(kind, data, i);
4360 : :
4361 [ + + ]: 349610 : if (inShift) {
4362 [ + + + - : 29654 : if (ENCODE_DIRECT(ch, !base64SetO, !base64WhiteSpace)) {
+ + + - +
+ + - -
+ ]
4363 : : /* shifting out */
4364 [ + + ]: 13622 : if (base64bits) { /* output remaining bits */
4365 : 13619 : *out++ = TO_BASE64(base64buffer << (6-base64bits));
4366 : 13619 : base64buffer = 0;
4367 : 13619 : base64bits = 0;
4368 : : }
4369 : 13622 : inShift = 0;
4370 : : /* Characters not in the BASE64 set implicitly unshift the sequence
4371 : : so no '-' is required, except if the character is itself a '-' */
4372 [ + + + - : 13622 : if (IS_BASE64(ch) || ch == '-') {
+ + - + +
+ + + + -
+ - + + ]
4373 : 13612 : *out++ = '-';
4374 : : }
4375 : 13622 : *out++ = (char) ch;
4376 : : }
4377 : : else {
4378 : 16032 : goto encode_char;
4379 : : }
4380 : : }
4381 : : else { /* not in a shift sequence */
4382 [ + + ]: 319956 : if (ch == '+') {
4383 : 13 : *out++ = '+';
4384 : 13 : *out++ = '-';
4385 : : }
4386 [ + + + + : 319943 : else if (ENCODE_DIRECT(ch, !base64SetO, !base64WhiteSpace)) {
+ + + - +
+ + - +
+ ]
4387 : 305351 : *out++ = (char) ch;
4388 : : }
4389 : : else {
4390 : 14592 : *out++ = '+';
4391 : 14592 : inShift = 1;
4392 : 14592 : goto encode_char;
4393 : : }
4394 : : }
4395 : 318986 : continue;
4396 : 30624 : encode_char:
4397 [ + + ]: 30624 : if (ch >= 0x10000) {
4398 : : assert(ch <= MAX_UNICODE);
4399 : :
4400 : : /* code first surrogate */
4401 : 9 : base64bits += 16;
4402 : 9 : base64buffer = (base64buffer << 16) | Py_UNICODE_HIGH_SURROGATE(ch);
4403 [ + + ]: 30 : while (base64bits >= 6) {
4404 : 21 : *out++ = TO_BASE64(base64buffer >> (base64bits-6));
4405 : 21 : base64bits -= 6;
4406 : : }
4407 : : /* prepare second surrogate */
4408 : 9 : ch = Py_UNICODE_LOW_SURROGATE(ch);
4409 : : }
4410 : 30624 : base64bits += 16;
4411 : 30624 : base64buffer = (base64buffer << 16) | ch;
4412 [ + + ]: 102575 : while (base64bits >= 6) {
4413 : 71951 : *out++ = TO_BASE64(base64buffer >> (base64bits-6));
4414 : 71951 : base64bits -= 6;
4415 : : }
4416 : : }
4417 [ + + ]: 1887 : if (base64bits)
4418 : 961 : *out++= TO_BASE64(base64buffer << (6-base64bits) );
4419 [ + + ]: 1887 : if (inShift)
4420 : 970 : *out++ = '-';
4421 [ - + ]: 1887 : if (_PyBytes_Resize(&v, out - start) < 0)
4422 : 0 : return NULL;
4423 : 1887 : return v;
4424 : : }
4425 : :
4426 : : #undef IS_BASE64
4427 : : #undef FROM_BASE64
4428 : : #undef TO_BASE64
4429 : : #undef DECODE_DIRECT
4430 : : #undef ENCODE_DIRECT
4431 : :
4432 : : /* --- UTF-8 Codec -------------------------------------------------------- */
4433 : :
4434 : : PyObject *
4435 : 34713031 : PyUnicode_DecodeUTF8(const char *s,
4436 : : Py_ssize_t size,
4437 : : const char *errors)
4438 : : {
4439 : 34713031 : return PyUnicode_DecodeUTF8Stateful(s, size, errors, NULL);
4440 : : }
4441 : :
4442 : : #include "stringlib/asciilib.h"
4443 : : #include "stringlib/codecs.h"
4444 : : #include "stringlib/undef.h"
4445 : :
4446 : : #include "stringlib/ucs1lib.h"
4447 : : #include "stringlib/codecs.h"
4448 : : #include "stringlib/undef.h"
4449 : :
4450 : : #include "stringlib/ucs2lib.h"
4451 : : #include "stringlib/codecs.h"
4452 : : #include "stringlib/undef.h"
4453 : :
4454 : : #include "stringlib/ucs4lib.h"
4455 : : #include "stringlib/codecs.h"
4456 : : #include "stringlib/undef.h"
4457 : :
4458 : : /* Mask to quickly check whether a C 'size_t' contains a
4459 : : non-ASCII, UTF8-encoded char. */
4460 : : #if (SIZEOF_SIZE_T == 8)
4461 : : # define ASCII_CHAR_MASK 0x8080808080808080ULL
4462 : : #elif (SIZEOF_SIZE_T == 4)
4463 : : # define ASCII_CHAR_MASK 0x80808080U
4464 : : #else
4465 : : # error C 'size_t' size should be either 4 or 8!
4466 : : #endif
4467 : :
4468 : : static Py_ssize_t
4469 : 78892378 : ascii_decode(const char *start, const char *end, Py_UCS1 *dest)
4470 : : {
4471 : 78892378 : const char *p = start;
4472 : :
4473 : : #if SIZEOF_SIZE_T <= SIZEOF_VOID_P
4474 : : assert(_Py_IS_ALIGNED(dest, ALIGNOF_SIZE_T));
4475 [ + + ]: 78892378 : if (_Py_IS_ALIGNED(p, ALIGNOF_SIZE_T)) {
4476 : : /* Fast path, see in STRINGLIB(utf8_decode) for
4477 : : an explanation. */
4478 : : /* Help allocation */
4479 : 44291612 : const char *_p = p;
4480 : 44291612 : Py_UCS1 * q = dest;
4481 [ + + ]: 125019254 : while (_p + SIZEOF_SIZE_T <= end) {
4482 : 80883838 : size_t value = *(const size_t *) _p;
4483 [ + + ]: 80883838 : if (value & ASCII_CHAR_MASK)
4484 : 156196 : break;
4485 : 80727642 : *((size_t *)q) = value;
4486 : 80727642 : _p += SIZEOF_SIZE_T;
4487 : 80727642 : q += SIZEOF_SIZE_T;
4488 : : }
4489 : 44291612 : p = _p;
4490 [ + + ]: 213046233 : while (p < end) {
4491 [ + + ]: 169058516 : if ((unsigned char)*p & 0x80)
4492 : 303895 : break;
4493 : 168754621 : *q++ = *p++;
4494 : : }
4495 : 44291612 : return p - start;
4496 : : }
4497 : : #endif
4498 [ + + ]: 262158292 : while (p < end) {
4499 : : /* Fast path, see in STRINGLIB(utf8_decode) in stringlib/codecs.h
4500 : : for an explanation. */
4501 [ + + ]: 229023612 : if (_Py_IS_ALIGNED(p, ALIGNOF_SIZE_T)) {
4502 : : /* Help allocation */
4503 : 28478555 : const char *_p = p;
4504 [ + + ]: 48287998 : while (_p + SIZEOF_SIZE_T <= end) {
4505 : 19815165 : size_t value = *(const size_t *) _p;
4506 [ + + ]: 19815165 : if (value & ASCII_CHAR_MASK)
4507 : 5722 : break;
4508 : 19809443 : _p += SIZEOF_SIZE_T;
4509 : : }
4510 : 28478555 : p = _p;
4511 [ + + ]: 28478555 : if (_p == end)
4512 : 1271883 : break;
4513 : : }
4514 [ + + ]: 227751729 : if ((unsigned char)*p & 0x80)
4515 : 194203 : break;
4516 : 227557526 : ++p;
4517 : : }
4518 : 34600766 : memcpy(dest, start, p - start);
4519 : 34600766 : return p - start;
4520 : : }
4521 : :
4522 : : static PyObject *
4523 : 91756904 : unicode_decode_utf8(const char *s, Py_ssize_t size,
4524 : : _Py_error_handler error_handler, const char *errors,
4525 : : Py_ssize_t *consumed)
4526 : : {
4527 [ + + ]: 91756904 : if (size == 0) {
4528 [ + + ]: 4034100 : if (consumed)
4529 : 38 : *consumed = 0;
4530 : 4034100 : _Py_RETURN_UNICODE_EMPTY();
4531 : : }
4532 : :
4533 : : /* ASCII is equivalent to the first 128 ordinals in Unicode. */
4534 [ + + + + ]: 87722804 : if (size == 1 && (unsigned char)s[0] < 128) {
4535 [ + + ]: 9110027 : if (consumed) {
4536 : 6973 : *consumed = 1;
4537 : : }
4538 : 9110027 : return get_latin1_char((unsigned char)s[0]);
4539 : : }
4540 : :
4541 : 78612777 : const char *starts = s;
4542 : 78612777 : const char *end = s + size;
4543 : :
4544 : : // fast path: try ASCII string.
4545 : 78612777 : PyObject *u = PyUnicode_New(size, 127);
4546 [ + + ]: 78612777 : if (u == NULL) {
4547 : 279 : return NULL;
4548 : : }
4549 : 78612498 : s += ascii_decode(s, end, PyUnicode_1BYTE_DATA(u));
4550 [ + + ]: 78612498 : if (s == end) {
4551 : 78114787 : return u;
4552 : : }
4553 : :
4554 : : // Use _PyUnicodeWriter after fast path is failed.
4555 : : _PyUnicodeWriter writer;
4556 : 497711 : _PyUnicodeWriter_InitWithBuffer(&writer, u);
4557 : 497711 : writer.pos = s - starts;
4558 : :
4559 : : Py_ssize_t startinpos, endinpos;
4560 : 497711 : const char *errmsg = "";
4561 : 497711 : PyObject *error_handler_obj = NULL;
4562 : 497711 : PyObject *exc = NULL;
4563 : :
4564 [ + + ]: 966327 : while (s < end) {
4565 : : Py_UCS4 ch;
4566 : 778115 : int kind = writer.kind;
4567 : :
4568 [ + + ]: 778115 : if (kind == PyUnicode_1BYTE_KIND) {
4569 [ + + ]: 586773 : if (PyUnicode_IS_ASCII(writer.buffer))
4570 : 498470 : ch = asciilib_utf8_decode(&s, end, writer.data, &writer.pos);
4571 : : else
4572 : 88303 : ch = ucs1lib_utf8_decode(&s, end, writer.data, &writer.pos);
4573 [ + + ]: 191342 : } else if (kind == PyUnicode_2BYTE_KIND) {
4574 : 165025 : ch = ucs2lib_utf8_decode(&s, end, writer.data, &writer.pos);
4575 : : } else {
4576 : : assert(kind == PyUnicode_4BYTE_KIND);
4577 : 26317 : ch = ucs4lib_utf8_decode(&s, end, writer.data, &writer.pos);
4578 : : }
4579 : :
4580 [ + + + + : 778115 : switch (ch) {
+ ]
4581 : 312513 : case 0:
4582 [ + + + + ]: 312513 : if (s == end || consumed)
4583 : 306120 : goto End;
4584 : 6393 : errmsg = "unexpected end of data";
4585 : 6393 : startinpos = s - starts;
4586 : 6393 : endinpos = end - starts;
4587 : 6393 : break;
4588 : 4882 : case 1:
4589 : 4882 : errmsg = "invalid start byte";
4590 : 4882 : startinpos = s - starts;
4591 : 4882 : endinpos = startinpos + 1;
4592 : 4882 : break;
4593 : 10988 : case 2:
4594 [ + + + + : 10988 : if (consumed && (unsigned char)s[0] == 0xED && end - s == 2
+ + ]
4595 [ + - + - ]: 4 : && (unsigned char)s[1] >= 0xA0 && (unsigned char)s[1] <= 0xBF)
4596 : : {
4597 : : /* Truncated surrogate code in range D800-DFFF */
4598 : 4 : goto End;
4599 : : }
4600 : : /* fall through */
4601 : : case 3:
4602 : : case 4:
4603 : 11850 : errmsg = "invalid continuation byte";
4604 : 11850 : startinpos = s - starts;
4605 : 11850 : endinpos = startinpos + ch - 1;
4606 : 11850 : break;
4607 : 448866 : default:
4608 [ - + ]: 448866 : if (_PyUnicodeWriter_WriteCharInline(&writer, ch) < 0)
4609 : 0 : goto onError;
4610 : 448866 : continue;
4611 : : }
4612 : :
4613 [ + + ]: 23125 : if (error_handler == _Py_ERROR_UNKNOWN)
4614 : 13437 : error_handler = _Py_GetErrorHandler(errors);
4615 : :
4616 [ + + + + ]: 23125 : switch (error_handler) {
4617 : 894 : case _Py_ERROR_IGNORE:
4618 : 894 : s += (endinpos - startinpos);
4619 : 894 : break;
4620 : :
4621 : 1286 : case _Py_ERROR_REPLACE:
4622 [ - + ]: 1286 : if (_PyUnicodeWriter_WriteCharInline(&writer, 0xfffd) < 0)
4623 : 0 : goto onError;
4624 : 1286 : s += (endinpos - startinpos);
4625 : 1286 : break;
4626 : :
4627 : 16219 : case _Py_ERROR_SURROGATEESCAPE:
4628 : : {
4629 : : Py_ssize_t i;
4630 : :
4631 [ + + - + ]: 16219 : if (_PyUnicodeWriter_PrepareKind(&writer, PyUnicode_2BYTE_KIND) < 0)
4632 : 0 : goto onError;
4633 [ + + ]: 32438 : for (i=startinpos; i<endinpos; i++) {
4634 : 16219 : ch = (Py_UCS4)(unsigned char)(starts[i]);
4635 : 16219 : PyUnicode_WRITE(writer.kind, writer.data, writer.pos,
4636 : : ch + 0xdc00);
4637 : 16219 : writer.pos++;
4638 : : }
4639 : 16219 : s += (endinpos - startinpos);
4640 : 16219 : break;
4641 : : }
4642 : :
4643 : 4726 : default:
4644 [ + + ]: 4726 : if (unicode_decode_call_errorhandler_writer(
4645 : : errors, &error_handler_obj,
4646 : : "utf-8", errmsg,
4647 : : &starts, &end, &startinpos, &endinpos, &exc, &s,
4648 : : &writer))
4649 : 3375 : goto onError;
4650 : : }
4651 : : }
4652 : :
4653 : 188212 : End:
4654 [ + + ]: 494336 : if (consumed)
4655 : 200032 : *consumed = s - starts;
4656 : :
4657 : 494336 : Py_XDECREF(error_handler_obj);
4658 : 494336 : Py_XDECREF(exc);
4659 : 494336 : return _PyUnicodeWriter_Finish(&writer);
4660 : :
4661 : 3375 : onError:
4662 : 3375 : Py_XDECREF(error_handler_obj);
4663 : 3375 : Py_XDECREF(exc);
4664 : 3375 : _PyUnicodeWriter_Dealloc(&writer);
4665 : 3375 : return NULL;
4666 : : }
4667 : :
4668 : :
4669 : : PyObject *
4670 : 90327442 : PyUnicode_DecodeUTF8Stateful(const char *s,
4671 : : Py_ssize_t size,
4672 : : const char *errors,
4673 : : Py_ssize_t *consumed)
4674 : : {
4675 : 90327442 : return unicode_decode_utf8(s, size, _Py_ERROR_UNKNOWN, errors, consumed);
4676 : : }
4677 : :
4678 : :
4679 : : /* UTF-8 decoder: use surrogateescape error handler if 'surrogateescape' is
4680 : : non-zero, use strict error handler otherwise.
4681 : :
4682 : : On success, write a pointer to a newly allocated wide character string into
4683 : : *wstr (use PyMem_RawFree() to free the memory) and write the output length
4684 : : (in number of wchar_t units) into *wlen (if wlen is set).
4685 : :
4686 : : On memory allocation failure, return -1.
4687 : :
4688 : : On decoding error (if surrogateescape is zero), return -2. If wlen is
4689 : : non-NULL, write the start of the illegal byte sequence into *wlen. If reason
4690 : : is not NULL, write the decoding error message into *reason. */
4691 : : int
4692 : 25387 : _Py_DecodeUTF8Ex(const char *s, Py_ssize_t size, wchar_t **wstr, size_t *wlen,
4693 : : const char **reason, _Py_error_handler errors)
4694 : : {
4695 : 25387 : const char *orig_s = s;
4696 : : const char *e;
4697 : : wchar_t *unicode;
4698 : : Py_ssize_t outpos;
4699 : :
4700 : 25387 : int surrogateescape = 0;
4701 : 25387 : int surrogatepass = 0;
4702 [ - + - - ]: 25387 : switch (errors)
4703 : : {
4704 : 0 : case _Py_ERROR_STRICT:
4705 : 0 : break;
4706 : 25387 : case _Py_ERROR_SURROGATEESCAPE:
4707 : 25387 : surrogateescape = 1;
4708 : 25387 : break;
4709 : 0 : case _Py_ERROR_SURROGATEPASS:
4710 : 0 : surrogatepass = 1;
4711 : 0 : break;
4712 : 0 : default:
4713 : 0 : return -3;
4714 : : }
4715 : :
4716 : : /* Note: size will always be longer than the resulting Unicode
4717 : : character count */
4718 [ - + ]: 25387 : if (PY_SSIZE_T_MAX / (Py_ssize_t)sizeof(wchar_t) - 1 < size) {
4719 : 0 : return -1;
4720 : : }
4721 : :
4722 : 25387 : unicode = PyMem_RawMalloc((size + 1) * sizeof(wchar_t));
4723 [ - + ]: 25387 : if (!unicode) {
4724 : 0 : return -1;
4725 : : }
4726 : :
4727 : : /* Unpack UTF-8 encoded data */
4728 : 25387 : e = s + size;
4729 : 25387 : outpos = 0;
4730 [ + + ]: 25437 : while (s < e) {
4731 : : Py_UCS4 ch;
4732 : : #if SIZEOF_WCHAR_T == 4
4733 : 25433 : ch = ucs4lib_utf8_decode(&s, e, (Py_UCS4 *)unicode, &outpos);
4734 : : #else
4735 : : ch = ucs2lib_utf8_decode(&s, e, (Py_UCS2 *)unicode, &outpos);
4736 : : #endif
4737 [ - + ]: 25433 : if (ch > 0xFF) {
4738 : : #if SIZEOF_WCHAR_T == 4
4739 : 0 : Py_UNREACHABLE();
4740 : : #else
4741 : : assert(ch > 0xFFFF && ch <= MAX_UNICODE);
4742 : : /* write a surrogate pair */
4743 : : unicode[outpos++] = (wchar_t)Py_UNICODE_HIGH_SURROGATE(ch);
4744 : : unicode[outpos++] = (wchar_t)Py_UNICODE_LOW_SURROGATE(ch);
4745 : : #endif
4746 : : }
4747 : : else {
4748 [ + + + - ]: 25433 : if (!ch && s == e) {
4749 : 25383 : break;
4750 : : }
4751 : :
4752 [ + - ]: 50 : if (surrogateescape) {
4753 : 50 : unicode[outpos++] = 0xDC00 + (unsigned char)*s++;
4754 : : }
4755 : : else {
4756 : : /* Is it a valid three-byte code? */
4757 [ # # ]: 0 : if (surrogatepass
4758 [ # # ]: 0 : && (e - s) >= 3
4759 [ # # ]: 0 : && (s[0] & 0xf0) == 0xe0
4760 [ # # ]: 0 : && (s[1] & 0xc0) == 0x80
4761 [ # # ]: 0 : && (s[2] & 0xc0) == 0x80)
4762 : : {
4763 : 0 : ch = ((s[0] & 0x0f) << 12) + ((s[1] & 0x3f) << 6) + (s[2] & 0x3f);
4764 : 0 : s += 3;
4765 : 0 : unicode[outpos++] = ch;
4766 : : }
4767 : : else {
4768 : 0 : PyMem_RawFree(unicode );
4769 [ # # ]: 0 : if (reason != NULL) {
4770 [ # # # ]: 0 : switch (ch) {
4771 : 0 : case 0:
4772 : 0 : *reason = "unexpected end of data";
4773 : 0 : break;
4774 : 0 : case 1:
4775 : 0 : *reason = "invalid start byte";
4776 : 0 : break;
4777 : : /* 2, 3, 4 */
4778 : 0 : default:
4779 : 0 : *reason = "invalid continuation byte";
4780 : 0 : break;
4781 : : }
4782 : : }
4783 [ # # ]: 0 : if (wlen != NULL) {
4784 : 0 : *wlen = s - orig_s;
4785 : : }
4786 : 0 : return -2;
4787 : : }
4788 : : }
4789 : : }
4790 : : }
4791 : 25387 : unicode[outpos] = L'\0';
4792 [ + - ]: 25387 : if (wlen) {
4793 : 25387 : *wlen = outpos;
4794 : : }
4795 : 25387 : *wstr = unicode;
4796 : 25387 : return 0;
4797 : : }
4798 : :
4799 : :
4800 : : wchar_t*
4801 : 3193 : _Py_DecodeUTF8_surrogateescape(const char *arg, Py_ssize_t arglen,
4802 : : size_t *wlen)
4803 : : {
4804 : : wchar_t *wstr;
4805 : 3193 : int res = _Py_DecodeUTF8Ex(arg, arglen,
4806 : : &wstr, wlen,
4807 : : NULL, _Py_ERROR_SURROGATEESCAPE);
4808 [ - + ]: 3193 : if (res != 0) {
4809 : : /* _Py_DecodeUTF8Ex() must support _Py_ERROR_SURROGATEESCAPE */
4810 : : assert(res != -3);
4811 [ # # ]: 0 : if (wlen) {
4812 : 0 : *wlen = (size_t)res;
4813 : : }
4814 : 0 : return NULL;
4815 : : }
4816 : 3193 : return wstr;
4817 : : }
4818 : :
4819 : :
4820 : : /* UTF-8 encoder using the surrogateescape error handler .
4821 : :
4822 : : On success, return 0 and write the newly allocated character string (use
4823 : : PyMem_Free() to free the memory) into *str.
4824 : :
4825 : : On encoding failure, return -2 and write the position of the invalid
4826 : : surrogate character into *error_pos (if error_pos is set) and the decoding
4827 : : error message into *reason (if reason is set).
4828 : :
4829 : : On memory allocation failure, return -1. */
4830 : : int
4831 : 14851 : _Py_EncodeUTF8Ex(const wchar_t *text, char **str, size_t *error_pos,
4832 : : const char **reason, int raw_malloc, _Py_error_handler errors)
4833 : : {
4834 : 14851 : const Py_ssize_t max_char_size = 4;
4835 : 14851 : Py_ssize_t len = wcslen(text);
4836 : :
4837 : : assert(len >= 0);
4838 : :
4839 : 14851 : int surrogateescape = 0;
4840 : 14851 : int surrogatepass = 0;
4841 [ + + - - ]: 14851 : switch (errors)
4842 : : {
4843 : 12536 : case _Py_ERROR_STRICT:
4844 : 12536 : break;
4845 : 2315 : case _Py_ERROR_SURROGATEESCAPE:
4846 : 2315 : surrogateescape = 1;
4847 : 2315 : break;
4848 : 0 : case _Py_ERROR_SURROGATEPASS:
4849 : 0 : surrogatepass = 1;
4850 : 0 : break;
4851 : 0 : default:
4852 : 0 : return -3;
4853 : : }
4854 : :
4855 [ - + ]: 14851 : if (len > PY_SSIZE_T_MAX / max_char_size - 1) {
4856 : 0 : return -1;
4857 : : }
4858 : : char *bytes;
4859 [ + - ]: 14851 : if (raw_malloc) {
4860 : 14851 : bytes = PyMem_RawMalloc((len + 1) * max_char_size);
4861 : : }
4862 : : else {
4863 : 0 : bytes = PyMem_Malloc((len + 1) * max_char_size);
4864 : : }
4865 [ - + ]: 14851 : if (bytes == NULL) {
4866 : 0 : return -1;
4867 : : }
4868 : :
4869 : 14851 : char *p = bytes;
4870 : : Py_ssize_t i;
4871 [ + + ]: 229027 : for (i = 0; i < len; ) {
4872 : 214176 : Py_ssize_t ch_pos = i;
4873 : 214176 : Py_UCS4 ch = text[i];
4874 : 214176 : i++;
4875 : : #if Py_UNICODE_SIZE == 2
4876 : : if (Py_UNICODE_IS_HIGH_SURROGATE(ch)
4877 : : && i < len
4878 : : && Py_UNICODE_IS_LOW_SURROGATE(text[i]))
4879 : : {
4880 : : ch = Py_UNICODE_JOIN_SURROGATES(ch, text[i]);
4881 : : i++;
4882 : : }
4883 : : #endif
4884 : :
4885 [ + - ]: 214176 : if (ch < 0x80) {
4886 : : /* Encode ASCII */
4887 : 214176 : *p++ = (char) ch;
4888 : :
4889 : : }
4890 [ # # ]: 0 : else if (ch < 0x0800) {
4891 : : /* Encode Latin-1 */
4892 : 0 : *p++ = (char)(0xc0 | (ch >> 6));
4893 : 0 : *p++ = (char)(0x80 | (ch & 0x3f));
4894 : : }
4895 [ # # # # ]: 0 : else if (Py_UNICODE_IS_SURROGATE(ch) && !surrogatepass) {
4896 : : /* surrogateescape error handler */
4897 [ # # # # : 0 : if (!surrogateescape || !(0xDC80 <= ch && ch <= 0xDCFF)) {
# # ]
4898 [ # # ]: 0 : if (error_pos != NULL) {
4899 : 0 : *error_pos = (size_t)ch_pos;
4900 : : }
4901 [ # # ]: 0 : if (reason != NULL) {
4902 : 0 : *reason = "encoding error";
4903 : : }
4904 [ # # ]: 0 : if (raw_malloc) {
4905 : 0 : PyMem_RawFree(bytes);
4906 : : }
4907 : : else {
4908 : 0 : PyMem_Free(bytes);
4909 : : }
4910 : 0 : return -2;
4911 : : }
4912 : 0 : *p++ = (char)(ch & 0xff);
4913 : : }
4914 [ # # ]: 0 : else if (ch < 0x10000) {
4915 : 0 : *p++ = (char)(0xe0 | (ch >> 12));
4916 : 0 : *p++ = (char)(0x80 | ((ch >> 6) & 0x3f));
4917 : 0 : *p++ = (char)(0x80 | (ch & 0x3f));
4918 : : }
4919 : : else { /* ch >= 0x10000 */
4920 : : assert(ch <= MAX_UNICODE);
4921 : : /* Encode UCS4 Unicode ordinals */
4922 : 0 : *p++ = (char)(0xf0 | (ch >> 18));
4923 : 0 : *p++ = (char)(0x80 | ((ch >> 12) & 0x3f));
4924 : 0 : *p++ = (char)(0x80 | ((ch >> 6) & 0x3f));
4925 : 0 : *p++ = (char)(0x80 | (ch & 0x3f));
4926 : : }
4927 : : }
4928 : 14851 : *p++ = '\0';
4929 : :
4930 : 14851 : size_t final_size = (p - bytes);
4931 : : char *bytes2;
4932 [ + - ]: 14851 : if (raw_malloc) {
4933 : 14851 : bytes2 = PyMem_RawRealloc(bytes, final_size);
4934 : : }
4935 : : else {
4936 : 0 : bytes2 = PyMem_Realloc(bytes, final_size);
4937 : : }
4938 [ - + ]: 14851 : if (bytes2 == NULL) {
4939 [ # # ]: 0 : if (error_pos != NULL) {
4940 : 0 : *error_pos = (size_t)-1;
4941 : : }
4942 [ # # ]: 0 : if (raw_malloc) {
4943 : 0 : PyMem_RawFree(bytes);
4944 : : }
4945 : : else {
4946 : 0 : PyMem_Free(bytes);
4947 : : }
4948 : 0 : return -1;
4949 : : }
4950 : 14851 : *str = bytes2;
4951 : 14851 : return 0;
4952 : : }
4953 : :
4954 : :
4955 : : /* Primary internal function which creates utf8 encoded bytes objects.
4956 : :
4957 : : Allocation strategy: if the string is short, convert into a stack buffer
4958 : : and allocate exactly as much space needed at the end. Else allocate the
4959 : : maximum possible needed (4 result bytes per Unicode character), and return
4960 : : the excess memory at the end.
4961 : : */
4962 : : static PyObject *
4963 : 4879167 : unicode_encode_utf8(PyObject *unicode, _Py_error_handler error_handler,
4964 : : const char *errors)
4965 : : {
4966 [ - + ]: 4879167 : if (!PyUnicode_Check(unicode)) {
4967 : 0 : PyErr_BadArgument();
4968 : 0 : return NULL;
4969 : : }
4970 : :
4971 [ + + + + ]: 4879167 : if (PyUnicode_UTF8(unicode))
4972 [ + + + + ]: 3383928 : return PyBytes_FromStringAndSize(PyUnicode_UTF8(unicode),
4973 : 3383928 : PyUnicode_UTF8_LENGTH(unicode));
4974 : :
4975 : 1495239 : int kind = PyUnicode_KIND(unicode);
4976 : 1495239 : const void *data = PyUnicode_DATA(unicode);
4977 : 1495239 : Py_ssize_t size = PyUnicode_GET_LENGTH(unicode);
4978 : :
4979 : : _PyBytesWriter writer;
4980 : : char *end;
4981 : :
4982 [ - + + + ]: 1495239 : switch (kind) {
4983 : 0 : default:
4984 : 0 : Py_UNREACHABLE();
4985 : 184917 : case PyUnicode_1BYTE_KIND:
4986 : : /* the string cannot be ASCII, or PyUnicode_UTF8() would be set */
4987 : : assert(!PyUnicode_IS_ASCII(unicode));
4988 : 184917 : end = ucs1lib_utf8_encoder(&writer, unicode, data, size, error_handler, errors);
4989 : 184917 : break;
4990 : 246857 : case PyUnicode_2BYTE_KIND:
4991 : 246857 : end = ucs2lib_utf8_encoder(&writer, unicode, data, size, error_handler, errors);
4992 : 246857 : break;
4993 : 1063465 : case PyUnicode_4BYTE_KIND:
4994 : 1063465 : end = ucs4lib_utf8_encoder(&writer, unicode, data, size, error_handler, errors);
4995 : 1063465 : break;
4996 : : }
4997 : :
4998 [ + + ]: 1495239 : if (end == NULL) {
4999 : 312 : _PyBytesWriter_Dealloc(&writer);
5000 : 312 : return NULL;
5001 : : }
5002 : 1494927 : return _PyBytesWriter_Finish(&writer, end);
5003 : : }
5004 : :
5005 : : static int
5006 : 4537 : unicode_fill_utf8(PyObject *unicode)
5007 : : {
5008 : : /* the string cannot be ASCII, or PyUnicode_UTF8() would be set */
5009 : : assert(!PyUnicode_IS_ASCII(unicode));
5010 : :
5011 : 4537 : int kind = PyUnicode_KIND(unicode);
5012 : 4537 : const void *data = PyUnicode_DATA(unicode);
5013 : 4537 : Py_ssize_t size = PyUnicode_GET_LENGTH(unicode);
5014 : :
5015 : : _PyBytesWriter writer;
5016 : : char *end;
5017 : :
5018 [ - + + + ]: 4537 : switch (kind) {
5019 : 0 : default:
5020 : 0 : Py_UNREACHABLE();
5021 : 3470 : case PyUnicode_1BYTE_KIND:
5022 : 3470 : end = ucs1lib_utf8_encoder(&writer, unicode, data, size,
5023 : : _Py_ERROR_STRICT, NULL);
5024 : 3470 : break;
5025 : 956 : case PyUnicode_2BYTE_KIND:
5026 : 956 : end = ucs2lib_utf8_encoder(&writer, unicode, data, size,
5027 : : _Py_ERROR_STRICT, NULL);
5028 : 956 : break;
5029 : 111 : case PyUnicode_4BYTE_KIND:
5030 : 111 : end = ucs4lib_utf8_encoder(&writer, unicode, data, size,
5031 : : _Py_ERROR_STRICT, NULL);
5032 : 111 : break;
5033 : : }
5034 [ + + ]: 4537 : if (end == NULL) {
5035 : 70 : _PyBytesWriter_Dealloc(&writer);
5036 : 70 : return -1;
5037 : : }
5038 : :
5039 [ + + ]: 4467 : const char *start = writer.use_small_buffer ? writer.small_buffer :
5040 : 1013 : PyBytes_AS_STRING(writer.buffer);
5041 : 4467 : Py_ssize_t len = end - start;
5042 : :
5043 : 4467 : char *cache = PyObject_Malloc(len + 1);
5044 [ - + ]: 4467 : if (cache == NULL) {
5045 : 0 : _PyBytesWriter_Dealloc(&writer);
5046 : : PyErr_NoMemory();
5047 : 0 : return -1;
5048 : : }
5049 : 4467 : _PyUnicode_UTF8(unicode) = cache;
5050 : 4467 : _PyUnicode_UTF8_LENGTH(unicode) = len;
5051 : 4467 : memcpy(cache, start, len);
5052 : 4467 : cache[len] = '\0';
5053 : 4467 : _PyBytesWriter_Dealloc(&writer);
5054 : 4467 : return 0;
5055 : : }
5056 : :
5057 : : PyObject *
5058 : 2824690 : _PyUnicode_AsUTF8String(PyObject *unicode, const char *errors)
5059 : : {
5060 : 2824690 : return unicode_encode_utf8(unicode, _Py_ERROR_UNKNOWN, errors);
5061 : : }
5062 : :
5063 : :
5064 : : PyObject *
5065 : 42250 : PyUnicode_AsUTF8String(PyObject *unicode)
5066 : : {
5067 : 42250 : return _PyUnicode_AsUTF8String(unicode, NULL);
5068 : : }
5069 : :
5070 : : /* --- UTF-32 Codec ------------------------------------------------------- */
5071 : :
5072 : : PyObject *
5073 : 34 : PyUnicode_DecodeUTF32(const char *s,
5074 : : Py_ssize_t size,
5075 : : const char *errors,
5076 : : int *byteorder)
5077 : : {
5078 : 34 : return PyUnicode_DecodeUTF32Stateful(s, size, errors, byteorder, NULL);
5079 : : }
5080 : :
5081 : : PyObject *
5082 : 57996 : PyUnicode_DecodeUTF32Stateful(const char *s,
5083 : : Py_ssize_t size,
5084 : : const char *errors,
5085 : : int *byteorder,
5086 : : Py_ssize_t *consumed)
5087 : : {
5088 : 57996 : const char *starts = s;
5089 : : Py_ssize_t startinpos;
5090 : : Py_ssize_t endinpos;
5091 : : _PyUnicodeWriter writer;
5092 : : const unsigned char *q, *e;
5093 : 57996 : int le, bo = 0; /* assume native ordering by default */
5094 : : const char *encoding;
5095 : 57996 : const char *errmsg = "";
5096 : 57996 : PyObject *errorHandler = NULL;
5097 : 57996 : PyObject *exc = NULL;
5098 : :
5099 : 57996 : q = (const unsigned char *)s;
5100 : 57996 : e = q + size;
5101 : :
5102 [ + + ]: 57996 : if (byteorder)
5103 : 57963 : bo = *byteorder;
5104 : :
5105 : : /* Check for BOM marks (U+FEFF) in the input and adjust current
5106 : : byte order setting accordingly. In native mode, the leading BOM
5107 : : mark is skipped, in all other modes, it is copied to the output
5108 : : stream as-is (giving a ZWNBSP character). */
5109 [ + + + + ]: 57996 : if (bo == 0 && size >= 4) {
5110 : 977 : Py_UCS4 bom = ((unsigned int)q[3] << 24) | (q[2] << 16) | (q[1] << 8) | q[0];
5111 [ + + ]: 977 : if (bom == 0x0000FEFF) {
5112 : 935 : bo = -1;
5113 : 935 : q += 4;
5114 : : }
5115 [ + + ]: 42 : else if (bom == 0xFFFE0000) {
5116 : 40 : bo = 1;
5117 : 40 : q += 4;
5118 : : }
5119 [ + + ]: 977 : if (byteorder)
5120 : 947 : *byteorder = bo;
5121 : : }
5122 : :
5123 [ + + ]: 57996 : if (q == e) {
5124 [ + + ]: 1142 : if (consumed)
5125 : 51 : *consumed = size;
5126 : 1142 : _Py_RETURN_UNICODE_EMPTY();
5127 : : }
5128 : :
5129 : : #ifdef WORDS_BIGENDIAN
5130 : : le = bo < 0;
5131 : : #else
5132 : 56854 : le = bo <= 0;
5133 : : #endif
5134 [ + + ]: 56854 : encoding = le ? "utf-32-le" : "utf-32-be";
5135 : :
5136 : 56854 : _PyUnicodeWriter_Init(&writer);
5137 : 56854 : writer.min_length = (e - q + 3) / 4;
5138 [ - + - - : 56854 : if (_PyUnicodeWriter_Prepare(&writer, writer.min_length, 127) == -1)
- + + - ]
5139 : 0 : goto onError;
5140 : :
5141 : 4955 : while (1) {
5142 : 61809 : Py_UCS4 ch = 0;
5143 : 61809 : Py_UCS4 maxch = PyUnicode_MAX_CHAR_VALUE(writer.buffer);
5144 : :
5145 [ + + ]: 61809 : if (e - q >= 4) {
5146 : 57042 : int kind = writer.kind;
5147 : 57042 : void *data = writer.data;
5148 : 57042 : const unsigned char *last = e - 4;
5149 : 57042 : Py_ssize_t pos = writer.pos;
5150 [ + + ]: 57042 : if (le) {
5151 : : do {
5152 : 600426 : ch = ((unsigned int)q[3] << 24) | (q[2] << 16) | (q[1] << 8) | q[0];
5153 [ + + ]: 600426 : if (ch > maxch)
5154 : 3265 : break;
5155 [ + + + + ]: 634421 : if (kind != PyUnicode_1BYTE_KIND &&
5156 : 37260 : Py_UNICODE_IS_SURROGATE(ch))
5157 : 10 : break;
5158 : 597151 : PyUnicode_WRITE(kind, data, pos++, ch);
5159 : 597151 : q += 4;
5160 [ + + ]: 597151 : } while (q <= last);
5161 : : }
5162 : : else {
5163 : : do {
5164 : 301597 : ch = ((unsigned int)q[0] << 24) | (q[1] << 16) | (q[2] << 8) | q[3];
5165 [ + + ]: 301597 : if (ch > maxch)
5166 : 1682 : break;
5167 [ + + + + ]: 319891 : if (kind != PyUnicode_1BYTE_KIND &&
5168 : 19976 : Py_UNICODE_IS_SURROGATE(ch))
5169 : 5 : break;
5170 : 299910 : PyUnicode_WRITE(kind, data, pos++, ch);
5171 : 299910 : q += 4;
5172 [ + + ]: 299910 : } while (q <= last);
5173 : : }
5174 : 57042 : writer.pos = pos;
5175 : : }
5176 : :
5177 [ + + ]: 61809 : if (Py_UNICODE_IS_SURROGATE(ch)) {
5178 : 122 : errmsg = "code point in surrogate code point range(0xd800, 0xe000)";
5179 : 122 : startinpos = ((const char *)q) - starts;
5180 : 122 : endinpos = startinpos + 4;
5181 : : }
5182 [ + + ]: 61687 : else if (ch <= maxch) {
5183 [ + + + + ]: 56847 : if (q == e || consumed)
5184 : : break;
5185 : : /* remaining bytes at the end? (size should be divisible by 4) */
5186 : 8 : errmsg = "truncated data";
5187 : 8 : startinpos = ((const char *)q) - starts;
5188 : 8 : endinpos = ((const char *)e) - starts;
5189 : : }
5190 : : else {
5191 [ + + ]: 4840 : if (ch < 0x110000) {
5192 [ - + ]: 4832 : if (_PyUnicodeWriter_WriteCharInline(&writer, ch) < 0)
5193 : 0 : goto onError;
5194 : 4832 : q += 4;
5195 : 4832 : continue;
5196 : : }
5197 : 8 : errmsg = "code point not in range(0x110000)";
5198 : 8 : startinpos = ((const char *)q) - starts;
5199 : 8 : endinpos = startinpos + 4;
5200 : : }
5201 : :
5202 : : /* The remaining input chars are ignored if the callback
5203 : : chooses to skip the input */
5204 [ + + ]: 138 : if (unicode_decode_call_errorhandler_writer(
5205 : : errors, &errorHandler,
5206 : : encoding, errmsg,
5207 : : &starts, (const char **)&e, &startinpos, &endinpos, &exc, (const char **)&q,
5208 : : &writer))
5209 : 15 : goto onError;
5210 : : }
5211 : :
5212 [ + + ]: 56839 : if (consumed)
5213 : 56657 : *consumed = (const char *)q-starts;
5214 : :
5215 : 56839 : Py_XDECREF(errorHandler);
5216 : 56839 : Py_XDECREF(exc);
5217 : 56839 : return _PyUnicodeWriter_Finish(&writer);
5218 : :
5219 : 15 : onError:
5220 : 15 : _PyUnicodeWriter_Dealloc(&writer);
5221 : 15 : Py_XDECREF(errorHandler);
5222 : 15 : Py_XDECREF(exc);
5223 : 15 : return NULL;
5224 : : }
5225 : :
5226 : : PyObject *
5227 : 2457 : _PyUnicode_EncodeUTF32(PyObject *str,
5228 : : const char *errors,
5229 : : int byteorder)
5230 : : {
5231 : : int kind;
5232 : : const void *data;
5233 : : Py_ssize_t len;
5234 : : PyObject *v;
5235 : : uint32_t *out;
5236 : : #if PY_LITTLE_ENDIAN
5237 : 2457 : int native_ordering = byteorder <= 0;
5238 : : #else
5239 : : int native_ordering = byteorder >= 0;
5240 : : #endif
5241 : : const char *encoding;
5242 : : Py_ssize_t nsize, pos;
5243 : 2457 : PyObject *errorHandler = NULL;
5244 : 2457 : PyObject *exc = NULL;
5245 : 2457 : PyObject *rep = NULL;
5246 : :
5247 [ - + ]: 2457 : if (!PyUnicode_Check(str)) {
5248 : 0 : PyErr_BadArgument();
5249 : 0 : return NULL;
5250 : : }
5251 : 2457 : kind = PyUnicode_KIND(str);
5252 : 2457 : data = PyUnicode_DATA(str);
5253 : 2457 : len = PyUnicode_GET_LENGTH(str);
5254 : :
5255 [ + + - + ]: 2457 : if (len > PY_SSIZE_T_MAX / 4 - (byteorder == 0))
5256 : : return PyErr_NoMemory();
5257 : 2457 : nsize = len + (byteorder == 0);
5258 : 2457 : v = PyBytes_FromStringAndSize(NULL, nsize * 4);
5259 [ - + ]: 2457 : if (v == NULL)
5260 : 0 : return NULL;
5261 : :
5262 : : /* output buffer is 4-bytes aligned */
5263 : : assert(_Py_IS_ALIGNED(PyBytes_AS_STRING(v), 4));
5264 : 2457 : out = (uint32_t *)PyBytes_AS_STRING(v);
5265 [ + + ]: 2457 : if (byteorder == 0)
5266 : 806 : *out++ = 0xFEFF;
5267 [ + + ]: 2457 : if (len == 0)
5268 : 5 : goto done;
5269 : :
5270 [ + + ]: 2452 : if (byteorder == -1)
5271 : 868 : encoding = "utf-32-le";
5272 [ + + ]: 1584 : else if (byteorder == 1)
5273 : 779 : encoding = "utf-32-be";
5274 : : else
5275 : 805 : encoding = "utf-32";
5276 : :
5277 [ + + ]: 2452 : if (kind == PyUnicode_1BYTE_KIND) {
5278 : 1816 : ucs1lib_utf32_encode((const Py_UCS1 *)data, len, &out, native_ordering);
5279 : 1816 : goto done;
5280 : : }
5281 : :
5282 : 636 : pos = 0;
5283 [ + + ]: 731 : while (pos < len) {
5284 : : Py_ssize_t newpos, repsize, moreunits;
5285 : :
5286 [ + + ]: 724 : if (kind == PyUnicode_2BYTE_KIND) {
5287 : 690 : pos += ucs2lib_utf32_encode((const Py_UCS2 *)data + pos, len - pos,
5288 : : &out, native_ordering);
5289 : : }
5290 : : else {
5291 : : assert(kind == PyUnicode_4BYTE_KIND);
5292 : 34 : pos += ucs4lib_utf32_encode((const Py_UCS4 *)data + pos, len - pos,
5293 : : &out, native_ordering);
5294 : : }
5295 [ + + ]: 724 : if (pos == len)
5296 : 615 : break;
5297 : :
5298 : 109 : rep = unicode_encode_call_errorhandler(
5299 : : errors, &errorHandler,
5300 : : encoding, "surrogates not allowed",
5301 : : str, &exc, pos, pos + 1, &newpos);
5302 [ + + ]: 109 : if (!rep)
5303 : 14 : goto error;
5304 : :
5305 [ + + ]: 106 : if (PyBytes_Check(rep)) {
5306 : 25 : repsize = PyBytes_GET_SIZE(rep);
5307 [ + + ]: 25 : if (repsize & 3) {
5308 : 8 : raise_encode_exception(&exc, encoding,
5309 : : str, pos, pos + 1,
5310 : : "surrogates not allowed");
5311 : 8 : goto error;
5312 : : }
5313 : 17 : moreunits = repsize / 4;
5314 : : }
5315 : : else {
5316 : : assert(PyUnicode_Check(rep));
5317 : 81 : moreunits = repsize = PyUnicode_GET_LENGTH(rep);
5318 [ + + ]: 81 : if (!PyUnicode_IS_ASCII(rep)) {
5319 : 3 : raise_encode_exception(&exc, encoding,
5320 : : str, pos, pos + 1,
5321 : : "surrogates not allowed");
5322 : 3 : goto error;
5323 : : }
5324 : : }
5325 : 95 : moreunits += pos - newpos;
5326 : 95 : pos = newpos;
5327 : :
5328 : : /* four bytes are reserved for each surrogate */
5329 [ + + ]: 95 : if (moreunits > 0) {
5330 : 59 : Py_ssize_t outpos = out - (uint32_t*) PyBytes_AS_STRING(v);
5331 [ - + ]: 59 : if (moreunits >= (PY_SSIZE_T_MAX - PyBytes_GET_SIZE(v)) / 4) {
5332 : : /* integer overflow */
5333 : : PyErr_NoMemory();
5334 : 0 : goto error;
5335 : : }
5336 [ - + ]: 59 : if (_PyBytes_Resize(&v, PyBytes_GET_SIZE(v) + 4 * moreunits) < 0)
5337 : 0 : goto error;
5338 : 59 : out = (uint32_t*) PyBytes_AS_STRING(v) + outpos;
5339 : : }
5340 : :
5341 [ + + ]: 95 : if (PyBytes_Check(rep)) {
5342 : 17 : memcpy(out, PyBytes_AS_STRING(rep), repsize);
5343 : 17 : out += repsize / 4;
5344 : : } else /* rep is unicode */ {
5345 : : assert(PyUnicode_KIND(rep) == PyUnicode_1BYTE_KIND);
5346 : 78 : ucs1lib_utf32_encode(PyUnicode_1BYTE_DATA(rep), repsize,
5347 : : &out, native_ordering);
5348 : : }
5349 : :
5350 [ + - ]: 95 : Py_CLEAR(rep);
5351 : : }
5352 : :
5353 : : /* Cut back to size actually needed. This is necessary for, for example,
5354 : : encoding of a string containing isolated surrogates and the 'ignore'
5355 : : handler is used. */
5356 : 622 : nsize = (unsigned char*) out - (unsigned char*) PyBytes_AS_STRING(v);
5357 [ + + ]: 622 : if (nsize != PyBytes_GET_SIZE(v))
5358 : 6 : _PyBytes_Resize(&v, nsize);
5359 : 622 : Py_XDECREF(errorHandler);
5360 : 622 : Py_XDECREF(exc);
5361 : 2443 : done:
5362 : 2443 : return v;
5363 : 14 : error:
5364 : 14 : Py_XDECREF(rep);
5365 : 14 : Py_XDECREF(errorHandler);
5366 : 14 : Py_XDECREF(exc);
5367 : 14 : Py_XDECREF(v);
5368 : 14 : return NULL;
5369 : : }
5370 : :
5371 : : PyObject *
5372 : 0 : PyUnicode_AsUTF32String(PyObject *unicode)
5373 : : {
5374 : 0 : return _PyUnicode_EncodeUTF32(unicode, NULL, 0);
5375 : : }
5376 : :
5377 : : /* --- UTF-16 Codec ------------------------------------------------------- */
5378 : :
5379 : : PyObject *
5380 : 1065 : PyUnicode_DecodeUTF16(const char *s,
5381 : : Py_ssize_t size,
5382 : : const char *errors,
5383 : : int *byteorder)
5384 : : {
5385 : 1065 : return PyUnicode_DecodeUTF16Stateful(s, size, errors, byteorder, NULL);
5386 : : }
5387 : :
5388 : : PyObject *
5389 : 33856 : PyUnicode_DecodeUTF16Stateful(const char *s,
5390 : : Py_ssize_t size,
5391 : : const char *errors,
5392 : : int *byteorder,
5393 : : Py_ssize_t *consumed)
5394 : : {
5395 : 33856 : const char *starts = s;
5396 : : Py_ssize_t startinpos;
5397 : : Py_ssize_t endinpos;
5398 : : _PyUnicodeWriter writer;
5399 : : const unsigned char *q, *e;
5400 : 33856 : int bo = 0; /* assume native ordering by default */
5401 : : int native_ordering;
5402 : 33856 : const char *errmsg = "";
5403 : 33856 : PyObject *errorHandler = NULL;
5404 : 33856 : PyObject *exc = NULL;
5405 : : const char *encoding;
5406 : :
5407 : 33856 : q = (const unsigned char *)s;
5408 : 33856 : e = q + size;
5409 : :
5410 [ + + ]: 33856 : if (byteorder)
5411 : 32793 : bo = *byteorder;
5412 : :
5413 : : /* Check for BOM marks (U+FEFF) in the input and adjust current
5414 : : byte order setting accordingly. In native mode, the leading BOM
5415 : : mark is skipped, in all other modes, it is copied to the output
5416 : : stream as-is (giving a ZWNBSP character). */
5417 [ + + + + ]: 33856 : if (bo == 0 && size >= 2) {
5418 : 2000 : const Py_UCS4 bom = (q[1] << 8) | q[0];
5419 [ + + ]: 2000 : if (bom == 0xFEFF) {
5420 : 1977 : q += 2;
5421 : 1977 : bo = -1;
5422 : : }
5423 [ + + ]: 23 : else if (bom == 0xFFFE) {
5424 : 21 : q += 2;
5425 : 21 : bo = 1;
5426 : : }
5427 [ + + ]: 2000 : if (byteorder)
5428 : 940 : *byteorder = bo;
5429 : : }
5430 : :
5431 [ + + ]: 33856 : if (q == e) {
5432 [ + + ]: 1190 : if (consumed)
5433 : 72 : *consumed = size;
5434 : 1190 : _Py_RETURN_UNICODE_EMPTY();
5435 : : }
5436 : :
5437 : : #if PY_LITTLE_ENDIAN
5438 : 32666 : native_ordering = bo <= 0;
5439 [ + + ]: 32666 : encoding = bo <= 0 ? "utf-16-le" : "utf-16-be";
5440 : : #else
5441 : : native_ordering = bo >= 0;
5442 : : encoding = bo >= 0 ? "utf-16-be" : "utf-16-le";
5443 : : #endif
5444 : :
5445 : : /* Note: size will always be longer than the resulting Unicode
5446 : : character count normally. Error handler will take care of
5447 : : resizing when needed. */
5448 : 32666 : _PyUnicodeWriter_Init(&writer);
5449 : 32666 : writer.min_length = (e - q + 1) / 2;
5450 [ - + - - : 32666 : if (_PyUnicodeWriter_Prepare(&writer, writer.min_length, 127) == -1)
- + + - ]
5451 : 0 : goto onError;
5452 : :
5453 : 7106 : while (1) {
5454 : 39772 : Py_UCS4 ch = 0;
5455 [ + + ]: 39772 : if (e - q >= 2) {
5456 : 35617 : int kind = writer.kind;
5457 [ + + ]: 35617 : if (kind == PyUnicode_1BYTE_KIND) {
5458 [ + + ]: 31487 : if (PyUnicode_IS_ASCII(writer.buffer))
5459 : 31469 : ch = asciilib_utf16_decode(&q, e,
5460 : 31469 : (Py_UCS1*)writer.data, &writer.pos,
5461 : : native_ordering);
5462 : : else
5463 : 18 : ch = ucs1lib_utf16_decode(&q, e,
5464 : 18 : (Py_UCS1*)writer.data, &writer.pos,
5465 : : native_ordering);
5466 [ + + ]: 4130 : } else if (kind == PyUnicode_2BYTE_KIND) {
5467 : 4092 : ch = ucs2lib_utf16_decode(&q, e,
5468 : 4092 : (Py_UCS2*)writer.data, &writer.pos,
5469 : : native_ordering);
5470 : : } else {
5471 : : assert(kind == PyUnicode_4BYTE_KIND);
5472 : 38 : ch = ucs4lib_utf16_decode(&q, e,
5473 : 38 : (Py_UCS4*)writer.data, &writer.pos,
5474 : : native_ordering);
5475 : : }
5476 : : }
5477 : :
5478 [ + + + + : 39772 : switch (ch)
+ ]
5479 : : {
5480 : 32628 : case 0:
5481 : : /* remaining byte at the end? (size should be even) */
5482 [ + + + + ]: 32628 : if (q == e || consumed)
5483 : 32609 : goto End;
5484 : 19 : errmsg = "truncated data";
5485 : 19 : startinpos = ((const char *)q) - starts;
5486 : 19 : endinpos = ((const char *)e) - starts;
5487 : 19 : break;
5488 : : /* The remaining input chars are ignored if the callback
5489 : : chooses to skip the input */
5490 : 44 : case 1:
5491 : 44 : q -= 2;
5492 [ + + ]: 44 : if (consumed)
5493 : 30 : goto End;
5494 : 14 : errmsg = "unexpected end of data";
5495 : 14 : startinpos = ((const char *)q) - starts;
5496 : 14 : endinpos = ((const char *)e) - starts;
5497 : 14 : break;
5498 : 105 : case 2:
5499 : 105 : errmsg = "illegal encoding";
5500 : 105 : startinpos = ((const char *)q) - 2 - starts;
5501 : 105 : endinpos = startinpos + 2;
5502 : 105 : break;
5503 : 12 : case 3:
5504 : 12 : errmsg = "illegal UTF-16 surrogate";
5505 : 12 : startinpos = ((const char *)q) - 4 - starts;
5506 : 12 : endinpos = startinpos + 2;
5507 : 12 : break;
5508 : 6983 : default:
5509 [ - + ]: 6983 : if (_PyUnicodeWriter_WriteCharInline(&writer, ch) < 0)
5510 : 0 : goto onError;
5511 : 6983 : continue;
5512 : : }
5513 : :
5514 [ + + ]: 150 : if (unicode_decode_call_errorhandler_writer(
5515 : : errors,
5516 : : &errorHandler,
5517 : : encoding, errmsg,
5518 : : &starts,
5519 : : (const char **)&e,
5520 : : &startinpos,
5521 : : &endinpos,
5522 : : &exc,
5523 : : (const char **)&q,
5524 : : &writer))
5525 : 27 : goto onError;
5526 : : }
5527 : :
5528 : 32639 : End:
5529 [ + + ]: 32639 : if (consumed)
5530 : 29336 : *consumed = (const char *)q-starts;
5531 : :
5532 : 32639 : Py_XDECREF(errorHandler);
5533 : 32639 : Py_XDECREF(exc);
5534 : 32639 : return _PyUnicodeWriter_Finish(&writer);
5535 : :
5536 : 27 : onError:
5537 : 27 : _PyUnicodeWriter_Dealloc(&writer);
5538 : 27 : Py_XDECREF(errorHandler);
5539 : 27 : Py_XDECREF(exc);
5540 : 27 : return NULL;
5541 : : }
5542 : :
5543 : : PyObject *
5544 : 5836 : _PyUnicode_EncodeUTF16(PyObject *str,
5545 : : const char *errors,
5546 : : int byteorder)
5547 : : {
5548 : : int kind;
5549 : : const void *data;
5550 : : Py_ssize_t len;
5551 : : PyObject *v;
5552 : : unsigned short *out;
5553 : : Py_ssize_t pairs;
5554 : : #if PY_BIG_ENDIAN
5555 : : int native_ordering = byteorder >= 0;
5556 : : #else
5557 : 5836 : int native_ordering = byteorder <= 0;
5558 : : #endif
5559 : : const char *encoding;
5560 : : Py_ssize_t nsize, pos;
5561 : 5836 : PyObject *errorHandler = NULL;
5562 : 5836 : PyObject *exc = NULL;
5563 : 5836 : PyObject *rep = NULL;
5564 : :
5565 [ - + ]: 5836 : if (!PyUnicode_Check(str)) {
5566 : 0 : PyErr_BadArgument();
5567 : 0 : return NULL;
5568 : : }
5569 : 5836 : kind = PyUnicode_KIND(str);
5570 : 5836 : data = PyUnicode_DATA(str);
5571 : 5836 : len = PyUnicode_GET_LENGTH(str);
5572 : :
5573 : 5836 : pairs = 0;
5574 [ + + ]: 5836 : if (kind == PyUnicode_4BYTE_KIND) {
5575 : 56 : const Py_UCS4 *in = (const Py_UCS4 *)data;
5576 : 56 : const Py_UCS4 *end = in + len;
5577 [ + + ]: 1454 : while (in < end) {
5578 [ + + ]: 1398 : if (*in++ >= 0x10000) {
5579 : 94 : pairs++;
5580 : : }
5581 : : }
5582 : : }
5583 [ - + ]: 5836 : if (len > PY_SSIZE_T_MAX / 2 - pairs - (byteorder == 0)) {
5584 : : return PyErr_NoMemory();
5585 : : }
5586 : 5836 : nsize = len + pairs + (byteorder == 0);
5587 : 5836 : v = PyBytes_FromStringAndSize(NULL, nsize * 2);
5588 [ - + ]: 5836 : if (v == NULL) {
5589 : 0 : return NULL;
5590 : : }
5591 : :
5592 : : /* output buffer is 2-bytes aligned */
5593 : : assert(_Py_IS_ALIGNED(PyBytes_AS_STRING(v), 2));
5594 : 5836 : out = (unsigned short *)PyBytes_AS_STRING(v);
5595 [ + + ]: 5836 : if (byteorder == 0) {
5596 : 1887 : *out++ = 0xFEFF;
5597 : : }
5598 [ + + ]: 5836 : if (len == 0) {
5599 : 23 : goto done;
5600 : : }
5601 : :
5602 [ + + ]: 5813 : if (kind == PyUnicode_1BYTE_KIND) {
5603 : 2834 : ucs1lib_utf16_encode((const Py_UCS1 *)data, len, &out, native_ordering);
5604 : 2834 : goto done;
5605 : : }
5606 : :
5607 [ + + ]: 2979 : if (byteorder < 0) {
5608 : 996 : encoding = "utf-16-le";
5609 : : }
5610 [ + + ]: 1983 : else if (byteorder > 0) {
5611 : 988 : encoding = "utf-16-be";
5612 : : }
5613 : : else {
5614 : 995 : encoding = "utf-16";
5615 : : }
5616 : :
5617 : 2979 : pos = 0;
5618 [ + + ]: 3074 : while (pos < len) {
5619 : : Py_ssize_t newpos, repsize, moreunits;
5620 : :
5621 [ + + ]: 3067 : if (kind == PyUnicode_2BYTE_KIND) {
5622 : 3005 : pos += ucs2lib_utf16_encode((const Py_UCS2 *)data + pos, len - pos,
5623 : : &out, native_ordering);
5624 : : }
5625 : : else {
5626 : : assert(kind == PyUnicode_4BYTE_KIND);
5627 : 62 : pos += ucs4lib_utf16_encode((const Py_UCS4 *)data + pos, len - pos,
5628 : : &out, native_ordering);
5629 : : }
5630 [ + + ]: 3067 : if (pos == len)
5631 : 2960 : break;
5632 : :
5633 : 107 : rep = unicode_encode_call_errorhandler(
5634 : : errors, &errorHandler,
5635 : : encoding, "surrogates not allowed",
5636 : : str, &exc, pos, pos + 1, &newpos);
5637 [ + + ]: 107 : if (!rep)
5638 : 12 : goto error;
5639 : :
5640 [ + + ]: 102 : if (PyBytes_Check(rep)) {
5641 : 21 : repsize = PyBytes_GET_SIZE(rep);
5642 [ + + ]: 21 : if (repsize & 1) {
5643 : 4 : raise_encode_exception(&exc, encoding,
5644 : : str, pos, pos + 1,
5645 : : "surrogates not allowed");
5646 : 4 : goto error;
5647 : : }
5648 : 17 : moreunits = repsize / 2;
5649 : : }
5650 : : else {
5651 : : assert(PyUnicode_Check(rep));
5652 : 81 : moreunits = repsize = PyUnicode_GET_LENGTH(rep);
5653 [ + + ]: 81 : if (!PyUnicode_IS_ASCII(rep)) {
5654 : 3 : raise_encode_exception(&exc, encoding,
5655 : : str, pos, pos + 1,
5656 : : "surrogates not allowed");
5657 : 3 : goto error;
5658 : : }
5659 : : }
5660 : 95 : moreunits += pos - newpos;
5661 : 95 : pos = newpos;
5662 : :
5663 : : /* two bytes are reserved for each surrogate */
5664 [ + + ]: 95 : if (moreunits > 0) {
5665 : 59 : Py_ssize_t outpos = out - (unsigned short*) PyBytes_AS_STRING(v);
5666 [ - + ]: 59 : if (moreunits >= (PY_SSIZE_T_MAX - PyBytes_GET_SIZE(v)) / 2) {
5667 : : /* integer overflow */
5668 : : PyErr_NoMemory();
5669 : 0 : goto error;
5670 : : }
5671 [ - + ]: 59 : if (_PyBytes_Resize(&v, PyBytes_GET_SIZE(v) + 2 * moreunits) < 0)
5672 : 0 : goto error;
5673 : 59 : out = (unsigned short*) PyBytes_AS_STRING(v) + outpos;
5674 : : }
5675 : :
5676 [ + + ]: 95 : if (PyBytes_Check(rep)) {
5677 : 17 : memcpy(out, PyBytes_AS_STRING(rep), repsize);
5678 : 17 : out += repsize / 2;
5679 : : } else /* rep is unicode */ {
5680 : : assert(PyUnicode_KIND(rep) == PyUnicode_1BYTE_KIND);
5681 : 78 : ucs1lib_utf16_encode(PyUnicode_1BYTE_DATA(rep), repsize,
5682 : : &out, native_ordering);
5683 : : }
5684 : :
5685 [ + - ]: 95 : Py_CLEAR(rep);
5686 : : }
5687 : :
5688 : : /* Cut back to size actually needed. This is necessary for, for example,
5689 : : encoding of a string containing isolated surrogates and the 'ignore' handler
5690 : : is used. */
5691 : 2967 : nsize = (unsigned char*) out - (unsigned char*) PyBytes_AS_STRING(v);
5692 [ + + ]: 2967 : if (nsize != PyBytes_GET_SIZE(v))
5693 : 6 : _PyBytes_Resize(&v, nsize);
5694 : 2967 : Py_XDECREF(errorHandler);
5695 : 2967 : Py_XDECREF(exc);
5696 : 5824 : done:
5697 : 5824 : return v;
5698 : 12 : error:
5699 : 12 : Py_XDECREF(rep);
5700 : 12 : Py_XDECREF(errorHandler);
5701 : 12 : Py_XDECREF(exc);
5702 : 12 : Py_XDECREF(v);
5703 : 12 : return NULL;
5704 : : #undef STORECHAR
5705 : : }
5706 : :
5707 : : PyObject *
5708 : 0 : PyUnicode_AsUTF16String(PyObject *unicode)
5709 : : {
5710 : 0 : return _PyUnicode_EncodeUTF16(unicode, NULL, 0);
5711 : : }
5712 : :
5713 : : /* --- Unicode Escape Codec ----------------------------------------------- */
5714 : :
5715 : : static _PyUnicode_Name_CAPI *ucnhash_capi = NULL;
5716 : :
5717 : : PyObject *
5718 : 246092 : _PyUnicode_DecodeUnicodeEscapeInternal(const char *s,
5719 : : Py_ssize_t size,
5720 : : const char *errors,
5721 : : Py_ssize_t *consumed,
5722 : : const char **first_invalid_escape)
5723 : : {
5724 : 246092 : const char *starts = s;
5725 : : _PyUnicodeWriter writer;
5726 : : const char *end;
5727 : 246092 : PyObject *errorHandler = NULL;
5728 : 246092 : PyObject *exc = NULL;
5729 : :
5730 : : // so we can remember if we've seen an invalid escape char or not
5731 : 246092 : *first_invalid_escape = NULL;
5732 : :
5733 [ + + ]: 246092 : if (size == 0) {
5734 [ + + ]: 17 : if (consumed) {
5735 : 8 : *consumed = 0;
5736 : : }
5737 : 17 : _Py_RETURN_UNICODE_EMPTY();
5738 : : }
5739 : : /* Escaped strings will always be longer than the resulting
5740 : : Unicode string, so we start with size here and then reduce the
5741 : : length after conversion to the true value.
5742 : : (but if the error callback returns a long replacement string
5743 : : we'll have to allocate more space) */
5744 : 246075 : _PyUnicodeWriter_Init(&writer);
5745 : 246075 : writer.min_length = size;
5746 [ - + - - : 246075 : if (_PyUnicodeWriter_Prepare(&writer, size, 127) < 0) {
+ - - + ]
5747 : 0 : goto onError;
5748 : : }
5749 : :
5750 : 246075 : end = s + size;
5751 [ + + ]: 4150536 : while (s < end) {
5752 : 3905459 : unsigned char c = (unsigned char) *s++;
5753 : : Py_UCS4 ch;
5754 : : int count;
5755 : : const char *message;
5756 : :
5757 : : #define WRITE_ASCII_CHAR(ch) \
5758 : : do { \
5759 : : assert(ch <= 127); \
5760 : : assert(writer.pos < writer.size); \
5761 : : PyUnicode_WRITE(writer.kind, writer.data, writer.pos++, ch); \
5762 : : } while(0)
5763 : :
5764 : : #define WRITE_CHAR(ch) \
5765 : : do { \
5766 : : if (ch <= writer.maxchar) { \
5767 : : assert(writer.pos < writer.size); \
5768 : : PyUnicode_WRITE(writer.kind, writer.data, writer.pos++, ch); \
5769 : : } \
5770 : : else if (_PyUnicodeWriter_WriteCharInline(&writer, ch) < 0) { \
5771 : : goto onError; \
5772 : : } \
5773 : : } while(0)
5774 : :
5775 : : /* Non-escape characters are interpreted as Unicode ordinals */
5776 [ + + ]: 3905459 : if (c != '\\') {
5777 [ + + - + ]: 3619021 : WRITE_CHAR(c);
5778 : 3904413 : continue;
5779 : : }
5780 : :
5781 : 286966 : Py_ssize_t startinpos = s - starts - 1;
5782 : : /* \ - Escapes */
5783 [ + + ]: 286966 : if (s >= end) {
5784 : 226 : message = "\\ at end of string";
5785 : 226 : goto incomplete;
5786 : : }
5787 : 286740 : c = (unsigned char) *s++;
5788 : :
5789 : : assert(writer.pos < writer.size);
5790 [ + + + + : 286740 : switch (c) {
+ + + + +
+ + + + +
+ + + ]
5791 : :
5792 : : /* \x escapes */
5793 : 3066 : case '\n': continue;
5794 : 23956 : case '\\': WRITE_ASCII_CHAR('\\'); continue;
5795 : 3327 : case '\'': WRITE_ASCII_CHAR('\''); continue;
5796 : 1368 : case '\"': WRITE_ASCII_CHAR('\"'); continue;
5797 : 202 : case 'b': WRITE_ASCII_CHAR('\b'); continue;
5798 : : /* FF */
5799 : 244 : case 'f': WRITE_ASCII_CHAR('\014'); continue;
5800 : 6619 : case 't': WRITE_ASCII_CHAR('\t'); continue;
5801 : 74317 : case 'n': WRITE_ASCII_CHAR('\n'); continue;
5802 : 7720 : case 'r': WRITE_ASCII_CHAR('\r'); continue;
5803 : : /* VT */
5804 : 116 : case 'v': WRITE_ASCII_CHAR('\013'); continue;
5805 : : /* BEL, not classic C */
5806 : 96 : case 'a': WRITE_ASCII_CHAR('\007'); continue;
5807 : :
5808 : : /* \OOO (octal) escapes */
5809 : 1415 : case '0': case '1': case '2': case '3':
5810 : : case '4': case '5': case '6': case '7':
5811 : 1415 : ch = c - '0';
5812 [ + + + + : 1415 : if (s < end && '0' <= *s && *s <= '7') {
+ + ]
5813 : 764 : ch = (ch<<3) + *s++ - '0';
5814 [ + + + + : 764 : if (s < end && '0' <= *s && *s <= '7') {
+ + ]
5815 : 740 : ch = (ch<<3) + *s++ - '0';
5816 : : }
5817 : : }
5818 [ + + ]: 1415 : if (ch > 0377) {
5819 [ + - ]: 514 : if (*first_invalid_escape == NULL) {
5820 : 514 : *first_invalid_escape = s-3; /* Back up 3 chars, since we've
5821 : : already incremented s. */
5822 : : }
5823 : : }
5824 [ + + - + ]: 1415 : WRITE_CHAR(ch);
5825 : 1415 : continue;
5826 : :
5827 : : /* hex escapes */
5828 : : /* \xXX */
5829 : 16927 : case 'x':
5830 : 16927 : count = 2;
5831 : 16927 : message = "truncated \\xXX escape";
5832 : 16927 : goto hexescape;
5833 : :
5834 : : /* \uXXXX */
5835 : 87687 : case 'u':
5836 : 87687 : count = 4;
5837 : 87687 : message = "truncated \\uXXXX escape";
5838 : 87687 : goto hexescape;
5839 : :
5840 : : /* \UXXXXXXXX */
5841 : 58896 : case 'U':
5842 : 58896 : count = 8;
5843 : 58896 : message = "truncated \\UXXXXXXXX escape";
5844 : 163510 : hexescape:
5845 [ + + ]: 1018313 : for (ch = 0; count; ++s, --count) {
5846 [ + + ]: 855131 : if (s >= end) {
5847 : 293 : goto incomplete;
5848 : : }
5849 : 854838 : c = (unsigned char)*s;
5850 : 854838 : ch <<= 4;
5851 [ + - + + ]: 854838 : if (c >= '0' && c <= '9') {
5852 : 659850 : ch += c - '0';
5853 : : }
5854 [ + + + + ]: 194988 : else if (c >= 'a' && c <= 'f') {
5855 : 188135 : ch += c - ('a' - 10);
5856 : : }
5857 [ + - + + ]: 6853 : else if (c >= 'A' && c <= 'F') {
5858 : 6818 : ch += c - ('A' - 10);
5859 : : }
5860 : : else {
5861 : 35 : goto error;
5862 : : }
5863 : : }
5864 : :
5865 : : /* when we get here, ch is a 32-bit unicode character */
5866 [ + + ]: 163182 : if (ch > MAX_UNICODE) {
5867 : 10 : message = "illegal Unicode character";
5868 : 10 : goto error;
5869 : : }
5870 : :
5871 [ + + - + ]: 163172 : WRITE_CHAR(ch);
5872 : 163172 : continue;
5873 : :
5874 : : /* \N{name} */
5875 : 633 : case 'N':
5876 [ + + ]: 633 : if (ucnhash_capi == NULL) {
5877 : : /* load the unicode data module */
5878 : 16 : ucnhash_capi = (_PyUnicode_Name_CAPI *)PyCapsule_Import(
5879 : : PyUnicodeData_CAPSULE_NAME, 1);
5880 [ + + ]: 16 : if (ucnhash_capi == NULL) {
5881 : 1 : PyErr_SetString(
5882 : : PyExc_UnicodeError,
5883 : : "\\N escapes not supported (can't load unicodedata module)"
5884 : : );
5885 : 1 : goto onError;
5886 : : }
5887 : : }
5888 : :
5889 : 632 : message = "malformed \\N character escape";
5890 [ + + ]: 632 : if (s >= end) {
5891 : 2 : goto incomplete;
5892 : : }
5893 [ + + ]: 630 : if (*s == '{') {
5894 : 625 : const char *start = ++s;
5895 : : size_t namelen;
5896 : : /* look for the closing brace */
5897 [ + + + + ]: 115149 : while (s < end && *s != '}')
5898 : 114524 : s++;
5899 [ + + ]: 625 : if (s >= end) {
5900 : 5 : goto incomplete;
5901 : : }
5902 : 620 : namelen = s - start;
5903 [ + - ]: 620 : if (namelen) {
5904 : : /* found a name. look it up in the unicode database */
5905 : 620 : s++;
5906 : 620 : ch = 0xffffffff; /* in case 'getcode' messes up */
5907 [ + - + + ]: 1240 : if (namelen <= INT_MAX &&
5908 : 620 : ucnhash_capi->getcode(start, (int)namelen,
5909 : : &ch, 0)) {
5910 : : assert(ch <= MAX_UNICODE);
5911 [ + + - + ]: 151 : WRITE_CHAR(ch);
5912 : 151 : continue;
5913 : : }
5914 : 469 : message = "unknown Unicode character name";
5915 : : }
5916 : : }
5917 : 474 : goto error;
5918 : :
5919 : 151 : default:
5920 [ + - ]: 151 : if (*first_invalid_escape == NULL) {
5921 : 151 : *first_invalid_escape = s-1; /* Back up one char, since we've
5922 : : already incremented s. */
5923 : : }
5924 : 151 : WRITE_ASCII_CHAR('\\');
5925 [ + + - + ]: 151 : WRITE_CHAR(c);
5926 : 151 : continue;
5927 : : }
5928 : :
5929 : 526 : incomplete:
5930 [ + + ]: 526 : if (consumed) {
5931 : 470 : *consumed = startinpos;
5932 : 470 : break;
5933 : : }
5934 : 56 : error:;
5935 : 575 : Py_ssize_t endinpos = s-starts;
5936 : 575 : writer.min_length = end - s + writer.pos;
5937 [ + + ]: 575 : if (unicode_decode_call_errorhandler_writer(
5938 : : errors, &errorHandler,
5939 : : "unicodeescape", message,
5940 : : &starts, &end, &startinpos, &endinpos, &exc, &s,
5941 : : &writer)) {
5942 : 527 : goto onError;
5943 : : }
5944 : : assert(end - s <= writer.size - writer.pos);
5945 : :
5946 : : #undef WRITE_ASCII_CHAR
5947 : : #undef WRITE_CHAR
5948 : : }
5949 : :
5950 : 245547 : Py_XDECREF(errorHandler);
5951 : 245547 : Py_XDECREF(exc);
5952 : 245547 : return _PyUnicodeWriter_Finish(&writer);
5953 : :
5954 : 528 : onError:
5955 : 528 : _PyUnicodeWriter_Dealloc(&writer);
5956 : 528 : Py_XDECREF(errorHandler);
5957 : 528 : Py_XDECREF(exc);
5958 : 528 : return NULL;
5959 : : }
5960 : :
5961 : : PyObject *
5962 : 6315 : _PyUnicode_DecodeUnicodeEscapeStateful(const char *s,
5963 : : Py_ssize_t size,
5964 : : const char *errors,
5965 : : Py_ssize_t *consumed)
5966 : : {
5967 : : const char *first_invalid_escape;
5968 : 6315 : PyObject *result = _PyUnicode_DecodeUnicodeEscapeInternal(s, size, errors,
5969 : : consumed,
5970 : : &first_invalid_escape);
5971 [ + + ]: 6315 : if (result == NULL)
5972 : 32 : return NULL;
5973 [ + + ]: 6283 : if (first_invalid_escape != NULL) {
5974 : 300 : unsigned char c = *first_invalid_escape;
5975 [ + - + + ]: 300 : if ('4' <= c && c <= '7') {
5976 [ - + ]: 256 : if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1,
5977 : : "invalid octal escape sequence '\\%.3s'",
5978 : : first_invalid_escape) < 0)
5979 : : {
5980 : 0 : Py_DECREF(result);
5981 : 0 : return NULL;
5982 : : }
5983 : : }
5984 : : else {
5985 [ - + ]: 44 : if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1,
5986 : : "invalid escape sequence '\\%c'",
5987 : : c) < 0)
5988 : : {
5989 : 0 : Py_DECREF(result);
5990 : 0 : return NULL;
5991 : : }
5992 : : }
5993 : : }
5994 : 6283 : return result;
5995 : : }
5996 : :
5997 : : PyObject *
5998 : 0 : PyUnicode_DecodeUnicodeEscape(const char *s,
5999 : : Py_ssize_t size,
6000 : : const char *errors)
6001 : : {
6002 : 0 : return _PyUnicode_DecodeUnicodeEscapeStateful(s, size, errors, NULL);
6003 : : }
6004 : :
6005 : : /* Return a Unicode-Escape string version of the Unicode object. */
6006 : :
6007 : : PyObject *
6008 : 3762 : PyUnicode_AsUnicodeEscapeString(PyObject *unicode)
6009 : : {
6010 : : Py_ssize_t i, len;
6011 : : PyObject *repr;
6012 : : char *p;
6013 : : int kind;
6014 : : const void *data;
6015 : : Py_ssize_t expandsize;
6016 : :
6017 : : /* Initial allocation is based on the longest-possible character
6018 : : escape.
6019 : :
6020 : : For UCS1 strings it's '\xxx', 4 bytes per source character.
6021 : : For UCS2 strings it's '\uxxxx', 6 bytes per source character.
6022 : : For UCS4 strings it's '\U00xxxxxx', 10 bytes per source character.
6023 : : */
6024 : :
6025 [ - + ]: 3762 : if (!PyUnicode_Check(unicode)) {
6026 : 0 : PyErr_BadArgument();
6027 : 0 : return NULL;
6028 : : }
6029 : :
6030 : 3762 : len = PyUnicode_GET_LENGTH(unicode);
6031 [ + + ]: 3762 : if (len == 0) {
6032 : 7 : return PyBytes_FromStringAndSize(NULL, 0);
6033 : : }
6034 : :
6035 : 3755 : kind = PyUnicode_KIND(unicode);
6036 : 3755 : data = PyUnicode_DATA(unicode);
6037 : : /* 4 byte characters can take up 10 bytes, 2 byte characters can take up 6
6038 : : bytes, and 1 byte characters 4. */
6039 : 3755 : expandsize = kind * 2 + 2;
6040 [ - + ]: 3755 : if (len > PY_SSIZE_T_MAX / expandsize) {
6041 : : return PyErr_NoMemory();
6042 : : }
6043 : 3755 : repr = PyBytes_FromStringAndSize(NULL, expandsize * len);
6044 [ - + ]: 3755 : if (repr == NULL) {
6045 : 0 : return NULL;
6046 : : }
6047 : :
6048 : 3755 : p = PyBytes_AS_STRING(repr);
6049 [ + + ]: 301839 : for (i = 0; i < len; i++) {
6050 : 298084 : Py_UCS4 ch = PyUnicode_READ(kind, data, i);
6051 : :
6052 : : /* U+0000-U+00ff range */
6053 [ + + ]: 298084 : if (ch < 0x100) {
6054 [ + + + + ]: 291691 : if (ch >= ' ' && ch < 127) {
6055 [ + + ]: 277279 : if (ch != '\\') {
6056 : : /* Copy printable US ASCII as-is */
6057 : 276597 : *p++ = (char) ch;
6058 : : }
6059 : : /* Escape backslashes */
6060 : : else {
6061 : 682 : *p++ = '\\';
6062 : 682 : *p++ = '\\';
6063 : : }
6064 : : }
6065 : :
6066 : : /* Map special whitespace to '\t', \n', '\r' */
6067 [ + + ]: 14412 : else if (ch == '\t') {
6068 : 14 : *p++ = '\\';
6069 : 14 : *p++ = 't';
6070 : : }
6071 [ + + ]: 14398 : else if (ch == '\n') {
6072 : 10754 : *p++ = '\\';
6073 : 10754 : *p++ = 'n';
6074 : : }
6075 [ + + ]: 3644 : else if (ch == '\r') {
6076 : 3319 : *p++ = '\\';
6077 : 3319 : *p++ = 'r';
6078 : : }
6079 : :
6080 : : /* Map non-printable US ASCII and 8-bit characters to '\xHH' */
6081 : : else {
6082 : 325 : *p++ = '\\';
6083 : 325 : *p++ = 'x';
6084 : 325 : *p++ = Py_hexdigits[(ch >> 4) & 0x000F];
6085 : 325 : *p++ = Py_hexdigits[ch & 0x000F];
6086 : : }
6087 : : }
6088 : : /* U+0100-U+ffff range: Map 16-bit characters to '\uHHHH' */
6089 [ + + ]: 6393 : else if (ch < 0x10000) {
6090 : 6383 : *p++ = '\\';
6091 : 6383 : *p++ = 'u';
6092 : 6383 : *p++ = Py_hexdigits[(ch >> 12) & 0x000F];
6093 : 6383 : *p++ = Py_hexdigits[(ch >> 8) & 0x000F];
6094 : 6383 : *p++ = Py_hexdigits[(ch >> 4) & 0x000F];
6095 : 6383 : *p++ = Py_hexdigits[ch & 0x000F];
6096 : : }
6097 : : /* U+010000-U+10ffff range: Map 21-bit characters to '\U00HHHHHH' */
6098 : : else {
6099 : :
6100 : : /* Make sure that the first two digits are zero */
6101 : : assert(ch <= MAX_UNICODE && MAX_UNICODE <= 0x10ffff);
6102 : 10 : *p++ = '\\';
6103 : 10 : *p++ = 'U';
6104 : 10 : *p++ = '0';
6105 : 10 : *p++ = '0';
6106 : 10 : *p++ = Py_hexdigits[(ch >> 20) & 0x0000000F];
6107 : 10 : *p++ = Py_hexdigits[(ch >> 16) & 0x0000000F];
6108 : 10 : *p++ = Py_hexdigits[(ch >> 12) & 0x0000000F];
6109 : 10 : *p++ = Py_hexdigits[(ch >> 8) & 0x0000000F];
6110 : 10 : *p++ = Py_hexdigits[(ch >> 4) & 0x0000000F];
6111 : 10 : *p++ = Py_hexdigits[ch & 0x0000000F];
6112 : : }
6113 : : }
6114 : :
6115 : : assert(p - PyBytes_AS_STRING(repr) > 0);
6116 [ - + ]: 3755 : if (_PyBytes_Resize(&repr, p - PyBytes_AS_STRING(repr)) < 0) {
6117 : 0 : return NULL;
6118 : : }
6119 : 3755 : return repr;
6120 : : }
6121 : :
6122 : : /* --- Raw Unicode Escape Codec ------------------------------------------- */
6123 : :
6124 : : PyObject *
6125 : 82698 : _PyUnicode_DecodeRawUnicodeEscapeStateful(const char *s,
6126 : : Py_ssize_t size,
6127 : : const char *errors,
6128 : : Py_ssize_t *consumed)
6129 : : {
6130 : 82698 : const char *starts = s;
6131 : : _PyUnicodeWriter writer;
6132 : : const char *end;
6133 : 82698 : PyObject *errorHandler = NULL;
6134 : 82698 : PyObject *exc = NULL;
6135 : :
6136 [ + + ]: 82698 : if (size == 0) {
6137 [ + + ]: 34 : if (consumed) {
6138 : 8 : *consumed = 0;
6139 : : }
6140 : 34 : _Py_RETURN_UNICODE_EMPTY();
6141 : : }
6142 : :
6143 : : /* Escaped strings will always be longer than the resulting
6144 : : Unicode string, so we start with size here and then reduce the
6145 : : length after conversion to the true value. (But decoding error
6146 : : handler might have to resize the string) */
6147 : 82664 : _PyUnicodeWriter_Init(&writer);
6148 : 82664 : writer.min_length = size;
6149 [ - + - - : 82664 : if (_PyUnicodeWriter_Prepare(&writer, size, 127) < 0) {
+ - - + ]
6150 : 0 : goto onError;
6151 : : }
6152 : :
6153 : 82664 : end = s + size;
6154 [ + + ]: 1121789 : while (s < end) {
6155 : 1039427 : unsigned char c = (unsigned char) *s++;
6156 : : Py_UCS4 ch;
6157 : : int count;
6158 : : const char *message;
6159 : :
6160 : : #define WRITE_CHAR(ch) \
6161 : : do { \
6162 : : if (ch <= writer.maxchar) { \
6163 : : assert(writer.pos < writer.size); \
6164 : : PyUnicode_WRITE(writer.kind, writer.data, writer.pos++, ch); \
6165 : : } \
6166 : : else if (_PyUnicodeWriter_WriteCharInline(&writer, ch) < 0) { \
6167 : : goto onError; \
6168 : : } \
6169 : : } while(0)
6170 : :
6171 : : /* Non-escape characters are interpreted as Unicode ordinals */
6172 [ + + + + : 1039427 : if (c != '\\' || (s >= end && !consumed)) {
+ + ]
6173 [ + + - + ]: 1032040 : WRITE_CHAR(c);
6174 : 1039087 : continue;
6175 : : }
6176 : :
6177 : 7408 : Py_ssize_t startinpos = s - starts - 1;
6178 : : /* \ - Escapes */
6179 [ + + ]: 7408 : if (s >= end) {
6180 : : assert(consumed);
6181 : : // Set message to silent compiler warning.
6182 : : // Actually it is never used.
6183 : 49 : message = "\\ at end of string";
6184 : 49 : goto incomplete;
6185 : : }
6186 : :
6187 : 7359 : c = (unsigned char) *s++;
6188 [ + + ]: 7359 : if (c == 'u') {
6189 : 6999 : count = 4;
6190 : 6999 : message = "truncated \\uXXXX escape";
6191 : : }
6192 [ + + ]: 360 : else if (c == 'U') {
6193 : 101 : count = 8;
6194 : 101 : message = "truncated \\UXXXXXXXX escape";
6195 : : }
6196 : : else {
6197 : : assert(writer.pos < writer.size);
6198 : 259 : PyUnicode_WRITE(writer.kind, writer.data, writer.pos++, '\\');
6199 [ + + - + ]: 259 : WRITE_CHAR(c);
6200 : 259 : continue;
6201 : : }
6202 : :
6203 : : /* \uHHHH with 4 hex digits, \U00HHHHHH with 8 */
6204 [ + + ]: 34984 : for (ch = 0; count; ++s, --count) {
6205 [ + + ]: 28168 : if (s >= end) {
6206 : 256 : goto incomplete;
6207 : : }
6208 : 27912 : c = (unsigned char)*s;
6209 : 27912 : ch <<= 4;
6210 [ + - + + ]: 27912 : if (c >= '0' && c <= '9') {
6211 : 27023 : ch += c - '0';
6212 : : }
6213 [ + + + + ]: 889 : else if (c >= 'a' && c <= 'f') {
6214 : 861 : ch += c - ('a' - 10);
6215 : : }
6216 [ + - - + ]: 28 : else if (c >= 'A' && c <= 'F') {
6217 : 0 : ch += c - ('A' - 10);
6218 : : }
6219 : : else {
6220 : 28 : goto error;
6221 : : }
6222 : : }
6223 [ + + ]: 6816 : if (ch > MAX_UNICODE) {
6224 : 7 : message = "\\Uxxxxxxxx out of range";
6225 : 7 : goto error;
6226 : : }
6227 [ + + - + ]: 6809 : WRITE_CHAR(ch);
6228 : 6809 : continue;
6229 : :
6230 : 305 : incomplete:
6231 [ + + ]: 305 : if (consumed) {
6232 : 281 : *consumed = startinpos;
6233 : 281 : break;
6234 : : }
6235 : 24 : error:;
6236 : 59 : Py_ssize_t endinpos = s-starts;
6237 : 59 : writer.min_length = end - s + writer.pos;
6238 [ + + ]: 59 : if (unicode_decode_call_errorhandler_writer(
6239 : : errors, &errorHandler,
6240 : : "rawunicodeescape", message,
6241 : : &starts, &end, &startinpos, &endinpos, &exc, &s,
6242 : : &writer)) {
6243 : 21 : goto onError;
6244 : : }
6245 : : assert(end - s <= writer.size - writer.pos);
6246 : :
6247 : : #undef WRITE_CHAR
6248 : : }
6249 : 82643 : Py_XDECREF(errorHandler);
6250 : 82643 : Py_XDECREF(exc);
6251 : 82643 : return _PyUnicodeWriter_Finish(&writer);
6252 : :
6253 : 21 : onError:
6254 : 21 : _PyUnicodeWriter_Dealloc(&writer);
6255 : 21 : Py_XDECREF(errorHandler);
6256 : 21 : Py_XDECREF(exc);
6257 : 21 : return NULL;
6258 : : }
6259 : :
6260 : : PyObject *
6261 : 41939 : PyUnicode_DecodeRawUnicodeEscape(const char *s,
6262 : : Py_ssize_t size,
6263 : : const char *errors)
6264 : : {
6265 : 41939 : return _PyUnicode_DecodeRawUnicodeEscapeStateful(s, size, errors, NULL);
6266 : : }
6267 : :
6268 : :
6269 : : PyObject *
6270 : 11252 : PyUnicode_AsRawUnicodeEscapeString(PyObject *unicode)
6271 : : {
6272 : : PyObject *repr;
6273 : : char *p;
6274 : : Py_ssize_t expandsize, pos;
6275 : : int kind;
6276 : : const void *data;
6277 : : Py_ssize_t len;
6278 : :
6279 [ - + ]: 11252 : if (!PyUnicode_Check(unicode)) {
6280 : 0 : PyErr_BadArgument();
6281 : 0 : return NULL;
6282 : : }
6283 : 11252 : kind = PyUnicode_KIND(unicode);
6284 : 11252 : data = PyUnicode_DATA(unicode);
6285 : 11252 : len = PyUnicode_GET_LENGTH(unicode);
6286 [ + + ]: 11252 : if (kind == PyUnicode_1BYTE_KIND) {
6287 : 10294 : return PyBytes_FromStringAndSize(data, len);
6288 : : }
6289 : :
6290 : : /* 4 byte characters can take up 10 bytes, 2 byte characters can take up 6
6291 : : bytes, and 1 byte characters 4. */
6292 : 958 : expandsize = kind * 2 + 2;
6293 : :
6294 [ - + ]: 958 : if (len > PY_SSIZE_T_MAX / expandsize) {
6295 : : return PyErr_NoMemory();
6296 : : }
6297 : 958 : repr = PyBytes_FromStringAndSize(NULL, expandsize * len);
6298 [ - + ]: 958 : if (repr == NULL) {
6299 : 0 : return NULL;
6300 : : }
6301 [ - + ]: 958 : if (len == 0) {
6302 : 0 : return repr;
6303 : : }
6304 : :
6305 : 958 : p = PyBytes_AS_STRING(repr);
6306 [ + + ]: 77140 : for (pos = 0; pos < len; pos++) {
6307 : 76182 : Py_UCS4 ch = PyUnicode_READ(kind, data, pos);
6308 : :
6309 : : /* U+0000-U+00ff range: Copy 8-bit characters as-is */
6310 [ + + ]: 76182 : if (ch < 0x100) {
6311 : 69776 : *p++ = (char) ch;
6312 : : }
6313 : : /* U+0100-U+ffff range: Map 16-bit characters to '\uHHHH' */
6314 [ + + ]: 6406 : else if (ch < 0x10000) {
6315 : 6389 : *p++ = '\\';
6316 : 6389 : *p++ = 'u';
6317 : 6389 : *p++ = Py_hexdigits[(ch >> 12) & 0xf];
6318 : 6389 : *p++ = Py_hexdigits[(ch >> 8) & 0xf];
6319 : 6389 : *p++ = Py_hexdigits[(ch >> 4) & 0xf];
6320 : 6389 : *p++ = Py_hexdigits[ch & 15];
6321 : : }
6322 : : /* U+010000-U+10ffff range: Map 32-bit characters to '\U00HHHHHH' */
6323 : : else {
6324 : : assert(ch <= MAX_UNICODE && MAX_UNICODE <= 0x10ffff);
6325 : 17 : *p++ = '\\';
6326 : 17 : *p++ = 'U';
6327 : 17 : *p++ = '0';
6328 : 17 : *p++ = '0';
6329 : 17 : *p++ = Py_hexdigits[(ch >> 20) & 0xf];
6330 : 17 : *p++ = Py_hexdigits[(ch >> 16) & 0xf];
6331 : 17 : *p++ = Py_hexdigits[(ch >> 12) & 0xf];
6332 : 17 : *p++ = Py_hexdigits[(ch >> 8) & 0xf];
6333 : 17 : *p++ = Py_hexdigits[(ch >> 4) & 0xf];
6334 : 17 : *p++ = Py_hexdigits[ch & 15];
6335 : : }
6336 : : }
6337 : :
6338 : : assert(p > PyBytes_AS_STRING(repr));
6339 [ - + ]: 958 : if (_PyBytes_Resize(&repr, p - PyBytes_AS_STRING(repr)) < 0) {
6340 : 0 : return NULL;
6341 : : }
6342 : 958 : return repr;
6343 : : }
6344 : :
6345 : : /* --- Latin-1 Codec ------------------------------------------------------ */
6346 : :
6347 : : PyObject *
6348 : 4905544 : PyUnicode_DecodeLatin1(const char *s,
6349 : : Py_ssize_t size,
6350 : : const char *errors)
6351 : : {
6352 : : /* Latin-1 is equivalent to the first 256 ordinals in Unicode. */
6353 : 4905544 : return _PyUnicode_FromUCS1((const unsigned char*)s, size);
6354 : : }
6355 : :
6356 : : /* create or adjust a UnicodeEncodeError */
6357 : : static void
6358 : 8148 : make_encode_exception(PyObject **exceptionObject,
6359 : : const char *encoding,
6360 : : PyObject *unicode,
6361 : : Py_ssize_t startpos, Py_ssize_t endpos,
6362 : : const char *reason)
6363 : : {
6364 [ + + ]: 8148 : if (*exceptionObject == NULL) {
6365 : 1798 : *exceptionObject = PyObject_CallFunction(
6366 : : PyExc_UnicodeEncodeError, "sOnns",
6367 : : encoding, unicode, startpos, endpos, reason);
6368 : : }
6369 : : else {
6370 [ - + ]: 6350 : if (PyUnicodeEncodeError_SetStart(*exceptionObject, startpos))
6371 : 0 : goto onError;
6372 [ - + ]: 6350 : if (PyUnicodeEncodeError_SetEnd(*exceptionObject, endpos))
6373 : 0 : goto onError;
6374 [ - + ]: 6350 : if (PyUnicodeEncodeError_SetReason(*exceptionObject, reason))
6375 : 0 : goto onError;
6376 : 6350 : return;
6377 : 0 : onError:
6378 [ # # ]: 0 : Py_CLEAR(*exceptionObject);
6379 : : }
6380 : : }
6381 : :
6382 : : /* raises a UnicodeEncodeError */
6383 : : static void
6384 : 1213 : raise_encode_exception(PyObject **exceptionObject,
6385 : : const char *encoding,
6386 : : PyObject *unicode,
6387 : : Py_ssize_t startpos, Py_ssize_t endpos,
6388 : : const char *reason)
6389 : : {
6390 : 1213 : make_encode_exception(exceptionObject,
6391 : : encoding, unicode, startpos, endpos, reason);
6392 [ + - ]: 1213 : if (*exceptionObject != NULL)
6393 : 1213 : PyCodec_StrictErrors(*exceptionObject);
6394 : 1213 : }
6395 : :
6396 : : /* error handling callback helper:
6397 : : build arguments, call the callback and check the arguments,
6398 : : put the result into newpos and return the replacement string, which
6399 : : has to be freed by the caller */
6400 : : static PyObject *
6401 : 6936 : unicode_encode_call_errorhandler(const char *errors,
6402 : : PyObject **errorHandler,
6403 : : const char *encoding, const char *reason,
6404 : : PyObject *unicode, PyObject **exceptionObject,
6405 : : Py_ssize_t startpos, Py_ssize_t endpos,
6406 : : Py_ssize_t *newpos)
6407 : : {
6408 : : static const char *argparse = "On;encoding error handler must return (str/bytes, int) tuple";
6409 : : Py_ssize_t len;
6410 : : PyObject *restuple;
6411 : : PyObject *resunicode;
6412 : :
6413 [ + + ]: 6936 : if (*errorHandler == NULL) {
6414 : 616 : *errorHandler = PyCodec_LookupError(errors);
6415 [ + + ]: 616 : if (*errorHandler == NULL)
6416 : 1 : return NULL;
6417 : : }
6418 : :
6419 : 6935 : len = PyUnicode_GET_LENGTH(unicode);
6420 : :
6421 : 6935 : make_encode_exception(exceptionObject,
6422 : : encoding, unicode, startpos, endpos, reason);
6423 [ - + ]: 6935 : if (*exceptionObject == NULL)
6424 : 0 : return NULL;
6425 : :
6426 : 6935 : restuple = PyObject_CallOneArg(*errorHandler, *exceptionObject);
6427 [ + + ]: 6935 : if (restuple == NULL)
6428 : 396 : return NULL;
6429 [ + + ]: 6539 : if (!PyTuple_Check(restuple)) {
6430 : 9 : PyErr_SetString(PyExc_TypeError, &argparse[3]);
6431 : 9 : Py_DECREF(restuple);
6432 : 9 : return NULL;
6433 : : }
6434 [ + + ]: 6530 : if (!PyArg_ParseTuple(restuple, argparse,
6435 : : &resunicode, newpos)) {
6436 : 29 : Py_DECREF(restuple);
6437 : 29 : return NULL;
6438 : : }
6439 [ + + - + ]: 6501 : if (!PyUnicode_Check(resunicode) && !PyBytes_Check(resunicode)) {
6440 : 0 : PyErr_SetString(PyExc_TypeError, &argparse[3]);
6441 : 0 : Py_DECREF(restuple);
6442 : 0 : return NULL;
6443 : : }
6444 [ + + ]: 6501 : if (*newpos<0)
6445 : 3 : *newpos = len + *newpos;
6446 [ + + + + ]: 6501 : if (*newpos<0 || *newpos>len) {
6447 : 2 : PyErr_Format(PyExc_IndexError, "position %zd from error handler out of bounds", *newpos);
6448 : 2 : Py_DECREF(restuple);
6449 : 2 : return NULL;
6450 : : }
6451 : 6499 : Py_INCREF(resunicode);
6452 : 6499 : Py_DECREF(restuple);
6453 : 6499 : return resunicode;
6454 : : }
6455 : :
6456 : : static PyObject *
6457 : 6099 : unicode_encode_ucs1(PyObject *unicode,
6458 : : const char *errors,
6459 : : const Py_UCS4 limit)
6460 : : {
6461 : : /* input state */
6462 : 6099 : Py_ssize_t pos=0, size;
6463 : : int kind;
6464 : : const void *data;
6465 : : /* pointer into the output */
6466 : : char *str;
6467 [ + + ]: 6099 : const char *encoding = (limit == 256) ? "latin-1" : "ascii";
6468 [ + + ]: 6099 : const char *reason = (limit == 256) ? "ordinal not in range(256)" : "ordinal not in range(128)";
6469 : 6099 : PyObject *error_handler_obj = NULL;
6470 : 6099 : PyObject *exc = NULL;
6471 : 6099 : _Py_error_handler error_handler = _Py_ERROR_UNKNOWN;
6472 : 6099 : PyObject *rep = NULL;
6473 : : /* output object */
6474 : : _PyBytesWriter writer;
6475 : :
6476 : 6099 : size = PyUnicode_GET_LENGTH(unicode);
6477 : 6099 : kind = PyUnicode_KIND(unicode);
6478 : 6099 : data = PyUnicode_DATA(unicode);
6479 : : /* allocate enough for a simple encoding without
6480 : : replacements, if we need more, we'll resize */
6481 [ + + ]: 6099 : if (size == 0)
6482 : 6 : return PyBytes_FromStringAndSize(NULL, 0);
6483 : :
6484 : 6093 : _PyBytesWriter_Init(&writer);
6485 : 6093 : str = _PyBytesWriter_Alloc(&writer, size);
6486 [ - + ]: 6093 : if (str == NULL)
6487 : 0 : return NULL;
6488 : :
6489 [ + + ]: 340423 : while (pos < size) {
6490 : 335548 : Py_UCS4 ch = PyUnicode_READ(kind, data, pos);
6491 : :
6492 : : /* can we encode this? */
6493 [ + + ]: 335548 : if (ch < limit) {
6494 : : /* no overflow check, because we know that the space is enough */
6495 : 295608 : *str++ = (char)ch;
6496 : 295608 : ++pos;
6497 : : }
6498 : : else {
6499 : : Py_ssize_t newpos, i;
6500 : : /* startpos for collecting unencodable chars */
6501 : 39940 : Py_ssize_t collstart = pos;
6502 : 39940 : Py_ssize_t collend = collstart + 1;
6503 : : /* find all unecodable characters */
6504 : :
6505 [ + + + + ]: 227811 : while ((collend < size) && (PyUnicode_READ(kind, data, collend) >= limit))
6506 : 187871 : ++collend;
6507 : :
6508 : : /* Only overallocate the buffer if it's not the last write */
6509 : 39940 : writer.overallocate = (collend < size);
6510 : :
6511 : : /* cache callback name lookup (if not done yet, i.e. it's the first error) */
6512 [ + + ]: 39940 : if (error_handler == _Py_ERROR_UNKNOWN)
6513 : 6041 : error_handler = _Py_GetErrorHandler(errors);
6514 : :
6515 [ + + + + : 39940 : switch (error_handler) {
+ + + ]
6516 : 1176 : case _Py_ERROR_STRICT:
6517 : 1176 : raise_encode_exception(&exc, encoding, unicode, collstart, collend, reason);
6518 : 1218 : goto onError;
6519 : :
6520 : 1193 : case _Py_ERROR_REPLACE:
6521 : 1193 : memset(str, '?', collend - collstart);
6522 : 1193 : str += (collend - collstart);
6523 : : /* fall through */
6524 : 2209 : case _Py_ERROR_IGNORE:
6525 : 2209 : pos = collend;
6526 : 2209 : break;
6527 : :
6528 : 8390 : case _Py_ERROR_BACKSLASHREPLACE:
6529 : : /* subtract preallocated bytes */
6530 : 8390 : writer.min_size -= (collend - collstart);
6531 : 8390 : str = backslashreplace(&writer, str,
6532 : : unicode, collstart, collend);
6533 [ - + ]: 8390 : if (str == NULL)
6534 : 0 : goto onError;
6535 : 8390 : pos = collend;
6536 : 8390 : break;
6537 : :
6538 : 1240 : case _Py_ERROR_XMLCHARREFREPLACE:
6539 : : /* subtract preallocated bytes */
6540 : 1240 : writer.min_size -= (collend - collstart);
6541 : 1240 : str = xmlcharrefreplace(&writer, str,
6542 : : unicode, collstart, collend);
6543 [ - + ]: 1240 : if (str == NULL)
6544 : 0 : goto onError;
6545 : 1240 : pos = collend;
6546 : 1240 : break;
6547 : :
6548 : 20745 : case _Py_ERROR_SURROGATEESCAPE:
6549 [ + + ]: 180165 : for (i = collstart; i < collend; ++i) {
6550 : 159422 : ch = PyUnicode_READ(kind, data, i);
6551 [ + + + - ]: 159422 : if (ch < 0xdc80 || 0xdcff < ch) {
6552 : : /* Not a UTF-8b surrogate */
6553 : : break;
6554 : : }
6555 : 159420 : *str++ = (char)(ch - 0xdc00);
6556 : 159420 : ++pos;
6557 : : }
6558 [ + + ]: 20745 : if (i >= collend)
6559 : 20743 : break;
6560 : 2 : collstart = pos;
6561 : : assert(collstart != collend);
6562 : : /* fall through */
6563 : :
6564 : 6182 : default:
6565 : 6182 : rep = unicode_encode_call_errorhandler(errors, &error_handler_obj,
6566 : : encoding, reason, unicode, &exc,
6567 : : collstart, collend, &newpos);
6568 [ + + ]: 6182 : if (rep == NULL)
6569 : 38 : goto onError;
6570 : :
6571 [ + + ]: 6144 : if (newpos < collstart) {
6572 : 102 : writer.overallocate = 1;
6573 : 102 : str = _PyBytesWriter_Prepare(&writer, str,
6574 : : collstart - newpos);
6575 [ - + ]: 102 : if (str == NULL)
6576 : 0 : goto onError;
6577 : : }
6578 : : else {
6579 : : /* subtract preallocated bytes */
6580 : 6042 : writer.min_size -= newpos - collstart;
6581 : : /* Only overallocate the buffer if it's not the last write */
6582 : 6042 : writer.overallocate = (newpos < size);
6583 : : }
6584 : :
6585 [ + + ]: 6144 : if (PyBytes_Check(rep)) {
6586 : : /* Directly copy bytes result to output. */
6587 : 4 : str = _PyBytesWriter_WriteBytes(&writer, str,
6588 : 2 : PyBytes_AS_STRING(rep),
6589 : : PyBytes_GET_SIZE(rep));
6590 : : }
6591 : : else {
6592 : : assert(PyUnicode_Check(rep));
6593 : :
6594 [ + + + + ]: 12284 : if (limit == 256 ?
6595 : 70 : PyUnicode_KIND(rep) != PyUnicode_1BYTE_KIND :
6596 : 6072 : !PyUnicode_IS_ASCII(rep))
6597 : : {
6598 : : /* Not all characters are smaller than limit */
6599 : 4 : raise_encode_exception(&exc, encoding, unicode,
6600 : : collstart, collend, reason);
6601 : 4 : goto onError;
6602 : : }
6603 : : assert(PyUnicode_KIND(rep) == PyUnicode_1BYTE_KIND);
6604 : 12276 : str = _PyBytesWriter_WriteBytes(&writer, str,
6605 : 6138 : PyUnicode_DATA(rep),
6606 : : PyUnicode_GET_LENGTH(rep));
6607 : : }
6608 [ - + ]: 6140 : if (str == NULL)
6609 : 0 : goto onError;
6610 : :
6611 : 6140 : pos = newpos;
6612 [ + - ]: 6140 : Py_CLEAR(rep);
6613 : : }
6614 : :
6615 : : /* If overallocation was disabled, ensure that it was the last
6616 : : write. Otherwise, we missed an optimization */
6617 : : assert(writer.overallocate || pos == size);
6618 : : }
6619 : : }
6620 : :
6621 : 4875 : Py_XDECREF(error_handler_obj);
6622 : 4875 : Py_XDECREF(exc);
6623 : 4875 : return _PyBytesWriter_Finish(&writer, str);
6624 : :
6625 : 1218 : onError:
6626 : 1218 : Py_XDECREF(rep);
6627 : 1218 : _PyBytesWriter_Dealloc(&writer);
6628 : 1218 : Py_XDECREF(error_handler_obj);
6629 : 1218 : Py_XDECREF(exc);
6630 : 1218 : return NULL;
6631 : : }
6632 : :
6633 : : PyObject *
6634 : 25157 : _PyUnicode_AsLatin1String(PyObject *unicode, const char *errors)
6635 : : {
6636 [ - + ]: 25157 : if (!PyUnicode_Check(unicode)) {
6637 : 0 : PyErr_BadArgument();
6638 : 0 : return NULL;
6639 : : }
6640 : : /* Fast path: if it is a one-byte string, construct
6641 : : bytes object directly. */
6642 [ + + ]: 25157 : if (PyUnicode_KIND(unicode) == PyUnicode_1BYTE_KIND)
6643 : 25075 : return PyBytes_FromStringAndSize(PyUnicode_DATA(unicode),
6644 : : PyUnicode_GET_LENGTH(unicode));
6645 : : /* Non-Latin-1 characters present. Defer to above function to
6646 : : raise the exception. */
6647 : 82 : return unicode_encode_ucs1(unicode, errors, 256);
6648 : : }
6649 : :
6650 : : PyObject*
6651 : 42 : PyUnicode_AsLatin1String(PyObject *unicode)
6652 : : {
6653 : 42 : return _PyUnicode_AsLatin1String(unicode, NULL);
6654 : : }
6655 : :
6656 : : /* --- 7-bit ASCII Codec -------------------------------------------------- */
6657 : :
6658 : : PyObject *
6659 : 798108 : PyUnicode_DecodeASCII(const char *s,
6660 : : Py_ssize_t size,
6661 : : const char *errors)
6662 : : {
6663 : 798108 : const char *starts = s;
6664 : 798108 : const char *e = s + size;
6665 : 798108 : PyObject *error_handler_obj = NULL;
6666 : 798108 : PyObject *exc = NULL;
6667 : 798108 : _Py_error_handler error_handler = _Py_ERROR_UNKNOWN;
6668 : :
6669 [ + + ]: 798108 : if (size == 0)
6670 : 621 : _Py_RETURN_UNICODE_EMPTY();
6671 : :
6672 : : /* ASCII is equivalent to the first 128 ordinals in Unicode. */
6673 [ + + + + ]: 797487 : if (size == 1 && (unsigned char)s[0] < 128) {
6674 : 517607 : return get_latin1_char((unsigned char)s[0]);
6675 : : }
6676 : :
6677 : : // Shortcut for simple case
6678 : 279880 : PyObject *u = PyUnicode_New(size, 127);
6679 [ - + ]: 279880 : if (u == NULL) {
6680 : 0 : return NULL;
6681 : : }
6682 : 279880 : Py_ssize_t outpos = ascii_decode(s, e, PyUnicode_1BYTE_DATA(u));
6683 [ + + ]: 279880 : if (outpos == size) {
6684 : 279493 : return u;
6685 : : }
6686 : :
6687 : : _PyUnicodeWriter writer;
6688 : 387 : _PyUnicodeWriter_InitWithBuffer(&writer, u);
6689 : 387 : writer.pos = outpos;
6690 : :
6691 : 387 : s += outpos;
6692 : 387 : int kind = writer.kind;
6693 : 387 : void *data = writer.data;
6694 : : Py_ssize_t startinpos, endinpos;
6695 : :
6696 [ + + ]: 228324 : while (s < e) {
6697 : 227994 : unsigned char c = (unsigned char)*s;
6698 [ + + ]: 227994 : if (c < 128) {
6699 : 69124 : PyUnicode_WRITE(kind, data, writer.pos, c);
6700 : 69124 : writer.pos++;
6701 : 69124 : ++s;
6702 : 69124 : continue;
6703 : : }
6704 : :
6705 : : /* byte outsize range 0x00..0x7f: call the error handler */
6706 : :
6707 [ + + ]: 158870 : if (error_handler == _Py_ERROR_UNKNOWN)
6708 : 387 : error_handler = _Py_GetErrorHandler(errors);
6709 : :
6710 [ + + + ]: 158870 : switch (error_handler)
6711 : : {
6712 : 158738 : case _Py_ERROR_REPLACE:
6713 : : case _Py_ERROR_SURROGATEESCAPE:
6714 : : /* Fast-path: the error handler only writes one character,
6715 : : but we may switch to UCS2 at the first write */
6716 [ + + - + ]: 158738 : if (_PyUnicodeWriter_PrepareKind(&writer, PyUnicode_2BYTE_KIND) < 0)
6717 : 0 : goto onError;
6718 : 158738 : kind = writer.kind;
6719 : 158738 : data = writer.data;
6720 : :
6721 [ + + ]: 158738 : if (error_handler == _Py_ERROR_REPLACE)
6722 : 762 : PyUnicode_WRITE(kind, data, writer.pos, 0xfffd);
6723 : : else
6724 : 157976 : PyUnicode_WRITE(kind, data, writer.pos, c + 0xdc00);
6725 : 158738 : writer.pos++;
6726 : 158738 : ++s;
6727 : 158738 : break;
6728 : :
6729 : 11 : case _Py_ERROR_IGNORE:
6730 : 11 : ++s;
6731 : 11 : break;
6732 : :
6733 : 121 : default:
6734 : 121 : startinpos = s-starts;
6735 : 121 : endinpos = startinpos + 1;
6736 [ + + ]: 121 : if (unicode_decode_call_errorhandler_writer(
6737 : : errors, &error_handler_obj,
6738 : : "ascii", "ordinal not in range(128)",
6739 : : &starts, &e, &startinpos, &endinpos, &exc, &s,
6740 : : &writer))
6741 : 57 : goto onError;
6742 : 64 : kind = writer.kind;
6743 : 64 : data = writer.data;
6744 : : }
6745 : : }
6746 : 330 : Py_XDECREF(error_handler_obj);
6747 : 330 : Py_XDECREF(exc);
6748 : 330 : return _PyUnicodeWriter_Finish(&writer);
6749 : :
6750 : 57 : onError:
6751 : 57 : _PyUnicodeWriter_Dealloc(&writer);
6752 : 57 : Py_XDECREF(error_handler_obj);
6753 : 57 : Py_XDECREF(exc);
6754 : 57 : return NULL;
6755 : : }
6756 : :
6757 : : PyObject *
6758 : 2168689 : _PyUnicode_AsASCIIString(PyObject *unicode, const char *errors)
6759 : : {
6760 [ - + ]: 2168689 : if (!PyUnicode_Check(unicode)) {
6761 : 0 : PyErr_BadArgument();
6762 : 0 : return NULL;
6763 : : }
6764 : : /* Fast path: if it is an ASCII-only string, construct bytes object
6765 : : directly. Else defer to above function to raise the exception. */
6766 [ + + ]: 2168689 : if (PyUnicode_IS_ASCII(unicode))
6767 : 2162730 : return PyBytes_FromStringAndSize(PyUnicode_DATA(unicode),
6768 : : PyUnicode_GET_LENGTH(unicode));
6769 : 5959 : return unicode_encode_ucs1(unicode, errors, 128);
6770 : : }
6771 : :
6772 : : PyObject *
6773 : 749593 : PyUnicode_AsASCIIString(PyObject *unicode)
6774 : : {
6775 : 749593 : return _PyUnicode_AsASCIIString(unicode, NULL);
6776 : : }
6777 : :
6778 : : #ifdef MS_WINDOWS
6779 : :
6780 : : /* --- MBCS codecs for Windows -------------------------------------------- */
6781 : :
6782 : : #if SIZEOF_INT < SIZEOF_SIZE_T
6783 : : #define NEED_RETRY
6784 : : #endif
6785 : :
6786 : : /* INT_MAX is the theoretical largest chunk (or INT_MAX / 2 when
6787 : : transcoding from UTF-16), but INT_MAX / 4 performs better in
6788 : : both cases also and avoids partial characters overrunning the
6789 : : length limit in MultiByteToWideChar on Windows */
6790 : : #define DECODING_CHUNK_SIZE (INT_MAX/4)
6791 : :
6792 : : #ifndef WC_ERR_INVALID_CHARS
6793 : : # define WC_ERR_INVALID_CHARS 0x0080
6794 : : #endif
6795 : :
6796 : : static const char*
6797 : : code_page_name(UINT code_page, PyObject **obj)
6798 : : {
6799 : : *obj = NULL;
6800 : : if (code_page == CP_ACP)
6801 : : return "mbcs";
6802 : : if (code_page == CP_UTF7)
6803 : : return "CP_UTF7";
6804 : : if (code_page == CP_UTF8)
6805 : : return "CP_UTF8";
6806 : :
6807 : : *obj = PyBytes_FromFormat("cp%u", code_page);
6808 : : if (*obj == NULL)
6809 : : return NULL;
6810 : : return PyBytes_AS_STRING(*obj);
6811 : : }
6812 : :
6813 : : static DWORD
6814 : : decode_code_page_flags(UINT code_page)
6815 : : {
6816 : : if (code_page == CP_UTF7) {
6817 : : /* The CP_UTF7 decoder only supports flags=0 */
6818 : : return 0;
6819 : : }
6820 : : else
6821 : : return MB_ERR_INVALID_CHARS;
6822 : : }
6823 : :
6824 : : /*
6825 : : * Decode a byte string from a Windows code page into unicode object in strict
6826 : : * mode.
6827 : : *
6828 : : * Returns consumed size if succeed, returns -2 on decode error, or raise an
6829 : : * OSError and returns -1 on other error.
6830 : : */
6831 : : static int
6832 : : decode_code_page_strict(UINT code_page,
6833 : : wchar_t **buf,
6834 : : Py_ssize_t *bufsize,
6835 : : const char *in,
6836 : : int insize)
6837 : : {
6838 : : DWORD flags = MB_ERR_INVALID_CHARS;
6839 : : wchar_t *out;
6840 : : DWORD outsize;
6841 : :
6842 : : /* First get the size of the result */
6843 : : assert(insize > 0);
6844 : : while ((outsize = MultiByteToWideChar(code_page, flags,
6845 : : in, insize, NULL, 0)) <= 0)
6846 : : {
6847 : : if (!flags || GetLastError() != ERROR_INVALID_FLAGS) {
6848 : : goto error;
6849 : : }
6850 : : /* For some code pages (e.g. UTF-7) flags must be set to 0. */
6851 : : flags = 0;
6852 : : }
6853 : :
6854 : : /* Extend a wchar_t* buffer */
6855 : : Py_ssize_t n = *bufsize; /* Get the current length */
6856 : : if (widechar_resize(buf, bufsize, n + outsize) < 0) {
6857 : : return -1;
6858 : : }
6859 : : out = *buf + n;
6860 : :
6861 : : /* Do the conversion */
6862 : : outsize = MultiByteToWideChar(code_page, flags, in, insize, out, outsize);
6863 : : if (outsize <= 0)
6864 : : goto error;
6865 : : return insize;
6866 : :
6867 : : error:
6868 : : if (GetLastError() == ERROR_NO_UNICODE_TRANSLATION)
6869 : : return -2;
6870 : : PyErr_SetFromWindowsErr(0);
6871 : : return -1;
6872 : : }
6873 : :
6874 : : /*
6875 : : * Decode a byte string from a code page into unicode object with an error
6876 : : * handler.
6877 : : *
6878 : : * Returns consumed size if succeed, or raise an OSError or
6879 : : * UnicodeDecodeError exception and returns -1 on error.
6880 : : */
6881 : : static int
6882 : : decode_code_page_errors(UINT code_page,
6883 : : wchar_t **buf,
6884 : : Py_ssize_t *bufsize,
6885 : : const char *in, const int size,
6886 : : const char *errors, int final)
6887 : : {
6888 : : const char *startin = in;
6889 : : const char *endin = in + size;
6890 : : DWORD flags = MB_ERR_INVALID_CHARS;
6891 : : /* Ideally, we should get reason from FormatMessage. This is the Windows
6892 : : 2000 English version of the message. */
6893 : : const char *reason = "No mapping for the Unicode character exists "
6894 : : "in the target code page.";
6895 : : /* each step cannot decode more than 1 character, but a character can be
6896 : : represented as a surrogate pair */
6897 : : wchar_t buffer[2], *out;
6898 : : int insize;
6899 : : Py_ssize_t outsize;
6900 : : PyObject *errorHandler = NULL;
6901 : : PyObject *exc = NULL;
6902 : : PyObject *encoding_obj = NULL;
6903 : : const char *encoding;
6904 : : DWORD err;
6905 : : int ret = -1;
6906 : :
6907 : : assert(size > 0);
6908 : :
6909 : : encoding = code_page_name(code_page, &encoding_obj);
6910 : : if (encoding == NULL)
6911 : : return -1;
6912 : :
6913 : : if ((errors == NULL || strcmp(errors, "strict") == 0) && final) {
6914 : : /* The last error was ERROR_NO_UNICODE_TRANSLATION, then we raise a
6915 : : UnicodeDecodeError. */
6916 : : make_decode_exception(&exc, encoding, in, size, 0, 0, reason);
6917 : : if (exc != NULL) {
6918 : : PyCodec_StrictErrors(exc);
6919 : : Py_CLEAR(exc);
6920 : : }
6921 : : goto error;
6922 : : }
6923 : :
6924 : : /* Extend a wchar_t* buffer */
6925 : : Py_ssize_t n = *bufsize; /* Get the current length */
6926 : : if (size > (PY_SSIZE_T_MAX - n) / (Py_ssize_t)Py_ARRAY_LENGTH(buffer)) {
6927 : : PyErr_NoMemory();
6928 : : goto error;
6929 : : }
6930 : : if (widechar_resize(buf, bufsize, n + size * Py_ARRAY_LENGTH(buffer)) < 0) {
6931 : : goto error;
6932 : : }
6933 : : out = *buf + n;
6934 : :
6935 : : /* Decode the byte string character per character */
6936 : : while (in < endin)
6937 : : {
6938 : : /* Decode a character */
6939 : : insize = 1;
6940 : : do
6941 : : {
6942 : : outsize = MultiByteToWideChar(code_page, flags,
6943 : : in, insize,
6944 : : buffer, Py_ARRAY_LENGTH(buffer));
6945 : : if (outsize > 0)
6946 : : break;
6947 : : err = GetLastError();
6948 : : if (err == ERROR_INVALID_FLAGS && flags) {
6949 : : /* For some code pages (e.g. UTF-7) flags must be set to 0. */
6950 : : flags = 0;
6951 : : continue;
6952 : : }
6953 : : if (err != ERROR_NO_UNICODE_TRANSLATION
6954 : : && err != ERROR_INSUFFICIENT_BUFFER)
6955 : : {
6956 : : PyErr_SetFromWindowsErr(0);
6957 : : goto error;
6958 : : }
6959 : : insize++;
6960 : : }
6961 : : /* 4=maximum length of a UTF-8 sequence */
6962 : : while (insize <= 4 && (in + insize) <= endin);
6963 : :
6964 : : if (outsize <= 0) {
6965 : : Py_ssize_t startinpos, endinpos, outpos;
6966 : :
6967 : : /* last character in partial decode? */
6968 : : if (in + insize >= endin && !final)
6969 : : break;
6970 : :
6971 : : startinpos = in - startin;
6972 : : endinpos = startinpos + 1;
6973 : : outpos = out - *buf;
6974 : : if (unicode_decode_call_errorhandler_wchar(
6975 : : errors, &errorHandler,
6976 : : encoding, reason,
6977 : : &startin, &endin, &startinpos, &endinpos, &exc, &in,
6978 : : buf, bufsize, &outpos))
6979 : : {
6980 : : goto error;
6981 : : }
6982 : : out = *buf + outpos;
6983 : : }
6984 : : else {
6985 : : in += insize;
6986 : : memcpy(out, buffer, outsize * sizeof(wchar_t));
6987 : : out += outsize;
6988 : : }
6989 : : }
6990 : :
6991 : : /* Shrink the buffer */
6992 : : assert(out - *buf <= *bufsize);
6993 : : *bufsize = out - *buf;
6994 : : /* (in - startin) <= size and size is an int */
6995 : : ret = Py_SAFE_DOWNCAST(in - startin, Py_ssize_t, int);
6996 : :
6997 : : error:
6998 : : Py_XDECREF(encoding_obj);
6999 : : Py_XDECREF(errorHandler);
7000 : : Py_XDECREF(exc);
7001 : : return ret;
7002 : : }
7003 : :
7004 : : static PyObject *
7005 : : decode_code_page_stateful(int code_page,
7006 : : const char *s, Py_ssize_t size,
7007 : : const char *errors, Py_ssize_t *consumed)
7008 : : {
7009 : : wchar_t *buf = NULL;
7010 : : Py_ssize_t bufsize = 0;
7011 : : int chunk_size, final, converted, done;
7012 : :
7013 : : if (code_page < 0) {
7014 : : PyErr_SetString(PyExc_ValueError, "invalid code page number");
7015 : : return NULL;
7016 : : }
7017 : : if (size < 0) {
7018 : : PyErr_BadInternalCall();
7019 : : return NULL;
7020 : : }
7021 : :
7022 : : if (consumed)
7023 : : *consumed = 0;
7024 : :
7025 : : do
7026 : : {
7027 : : #ifdef NEED_RETRY
7028 : : if (size > DECODING_CHUNK_SIZE) {
7029 : : chunk_size = DECODING_CHUNK_SIZE;
7030 : : final = 0;
7031 : : done = 0;
7032 : : }
7033 : : else
7034 : : #endif
7035 : : {
7036 : : chunk_size = (int)size;
7037 : : final = (consumed == NULL);
7038 : : done = 1;
7039 : : }
7040 : :
7041 : : if (chunk_size == 0 && done) {
7042 : : if (buf != NULL)
7043 : : break;
7044 : : _Py_RETURN_UNICODE_EMPTY();
7045 : : }
7046 : :
7047 : : converted = decode_code_page_strict(code_page, &buf, &bufsize,
7048 : : s, chunk_size);
7049 : : if (converted == -2)
7050 : : converted = decode_code_page_errors(code_page, &buf, &bufsize,
7051 : : s, chunk_size,
7052 : : errors, final);
7053 : : assert(converted != 0 || done);
7054 : :
7055 : : if (converted < 0) {
7056 : : PyMem_Free(buf);
7057 : : return NULL;
7058 : : }
7059 : :
7060 : : if (consumed)
7061 : : *consumed += converted;
7062 : :
7063 : : s += converted;
7064 : : size -= converted;
7065 : : } while (!done);
7066 : :
7067 : : PyObject *v = PyUnicode_FromWideChar(buf, bufsize);
7068 : : PyMem_Free(buf);
7069 : : return v;
7070 : : }
7071 : :
7072 : : PyObject *
7073 : : PyUnicode_DecodeCodePageStateful(int code_page,
7074 : : const char *s,
7075 : : Py_ssize_t size,
7076 : : const char *errors,
7077 : : Py_ssize_t *consumed)
7078 : : {
7079 : : return decode_code_page_stateful(code_page, s, size, errors, consumed);
7080 : : }
7081 : :
7082 : : PyObject *
7083 : : PyUnicode_DecodeMBCSStateful(const char *s,
7084 : : Py_ssize_t size,
7085 : : const char *errors,
7086 : : Py_ssize_t *consumed)
7087 : : {
7088 : : return decode_code_page_stateful(CP_ACP, s, size, errors, consumed);
7089 : : }
7090 : :
7091 : : PyObject *
7092 : : PyUnicode_DecodeMBCS(const char *s,
7093 : : Py_ssize_t size,
7094 : : const char *errors)
7095 : : {
7096 : : return PyUnicode_DecodeMBCSStateful(s, size, errors, NULL);
7097 : : }
7098 : :
7099 : : static DWORD
7100 : : encode_code_page_flags(UINT code_page, const char *errors)
7101 : : {
7102 : : if (code_page == CP_UTF8) {
7103 : : return WC_ERR_INVALID_CHARS;
7104 : : }
7105 : : else if (code_page == CP_UTF7) {
7106 : : /* CP_UTF7 only supports flags=0 */
7107 : : return 0;
7108 : : }
7109 : : else {
7110 : : if (errors != NULL && strcmp(errors, "replace") == 0)
7111 : : return 0;
7112 : : else
7113 : : return WC_NO_BEST_FIT_CHARS;
7114 : : }
7115 : : }
7116 : :
7117 : : /*
7118 : : * Encode a Unicode string to a Windows code page into a byte string in strict
7119 : : * mode.
7120 : : *
7121 : : * Returns consumed characters if succeed, returns -2 on encode error, or raise
7122 : : * an OSError and returns -1 on other error.
7123 : : */
7124 : : static int
7125 : : encode_code_page_strict(UINT code_page, PyObject **outbytes,
7126 : : PyObject *unicode, Py_ssize_t offset, int len,
7127 : : const char* errors)
7128 : : {
7129 : : BOOL usedDefaultChar = FALSE;
7130 : : BOOL *pusedDefaultChar = &usedDefaultChar;
7131 : : int outsize;
7132 : : wchar_t *p;
7133 : : Py_ssize_t size;
7134 : : const DWORD flags = encode_code_page_flags(code_page, NULL);
7135 : : char *out;
7136 : : /* Create a substring so that we can get the UTF-16 representation
7137 : : of just the slice under consideration. */
7138 : : PyObject *substring;
7139 : : int ret = -1;
7140 : :
7141 : : assert(len > 0);
7142 : :
7143 : : if (code_page != CP_UTF8 && code_page != CP_UTF7)
7144 : : pusedDefaultChar = &usedDefaultChar;
7145 : : else
7146 : : pusedDefaultChar = NULL;
7147 : :
7148 : : substring = PyUnicode_Substring(unicode, offset, offset+len);
7149 : : if (substring == NULL)
7150 : : return -1;
7151 : : p = PyUnicode_AsWideCharString(substring, &size);
7152 : : Py_CLEAR(substring);
7153 : : if (p == NULL) {
7154 : : return -1;
7155 : : }
7156 : : assert(size <= INT_MAX);
7157 : :
7158 : : /* First get the size of the result */
7159 : : outsize = WideCharToMultiByte(code_page, flags,
7160 : : p, (int)size,
7161 : : NULL, 0,
7162 : : NULL, pusedDefaultChar);
7163 : : if (outsize <= 0)
7164 : : goto error;
7165 : : /* If we used a default char, then we failed! */
7166 : : if (pusedDefaultChar && *pusedDefaultChar) {
7167 : : ret = -2;
7168 : : goto done;
7169 : : }
7170 : :
7171 : : if (*outbytes == NULL) {
7172 : : /* Create string object */
7173 : : *outbytes = PyBytes_FromStringAndSize(NULL, outsize);
7174 : : if (*outbytes == NULL) {
7175 : : goto done;
7176 : : }
7177 : : out = PyBytes_AS_STRING(*outbytes);
7178 : : }
7179 : : else {
7180 : : /* Extend string object */
7181 : : const Py_ssize_t n = PyBytes_Size(*outbytes);
7182 : : if (outsize > PY_SSIZE_T_MAX - n) {
7183 : : PyErr_NoMemory();
7184 : : goto done;
7185 : : }
7186 : : if (_PyBytes_Resize(outbytes, n + outsize) < 0) {
7187 : : goto done;
7188 : : }
7189 : : out = PyBytes_AS_STRING(*outbytes) + n;
7190 : : }
7191 : :
7192 : : /* Do the conversion */
7193 : : outsize = WideCharToMultiByte(code_page, flags,
7194 : : p, (int)size,
7195 : : out, outsize,
7196 : : NULL, pusedDefaultChar);
7197 : : if (outsize <= 0)
7198 : : goto error;
7199 : : if (pusedDefaultChar && *pusedDefaultChar) {
7200 : : ret = -2;
7201 : : goto done;
7202 : : }
7203 : : ret = 0;
7204 : :
7205 : : done:
7206 : : PyMem_Free(p);
7207 : : return ret;
7208 : :
7209 : : error:
7210 : : if (GetLastError() == ERROR_NO_UNICODE_TRANSLATION) {
7211 : : ret = -2;
7212 : : goto done;
7213 : : }
7214 : : PyErr_SetFromWindowsErr(0);
7215 : : goto done;
7216 : : }
7217 : :
7218 : : /*
7219 : : * Encode a Unicode string to a Windows code page into a byte string using an
7220 : : * error handler.
7221 : : *
7222 : : * Returns consumed characters if succeed, or raise an OSError and returns
7223 : : * -1 on other error.
7224 : : */
7225 : : static int
7226 : : encode_code_page_errors(UINT code_page, PyObject **outbytes,
7227 : : PyObject *unicode, Py_ssize_t unicode_offset,
7228 : : Py_ssize_t insize, const char* errors)
7229 : : {
7230 : : const DWORD flags = encode_code_page_flags(code_page, errors);
7231 : : Py_ssize_t pos = unicode_offset;
7232 : : Py_ssize_t endin = unicode_offset + insize;
7233 : : /* Ideally, we should get reason from FormatMessage. This is the Windows
7234 : : 2000 English version of the message. */
7235 : : const char *reason = "invalid character";
7236 : : /* 4=maximum length of a UTF-8 sequence */
7237 : : char buffer[4];
7238 : : BOOL usedDefaultChar = FALSE, *pusedDefaultChar;
7239 : : Py_ssize_t outsize;
7240 : : char *out;
7241 : : PyObject *errorHandler = NULL;
7242 : : PyObject *exc = NULL;
7243 : : PyObject *encoding_obj = NULL;
7244 : : const char *encoding;
7245 : : Py_ssize_t newpos, newoutsize;
7246 : : PyObject *rep;
7247 : : int ret = -1;
7248 : :
7249 : : assert(insize > 0);
7250 : :
7251 : : encoding = code_page_name(code_page, &encoding_obj);
7252 : : if (encoding == NULL)
7253 : : return -1;
7254 : :
7255 : : if (errors == NULL || strcmp(errors, "strict") == 0) {
7256 : : /* The last error was ERROR_NO_UNICODE_TRANSLATION,
7257 : : then we raise a UnicodeEncodeError. */
7258 : : make_encode_exception(&exc, encoding, unicode, 0, 0, reason);
7259 : : if (exc != NULL) {
7260 : : PyCodec_StrictErrors(exc);
7261 : : Py_DECREF(exc);
7262 : : }
7263 : : Py_XDECREF(encoding_obj);
7264 : : return -1;
7265 : : }
7266 : :
7267 : : if (code_page != CP_UTF8 && code_page != CP_UTF7)
7268 : : pusedDefaultChar = &usedDefaultChar;
7269 : : else
7270 : : pusedDefaultChar = NULL;
7271 : :
7272 : : if (Py_ARRAY_LENGTH(buffer) > PY_SSIZE_T_MAX / insize) {
7273 : : PyErr_NoMemory();
7274 : : goto error;
7275 : : }
7276 : : outsize = insize * Py_ARRAY_LENGTH(buffer);
7277 : :
7278 : : if (*outbytes == NULL) {
7279 : : /* Create string object */
7280 : : *outbytes = PyBytes_FromStringAndSize(NULL, outsize);
7281 : : if (*outbytes == NULL)
7282 : : goto error;
7283 : : out = PyBytes_AS_STRING(*outbytes);
7284 : : }
7285 : : else {
7286 : : /* Extend string object */
7287 : : Py_ssize_t n = PyBytes_Size(*outbytes);
7288 : : if (n > PY_SSIZE_T_MAX - outsize) {
7289 : : PyErr_NoMemory();
7290 : : goto error;
7291 : : }
7292 : : if (_PyBytes_Resize(outbytes, n + outsize) < 0)
7293 : : goto error;
7294 : : out = PyBytes_AS_STRING(*outbytes) + n;
7295 : : }
7296 : :
7297 : : /* Encode the string character per character */
7298 : : while (pos < endin)
7299 : : {
7300 : : Py_UCS4 ch = PyUnicode_READ_CHAR(unicode, pos);
7301 : : wchar_t chars[2];
7302 : : int charsize;
7303 : : if (ch < 0x10000) {
7304 : : chars[0] = (wchar_t)ch;
7305 : : charsize = 1;
7306 : : }
7307 : : else {
7308 : : chars[0] = Py_UNICODE_HIGH_SURROGATE(ch);
7309 : : chars[1] = Py_UNICODE_LOW_SURROGATE(ch);
7310 : : charsize = 2;
7311 : : }
7312 : :
7313 : : outsize = WideCharToMultiByte(code_page, flags,
7314 : : chars, charsize,
7315 : : buffer, Py_ARRAY_LENGTH(buffer),
7316 : : NULL, pusedDefaultChar);
7317 : : if (outsize > 0) {
7318 : : if (pusedDefaultChar == NULL || !(*pusedDefaultChar))
7319 : : {
7320 : : pos++;
7321 : : memcpy(out, buffer, outsize);
7322 : : out += outsize;
7323 : : continue;
7324 : : }
7325 : : }
7326 : : else if (GetLastError() != ERROR_NO_UNICODE_TRANSLATION) {
7327 : : PyErr_SetFromWindowsErr(0);
7328 : : goto error;
7329 : : }
7330 : :
7331 : : rep = unicode_encode_call_errorhandler(
7332 : : errors, &errorHandler, encoding, reason,
7333 : : unicode, &exc,
7334 : : pos, pos + 1, &newpos);
7335 : : if (rep == NULL)
7336 : : goto error;
7337 : :
7338 : : Py_ssize_t morebytes = pos - newpos;
7339 : : if (PyBytes_Check(rep)) {
7340 : : outsize = PyBytes_GET_SIZE(rep);
7341 : : morebytes += outsize;
7342 : : if (morebytes > 0) {
7343 : : Py_ssize_t offset = out - PyBytes_AS_STRING(*outbytes);
7344 : : newoutsize = PyBytes_GET_SIZE(*outbytes) + morebytes;
7345 : : if (_PyBytes_Resize(outbytes, newoutsize) < 0) {
7346 : : Py_DECREF(rep);
7347 : : goto error;
7348 : : }
7349 : : out = PyBytes_AS_STRING(*outbytes) + offset;
7350 : : }
7351 : : memcpy(out, PyBytes_AS_STRING(rep), outsize);
7352 : : out += outsize;
7353 : : }
7354 : : else {
7355 : : Py_ssize_t i;
7356 : : int kind;
7357 : : const void *data;
7358 : :
7359 : : outsize = PyUnicode_GET_LENGTH(rep);
7360 : : morebytes += outsize;
7361 : : if (morebytes > 0) {
7362 : : Py_ssize_t offset = out - PyBytes_AS_STRING(*outbytes);
7363 : : newoutsize = PyBytes_GET_SIZE(*outbytes) + morebytes;
7364 : : if (_PyBytes_Resize(outbytes, newoutsize) < 0) {
7365 : : Py_DECREF(rep);
7366 : : goto error;
7367 : : }
7368 : : out = PyBytes_AS_STRING(*outbytes) + offset;
7369 : : }
7370 : : kind = PyUnicode_KIND(rep);
7371 : : data = PyUnicode_DATA(rep);
7372 : : for (i=0; i < outsize; i++) {
7373 : : Py_UCS4 ch = PyUnicode_READ(kind, data, i);
7374 : : if (ch > 127) {
7375 : : raise_encode_exception(&exc,
7376 : : encoding, unicode,
7377 : : pos, pos + 1,
7378 : : "unable to encode error handler result to ASCII");
7379 : : Py_DECREF(rep);
7380 : : goto error;
7381 : : }
7382 : : *out = (unsigned char)ch;
7383 : : out++;
7384 : : }
7385 : : }
7386 : : pos = newpos;
7387 : : Py_DECREF(rep);
7388 : : }
7389 : : /* write a NUL byte */
7390 : : *out = 0;
7391 : : outsize = out - PyBytes_AS_STRING(*outbytes);
7392 : : assert(outsize <= PyBytes_GET_SIZE(*outbytes));
7393 : : if (_PyBytes_Resize(outbytes, outsize) < 0)
7394 : : goto error;
7395 : : ret = 0;
7396 : :
7397 : : error:
7398 : : Py_XDECREF(encoding_obj);
7399 : : Py_XDECREF(errorHandler);
7400 : : Py_XDECREF(exc);
7401 : : return ret;
7402 : : }
7403 : :
7404 : : static PyObject *
7405 : : encode_code_page(int code_page,
7406 : : PyObject *unicode,
7407 : : const char *errors)
7408 : : {
7409 : : Py_ssize_t len;
7410 : : PyObject *outbytes = NULL;
7411 : : Py_ssize_t offset;
7412 : : int chunk_len, ret, done;
7413 : :
7414 : : if (!PyUnicode_Check(unicode)) {
7415 : : PyErr_BadArgument();
7416 : : return NULL;
7417 : : }
7418 : :
7419 : : len = PyUnicode_GET_LENGTH(unicode);
7420 : :
7421 : : if (code_page < 0) {
7422 : : PyErr_SetString(PyExc_ValueError, "invalid code page number");
7423 : : return NULL;
7424 : : }
7425 : :
7426 : : if (len == 0)
7427 : : return PyBytes_FromStringAndSize(NULL, 0);
7428 : :
7429 : : offset = 0;
7430 : : do
7431 : : {
7432 : : #ifdef NEED_RETRY
7433 : : if (len > DECODING_CHUNK_SIZE) {
7434 : : chunk_len = DECODING_CHUNK_SIZE;
7435 : : done = 0;
7436 : : }
7437 : : else
7438 : : #endif
7439 : : {
7440 : : chunk_len = (int)len;
7441 : : done = 1;
7442 : : }
7443 : :
7444 : : ret = encode_code_page_strict(code_page, &outbytes,
7445 : : unicode, offset, chunk_len,
7446 : : errors);
7447 : : if (ret == -2)
7448 : : ret = encode_code_page_errors(code_page, &outbytes,
7449 : : unicode, offset,
7450 : : chunk_len, errors);
7451 : : if (ret < 0) {
7452 : : Py_XDECREF(outbytes);
7453 : : return NULL;
7454 : : }
7455 : :
7456 : : offset += chunk_len;
7457 : : len -= chunk_len;
7458 : : } while (!done);
7459 : :
7460 : : return outbytes;
7461 : : }
7462 : :
7463 : : PyObject *
7464 : : PyUnicode_EncodeCodePage(int code_page,
7465 : : PyObject *unicode,
7466 : : const char *errors)
7467 : : {
7468 : : return encode_code_page(code_page, unicode, errors);
7469 : : }
7470 : :
7471 : : PyObject *
7472 : : PyUnicode_AsMBCSString(PyObject *unicode)
7473 : : {
7474 : : return PyUnicode_EncodeCodePage(CP_ACP, unicode, NULL);
7475 : : }
7476 : :
7477 : : #undef NEED_RETRY
7478 : :
7479 : : #endif /* MS_WINDOWS */
7480 : :
7481 : : /* --- Character Mapping Codec -------------------------------------------- */
7482 : :
7483 : : static int
7484 : 22831 : charmap_decode_string(const char *s,
7485 : : Py_ssize_t size,
7486 : : PyObject *mapping,
7487 : : const char *errors,
7488 : : _PyUnicodeWriter *writer)
7489 : : {
7490 : 22831 : const char *starts = s;
7491 : : const char *e;
7492 : : Py_ssize_t startinpos, endinpos;
7493 : 22831 : PyObject *errorHandler = NULL, *exc = NULL;
7494 : : Py_ssize_t maplen;
7495 : : int mapkind;
7496 : : const void *mapdata;
7497 : : Py_UCS4 x;
7498 : : unsigned char ch;
7499 : :
7500 : 22831 : maplen = PyUnicode_GET_LENGTH(mapping);
7501 : 22831 : mapdata = PyUnicode_DATA(mapping);
7502 : 22831 : mapkind = PyUnicode_KIND(mapping);
7503 : :
7504 : 22831 : e = s + size;
7505 : :
7506 [ + + + + ]: 22831 : if (mapkind == PyUnicode_1BYTE_KIND && maplen >= 256) {
7507 : : /* fast-path for cp037, cp500 and iso8859_1 encodings. iso8859_1
7508 : : * is disabled in encoding aliases, latin1 is preferred because
7509 : : * its implementation is faster. */
7510 : 112 : const Py_UCS1 *mapdata_ucs1 = (const Py_UCS1 *)mapdata;
7511 : 112 : Py_UCS1 *outdata = (Py_UCS1 *)writer->data;
7512 : 112 : Py_UCS4 maxchar = writer->maxchar;
7513 : :
7514 : : assert (writer->kind == PyUnicode_1BYTE_KIND);
7515 [ + + ]: 12812 : while (s < e) {
7516 : 12700 : ch = *s;
7517 : 12700 : x = mapdata_ucs1[ch];
7518 [ + + ]: 12700 : if (x > maxchar) {
7519 [ - + - - : 4 : if (_PyUnicodeWriter_Prepare(writer, 1, 0xff) == -1)
- + ]
7520 : 0 : goto onError;
7521 : 4 : maxchar = writer->maxchar;
7522 : 4 : outdata = (Py_UCS1 *)writer->data;
7523 : : }
7524 : 12700 : outdata[writer->pos] = x;
7525 : 12700 : writer->pos++;
7526 : 12700 : ++s;
7527 : : }
7528 : 112 : return 0;
7529 : : }
7530 : :
7531 [ + + ]: 23956 : while (s < e) {
7532 [ + + + + ]: 23921 : if (mapkind == PyUnicode_2BYTE_KIND && maplen >= 256) {
7533 : 23635 : int outkind = writer->kind;
7534 : 23635 : const Py_UCS2 *mapdata_ucs2 = (const Py_UCS2 *)mapdata;
7535 [ + + ]: 23635 : if (outkind == PyUnicode_1BYTE_KIND) {
7536 : 22881 : Py_UCS1 *outdata = (Py_UCS1 *)writer->data;
7537 : 22881 : Py_UCS4 maxchar = writer->maxchar;
7538 [ + + ]: 1018348 : while (s < e) {
7539 : 995866 : ch = *s;
7540 : 995866 : x = mapdata_ucs2[ch];
7541 [ + + ]: 995866 : if (x > maxchar)
7542 : 399 : goto Error;
7543 : 995467 : outdata[writer->pos] = x;
7544 : 995467 : writer->pos++;
7545 : 995467 : ++s;
7546 : : }
7547 : 22482 : break;
7548 : : }
7549 [ + - ]: 754 : else if (outkind == PyUnicode_2BYTE_KIND) {
7550 : 754 : Py_UCS2 *outdata = (Py_UCS2 *)writer->data;
7551 [ + + ]: 43059 : while (s < e) {
7552 : 42859 : ch = *s;
7553 : 42859 : x = mapdata_ucs2[ch];
7554 [ + + ]: 42859 : if (x == 0xFFFE)
7555 : 554 : goto Error;
7556 : 42305 : outdata[writer->pos] = x;
7557 : 42305 : writer->pos++;
7558 : 42305 : ++s;
7559 : : }
7560 : 200 : break;
7561 : : }
7562 : : }
7563 : 286 : ch = *s;
7564 : :
7565 [ + + ]: 286 : if (ch < maplen)
7566 : 26 : x = PyUnicode_READ(mapkind, mapdata, ch);
7567 : : else
7568 : 260 : x = 0xfffe; /* invalid value */
7569 : 1239 : Error:
7570 [ + + ]: 1239 : if (x == 0xfffe)
7571 : : {
7572 : : /* undefined mapping */
7573 : 876 : startinpos = s-starts;
7574 : 876 : endinpos = startinpos+1;
7575 [ + + ]: 876 : if (unicode_decode_call_errorhandler_writer(
7576 : : errors, &errorHandler,
7577 : : "charmap", "character maps to <undefined>",
7578 : : &starts, &e, &startinpos, &endinpos, &exc, &s,
7579 : : writer)) {
7580 : 2 : goto onError;
7581 : : }
7582 : 874 : continue;
7583 : : }
7584 : :
7585 [ - + ]: 363 : if (_PyUnicodeWriter_WriteCharInline(writer, x) < 0)
7586 : 0 : goto onError;
7587 : 363 : ++s;
7588 : : }
7589 : 22717 : Py_XDECREF(errorHandler);
7590 : 22717 : Py_XDECREF(exc);
7591 : 22717 : return 0;
7592 : :
7593 : 2 : onError:
7594 : 2 : Py_XDECREF(errorHandler);
7595 : 2 : Py_XDECREF(exc);
7596 : 2 : return -1;
7597 : : }
7598 : :
7599 : : static int
7600 : 45 : charmap_decode_mapping(const char *s,
7601 : : Py_ssize_t size,
7602 : : PyObject *mapping,
7603 : : const char *errors,
7604 : : _PyUnicodeWriter *writer)
7605 : 102 : {
7606 : 45 : const char *starts = s;
7607 : : const char *e;
7608 : : Py_ssize_t startinpos, endinpos;
7609 : 45 : PyObject *errorHandler = NULL, *exc = NULL;
7610 : : unsigned char ch;
7611 : 45 : PyObject *key, *item = NULL;
7612 : :
7613 : 45 : e = s + size;
7614 : :
7615 [ + + ]: 420 : while (s < e) {
7616 : 387 : ch = *s;
7617 : :
7618 : : /* Get mapping (char ordinal -> integer, Unicode char or None) */
7619 : 387 : key = PyLong_FromLong((long)ch);
7620 [ - + ]: 387 : if (key == NULL)
7621 : 0 : goto onError;
7622 : :
7623 : 387 : item = PyObject_GetItem(mapping, key);
7624 : 387 : Py_DECREF(key);
7625 [ + + ]: 387 : if (item == NULL) {
7626 [ + + ]: 267 : if (PyErr_ExceptionMatches(PyExc_LookupError)) {
7627 : : /* No mapping found means: mapping is undefined. */
7628 : 266 : PyErr_Clear();
7629 : 266 : goto Undefined;
7630 : : } else
7631 : 1 : goto onError;
7632 : : }
7633 : :
7634 : : /* Apply mapping */
7635 [ + + ]: 120 : if (item == Py_None)
7636 : 6 : goto Undefined;
7637 [ + + ]: 114 : if (PyLong_Check(item)) {
7638 : 59 : long value = PyLong_AS_LONG(item);
7639 [ + + ]: 59 : if (value == 0xFFFE)
7640 : 4 : goto Undefined;
7641 [ + + + + ]: 55 : if (value < 0 || value > MAX_UNICODE) {
7642 : 4 : PyErr_Format(PyExc_TypeError,
7643 : : "character mapping must be in range(0x%x)",
7644 : : (unsigned long)MAX_UNICODE + 1);
7645 : 4 : goto onError;
7646 : : }
7647 : :
7648 [ - + ]: 51 : if (_PyUnicodeWriter_WriteCharInline(writer, value) < 0)
7649 : 0 : goto onError;
7650 : : }
7651 [ + - ]: 55 : else if (PyUnicode_Check(item)) {
7652 [ + + ]: 55 : if (PyUnicode_GET_LENGTH(item) == 1) {
7653 : 39 : Py_UCS4 value = PyUnicode_READ_CHAR(item, 0);
7654 [ + + ]: 39 : if (value == 0xFFFE)
7655 : 4 : goto Undefined;
7656 [ - + ]: 35 : if (_PyUnicodeWriter_WriteCharInline(writer, value) < 0)
7657 : 0 : goto onError;
7658 : : }
7659 : : else {
7660 : 16 : writer->overallocate = 1;
7661 [ - + ]: 16 : if (_PyUnicodeWriter_WriteStr(writer, item) == -1)
7662 : 0 : goto onError;
7663 : : }
7664 : : }
7665 : : else {
7666 : : /* wrong return value */
7667 : 0 : PyErr_SetString(PyExc_TypeError,
7668 : : "character mapping must return integer, None or str");
7669 : 0 : goto onError;
7670 : : }
7671 [ + - ]: 102 : Py_CLEAR(item);
7672 : 102 : ++s;
7673 : 102 : continue;
7674 : :
7675 : 280 : Undefined:
7676 : : /* undefined mapping */
7677 [ + + ]: 280 : Py_CLEAR(item);
7678 : 280 : startinpos = s-starts;
7679 : 280 : endinpos = startinpos+1;
7680 [ + + ]: 280 : if (unicode_decode_call_errorhandler_writer(
7681 : : errors, &errorHandler,
7682 : : "charmap", "character maps to <undefined>",
7683 : : &starts, &e, &startinpos, &endinpos, &exc, &s,
7684 : : writer)) {
7685 : 7 : goto onError;
7686 : : }
7687 : : }
7688 : 33 : Py_XDECREF(errorHandler);
7689 : 33 : Py_XDECREF(exc);
7690 : 33 : return 0;
7691 : :
7692 : 12 : onError:
7693 : 12 : Py_XDECREF(item);
7694 : 12 : Py_XDECREF(errorHandler);
7695 : 12 : Py_XDECREF(exc);
7696 : 12 : return -1;
7697 : : }
7698 : :
7699 : : PyObject *
7700 : 23785 : PyUnicode_DecodeCharmap(const char *s,
7701 : : Py_ssize_t size,
7702 : : PyObject *mapping,
7703 : : const char *errors)
7704 : : {
7705 : : _PyUnicodeWriter writer;
7706 : :
7707 : : /* Default to Latin-1 */
7708 [ + + ]: 23785 : if (mapping == NULL)
7709 : 67 : return PyUnicode_DecodeLatin1(s, size, errors);
7710 : :
7711 [ + + ]: 23718 : if (size == 0)
7712 : 842 : _Py_RETURN_UNICODE_EMPTY();
7713 : 22876 : _PyUnicodeWriter_Init(&writer);
7714 : 22876 : writer.min_length = size;
7715 [ - + - - : 22876 : if (_PyUnicodeWriter_Prepare(&writer, writer.min_length, 127) == -1)
+ - - + ]
7716 : 0 : goto onError;
7717 : :
7718 [ + + ]: 22876 : if (PyUnicode_CheckExact(mapping)) {
7719 [ + + ]: 22831 : if (charmap_decode_string(s, size, mapping, errors, &writer) < 0)
7720 : 2 : goto onError;
7721 : : }
7722 : : else {
7723 [ + + ]: 45 : if (charmap_decode_mapping(s, size, mapping, errors, &writer) < 0)
7724 : 12 : goto onError;
7725 : : }
7726 : 22862 : return _PyUnicodeWriter_Finish(&writer);
7727 : :
7728 : 14 : onError:
7729 : 14 : _PyUnicodeWriter_Dealloc(&writer);
7730 : 14 : return NULL;
7731 : : }
7732 : :
7733 : : /* Charmap encoding: the lookup table */
7734 : :
7735 : : /*[clinic input]
7736 : : class EncodingMap "struct encoding_map *" "&EncodingMapType"
7737 : : [clinic start generated code]*/
7738 : : /*[clinic end generated code: output=da39a3ee5e6b4b0d input=14e46bbb6c522d22]*/
7739 : :
7740 : : struct encoding_map {
7741 : : PyObject_HEAD
7742 : : unsigned char level1[32];
7743 : : int count2, count3;
7744 : : unsigned char level23[1];
7745 : : };
7746 : :
7747 : : /*[clinic input]
7748 : : EncodingMap.size
7749 : :
7750 : : Return the size (in bytes) of this object.
7751 : : [clinic start generated code]*/
7752 : :
7753 : : static PyObject *
7754 : 0 : EncodingMap_size_impl(struct encoding_map *self)
7755 : : /*[clinic end generated code: output=c4c969e4c99342a4 input=004ff13f26bb5366]*/
7756 : : {
7757 : 0 : return PyLong_FromLong((sizeof(*self) - 1) + 16*self->count2 +
7758 : 0 : 128*self->count3);
7759 : : }
7760 : :
7761 : : static PyMethodDef encoding_map_methods[] = {
7762 : : ENCODINGMAP_SIZE_METHODDEF
7763 : : {NULL, NULL}
7764 : : };
7765 : :
7766 : : static PyTypeObject EncodingMapType = {
7767 : : PyVarObject_HEAD_INIT(NULL, 0)
7768 : : .tp_name = "EncodingMap",
7769 : : .tp_basicsize = sizeof(struct encoding_map),
7770 : : /* methods */
7771 : : .tp_flags = Py_TPFLAGS_DEFAULT,
7772 : : .tp_methods = encoding_map_methods,
7773 : : };
7774 : :
7775 : : PyObject*
7776 : 217 : PyUnicode_BuildEncodingMap(PyObject* string)
7777 : : {
7778 : : PyObject *result;
7779 : : struct encoding_map *mresult;
7780 : : int i;
7781 : 217 : int need_dict = 0;
7782 : : unsigned char level1[32];
7783 : : unsigned char level2[512];
7784 : : unsigned char *mlevel1, *mlevel2, *mlevel3;
7785 : 217 : int count2 = 0, count3 = 0;
7786 : : int kind;
7787 : : const void *data;
7788 : : Py_ssize_t length;
7789 : : Py_UCS4 ch;
7790 : :
7791 [ + - - + ]: 217 : if (!PyUnicode_Check(string) || !PyUnicode_GET_LENGTH(string)) {
7792 : 0 : PyErr_BadArgument();
7793 : 0 : return NULL;
7794 : : }
7795 : 217 : kind = PyUnicode_KIND(string);
7796 : 217 : data = PyUnicode_DATA(string);
7797 : 217 : length = PyUnicode_GET_LENGTH(string);
7798 : 217 : length = Py_MIN(length, 256);
7799 : 217 : memset(level1, 0xFF, sizeof level1);
7800 : 217 : memset(level2, 0xFF, sizeof level2);
7801 : :
7802 : : /* If there isn't a one-to-one mapping of NULL to \0,
7803 : : or if there are non-BMP characters, we need to use
7804 : : a mapping dictionary. */
7805 [ - + ]: 217 : if (PyUnicode_READ(kind, data, 0) != 0)
7806 : 0 : need_dict = 1;
7807 [ + + ]: 55552 : for (i = 1; i < length; i++) {
7808 : : int l1, l2;
7809 : 55335 : ch = PyUnicode_READ(kind, data, i);
7810 [ + - - + ]: 55335 : if (ch == 0 || ch > 0xFFFF) {
7811 : 0 : need_dict = 1;
7812 : 0 : break;
7813 : : }
7814 [ + + ]: 55335 : if (ch == 0xFFFE)
7815 : : /* unmapped character */
7816 : 1340 : continue;
7817 : 53995 : l1 = ch >> 11;
7818 : 53995 : l2 = ch >> 7;
7819 [ + + ]: 53995 : if (level1[l1] == 0xFF)
7820 : 415 : level1[l1] = count2++;
7821 [ + + ]: 53995 : if (level2[l2] == 0xFF)
7822 : 1299 : level2[l2] = count3++;
7823 : : }
7824 : :
7825 [ + - - + ]: 217 : if (count2 >= 0xFF || count3 >= 0xFF)
7826 : 0 : need_dict = 1;
7827 : :
7828 [ - + ]: 217 : if (need_dict) {
7829 : 0 : PyObject *result = PyDict_New();
7830 : : PyObject *key, *value;
7831 [ # # ]: 0 : if (!result)
7832 : 0 : return NULL;
7833 [ # # ]: 0 : for (i = 0; i < length; i++) {
7834 : 0 : key = PyLong_FromLong(PyUnicode_READ(kind, data, i));
7835 : 0 : value = PyLong_FromLong(i);
7836 [ # # # # ]: 0 : if (!key || !value)
7837 : 0 : goto failed1;
7838 [ # # ]: 0 : if (PyDict_SetItem(result, key, value) == -1)
7839 : 0 : goto failed1;
7840 : 0 : Py_DECREF(key);
7841 : 0 : Py_DECREF(value);
7842 : : }
7843 : 0 : return result;
7844 : 0 : failed1:
7845 : 0 : Py_XDECREF(key);
7846 : 0 : Py_XDECREF(value);
7847 : 0 : Py_DECREF(result);
7848 : 0 : return NULL;
7849 : : }
7850 : :
7851 : : /* Create a three-level trie */
7852 : 217 : result = PyObject_Malloc(sizeof(struct encoding_map) +
7853 : 217 : 16*count2 + 128*count3 - 1);
7854 [ - + ]: 217 : if (!result) {
7855 : : return PyErr_NoMemory();
7856 : : }
7857 : :
7858 : 217 : _PyObject_Init(result, &EncodingMapType);
7859 : 217 : mresult = (struct encoding_map*)result;
7860 : 217 : mresult->count2 = count2;
7861 : 217 : mresult->count3 = count3;
7862 : 217 : mlevel1 = mresult->level1;
7863 : 217 : mlevel2 = mresult->level23;
7864 : 217 : mlevel3 = mresult->level23 + 16*count2;
7865 : 217 : memcpy(mlevel1, level1, 32);
7866 : 217 : memset(mlevel2, 0xFF, 16*count2);
7867 : 217 : memset(mlevel3, 0, 128*count3);
7868 : 217 : count3 = 0;
7869 [ + + ]: 55552 : for (i = 1; i < length; i++) {
7870 : : int o1, o2, o3, i2, i3;
7871 : 55335 : Py_UCS4 ch = PyUnicode_READ(kind, data, i);
7872 [ + + ]: 55335 : if (ch == 0xFFFE)
7873 : : /* unmapped character */
7874 : 1340 : continue;
7875 : 53995 : o1 = ch>>11;
7876 : 53995 : o2 = (ch>>7) & 0xF;
7877 : 53995 : i2 = 16*mlevel1[o1] + o2;
7878 [ + + ]: 53995 : if (mlevel2[i2] == 0xFF)
7879 : 1299 : mlevel2[i2] = count3++;
7880 : 53995 : o3 = ch & 0x7F;
7881 : 53995 : i3 = 128*mlevel2[i2] + o3;
7882 : 53995 : mlevel3[i3] = i;
7883 : : }
7884 : 217 : return result;
7885 : : }
7886 : :
7887 : : static int
7888 : 220485 : encoding_map_lookup(Py_UCS4 c, PyObject *mapping)
7889 : : {
7890 : 220485 : struct encoding_map *map = (struct encoding_map*)mapping;
7891 : 220485 : int l1 = c>>11;
7892 : 220485 : int l2 = (c>>7) & 0xF;
7893 : 220485 : int l3 = c & 0x7F;
7894 : : int i;
7895 : :
7896 [ + + ]: 220485 : if (c > 0xFFFF)
7897 : 10 : return -1;
7898 [ + + ]: 220475 : if (c == 0)
7899 : 39 : return 0;
7900 : : /* level 1*/
7901 : 220436 : i = map->level1[l1];
7902 [ + + ]: 220436 : if (i == 0xFF) {
7903 : 12074 : return -1;
7904 : : }
7905 : : /* level 2*/
7906 : 208362 : i = map->level23[16*i+l2];
7907 [ + + ]: 208362 : if (i == 0xFF) {
7908 : 9 : return -1;
7909 : : }
7910 : : /* level 3 */
7911 : 208353 : i = map->level23[16*map->count2 + 128*i + l3];
7912 [ + + ]: 208353 : if (i == 0) {
7913 : 14 : return -1;
7914 : : }
7915 : 208339 : return i;
7916 : : }
7917 : :
7918 : : /* Lookup the character ch in the mapping. If the character
7919 : : can't be found, Py_None is returned (or NULL, if another
7920 : : error occurred). */
7921 : : static PyObject *
7922 : 28125 : charmapencode_lookup(Py_UCS4 c, PyObject *mapping)
7923 : : {
7924 : 28125 : PyObject *w = PyLong_FromLong((long)c);
7925 : : PyObject *x;
7926 : :
7927 [ - + ]: 28125 : if (w == NULL)
7928 : 0 : return NULL;
7929 : 28125 : x = PyObject_GetItem(mapping, w);
7930 : 28125 : Py_DECREF(w);
7931 [ + + ]: 28125 : if (x == NULL) {
7932 [ + + ]: 42 : if (PyErr_ExceptionMatches(PyExc_LookupError)) {
7933 : : /* No mapping found means: mapping is undefined. */
7934 : 36 : PyErr_Clear();
7935 : 36 : Py_RETURN_NONE;
7936 : : } else
7937 : 6 : return NULL;
7938 : : }
7939 [ + + ]: 28083 : else if (x == Py_None)
7940 : 6 : return x;
7941 [ + + ]: 28077 : else if (PyLong_Check(x)) {
7942 : 28056 : long value = PyLong_AS_LONG(x);
7943 [ + - + + ]: 28056 : if (value < 0 || value > 255) {
7944 : 6 : PyErr_SetString(PyExc_TypeError,
7945 : : "character mapping must be in range(256)");
7946 : 6 : Py_DECREF(x);
7947 : 6 : return NULL;
7948 : : }
7949 : 28050 : return x;
7950 : : }
7951 [ + + ]: 21 : else if (PyBytes_Check(x))
7952 : 20 : return x;
7953 : : else {
7954 : : /* wrong return value */
7955 : 1 : PyErr_Format(PyExc_TypeError,
7956 : : "character mapping must return integer, bytes or None, not %.400s",
7957 : 1 : Py_TYPE(x)->tp_name);
7958 : 1 : Py_DECREF(x);
7959 : 1 : return NULL;
7960 : : }
7961 : : }
7962 : :
7963 : : static int
7964 : 74 : charmapencode_resize(PyObject **outobj, Py_ssize_t *outpos, Py_ssize_t requiredsize)
7965 : : {
7966 : 74 : Py_ssize_t outsize = PyBytes_GET_SIZE(*outobj);
7967 : : /* exponentially overallocate to minimize reallocations */
7968 [ + - ]: 74 : if (requiredsize < 2*outsize)
7969 : 74 : requiredsize = 2*outsize;
7970 [ - + ]: 74 : if (_PyBytes_Resize(outobj, requiredsize))
7971 : 0 : return -1;
7972 : 74 : return 0;
7973 : : }
7974 : :
7975 : : typedef enum charmapencode_result {
7976 : : enc_SUCCESS, enc_FAILED, enc_EXCEPTION
7977 : : } charmapencode_result;
7978 : : /* lookup the character, put the result in the output string and adjust
7979 : : various state variables. Resize the output bytes object if not enough
7980 : : space is available. Return a new reference to the object that
7981 : : was put in the output buffer, or Py_None, if the mapping was undefined
7982 : : (in which case no character was written) or NULL, if a
7983 : : reallocation error occurred. The caller must decref the result */
7984 : : static charmapencode_result
7985 : 236558 : charmapencode_output(Py_UCS4 c, PyObject *mapping,
7986 : : PyObject **outobj, Py_ssize_t *outpos)
7987 : : {
7988 : : PyObject *rep;
7989 : : char *outstart;
7990 : 236558 : Py_ssize_t outsize = PyBytes_GET_SIZE(*outobj);
7991 : :
7992 [ + + ]: 236558 : if (Py_IS_TYPE(mapping, &EncodingMapType)) {
7993 : 208461 : int res = encoding_map_lookup(c, mapping);
7994 : 208461 : Py_ssize_t requiredsize = *outpos+1;
7995 [ + + ]: 208461 : if (res == -1)
7996 : 98 : return enc_FAILED;
7997 [ + + ]: 208363 : if (outsize<requiredsize)
7998 [ - + ]: 60 : if (charmapencode_resize(outobj, outpos, requiredsize))
7999 : 0 : return enc_EXCEPTION;
8000 : 208363 : outstart = PyBytes_AS_STRING(*outobj);
8001 : 208363 : outstart[(*outpos)++] = (char)res;
8002 : 208363 : return enc_SUCCESS;
8003 : : }
8004 : :
8005 : 28097 : rep = charmapencode_lookup(c, mapping);
8006 [ + + ]: 28097 : if (rep==NULL)
8007 : 13 : return enc_EXCEPTION;
8008 [ + + ]: 28084 : else if (rep==Py_None) {
8009 : 38 : Py_DECREF(rep);
8010 : 38 : return enc_FAILED;
8011 : : } else {
8012 [ + + ]: 28046 : if (PyLong_Check(rep)) {
8013 : 28026 : Py_ssize_t requiredsize = *outpos+1;
8014 [ + + ]: 28026 : if (outsize<requiredsize)
8015 [ - + ]: 8 : if (charmapencode_resize(outobj, outpos, requiredsize)) {
8016 : 0 : Py_DECREF(rep);
8017 : 0 : return enc_EXCEPTION;
8018 : : }
8019 : 28026 : outstart = PyBytes_AS_STRING(*outobj);
8020 : 28026 : outstart[(*outpos)++] = (char)PyLong_AS_LONG(rep);
8021 : : }
8022 : : else {
8023 : 20 : const char *repchars = PyBytes_AS_STRING(rep);
8024 : 20 : Py_ssize_t repsize = PyBytes_GET_SIZE(rep);
8025 : 20 : Py_ssize_t requiredsize = *outpos+repsize;
8026 [ + + ]: 20 : if (outsize<requiredsize)
8027 [ - + ]: 6 : if (charmapencode_resize(outobj, outpos, requiredsize)) {
8028 : 0 : Py_DECREF(rep);
8029 : 0 : return enc_EXCEPTION;
8030 : : }
8031 : 20 : outstart = PyBytes_AS_STRING(*outobj);
8032 : 20 : memcpy(outstart + *outpos, repchars, repsize);
8033 : 20 : *outpos += repsize;
8034 : : }
8035 : : }
8036 : 28046 : Py_DECREF(rep);
8037 : 28046 : return enc_SUCCESS;
8038 : : }
8039 : :
8040 : : /* handle an error in PyUnicode_EncodeCharmap
8041 : : Return 0 on success, -1 on error */
8042 : : static int
8043 : 129 : charmap_encoding_error(
8044 : : PyObject *unicode, Py_ssize_t *inpos, PyObject *mapping,
8045 : : PyObject **exceptionObject,
8046 : : _Py_error_handler *error_handler, PyObject **error_handler_obj, const char *errors,
8047 : : PyObject **res, Py_ssize_t *respos)
8048 : : {
8049 : 129 : PyObject *repunicode = NULL; /* initialize to prevent gcc warning */
8050 : : Py_ssize_t size, repsize;
8051 : : Py_ssize_t newpos;
8052 : : int kind;
8053 : : const void *data;
8054 : : Py_ssize_t index;
8055 : : /* startpos for collecting unencodable chars */
8056 : 129 : Py_ssize_t collstartpos = *inpos;
8057 : 129 : Py_ssize_t collendpos = *inpos+1;
8058 : : Py_ssize_t collpos;
8059 : 129 : const char *encoding = "charmap";
8060 : 129 : const char *reason = "character maps to <undefined>";
8061 : : charmapencode_result x;
8062 : : Py_UCS4 ch;
8063 : : int val;
8064 : :
8065 : 129 : size = PyUnicode_GET_LENGTH(unicode);
8066 : : /* find all unencodable characters */
8067 [ + + ]: 12142 : while (collendpos < size) {
8068 : : PyObject *rep;
8069 [ + + ]: 12052 : if (Py_IS_TYPE(mapping, &EncodingMapType)) {
8070 : 12024 : ch = PyUnicode_READ_CHAR(unicode, collendpos);
8071 : 12024 : val = encoding_map_lookup(ch, mapping);
8072 [ + + ]: 12024 : if (val != -1)
8073 : 15 : break;
8074 : 12009 : ++collendpos;
8075 : 12009 : continue;
8076 : : }
8077 : :
8078 : 28 : ch = PyUnicode_READ_CHAR(unicode, collendpos);
8079 : 28 : rep = charmapencode_lookup(ch, mapping);
8080 [ - + ]: 28 : if (rep==NULL)
8081 : 0 : return -1;
8082 [ + + ]: 28 : else if (rep!=Py_None) {
8083 : 24 : Py_DECREF(rep);
8084 : 24 : break;
8085 : : }
8086 : 4 : Py_DECREF(rep);
8087 : 4 : ++collendpos;
8088 : : }
8089 : : /* cache callback name lookup
8090 : : * (if not done yet, i.e. it's the first error) */
8091 [ + + ]: 129 : if (*error_handler == _Py_ERROR_UNKNOWN)
8092 : 62 : *error_handler = _Py_GetErrorHandler(errors);
8093 : :
8094 [ + + + + : 129 : switch (*error_handler) {
+ ]
8095 : 5 : case _Py_ERROR_STRICT:
8096 : 5 : raise_encode_exception(exceptionObject, encoding, unicode, collstartpos, collendpos, reason);
8097 : 5 : return -1;
8098 : :
8099 : 8 : case _Py_ERROR_REPLACE:
8100 [ + + ]: 1015 : for (collpos = collstartpos; collpos<collendpos; ++collpos) {
8101 : 1009 : x = charmapencode_output('?', mapping, res, respos);
8102 [ + + ]: 1009 : if (x==enc_EXCEPTION) {
8103 : 1 : return -1;
8104 : : }
8105 [ + + ]: 1008 : else if (x==enc_FAILED) {
8106 : 1 : raise_encode_exception(exceptionObject, encoding, unicode, collstartpos, collendpos, reason);
8107 : 1 : return -1;
8108 : : }
8109 : : }
8110 : : /* fall through */
8111 : : case _Py_ERROR_IGNORE:
8112 : 11 : *inpos = collendpos;
8113 : 11 : break;
8114 : :
8115 : 9 : case _Py_ERROR_XMLCHARREFREPLACE:
8116 : : /* generate replacement (temporarily (mis)uses p) */
8117 [ + + ]: 1023 : for (collpos = collstartpos; collpos < collendpos; ++collpos) {
8118 : : char buffer[2+29+1+1];
8119 : : char *cp;
8120 : 1015 : sprintf(buffer, "&#%d;", (int)PyUnicode_READ_CHAR(unicode, collpos));
8121 [ + + ]: 9115 : for (cp = buffer; *cp; ++cp) {
8122 : 8101 : x = charmapencode_output(*cp, mapping, res, respos);
8123 [ - + ]: 8101 : if (x==enc_EXCEPTION)
8124 : 1 : return -1;
8125 [ + + ]: 8101 : else if (x==enc_FAILED) {
8126 : 1 : raise_encode_exception(exceptionObject, encoding, unicode, collstartpos, collendpos, reason);
8127 : 1 : return -1;
8128 : : }
8129 : : }
8130 : : }
8131 : 8 : *inpos = collendpos;
8132 : 8 : break;
8133 : :
8134 : 102 : default:
8135 : 102 : repunicode = unicode_encode_call_errorhandler(errors, error_handler_obj,
8136 : : encoding, reason, unicode, exceptionObject,
8137 : : collstartpos, collendpos, &newpos);
8138 [ + + ]: 102 : if (repunicode == NULL)
8139 : 12 : return -1;
8140 [ + + ]: 90 : if (PyBytes_Check(repunicode)) {
8141 : : /* Directly copy bytes result to output. */
8142 : 2 : Py_ssize_t outsize = PyBytes_Size(*res);
8143 : : Py_ssize_t requiredsize;
8144 : 2 : repsize = PyBytes_Size(repunicode);
8145 : 2 : requiredsize = *respos + repsize;
8146 [ - + ]: 2 : if (requiredsize > outsize)
8147 : : /* Make room for all additional bytes. */
8148 [ # # ]: 0 : if (charmapencode_resize(res, respos, requiredsize)) {
8149 : 0 : Py_DECREF(repunicode);
8150 : 0 : return -1;
8151 : : }
8152 : 2 : memcpy(PyBytes_AsString(*res) + *respos,
8153 : 2 : PyBytes_AsString(repunicode), repsize);
8154 : 2 : *respos += repsize;
8155 : 2 : *inpos = newpos;
8156 : 2 : Py_DECREF(repunicode);
8157 : 2 : break;
8158 : : }
8159 : : /* generate replacement */
8160 : 88 : repsize = PyUnicode_GET_LENGTH(repunicode);
8161 : 88 : data = PyUnicode_DATA(repunicode);
8162 : 88 : kind = PyUnicode_KIND(repunicode);
8163 [ + + ]: 63480 : for (index = 0; index < repsize; index++) {
8164 : 63397 : Py_UCS4 repch = PyUnicode_READ(kind, data, index);
8165 : 63397 : x = charmapencode_output(repch, mapping, res, respos);
8166 [ - + ]: 63397 : if (x==enc_EXCEPTION) {
8167 : 0 : Py_DECREF(repunicode);
8168 : 0 : return -1;
8169 : : }
8170 [ + + ]: 63397 : else if (x==enc_FAILED) {
8171 : 5 : Py_DECREF(repunicode);
8172 : 5 : raise_encode_exception(exceptionObject, encoding, unicode, collstartpos, collendpos, reason);
8173 : 5 : return -1;
8174 : : }
8175 : : }
8176 : 83 : *inpos = newpos;
8177 : 83 : Py_DECREF(repunicode);
8178 : : }
8179 : 104 : return 0;
8180 : : }
8181 : :
8182 : : PyObject *
8183 : 4689 : _PyUnicode_EncodeCharmap(PyObject *unicode,
8184 : : PyObject *mapping,
8185 : : const char *errors)
8186 : : {
8187 : : /* output object */
8188 : 4689 : PyObject *res = NULL;
8189 : : /* current input position */
8190 : 4689 : Py_ssize_t inpos = 0;
8191 : : Py_ssize_t size;
8192 : : /* current output position */
8193 : 4689 : Py_ssize_t respos = 0;
8194 : 4689 : PyObject *error_handler_obj = NULL;
8195 : 4689 : PyObject *exc = NULL;
8196 : 4689 : _Py_error_handler error_handler = _Py_ERROR_UNKNOWN;
8197 : : const void *data;
8198 : : int kind;
8199 : :
8200 : 4689 : size = PyUnicode_GET_LENGTH(unicode);
8201 : 4689 : data = PyUnicode_DATA(unicode);
8202 : 4689 : kind = PyUnicode_KIND(unicode);
8203 : :
8204 : : /* Default to Latin-1 */
8205 [ + + ]: 4689 : if (mapping == NULL)
8206 : 58 : return unicode_encode_ucs1(unicode, errors, 256);
8207 : :
8208 : : /* allocate enough for a simple encoding without
8209 : : replacements, if we need more, we'll resize */
8210 : 4631 : res = PyBytes_FromStringAndSize(NULL, size);
8211 [ - + ]: 4631 : if (res == NULL)
8212 : 0 : goto onError;
8213 [ + + ]: 4631 : if (size == 0)
8214 : 385 : return res;
8215 : :
8216 [ + + ]: 168260 : while (inpos<size) {
8217 : 164051 : Py_UCS4 ch = PyUnicode_READ(kind, data, inpos);
8218 : : /* try to encode it */
8219 : 164051 : charmapencode_result x = charmapencode_output(ch, mapping, &res, &respos);
8220 [ + + ]: 164051 : if (x==enc_EXCEPTION) /* error */
8221 : 12 : goto onError;
8222 [ + + ]: 164039 : if (x==enc_FAILED) { /* unencodable character */
8223 [ + + ]: 129 : if (charmap_encoding_error(unicode, &inpos, mapping,
8224 : : &exc,
8225 : : &error_handler, &error_handler_obj, errors,
8226 : : &res, &respos)) {
8227 : 25 : goto onError;
8228 : : }
8229 : : }
8230 : : else
8231 : : /* done with this character => adjust input position */
8232 : 163910 : ++inpos;
8233 : : }
8234 : :
8235 : : /* Resize if we allocated to much */
8236 [ + + ]: 4209 : if (respos<PyBytes_GET_SIZE(res))
8237 [ - + ]: 33 : if (_PyBytes_Resize(&res, respos) < 0)
8238 : 0 : goto onError;
8239 : :
8240 : 4209 : Py_XDECREF(exc);
8241 : 4209 : Py_XDECREF(error_handler_obj);
8242 : 4209 : return res;
8243 : :
8244 : 37 : onError:
8245 : 37 : Py_XDECREF(res);
8246 : 37 : Py_XDECREF(exc);
8247 : 37 : Py_XDECREF(error_handler_obj);
8248 : 37 : return NULL;
8249 : : }
8250 : :
8251 : : PyObject *
8252 : 0 : PyUnicode_AsCharmapString(PyObject *unicode,
8253 : : PyObject *mapping)
8254 : : {
8255 [ # # # # ]: 0 : if (!PyUnicode_Check(unicode) || mapping == NULL) {
8256 : 0 : PyErr_BadArgument();
8257 : 0 : return NULL;
8258 : : }
8259 : 0 : return _PyUnicode_EncodeCharmap(unicode, mapping, NULL);
8260 : : }
8261 : :
8262 : : /* create or adjust a UnicodeTranslateError */
8263 : : static void
8264 : 0 : make_translate_exception(PyObject **exceptionObject,
8265 : : PyObject *unicode,
8266 : : Py_ssize_t startpos, Py_ssize_t endpos,
8267 : : const char *reason)
8268 : : {
8269 [ # # ]: 0 : if (*exceptionObject == NULL) {
8270 : 0 : *exceptionObject = _PyUnicodeTranslateError_Create(
8271 : : unicode, startpos, endpos, reason);
8272 : : }
8273 : : else {
8274 [ # # ]: 0 : if (PyUnicodeTranslateError_SetStart(*exceptionObject, startpos))
8275 : 0 : goto onError;
8276 [ # # ]: 0 : if (PyUnicodeTranslateError_SetEnd(*exceptionObject, endpos))
8277 : 0 : goto onError;
8278 [ # # ]: 0 : if (PyUnicodeTranslateError_SetReason(*exceptionObject, reason))
8279 : 0 : goto onError;
8280 : 0 : return;
8281 : 0 : onError:
8282 [ # # ]: 0 : Py_CLEAR(*exceptionObject);
8283 : : }
8284 : : }
8285 : :
8286 : : /* error handling callback helper:
8287 : : build arguments, call the callback and check the arguments,
8288 : : put the result into newpos and return the replacement string, which
8289 : : has to be freed by the caller */
8290 : : static PyObject *
8291 : 0 : unicode_translate_call_errorhandler(const char *errors,
8292 : : PyObject **errorHandler,
8293 : : const char *reason,
8294 : : PyObject *unicode, PyObject **exceptionObject,
8295 : : Py_ssize_t startpos, Py_ssize_t endpos,
8296 : : Py_ssize_t *newpos)
8297 : : {
8298 : : static const char *argparse = "Un;translating error handler must return (str, int) tuple";
8299 : :
8300 : : Py_ssize_t i_newpos;
8301 : : PyObject *restuple;
8302 : : PyObject *resunicode;
8303 : :
8304 [ # # ]: 0 : if (*errorHandler == NULL) {
8305 : 0 : *errorHandler = PyCodec_LookupError(errors);
8306 [ # # ]: 0 : if (*errorHandler == NULL)
8307 : 0 : return NULL;
8308 : : }
8309 : :
8310 : 0 : make_translate_exception(exceptionObject,
8311 : : unicode, startpos, endpos, reason);
8312 [ # # ]: 0 : if (*exceptionObject == NULL)
8313 : 0 : return NULL;
8314 : :
8315 : 0 : restuple = PyObject_CallOneArg(*errorHandler, *exceptionObject);
8316 [ # # ]: 0 : if (restuple == NULL)
8317 : 0 : return NULL;
8318 [ # # ]: 0 : if (!PyTuple_Check(restuple)) {
8319 : 0 : PyErr_SetString(PyExc_TypeError, &argparse[3]);
8320 : 0 : Py_DECREF(restuple);
8321 : 0 : return NULL;
8322 : : }
8323 [ # # ]: 0 : if (!PyArg_ParseTuple(restuple, argparse,
8324 : : &resunicode, &i_newpos)) {
8325 : 0 : Py_DECREF(restuple);
8326 : 0 : return NULL;
8327 : : }
8328 [ # # ]: 0 : if (i_newpos<0)
8329 : 0 : *newpos = PyUnicode_GET_LENGTH(unicode)+i_newpos;
8330 : : else
8331 : 0 : *newpos = i_newpos;
8332 [ # # # # ]: 0 : if (*newpos<0 || *newpos>PyUnicode_GET_LENGTH(unicode)) {
8333 : 0 : PyErr_Format(PyExc_IndexError, "position %zd from error handler out of bounds", *newpos);
8334 : 0 : Py_DECREF(restuple);
8335 : 0 : return NULL;
8336 : : }
8337 : 0 : Py_INCREF(resunicode);
8338 : 0 : Py_DECREF(restuple);
8339 : 0 : return resunicode;
8340 : : }
8341 : :
8342 : : /* Lookup the character ch in the mapping and put the result in result,
8343 : : which must be decrefed by the caller.
8344 : : Return 0 on success, -1 on error */
8345 : : static int
8346 : 340819 : charmaptranslate_lookup(Py_UCS4 c, PyObject *mapping, PyObject **result)
8347 : : {
8348 : 340819 : PyObject *w = PyLong_FromLong((long)c);
8349 : : PyObject *x;
8350 : :
8351 [ - + ]: 340819 : if (w == NULL)
8352 : 0 : return -1;
8353 : 340819 : x = PyObject_GetItem(mapping, w);
8354 : 340819 : Py_DECREF(w);
8355 [ + + ]: 340819 : if (x == NULL) {
8356 [ + - ]: 199051 : if (PyErr_ExceptionMatches(PyExc_LookupError)) {
8357 : : /* No mapping found means: use 1:1 mapping. */
8358 : 199051 : PyErr_Clear();
8359 : 199051 : *result = NULL;
8360 : 199051 : return 0;
8361 : : } else
8362 : 0 : return -1;
8363 : : }
8364 [ + + ]: 141768 : else if (x == Py_None) {
8365 : 19 : *result = x;
8366 : 19 : return 0;
8367 : : }
8368 [ + + ]: 141749 : else if (PyLong_Check(x)) {
8369 : 2908 : long value = PyLong_AS_LONG(x);
8370 [ + - + + ]: 2908 : if (value < 0 || value > MAX_UNICODE) {
8371 : 5 : PyErr_Format(PyExc_ValueError,
8372 : : "character mapping must be in range(0x%x)",
8373 : : MAX_UNICODE+1);
8374 : 5 : Py_DECREF(x);
8375 : 5 : return -1;
8376 : : }
8377 : 2903 : *result = x;
8378 : 2903 : return 0;
8379 : : }
8380 [ + + ]: 138841 : else if (PyUnicode_Check(x)) {
8381 : 138840 : *result = x;
8382 : 138840 : return 0;
8383 : : }
8384 : : else {
8385 : : /* wrong return value */
8386 : 1 : PyErr_SetString(PyExc_TypeError,
8387 : : "character mapping must return integer, None or str");
8388 : 1 : Py_DECREF(x);
8389 : 1 : return -1;
8390 : : }
8391 : : }
8392 : :
8393 : : /* lookup the character, write the result into the writer.
8394 : : Return 1 if the result was written into the writer, return 0 if the mapping
8395 : : was undefined, raise an exception return -1 on error. */
8396 : : static int
8397 : 169331 : charmaptranslate_output(Py_UCS4 ch, PyObject *mapping,
8398 : : _PyUnicodeWriter *writer)
8399 : : {
8400 : : PyObject *item;
8401 : :
8402 [ + + ]: 169331 : if (charmaptranslate_lookup(ch, mapping, &item))
8403 : 5 : return -1;
8404 : :
8405 [ + + ]: 169326 : if (item == NULL) {
8406 : : /* not found => default to 1:1 mapping */
8407 [ - + ]: 80395 : if (_PyUnicodeWriter_WriteCharInline(writer, ch) < 0) {
8408 : 0 : return -1;
8409 : : }
8410 : 80395 : return 1;
8411 : : }
8412 : :
8413 [ + + ]: 88931 : if (item == Py_None) {
8414 : 5 : Py_DECREF(item);
8415 : 5 : return 0;
8416 : : }
8417 : :
8418 [ + + ]: 88926 : if (PyLong_Check(item)) {
8419 : 31 : long ch = (Py_UCS4)PyLong_AS_LONG(item);
8420 : : /* PyLong_AS_LONG() cannot fail, charmaptranslate_lookup() already
8421 : : used it */
8422 [ - + ]: 31 : if (_PyUnicodeWriter_WriteCharInline(writer, ch) < 0) {
8423 : 0 : Py_DECREF(item);
8424 : 0 : return -1;
8425 : : }
8426 : 31 : Py_DECREF(item);
8427 : 31 : return 1;
8428 : : }
8429 : :
8430 [ - + ]: 88895 : if (!PyUnicode_Check(item)) {
8431 : 0 : Py_DECREF(item);
8432 : 0 : return -1;
8433 : : }
8434 : :
8435 [ - + ]: 88895 : if (_PyUnicodeWriter_WriteStr(writer, item) < 0) {
8436 : 0 : Py_DECREF(item);
8437 : 0 : return -1;
8438 : : }
8439 : :
8440 : 88895 : Py_DECREF(item);
8441 : 88895 : return 1;
8442 : : }
8443 : :
8444 : : static int
8445 : 171483 : unicode_fast_translate_lookup(PyObject *mapping, Py_UCS1 ch,
8446 : : Py_UCS1 *translate)
8447 : : {
8448 : 171483 : PyObject *item = NULL;
8449 : 171483 : int ret = 0;
8450 : :
8451 [ + + ]: 171483 : if (charmaptranslate_lookup(ch, mapping, &item)) {
8452 : 1 : return -1;
8453 : : }
8454 : :
8455 [ + + ]: 171482 : if (item == Py_None) {
8456 : : /* deletion */
8457 : 14 : translate[ch] = 0xfe;
8458 : : }
8459 [ + + ]: 171468 : else if (item == NULL) {
8460 : : /* not found => default to 1:1 mapping */
8461 : 118655 : translate[ch] = ch;
8462 : 118655 : return 1;
8463 : : }
8464 [ + + ]: 52813 : else if (PyLong_Check(item)) {
8465 : 2872 : long replace = PyLong_AS_LONG(item);
8466 : : /* PyLong_AS_LONG() cannot fail, charmaptranslate_lookup() already
8467 : : used it */
8468 [ - + ]: 2872 : if (127 < replace) {
8469 : : /* invalid character or character outside ASCII:
8470 : : skip the fast translate */
8471 : 0 : goto exit;
8472 : : }
8473 : 2872 : translate[ch] = (Py_UCS1)replace;
8474 : : }
8475 [ + - ]: 49941 : else if (PyUnicode_Check(item)) {
8476 : : Py_UCS4 replace;
8477 : :
8478 [ + + ]: 49941 : if (PyUnicode_GET_LENGTH(item) != 1)
8479 : 49447 : goto exit;
8480 : :
8481 : 494 : replace = PyUnicode_READ_CHAR(item, 0);
8482 [ + + ]: 494 : if (replace > 127)
8483 : 2 : goto exit;
8484 : 492 : translate[ch] = (Py_UCS1)replace;
8485 : : }
8486 : : else {
8487 : : /* not None, NULL, long or unicode */
8488 : 0 : goto exit;
8489 : : }
8490 : 3378 : ret = 1;
8491 : :
8492 : 52827 : exit:
8493 : 52827 : Py_DECREF(item);
8494 : 52827 : return ret;
8495 : : }
8496 : :
8497 : : /* Fast path for ascii => ascii translation. Return 1 if the whole string
8498 : : was translated into writer, return 0 if the input string was partially
8499 : : translated into writer, raise an exception and return -1 on error. */
8500 : : static int
8501 : 97336 : unicode_fast_translate(PyObject *input, PyObject *mapping,
8502 : : _PyUnicodeWriter *writer, int ignore,
8503 : : Py_ssize_t *input_pos)
8504 : : {
8505 : : Py_UCS1 ascii_table[128], ch, ch2;
8506 : : Py_ssize_t len;
8507 : : const Py_UCS1 *in, *end;
8508 : : Py_UCS1 *out;
8509 : 97336 : int res = 0;
8510 : :
8511 : 97336 : len = PyUnicode_GET_LENGTH(input);
8512 : :
8513 : 97336 : memset(ascii_table, 0xff, 128);
8514 : :
8515 : 97336 : in = PyUnicode_1BYTE_DATA(input);
8516 : 97336 : end = in + len;
8517 : :
8518 : : assert(PyUnicode_IS_ASCII(writer->buffer));
8519 : : assert(PyUnicode_GET_LENGTH(writer->buffer) == len);
8520 : 97336 : out = PyUnicode_1BYTE_DATA(writer->buffer);
8521 : :
8522 [ + + ]: 268225 : for (; in < end; in++) {
8523 : 220339 : ch = *in;
8524 : 220339 : ch2 = ascii_table[ch];
8525 [ + + ]: 220339 : if (ch2 == 0xff) {
8526 : 171483 : int translate = unicode_fast_translate_lookup(mapping, ch,
8527 : : ascii_table);
8528 [ + + ]: 171483 : if (translate < 0)
8529 : 1 : return -1;
8530 [ + + ]: 171482 : if (translate == 0)
8531 : 49449 : goto exit;
8532 : 122033 : ch2 = ascii_table[ch];
8533 : : }
8534 [ + + ]: 170889 : if (ch2 == 0xfe) {
8535 [ + - ]: 25 : if (ignore)
8536 : 25 : continue;
8537 : 0 : goto exit;
8538 : : }
8539 : : assert(ch2 < 128);
8540 : 170864 : *out = ch2;
8541 : 170864 : out++;
8542 : : }
8543 : 47886 : res = 1;
8544 : :
8545 : 97335 : exit:
8546 : 97335 : writer->pos = out - PyUnicode_1BYTE_DATA(writer->buffer);
8547 : 97335 : *input_pos = in - PyUnicode_1BYTE_DATA(input);
8548 : 97335 : return res;
8549 : : }
8550 : :
8551 : : static PyObject *
8552 : 98282 : _PyUnicode_TranslateCharmap(PyObject *input,
8553 : : PyObject *mapping,
8554 : : const char *errors)
8555 : : {
8556 : : /* input object */
8557 : : const void *data;
8558 : : Py_ssize_t size, i;
8559 : : int kind;
8560 : : /* output buffer */
8561 : : _PyUnicodeWriter writer;
8562 : : /* error handler */
8563 : 98282 : const char *reason = "character maps to <undefined>";
8564 : 98282 : PyObject *errorHandler = NULL;
8565 : 98282 : PyObject *exc = NULL;
8566 : : int ignore;
8567 : : int res;
8568 : :
8569 [ - + ]: 98282 : if (mapping == NULL) {
8570 : 0 : PyErr_BadArgument();
8571 : 0 : return NULL;
8572 : : }
8573 : :
8574 : 98282 : data = PyUnicode_DATA(input);
8575 : 98282 : kind = PyUnicode_KIND(input);
8576 : 98282 : size = PyUnicode_GET_LENGTH(input);
8577 : :
8578 [ + + ]: 98282 : if (size == 0)
8579 : 77 : return PyUnicode_FromObject(input);
8580 : :
8581 : : /* allocate enough for a simple 1:1 translation without
8582 : : replacements, if we need more, we'll resize */
8583 : 98205 : _PyUnicodeWriter_Init(&writer);
8584 [ - + - - : 98205 : if (_PyUnicodeWriter_Prepare(&writer, size, 127) == -1)
+ - - + ]
8585 : 0 : goto onError;
8586 : :
8587 [ + - + - ]: 98205 : ignore = (errors != NULL && strcmp(errors, "ignore") == 0);
8588 : :
8589 [ + + ]: 98205 : if (PyUnicode_IS_ASCII(input)) {
8590 : 97336 : res = unicode_fast_translate(input, mapping, &writer, ignore, &i);
8591 [ + + ]: 97336 : if (res < 0) {
8592 : 1 : _PyUnicodeWriter_Dealloc(&writer);
8593 : 1 : return NULL;
8594 : : }
8595 [ + + ]: 97335 : if (res == 1)
8596 : 47886 : return _PyUnicodeWriter_Finish(&writer);
8597 : : }
8598 : : else {
8599 : 869 : i = 0;
8600 : : }
8601 : :
8602 [ + + ]: 219644 : while (i<size) {
8603 : : /* try to encode it */
8604 : : int translate;
8605 : 169331 : PyObject *repunicode = NULL; /* initialize to prevent gcc warning */
8606 : : Py_ssize_t newpos;
8607 : : /* startpos for collecting untranslatable chars */
8608 : : Py_ssize_t collstart;
8609 : : Py_ssize_t collend;
8610 : : Py_UCS4 ch;
8611 : :
8612 : 169331 : ch = PyUnicode_READ(kind, data, i);
8613 : 169331 : translate = charmaptranslate_output(ch, mapping, &writer);
8614 [ + + ]: 169331 : if (translate < 0)
8615 : 5 : goto onError;
8616 : :
8617 [ + + ]: 169326 : if (translate != 0) {
8618 : : /* it worked => adjust input pointer */
8619 : 169321 : ++i;
8620 : 169321 : continue;
8621 : : }
8622 : :
8623 : : /* untranslatable character */
8624 : 5 : collstart = i;
8625 : 5 : collend = i+1;
8626 : :
8627 : : /* find all untranslatable characters */
8628 [ + - ]: 5 : while (collend < size) {
8629 : : PyObject *x;
8630 : 5 : ch = PyUnicode_READ(kind, data, collend);
8631 [ - + ]: 5 : if (charmaptranslate_lookup(ch, mapping, &x))
8632 : 0 : goto onError;
8633 : 5 : Py_XDECREF(x);
8634 [ + - ]: 5 : if (x != Py_None)
8635 : 5 : break;
8636 : 0 : ++collend;
8637 : : }
8638 : :
8639 [ + - ]: 5 : if (ignore) {
8640 : 5 : i = collend;
8641 : : }
8642 : : else {
8643 : 0 : repunicode = unicode_translate_call_errorhandler(errors, &errorHandler,
8644 : : reason, input, &exc,
8645 : : collstart, collend, &newpos);
8646 [ # # ]: 0 : if (repunicode == NULL)
8647 : 0 : goto onError;
8648 [ # # ]: 0 : if (_PyUnicodeWriter_WriteStr(&writer, repunicode) < 0) {
8649 : 0 : Py_DECREF(repunicode);
8650 : 0 : goto onError;
8651 : : }
8652 : 0 : Py_DECREF(repunicode);
8653 : 0 : i = newpos;
8654 : : }
8655 : : }
8656 : 50313 : Py_XDECREF(exc);
8657 : 50313 : Py_XDECREF(errorHandler);
8658 : 50313 : return _PyUnicodeWriter_Finish(&writer);
8659 : :
8660 : 5 : onError:
8661 : 5 : _PyUnicodeWriter_Dealloc(&writer);
8662 : 5 : Py_XDECREF(exc);
8663 : 5 : Py_XDECREF(errorHandler);
8664 : 5 : return NULL;
8665 : : }
8666 : :
8667 : : PyObject *
8668 : 0 : PyUnicode_Translate(PyObject *str,
8669 : : PyObject *mapping,
8670 : : const char *errors)
8671 : : {
8672 [ # # ]: 0 : if (ensure_unicode(str) < 0)
8673 : 0 : return NULL;
8674 : 0 : return _PyUnicode_TranslateCharmap(str, mapping, errors);
8675 : : }
8676 : :
8677 : : PyObject *
8678 : 1265303 : _PyUnicode_TransformDecimalAndSpaceToASCII(PyObject *unicode)
8679 : : {
8680 [ - + ]: 1265303 : if (!PyUnicode_Check(unicode)) {
8681 : 0 : PyErr_BadInternalCall();
8682 : 0 : return NULL;
8683 : : }
8684 [ + + ]: 1265303 : if (PyUnicode_IS_ASCII(unicode)) {
8685 : : /* If the string is already ASCII, just return the same string */
8686 : 1265250 : Py_INCREF(unicode);
8687 : 1265250 : return unicode;
8688 : : }
8689 : :
8690 : 53 : Py_ssize_t len = PyUnicode_GET_LENGTH(unicode);
8691 : 53 : PyObject *result = PyUnicode_New(len, 127);
8692 [ - + ]: 53 : if (result == NULL) {
8693 : 0 : return NULL;
8694 : : }
8695 : :
8696 : 53 : Py_UCS1 *out = PyUnicode_1BYTE_DATA(result);
8697 : 53 : int kind = PyUnicode_KIND(unicode);
8698 : 53 : const void *data = PyUnicode_DATA(unicode);
8699 : : Py_ssize_t i;
8700 [ + + ]: 145 : for (i = 0; i < len; ++i) {
8701 : 135 : Py_UCS4 ch = PyUnicode_READ(kind, data, i);
8702 [ + + ]: 135 : if (ch < 127) {
8703 : 67 : out[i] = ch;
8704 : : }
8705 [ + + ]: 68 : else if (Py_UNICODE_ISSPACE(ch)) {
8706 : 6 : out[i] = ' ';
8707 : : }
8708 : : else {
8709 : 62 : int decimal = Py_UNICODE_TODECIMAL(ch);
8710 [ + + ]: 62 : if (decimal < 0) {
8711 : 43 : out[i] = '?';
8712 : 43 : out[i+1] = '\0';
8713 : 43 : _PyUnicode_LENGTH(result) = i + 1;
8714 : 43 : break;
8715 : : }
8716 : 19 : out[i] = '0' + decimal;
8717 : : }
8718 : : }
8719 : :
8720 : : assert(_PyUnicode_CheckConsistency(result, 1));
8721 : 53 : return result;
8722 : : }
8723 : :
8724 : : /* --- Helpers ------------------------------------------------------------ */
8725 : :
8726 : : /* helper macro to fixup start/end slice values */
8727 : : #define ADJUST_INDICES(start, end, len) \
8728 : : if (end > len) \
8729 : : end = len; \
8730 : : else if (end < 0) { \
8731 : : end += len; \
8732 : : if (end < 0) \
8733 : : end = 0; \
8734 : : } \
8735 : : if (start < 0) { \
8736 : : start += len; \
8737 : : if (start < 0) \
8738 : : start = 0; \
8739 : : }
8740 : :
8741 : : static Py_ssize_t
8742 : 2293509 : any_find_slice(PyObject* s1, PyObject* s2,
8743 : : Py_ssize_t start,
8744 : : Py_ssize_t end,
8745 : : int direction)
8746 : : {
8747 : : int kind1, kind2;
8748 : : const void *buf1, *buf2;
8749 : : Py_ssize_t len1, len2, result;
8750 : :
8751 : 2293509 : kind1 = PyUnicode_KIND(s1);
8752 : 2293509 : kind2 = PyUnicode_KIND(s2);
8753 [ + + ]: 2293509 : if (kind1 < kind2)
8754 : 24 : return -1;
8755 : :
8756 : 2293485 : len1 = PyUnicode_GET_LENGTH(s1);
8757 : 2293485 : len2 = PyUnicode_GET_LENGTH(s2);
8758 [ + + + + : 2293485 : ADJUST_INDICES(start, end, len1);
+ + + + -
+ ]
8759 [ + + ]: 2293485 : if (end - start < len2)
8760 : 171914 : return -1;
8761 : :
8762 : 2121571 : buf1 = PyUnicode_DATA(s1);
8763 : 2121571 : buf2 = PyUnicode_DATA(s2);
8764 [ + + ]: 2121571 : if (len2 == 1) {
8765 : 1565220 : Py_UCS4 ch = PyUnicode_READ(kind2, buf2, 0);
8766 : 1565220 : result = findchar((const char *)buf1 + kind1*start,
8767 : : kind1, end - start, ch, direction);
8768 [ + + ]: 1565220 : if (result == -1)
8769 : 468350 : return -1;
8770 : : else
8771 : 1096870 : return start + result;
8772 : : }
8773 : :
8774 [ + + ]: 556351 : if (kind2 != kind1) {
8775 : 14 : buf2 = unicode_askind(kind2, buf2, len2, kind1);
8776 [ - + ]: 14 : if (!buf2)
8777 : 0 : return -2;
8778 : : }
8779 : :
8780 [ + + ]: 556351 : if (direction > 0) {
8781 [ + + + - ]: 359499 : switch (kind1) {
8782 : 359491 : case PyUnicode_1BYTE_KIND:
8783 [ + - + - ]: 359491 : if (PyUnicode_IS_ASCII(s1) && PyUnicode_IS_ASCII(s2))
8784 : 359491 : result = asciilib_find_slice(buf1, len1, buf2, len2, start, end);
8785 : : else
8786 : 0 : result = ucs1lib_find_slice(buf1, len1, buf2, len2, start, end);
8787 : 359491 : break;
8788 : 4 : case PyUnicode_2BYTE_KIND:
8789 : 4 : result = ucs2lib_find_slice(buf1, len1, buf2, len2, start, end);
8790 : 4 : break;
8791 : 4 : case PyUnicode_4BYTE_KIND:
8792 : 4 : result = ucs4lib_find_slice(buf1, len1, buf2, len2, start, end);
8793 : 4 : break;
8794 : 0 : default:
8795 : 0 : Py_UNREACHABLE();
8796 : : }
8797 : : }
8798 : : else {
8799 [ + + + - ]: 196852 : switch (kind1) {
8800 : 196846 : case PyUnicode_1BYTE_KIND:
8801 [ + - + - ]: 196846 : if (PyUnicode_IS_ASCII(s1) && PyUnicode_IS_ASCII(s2))
8802 : 196846 : result = asciilib_rfind_slice(buf1, len1, buf2, len2, start, end);
8803 : : else
8804 : 0 : result = ucs1lib_rfind_slice(buf1, len1, buf2, len2, start, end);
8805 : 196846 : break;
8806 : 2 : case PyUnicode_2BYTE_KIND:
8807 : 2 : result = ucs2lib_rfind_slice(buf1, len1, buf2, len2, start, end);
8808 : 2 : break;
8809 : 4 : case PyUnicode_4BYTE_KIND:
8810 : 4 : result = ucs4lib_rfind_slice(buf1, len1, buf2, len2, start, end);
8811 : 4 : break;
8812 : 0 : default:
8813 : 0 : Py_UNREACHABLE();
8814 : : }
8815 : : }
8816 : :
8817 : : assert((kind2 != kind1) == (buf2 != PyUnicode_DATA(s2)));
8818 [ + + ]: 556351 : if (kind2 != kind1)
8819 : 14 : PyMem_Free((void *)buf2);
8820 : :
8821 : 556351 : return result;
8822 : : }
8823 : :
8824 : : /* _PyUnicode_InsertThousandsGrouping() helper functions */
8825 : : #include "stringlib/localeutil.h"
8826 : :
8827 : : /**
8828 : : * InsertThousandsGrouping:
8829 : : * @writer: Unicode writer.
8830 : : * @n_buffer: Number of characters in @buffer.
8831 : : * @digits: Digits we're reading from. If count is non-NULL, this is unused.
8832 : : * @d_pos: Start of digits string.
8833 : : * @n_digits: The number of digits in the string, in which we want
8834 : : * to put the grouping chars.
8835 : : * @min_width: The minimum width of the digits in the output string.
8836 : : * Output will be zero-padded on the left to fill.
8837 : : * @grouping: see definition in localeconv().
8838 : : * @thousands_sep: see definition in localeconv().
8839 : : *
8840 : : * There are 2 modes: counting and filling. If @writer is NULL,
8841 : : * we are in counting mode, else filling mode.
8842 : : * If counting, the required buffer size is returned.
8843 : : * If filling, we know the buffer will be large enough, so we don't
8844 : : * need to pass in the buffer size.
8845 : : * Inserts thousand grouping characters (as defined by grouping and
8846 : : * thousands_sep) into @writer.
8847 : : *
8848 : : * Return value: -1 on error, number of characters otherwise.
8849 : : **/
8850 : : Py_ssize_t
8851 : 949468 : _PyUnicode_InsertThousandsGrouping(
8852 : : _PyUnicodeWriter *writer,
8853 : : Py_ssize_t n_buffer,
8854 : : PyObject *digits,
8855 : : Py_ssize_t d_pos,
8856 : : Py_ssize_t n_digits,
8857 : : Py_ssize_t min_width,
8858 : : const char *grouping,
8859 : : PyObject *thousands_sep,
8860 : : Py_UCS4 *maxchar)
8861 : : {
8862 : 949468 : min_width = Py_MAX(0, min_width);
8863 : : if (writer) {
8864 : : assert(digits != NULL);
8865 : : assert(maxchar == NULL);
8866 : : }
8867 : : else {
8868 : : assert(digits == NULL);
8869 : : assert(maxchar != NULL);
8870 : : }
8871 : : assert(0 <= d_pos);
8872 : : assert(0 <= n_digits);
8873 : : assert(grouping != NULL);
8874 : :
8875 : 949468 : Py_ssize_t count = 0;
8876 : : Py_ssize_t n_zeros;
8877 : 949468 : int loop_broken = 0;
8878 : 949468 : int use_separator = 0; /* First time through, don't append the
8879 : : separator. They only go between
8880 : : groups. */
8881 : : Py_ssize_t buffer_pos;
8882 : : Py_ssize_t digits_pos;
8883 : : Py_ssize_t len;
8884 : : Py_ssize_t n_chars;
8885 : 949468 : Py_ssize_t remaining = n_digits; /* Number of chars remaining to
8886 : : be looked at */
8887 : : /* A generator that returns all of the grouping widths, until it
8888 : : returns 0. */
8889 : : GroupGenerator groupgen;
8890 : 949468 : GroupGenerator_init(&groupgen, grouping);
8891 : 949468 : const Py_ssize_t thousands_sep_len = PyUnicode_GET_LENGTH(thousands_sep);
8892 : :
8893 : : /* if digits are not grouped, thousands separator
8894 : : should be an empty string */
8895 : : assert(!(grouping[0] == CHAR_MAX && thousands_sep_len != 0));
8896 : :
8897 : 949468 : digits_pos = d_pos + n_digits;
8898 [ + + ]: 949468 : if (writer) {
8899 : 474731 : buffer_pos = writer->pos + n_buffer;
8900 : : assert(buffer_pos <= PyUnicode_GET_LENGTH(writer->buffer));
8901 : : assert(digits_pos <= PyUnicode_GET_LENGTH(digits));
8902 : : }
8903 : : else {
8904 : 474737 : buffer_pos = n_buffer;
8905 : : }
8906 : :
8907 [ + + ]: 949468 : if (!writer) {
8908 : 474737 : *maxchar = 127;
8909 : : }
8910 : :
8911 [ + + ]: 950300 : while ((len = GroupGenerator_next(&groupgen)) > 0) {
8912 : 1332 : len = Py_MIN(len, Py_MAX(Py_MAX(remaining, min_width), 1));
8913 : 1332 : n_zeros = Py_MAX(0, len - remaining);
8914 : 1332 : n_chars = Py_MAX(0, Py_MIN(remaining, len));
8915 : :
8916 : : /* Use n_zero zero's and n_chars chars */
8917 : :
8918 : : /* Count only, don't do anything. */
8919 [ + + ]: 1332 : count += (use_separator ? thousands_sep_len : 0) + n_zeros + n_chars;
8920 : :
8921 : : /* Copy into the writer. */
8922 [ + + ]: 1332 : InsertThousandsGrouping_fill(writer, &buffer_pos,
8923 : : digits, &digits_pos,
8924 : : n_chars, n_zeros,
8925 : : use_separator ? thousands_sep : NULL,
8926 : : thousands_sep_len, maxchar);
8927 : :
8928 : : /* Use a separator next time. */
8929 : 1332 : use_separator = 1;
8930 : :
8931 : 1332 : remaining -= n_chars;
8932 : 1332 : min_width -= len;
8933 : :
8934 [ + + + + ]: 1332 : if (remaining <= 0 && min_width <= 0) {
8935 : 500 : loop_broken = 1;
8936 : 500 : break;
8937 : : }
8938 : 832 : min_width -= thousands_sep_len;
8939 : : }
8940 [ + + ]: 949468 : if (!loop_broken) {
8941 : : /* We left the loop without using a break statement. */
8942 : :
8943 : 948968 : len = Py_MAX(Py_MAX(remaining, min_width), 1);
8944 : 948968 : n_zeros = Py_MAX(0, len - remaining);
8945 : 948968 : n_chars = Py_MAX(0, Py_MIN(remaining, len));
8946 : :
8947 : : /* Use n_zero zero's and n_chars chars */
8948 [ - + ]: 948968 : count += (use_separator ? thousands_sep_len : 0) + n_zeros + n_chars;
8949 : :
8950 : : /* Copy into the writer. */
8951 [ - + ]: 948968 : InsertThousandsGrouping_fill(writer, &buffer_pos,
8952 : : digits, &digits_pos,
8953 : : n_chars, n_zeros,
8954 : : use_separator ? thousands_sep : NULL,
8955 : : thousands_sep_len, maxchar);
8956 : : }
8957 : 949468 : return count;
8958 : : }
8959 : :
8960 : :
8961 : : Py_ssize_t
8962 : 0 : PyUnicode_Count(PyObject *str,
8963 : : PyObject *substr,
8964 : : Py_ssize_t start,
8965 : : Py_ssize_t end)
8966 : : {
8967 : : Py_ssize_t result;
8968 : : int kind1, kind2;
8969 : 0 : const void *buf1 = NULL, *buf2 = NULL;
8970 : : Py_ssize_t len1, len2;
8971 : :
8972 [ # # # # ]: 0 : if (ensure_unicode(str) < 0 || ensure_unicode(substr) < 0)
8973 : 0 : return -1;
8974 : :
8975 : 0 : kind1 = PyUnicode_KIND(str);
8976 : 0 : kind2 = PyUnicode_KIND(substr);
8977 [ # # ]: 0 : if (kind1 < kind2)
8978 : 0 : return 0;
8979 : :
8980 : 0 : len1 = PyUnicode_GET_LENGTH(str);
8981 : 0 : len2 = PyUnicode_GET_LENGTH(substr);
8982 [ # # # # : 0 : ADJUST_INDICES(start, end, len1);
# # # # #
# ]
8983 [ # # ]: 0 : if (end - start < len2)
8984 : 0 : return 0;
8985 : :
8986 : 0 : buf1 = PyUnicode_DATA(str);
8987 : 0 : buf2 = PyUnicode_DATA(substr);
8988 [ # # ]: 0 : if (kind2 != kind1) {
8989 : 0 : buf2 = unicode_askind(kind2, buf2, len2, kind1);
8990 [ # # ]: 0 : if (!buf2)
8991 : 0 : goto onError;
8992 : : }
8993 : :
8994 [ # # # # ]: 0 : switch (kind1) {
8995 : 0 : case PyUnicode_1BYTE_KIND:
8996 [ # # # # ]: 0 : if (PyUnicode_IS_ASCII(str) && PyUnicode_IS_ASCII(substr))
8997 : 0 : result = asciilib_count(
8998 : : ((const Py_UCS1*)buf1) + start, end - start,
8999 : : buf2, len2, PY_SSIZE_T_MAX
9000 : : );
9001 : : else
9002 : 0 : result = ucs1lib_count(
9003 : : ((const Py_UCS1*)buf1) + start, end - start,
9004 : : buf2, len2, PY_SSIZE_T_MAX
9005 : : );
9006 : 0 : break;
9007 : 0 : case PyUnicode_2BYTE_KIND:
9008 : 0 : result = ucs2lib_count(
9009 : 0 : ((const Py_UCS2*)buf1) + start, end - start,
9010 : : buf2, len2, PY_SSIZE_T_MAX
9011 : : );
9012 : 0 : break;
9013 : 0 : case PyUnicode_4BYTE_KIND:
9014 : 0 : result = ucs4lib_count(
9015 : 0 : ((const Py_UCS4*)buf1) + start, end - start,
9016 : : buf2, len2, PY_SSIZE_T_MAX
9017 : : );
9018 : 0 : break;
9019 : 0 : default:
9020 : 0 : Py_UNREACHABLE();
9021 : : }
9022 : :
9023 : : assert((kind2 != kind1) == (buf2 != PyUnicode_DATA(substr)));
9024 [ # # ]: 0 : if (kind2 != kind1)
9025 : 0 : PyMem_Free((void *)buf2);
9026 : :
9027 : 0 : return result;
9028 : 0 : onError:
9029 : : assert((kind2 != kind1) == (buf2 != PyUnicode_DATA(substr)));
9030 [ # # ]: 0 : if (kind2 != kind1)
9031 : 0 : PyMem_Free((void *)buf2);
9032 : 0 : return -1;
9033 : : }
9034 : :
9035 : : Py_ssize_t
9036 : 119 : PyUnicode_Find(PyObject *str,
9037 : : PyObject *substr,
9038 : : Py_ssize_t start,
9039 : : Py_ssize_t end,
9040 : : int direction)
9041 : : {
9042 [ + - - + ]: 119 : if (ensure_unicode(str) < 0 || ensure_unicode(substr) < 0)
9043 : 0 : return -2;
9044 : :
9045 : 119 : return any_find_slice(str, substr, start, end, direction);
9046 : : }
9047 : :
9048 : : Py_ssize_t
9049 : 5150352 : PyUnicode_FindChar(PyObject *str, Py_UCS4 ch,
9050 : : Py_ssize_t start, Py_ssize_t end,
9051 : : int direction)
9052 : : {
9053 : : int kind;
9054 : : Py_ssize_t len, result;
9055 : 5150352 : len = PyUnicode_GET_LENGTH(str);
9056 [ + + + + : 5150352 : ADJUST_INDICES(start, end, len);
- + + + -
+ ]
9057 [ + + ]: 5150352 : if (end - start < 1)
9058 : 1600 : return -1;
9059 : 5148752 : kind = PyUnicode_KIND(str);
9060 : 5148752 : result = findchar(PyUnicode_1BYTE_DATA(str) + kind*start,
9061 : : kind, end-start, ch, direction);
9062 [ + + ]: 5148752 : if (result == -1)
9063 : 4069376 : return -1;
9064 : : else
9065 : 1079376 : return start + result;
9066 : : }
9067 : :
9068 : : static int
9069 : 11014740 : tailmatch(PyObject *self,
9070 : : PyObject *substring,
9071 : : Py_ssize_t start,
9072 : : Py_ssize_t end,
9073 : : int direction)
9074 : : {
9075 : : int kind_self;
9076 : : int kind_sub;
9077 : : const void *data_self;
9078 : : const void *data_sub;
9079 : : Py_ssize_t offset;
9080 : : Py_ssize_t i;
9081 : : Py_ssize_t end_sub;
9082 : :
9083 [ + + + + : 11014740 : ADJUST_INDICES(start, end, PyUnicode_GET_LENGTH(self));
+ + + + +
+ ]
9084 : 11014740 : end -= PyUnicode_GET_LENGTH(substring);
9085 [ + + ]: 11014740 : if (end < start)
9086 : 315529 : return 0;
9087 : :
9088 [ + + ]: 10699211 : if (PyUnicode_GET_LENGTH(substring) == 0)
9089 : 3288 : return 1;
9090 : :
9091 : 10695923 : kind_self = PyUnicode_KIND(self);
9092 : 10695923 : data_self = PyUnicode_DATA(self);
9093 : 10695923 : kind_sub = PyUnicode_KIND(substring);
9094 : 10695923 : data_sub = PyUnicode_DATA(substring);
9095 : 10695923 : end_sub = PyUnicode_GET_LENGTH(substring) - 1;
9096 : :
9097 [ + + ]: 10695923 : if (direction > 0)
9098 : 1789506 : offset = end;
9099 : : else
9100 : 8906417 : offset = start;
9101 : :
9102 [ + + ]: 21391846 : if (PyUnicode_READ(kind_self, data_self, offset) ==
9103 [ + + ]: 13493655 : PyUnicode_READ(kind_sub, data_sub, 0) &&
9104 : 2797732 : PyUnicode_READ(kind_self, data_self, offset + end_sub) ==
9105 : 2797732 : PyUnicode_READ(kind_sub, data_sub, end_sub)) {
9106 : : /* If both are of the same kind, memcmp is sufficient */
9107 [ + + ]: 1896337 : if (kind_self == kind_sub) {
9108 : 1896159 : return ! memcmp((char *)data_self +
9109 : 1896159 : (offset * PyUnicode_KIND(substring)),
9110 : : data_sub,
9111 : 1896159 : PyUnicode_GET_LENGTH(substring) *
9112 : 1896159 : PyUnicode_KIND(substring));
9113 : : }
9114 : : /* otherwise we have to compare each character by first accessing it */
9115 : : else {
9116 : : /* We do not need to compare 0 and len(substring)-1 because
9117 : : the if statement above ensured already that they are equal
9118 : : when we end up here. */
9119 [ + + ]: 203 : for (i = 1; i < end_sub; ++i) {
9120 [ - + ]: 50 : if (PyUnicode_READ(kind_self, data_self, offset + i) !=
9121 : 25 : PyUnicode_READ(kind_sub, data_sub, i))
9122 : 0 : return 0;
9123 : : }
9124 : 178 : return 1;
9125 : : }
9126 : : }
9127 : :
9128 : 8799586 : return 0;
9129 : : }
9130 : :
9131 : : Py_ssize_t
9132 : 356 : PyUnicode_Tailmatch(PyObject *str,
9133 : : PyObject *substr,
9134 : : Py_ssize_t start,
9135 : : Py_ssize_t end,
9136 : : int direction)
9137 : : {
9138 [ + - - + ]: 356 : if (ensure_unicode(str) < 0 || ensure_unicode(substr) < 0)
9139 : 0 : return -1;
9140 : :
9141 : 356 : return tailmatch(str, substr, start, end, direction);
9142 : : }
9143 : :
9144 : : static PyObject *
9145 : 803957 : ascii_upper_or_lower(PyObject *self, int lower)
9146 : : {
9147 : 803957 : Py_ssize_t len = PyUnicode_GET_LENGTH(self);
9148 : 803957 : const char *data = PyUnicode_DATA(self);
9149 : : char *resdata;
9150 : : PyObject *res;
9151 : :
9152 : 803957 : res = PyUnicode_New(len, 127);
9153 [ - + ]: 803957 : if (res == NULL)
9154 : 0 : return NULL;
9155 : 803957 : resdata = PyUnicode_DATA(res);
9156 [ + + ]: 803957 : if (lower)
9157 : 741050 : _Py_bytes_lower(resdata, data, len);
9158 : : else
9159 : 62907 : _Py_bytes_upper(resdata, data, len);
9160 : 803957 : return res;
9161 : : }
9162 : :
9163 : : static Py_UCS4
9164 : 24 : handle_capital_sigma(int kind, const void *data, Py_ssize_t length, Py_ssize_t i)
9165 : : {
9166 : : Py_ssize_t j;
9167 : : int final_sigma;
9168 : 24 : Py_UCS4 c = 0; /* initialize to prevent gcc warning */
9169 : : /* U+03A3 is in the Final_Sigma context when, it is found like this:
9170 : :
9171 : : \p{cased}\p{case-ignorable}*U+03A3!(\p{case-ignorable}*\p{cased})
9172 : :
9173 : : where ! is a negation and \p{xxx} is a character with property xxx.
9174 : : */
9175 [ + + ]: 33 : for (j = i - 1; j >= 0; j--) {
9176 : 20 : c = PyUnicode_READ(kind, data, j);
9177 [ + + ]: 20 : if (!_PyUnicode_IsCaseIgnorable(c))
9178 : 11 : break;
9179 : : }
9180 [ + + + - ]: 24 : final_sigma = j >= 0 && _PyUnicode_IsCased(c);
9181 [ + + ]: 24 : if (final_sigma) {
9182 [ + + ]: 13 : for (j = i + 1; j < length; j++) {
9183 : 6 : c = PyUnicode_READ(kind, data, j);
9184 [ + + ]: 6 : if (!_PyUnicode_IsCaseIgnorable(c))
9185 : 4 : break;
9186 : : }
9187 [ + + + + ]: 11 : final_sigma = j == length || !_PyUnicode_IsCased(c);
9188 : : }
9189 [ + + ]: 24 : return (final_sigma) ? 0x3C2 : 0x3C3;
9190 : : }
9191 : :
9192 : : static int
9193 : 11426902 : lower_ucs4(int kind, const void *data, Py_ssize_t length, Py_ssize_t i,
9194 : : Py_UCS4 c, Py_UCS4 *mapped)
9195 : : {
9196 : : /* Obscure special case. */
9197 [ + + ]: 11426902 : if (c == 0x3A3) {
9198 : 24 : mapped[0] = handle_capital_sigma(kind, data, length, i);
9199 : 24 : return 1;
9200 : : }
9201 : 11426878 : return _PyUnicode_ToLowerFull(c, mapped);
9202 : : }
9203 : :
9204 : : static Py_ssize_t
9205 : 24184 : do_capitalize(int kind, const void *data, Py_ssize_t length, Py_UCS4 *res, Py_UCS4 *maxchar)
9206 : : {
9207 : 24184 : Py_ssize_t i, k = 0;
9208 : : int n_res, j;
9209 : : Py_UCS4 c, mapped[3];
9210 : :
9211 : 24184 : c = PyUnicode_READ(kind, data, 0);
9212 : 24184 : n_res = _PyUnicode_ToTitleFull(c, mapped);
9213 [ + + ]: 48371 : for (j = 0; j < n_res; j++) {
9214 : 24187 : *maxchar = Py_MAX(*maxchar, mapped[j]);
9215 : 24187 : res[k++] = mapped[j];
9216 : : }
9217 [ + + ]: 199740 : for (i = 1; i < length; i++) {
9218 : 175556 : c = PyUnicode_READ(kind, data, i);
9219 : 175556 : n_res = lower_ucs4(kind, data, length, i, c, mapped);
9220 [ + + ]: 351114 : for (j = 0; j < n_res; j++) {
9221 : 175558 : *maxchar = Py_MAX(*maxchar, mapped[j]);
9222 : 175558 : res[k++] = mapped[j];
9223 : : }
9224 : : }
9225 : 24184 : return k;
9226 : : }
9227 : :
9228 : : static Py_ssize_t
9229 : 29 : do_swapcase(int kind, const void *data, Py_ssize_t length, Py_UCS4 *res, Py_UCS4 *maxchar) {
9230 : 29 : Py_ssize_t i, k = 0;
9231 : :
9232 [ + + ]: 7251 : for (i = 0; i < length; i++) {
9233 : 7222 : Py_UCS4 c = PyUnicode_READ(kind, data, i), mapped[3];
9234 : : int n_res, j;
9235 [ + + ]: 7222 : if (Py_UNICODE_ISUPPER(c)) {
9236 : 1759 : n_res = lower_ucs4(kind, data, length, i, c, mapped);
9237 : : }
9238 [ + + ]: 5463 : else if (Py_UNICODE_ISLOWER(c)) {
9239 : 2405 : n_res = _PyUnicode_ToUpperFull(c, mapped);
9240 : : }
9241 : : else {
9242 : 3058 : n_res = 1;
9243 : 3058 : mapped[0] = c;
9244 : : }
9245 [ + + ]: 14449 : for (j = 0; j < n_res; j++) {
9246 : 7227 : *maxchar = Py_MAX(*maxchar, mapped[j]);
9247 : 7227 : res[k++] = mapped[j];
9248 : : }
9249 : : }
9250 : 29 : return k;
9251 : : }
9252 : :
9253 : : static Py_ssize_t
9254 : 6703725 : do_upper_or_lower(int kind, const void *data, Py_ssize_t length, Py_UCS4 *res,
9255 : : Py_UCS4 *maxchar, int lower)
9256 : : {
9257 : 6703725 : Py_ssize_t i, k = 0;
9258 : :
9259 [ + + ]: 20163696 : for (i = 0; i < length; i++) {
9260 : 13459971 : Py_UCS4 c = PyUnicode_READ(kind, data, i), mapped[3];
9261 : : int n_res, j;
9262 [ + + ]: 13459971 : if (lower)
9263 : 6768691 : n_res = lower_ucs4(kind, data, length, i, c, mapped);
9264 : : else
9265 : 6691280 : n_res = _PyUnicode_ToUpperFull(c, mapped);
9266 [ + + ]: 26920328 : for (j = 0; j < n_res; j++) {
9267 : 13460357 : *maxchar = Py_MAX(*maxchar, mapped[j]);
9268 : 13460357 : res[k++] = mapped[j];
9269 : : }
9270 : : }
9271 : 6703725 : return k;
9272 : : }
9273 : :
9274 : : static Py_ssize_t
9275 : 3349053 : do_upper(int kind, const void *data, Py_ssize_t length, Py_UCS4 *res, Py_UCS4 *maxchar)
9276 : : {
9277 : 3349053 : return do_upper_or_lower(kind, data, length, res, maxchar, 0);
9278 : : }
9279 : :
9280 : : static Py_ssize_t
9281 : 3354672 : do_lower(int kind, const void *data, Py_ssize_t length, Py_UCS4 *res, Py_UCS4 *maxchar)
9282 : : {
9283 : 3354672 : return do_upper_or_lower(kind, data, length, res, maxchar, 1);
9284 : : }
9285 : :
9286 : : static Py_ssize_t
9287 : 6 : do_casefold(int kind, const void *data, Py_ssize_t length, Py_UCS4 *res, Py_UCS4 *maxchar)
9288 : : {
9289 : 6 : Py_ssize_t i, k = 0;
9290 : :
9291 [ + + ]: 15 : for (i = 0; i < length; i++) {
9292 : 9 : Py_UCS4 c = PyUnicode_READ(kind, data, i);
9293 : : Py_UCS4 mapped[3];
9294 : 9 : int j, n_res = _PyUnicode_ToFoldedFull(c, mapped);
9295 [ + + ]: 20 : for (j = 0; j < n_res; j++) {
9296 : 11 : *maxchar = Py_MAX(*maxchar, mapped[j]);
9297 : 11 : res[k++] = mapped[j];
9298 : : }
9299 : : }
9300 : 6 : return k;
9301 : : }
9302 : :
9303 : : static Py_ssize_t
9304 : 4458340 : do_title(int kind, const void *data, Py_ssize_t length, Py_UCS4 *res, Py_UCS4 *maxchar)
9305 : : {
9306 : 4458340 : Py_ssize_t i, k = 0;
9307 : : int previous_is_cased;
9308 : :
9309 : 4458340 : previous_is_cased = 0;
9310 [ + + ]: 15617145 : for (i = 0; i < length; i++) {
9311 : 11158805 : const Py_UCS4 c = PyUnicode_READ(kind, data, i);
9312 : : Py_UCS4 mapped[3];
9313 : : int n_res, j;
9314 : :
9315 [ + + ]: 11158805 : if (previous_is_cased)
9316 : 4480896 : n_res = lower_ucs4(kind, data, length, i, c, mapped);
9317 : : else
9318 : 6677909 : n_res = _PyUnicode_ToTitleFull(c, mapped);
9319 : :
9320 [ + + ]: 22317867 : for (j = 0; j < n_res; j++) {
9321 : 11159062 : *maxchar = Py_MAX(*maxchar, mapped[j]);
9322 : 11159062 : res[k++] = mapped[j];
9323 : : }
9324 : :
9325 : 11158805 : previous_is_cased = _PyUnicode_IsCased(c);
9326 : : }
9327 : 4458340 : return k;
9328 : : }
9329 : :
9330 : : static PyObject *
9331 : 11186284 : case_operation(PyObject *self,
9332 : : Py_ssize_t (*perform)(int, const void *, Py_ssize_t, Py_UCS4 *, Py_UCS4 *))
9333 : : {
9334 : 11186284 : PyObject *res = NULL;
9335 : 11186284 : Py_ssize_t length, newlength = 0;
9336 : : int kind, outkind;
9337 : : const void *data;
9338 : : void *outdata;
9339 : 11186284 : Py_UCS4 maxchar = 0, *tmp, *tmpend;
9340 : :
9341 : 11186284 : kind = PyUnicode_KIND(self);
9342 : 11186284 : data = PyUnicode_DATA(self);
9343 : 11186284 : length = PyUnicode_GET_LENGTH(self);
9344 [ - + ]: 11186284 : if ((size_t) length > PY_SSIZE_T_MAX / (3 * sizeof(Py_UCS4))) {
9345 : 0 : PyErr_SetString(PyExc_OverflowError, "string is too long");
9346 : 0 : return NULL;
9347 : : }
9348 : 11186284 : tmp = PyMem_Malloc(sizeof(Py_UCS4) * 3 * length);
9349 [ - + ]: 11186284 : if (tmp == NULL)
9350 : : return PyErr_NoMemory();
9351 : 11186284 : newlength = perform(kind, data, length, tmp, &maxchar);
9352 : 11186284 : res = PyUnicode_New(newlength, maxchar);
9353 [ - + ]: 11186284 : if (res == NULL)
9354 : 0 : goto leave;
9355 : 11186284 : tmpend = tmp + newlength;
9356 : 11186284 : outdata = PyUnicode_DATA(res);
9357 : 11186284 : outkind = PyUnicode_KIND(res);
9358 [ + + + - ]: 11186284 : switch (outkind) {
9359 : 29156 : case PyUnicode_1BYTE_KIND:
9360 [ + + + + ]: 143861 : _PyUnicode_CONVERT_BYTES(Py_UCS4, Py_UCS1, tmp, tmpend, outdata);
9361 : 29156 : break;
9362 : 671313 : case PyUnicode_2BYTE_KIND:
9363 [ + + + + ]: 1343284 : _PyUnicode_CONVERT_BYTES(Py_UCS4, Py_UCS2, tmp, tmpend, outdata);
9364 : 671313 : break;
9365 : 10485815 : case PyUnicode_4BYTE_KIND:
9366 : 10485815 : memcpy(outdata, tmp, sizeof(Py_UCS4) * newlength);
9367 : 10485815 : break;
9368 : 0 : default:
9369 : 0 : Py_UNREACHABLE();
9370 : : }
9371 : 11186284 : leave:
9372 : 11186284 : PyMem_Free(tmp);
9373 : 11186284 : return res;
9374 : : }
9375 : :
9376 : : PyObject *
9377 : 6197517 : PyUnicode_Join(PyObject *separator, PyObject *seq)
9378 : : {
9379 : : PyObject *res;
9380 : : PyObject *fseq;
9381 : : Py_ssize_t seqlen;
9382 : : PyObject **items;
9383 : :
9384 : 6197517 : fseq = PySequence_Fast(seq, "can only join an iterable");
9385 [ + + ]: 6197517 : if (fseq == NULL) {
9386 : 6 : return NULL;
9387 : : }
9388 : :
9389 : : /* NOTE: the following code can't call back into Python code,
9390 : : * so we are sure that fseq won't be mutated.
9391 : : */
9392 : :
9393 [ + + ]: 6197511 : items = PySequence_Fast_ITEMS(fseq);
9394 [ + + ]: 6197511 : seqlen = PySequence_Fast_GET_SIZE(fseq);
9395 : 6197511 : res = _PyUnicode_JoinArray(separator, items, seqlen);
9396 : 6197511 : Py_DECREF(fseq);
9397 : 6197511 : return res;
9398 : : }
9399 : :
9400 : : PyObject *
9401 : 8474252 : _PyUnicode_JoinArray(PyObject *separator, PyObject *const *items, Py_ssize_t seqlen)
9402 : : {
9403 : 8474252 : PyObject *res = NULL; /* the result */
9404 : 8474252 : PyObject *sep = NULL;
9405 : : Py_ssize_t seplen;
9406 : : PyObject *item;
9407 : : Py_ssize_t sz, i, res_offset;
9408 : : Py_UCS4 maxchar;
9409 : : Py_UCS4 item_maxchar;
9410 : : int use_memcpy;
9411 : 8474252 : unsigned char *res_data = NULL, *sep_data = NULL;
9412 : : PyObject *last_obj;
9413 : 8474252 : int kind = 0;
9414 : :
9415 : : /* If empty sequence, return u"". */
9416 [ + + ]: 8474252 : if (seqlen == 0) {
9417 : 58531 : _Py_RETURN_UNICODE_EMPTY();
9418 : : }
9419 : :
9420 : : /* If singleton sequence with an exact Unicode, return that. */
9421 : 8415721 : last_obj = NULL;
9422 [ + + ]: 8415721 : if (seqlen == 1) {
9423 [ + + ]: 622250 : if (PyUnicode_CheckExact(items[0])) {
9424 : 604527 : res = items[0];
9425 : 604527 : Py_INCREF(res);
9426 : 604527 : return res;
9427 : : }
9428 : 17723 : seplen = 0;
9429 : 17723 : maxchar = 0;
9430 : : }
9431 : : else {
9432 : : /* Set up sep and seplen */
9433 [ - + ]: 7793471 : if (separator == NULL) {
9434 : : /* fall back to a blank space separator */
9435 : 0 : sep = PyUnicode_FromOrdinal(' ');
9436 [ # # ]: 0 : if (!sep)
9437 : 0 : goto onError;
9438 : 0 : seplen = 1;
9439 : 0 : maxchar = 32;
9440 : : }
9441 : : else {
9442 [ - + ]: 7793471 : if (!PyUnicode_Check(separator)) {
9443 : 0 : PyErr_Format(PyExc_TypeError,
9444 : : "separator: expected str instance,"
9445 : : " %.80s found",
9446 : 0 : Py_TYPE(separator)->tp_name);
9447 : 0 : goto onError;
9448 : : }
9449 : 7793471 : sep = separator;
9450 : 7793471 : seplen = PyUnicode_GET_LENGTH(separator);
9451 : 7793471 : maxchar = PyUnicode_MAX_CHAR_VALUE(separator);
9452 : : /* inc refcount to keep this code path symmetric with the
9453 : : above case of a blank separator */
9454 : 7793471 : Py_INCREF(sep);
9455 : : }
9456 : 7793471 : last_obj = sep;
9457 : : }
9458 : :
9459 : : /* There are at least two things to join, or else we have a subclass
9460 : : * of str in the sequence.
9461 : : * Do a pre-pass to figure out the total amount of space we'll
9462 : : * need (sz), and see whether all argument are strings.
9463 : : */
9464 : 7811194 : sz = 0;
9465 : : #ifdef Py_DEBUG
9466 : : use_memcpy = 0;
9467 : : #else
9468 : 7811194 : use_memcpy = 1;
9469 : : #endif
9470 [ + + ]: 86347144 : for (i = 0; i < seqlen; i++) {
9471 : : size_t add_sz;
9472 : 78535968 : item = items[i];
9473 [ + + ]: 78535968 : if (!PyUnicode_Check(item)) {
9474 : 18 : PyErr_Format(PyExc_TypeError,
9475 : : "sequence item %zd: expected str instance,"
9476 : : " %.80s found",
9477 : 18 : i, Py_TYPE(item)->tp_name);
9478 : 18 : goto onError;
9479 : : }
9480 : 78535950 : add_sz = PyUnicode_GET_LENGTH(item);
9481 : 78535950 : item_maxchar = PyUnicode_MAX_CHAR_VALUE(item);
9482 : 78535950 : maxchar = Py_MAX(maxchar, item_maxchar);
9483 [ + + ]: 78535950 : if (i != 0) {
9484 : 70724766 : add_sz += seplen;
9485 : : }
9486 [ - + ]: 78535950 : if (add_sz > (size_t)(PY_SSIZE_T_MAX - sz)) {
9487 : 0 : PyErr_SetString(PyExc_OverflowError,
9488 : : "join() result is too long for a Python string");
9489 : 0 : goto onError;
9490 : : }
9491 : 78535950 : sz += add_sz;
9492 [ + + + + ]: 78535950 : if (use_memcpy && last_obj != NULL) {
9493 [ + + ]: 68949767 : if (PyUnicode_KIND(last_obj) != PyUnicode_KIND(item))
9494 : 1157601 : use_memcpy = 0;
9495 : : }
9496 : 78535950 : last_obj = item;
9497 : : }
9498 : :
9499 : 7811176 : res = PyUnicode_New(sz, maxchar);
9500 [ - + ]: 7811176 : if (res == NULL)
9501 : 0 : goto onError;
9502 : :
9503 : : /* Catenate everything. */
9504 : : #ifdef Py_DEBUG
9505 : : use_memcpy = 0;
9506 : : #else
9507 [ + + ]: 7811176 : if (use_memcpy) {
9508 : 6653575 : res_data = PyUnicode_1BYTE_DATA(res);
9509 : 6653575 : kind = PyUnicode_KIND(res);
9510 [ + + ]: 6653575 : if (seplen != 0)
9511 : 2432856 : sep_data = PyUnicode_1BYTE_DATA(sep);
9512 : : }
9513 : : #endif
9514 [ + + ]: 7811176 : if (use_memcpy) {
9515 [ + + ]: 53454297 : for (i = 0; i < seqlen; ++i) {
9516 : : Py_ssize_t itemlen;
9517 : 46800722 : item = items[i];
9518 : :
9519 : : /* Copy item, and maybe the separator. */
9520 [ + + + + ]: 46800722 : if (i && seplen != 0) {
9521 : 6430369 : memcpy(res_data,
9522 : : sep_data,
9523 : 6430369 : kind * seplen);
9524 : 6430369 : res_data += kind * seplen;
9525 : : }
9526 : :
9527 : 46800722 : itemlen = PyUnicode_GET_LENGTH(item);
9528 [ + + ]: 46800722 : if (itemlen != 0) {
9529 : 89522592 : memcpy(res_data,
9530 : 44761296 : PyUnicode_DATA(item),
9531 : 44761296 : kind * itemlen);
9532 : 44761296 : res_data += kind * itemlen;
9533 : : }
9534 : : }
9535 : : assert(res_data == PyUnicode_1BYTE_DATA(res)
9536 : : + kind * PyUnicode_GET_LENGTH(res));
9537 : : }
9538 : : else {
9539 [ + + ]: 32892810 : for (i = 0, res_offset = 0; i < seqlen; ++i) {
9540 : : Py_ssize_t itemlen;
9541 : 31735209 : item = items[i];
9542 : :
9543 : : /* Copy item, and maybe the separator. */
9544 [ + + + + ]: 31735209 : if (i && seplen != 0) {
9545 : 1593 : _PyUnicode_FastCopyCharacters(res, res_offset, sep, 0, seplen);
9546 : 1593 : res_offset += seplen;
9547 : : }
9548 : :
9549 : 31735209 : itemlen = PyUnicode_GET_LENGTH(item);
9550 [ + + ]: 31735209 : if (itemlen != 0) {
9551 : 31733614 : _PyUnicode_FastCopyCharacters(res, res_offset, item, 0, itemlen);
9552 : 31733614 : res_offset += itemlen;
9553 : : }
9554 : : }
9555 : : assert(res_offset == PyUnicode_GET_LENGTH(res));
9556 : : }
9557 : :
9558 : 7811176 : Py_XDECREF(sep);
9559 : : assert(_PyUnicode_CheckConsistency(res, 1));
9560 : 7811176 : return res;
9561 : :
9562 : 18 : onError:
9563 : 18 : Py_XDECREF(sep);
9564 : 18 : Py_XDECREF(res);
9565 : 18 : return NULL;
9566 : : }
9567 : :
9568 : : void
9569 : 14217 : _PyUnicode_FastFill(PyObject *unicode, Py_ssize_t start, Py_ssize_t length,
9570 : : Py_UCS4 fill_char)
9571 : : {
9572 : 14217 : const int kind = PyUnicode_KIND(unicode);
9573 : 14217 : void *data = PyUnicode_DATA(unicode);
9574 : : assert(unicode_modifiable(unicode));
9575 : : assert(fill_char <= PyUnicode_MAX_CHAR_VALUE(unicode));
9576 : : assert(start >= 0);
9577 : : assert(start + length <= PyUnicode_GET_LENGTH(unicode));
9578 : 14217 : unicode_fill(kind, data, fill_char, start, length);
9579 : 14217 : }
9580 : :
9581 : : Py_ssize_t
9582 : 7650 : PyUnicode_Fill(PyObject *unicode, Py_ssize_t start, Py_ssize_t length,
9583 : : Py_UCS4 fill_char)
9584 : : {
9585 : : Py_ssize_t maxlen;
9586 : :
9587 [ - + ]: 7650 : if (!PyUnicode_Check(unicode)) {
9588 : 0 : PyErr_BadInternalCall();
9589 : 0 : return -1;
9590 : : }
9591 [ - + ]: 7650 : if (unicode_check_modifiable(unicode))
9592 : 0 : return -1;
9593 : :
9594 [ - + ]: 7650 : if (start < 0) {
9595 : 0 : PyErr_SetString(PyExc_IndexError, "string index out of range");
9596 : 0 : return -1;
9597 : : }
9598 [ - + ]: 7650 : if (fill_char > PyUnicode_MAX_CHAR_VALUE(unicode)) {
9599 : 0 : PyErr_SetString(PyExc_ValueError,
9600 : : "fill character is bigger than "
9601 : : "the string maximum character");
9602 : 0 : return -1;
9603 : : }
9604 : :
9605 : 7650 : maxlen = PyUnicode_GET_LENGTH(unicode) - start;
9606 : 7650 : length = Py_MIN(maxlen, length);
9607 [ - + ]: 7650 : if (length <= 0)
9608 : 0 : return 0;
9609 : :
9610 : 7650 : _PyUnicode_FastFill(unicode, start, length, fill_char);
9611 : 7650 : return length;
9612 : : }
9613 : :
9614 : : static PyObject *
9615 : 68205 : pad(PyObject *self,
9616 : : Py_ssize_t left,
9617 : : Py_ssize_t right,
9618 : : Py_UCS4 fill)
9619 : : {
9620 : : PyObject *u;
9621 : : Py_UCS4 maxchar;
9622 : : int kind;
9623 : : void *data;
9624 : :
9625 [ - + ]: 68205 : if (left < 0)
9626 : 0 : left = 0;
9627 [ - + ]: 68205 : if (right < 0)
9628 : 0 : right = 0;
9629 : :
9630 [ + + - + ]: 68205 : if (left == 0 && right == 0)
9631 : 0 : return unicode_result_unchanged(self);
9632 : :
9633 [ + - ]: 68205 : if (left > PY_SSIZE_T_MAX - _PyUnicode_LENGTH(self) ||
9634 [ - + ]: 68205 : right > PY_SSIZE_T_MAX - (left + _PyUnicode_LENGTH(self))) {
9635 : 0 : PyErr_SetString(PyExc_OverflowError, "padded string is too long");
9636 : 0 : return NULL;
9637 : : }
9638 : 68205 : maxchar = PyUnicode_MAX_CHAR_VALUE(self);
9639 : 68205 : maxchar = Py_MAX(maxchar, fill);
9640 : 68205 : u = PyUnicode_New(left + _PyUnicode_LENGTH(self) + right, maxchar);
9641 [ - + ]: 68205 : if (!u)
9642 : 0 : return NULL;
9643 : :
9644 : 68205 : kind = PyUnicode_KIND(u);
9645 : 68205 : data = PyUnicode_DATA(u);
9646 [ + + ]: 68205 : if (left)
9647 : 42721 : unicode_fill(kind, data, fill, 0, left);
9648 [ + + ]: 68205 : if (right)
9649 : 26740 : unicode_fill(kind, data, fill, left + _PyUnicode_LENGTH(self), right);
9650 : 68205 : _PyUnicode_FastCopyCharacters(u, left, self, 0, _PyUnicode_LENGTH(self));
9651 : : assert(_PyUnicode_CheckConsistency(u, 1));
9652 : 68205 : return u;
9653 : : }
9654 : :
9655 : : PyObject *
9656 : 329403 : PyUnicode_Splitlines(PyObject *string, int keepends)
9657 : : {
9658 : : PyObject *list;
9659 : :
9660 [ - + ]: 329403 : if (ensure_unicode(string) < 0)
9661 : 0 : return NULL;
9662 : :
9663 [ + + + - ]: 329403 : switch (PyUnicode_KIND(string)) {
9664 : 159839 : case PyUnicode_1BYTE_KIND:
9665 [ + + ]: 159839 : if (PyUnicode_IS_ASCII(string))
9666 : 318144 : list = asciilib_splitlines(
9667 : 159072 : string, PyUnicode_1BYTE_DATA(string),
9668 : : PyUnicode_GET_LENGTH(string), keepends);
9669 : : else
9670 : 1534 : list = ucs1lib_splitlines(
9671 : 767 : string, PyUnicode_1BYTE_DATA(string),
9672 : : PyUnicode_GET_LENGTH(string), keepends);
9673 : 159839 : break;
9674 : 168769 : case PyUnicode_2BYTE_KIND:
9675 : 337538 : list = ucs2lib_splitlines(
9676 : 168769 : string, PyUnicode_2BYTE_DATA(string),
9677 : : PyUnicode_GET_LENGTH(string), keepends);
9678 : 168769 : break;
9679 : 795 : case PyUnicode_4BYTE_KIND:
9680 : 1590 : list = ucs4lib_splitlines(
9681 : 795 : string, PyUnicode_4BYTE_DATA(string),
9682 : : PyUnicode_GET_LENGTH(string), keepends);
9683 : 795 : break;
9684 : 0 : default:
9685 : 0 : Py_UNREACHABLE();
9686 : : }
9687 : 329403 : return list;
9688 : : }
9689 : :
9690 : : static PyObject *
9691 : 2415421 : split(PyObject *self,
9692 : : PyObject *substring,
9693 : : Py_ssize_t maxcount)
9694 : : {
9695 : : int kind1, kind2;
9696 : : const void *buf1, *buf2;
9697 : : Py_ssize_t len1, len2;
9698 : : PyObject* out;
9699 : :
9700 [ + + ]: 2415421 : if (maxcount < 0)
9701 : 2338298 : maxcount = PY_SSIZE_T_MAX;
9702 : :
9703 [ + + ]: 2415421 : if (substring == NULL)
9704 [ + + - - ]: 491440 : switch (PyUnicode_KIND(self)) {
9705 : 491434 : case PyUnicode_1BYTE_KIND:
9706 [ + + ]: 491434 : if (PyUnicode_IS_ASCII(self))
9707 : 982828 : return asciilib_split_whitespace(
9708 : 491414 : self, PyUnicode_1BYTE_DATA(self),
9709 : : PyUnicode_GET_LENGTH(self), maxcount
9710 : : );
9711 : : else
9712 : 40 : return ucs1lib_split_whitespace(
9713 : 20 : self, PyUnicode_1BYTE_DATA(self),
9714 : : PyUnicode_GET_LENGTH(self), maxcount
9715 : : );
9716 : 6 : case PyUnicode_2BYTE_KIND:
9717 : 12 : return ucs2lib_split_whitespace(
9718 : 6 : self, PyUnicode_2BYTE_DATA(self),
9719 : : PyUnicode_GET_LENGTH(self), maxcount
9720 : : );
9721 : 0 : case PyUnicode_4BYTE_KIND:
9722 : 0 : return ucs4lib_split_whitespace(
9723 : 0 : self, PyUnicode_4BYTE_DATA(self),
9724 : : PyUnicode_GET_LENGTH(self), maxcount
9725 : : );
9726 : 0 : default:
9727 : 0 : Py_UNREACHABLE();
9728 : : }
9729 : :
9730 : 1923981 : kind1 = PyUnicode_KIND(self);
9731 : 1923981 : kind2 = PyUnicode_KIND(substring);
9732 : 1923981 : len1 = PyUnicode_GET_LENGTH(self);
9733 : 1923981 : len2 = PyUnicode_GET_LENGTH(substring);
9734 [ + + + + ]: 1923981 : if (kind1 < kind2 || len1 < len2) {
9735 : 18191 : out = PyList_New(1);
9736 [ - + ]: 18191 : if (out == NULL)
9737 : 0 : return NULL;
9738 : 18191 : Py_INCREF(self);
9739 : 18191 : PyList_SET_ITEM(out, 0, self);
9740 : 18191 : return out;
9741 : : }
9742 : 1905790 : buf1 = PyUnicode_DATA(self);
9743 : 1905790 : buf2 = PyUnicode_DATA(substring);
9744 [ + + ]: 1905790 : if (kind2 != kind1) {
9745 : 19276 : buf2 = unicode_askind(kind2, buf2, len2, kind1);
9746 [ - + ]: 19276 : if (!buf2)
9747 : 0 : return NULL;
9748 : : }
9749 : :
9750 [ + + + - ]: 1905790 : switch (kind1) {
9751 : 1886500 : case PyUnicode_1BYTE_KIND:
9752 [ + + + - ]: 1886500 : if (PyUnicode_IS_ASCII(self) && PyUnicode_IS_ASCII(substring))
9753 : 1880006 : out = asciilib_split(
9754 : : self, buf1, len1, buf2, len2, maxcount);
9755 : : else
9756 : 6494 : out = ucs1lib_split(
9757 : : self, buf1, len1, buf2, len2, maxcount);
9758 : 1886500 : break;
9759 : 16850 : case PyUnicode_2BYTE_KIND:
9760 : 16850 : out = ucs2lib_split(
9761 : : self, buf1, len1, buf2, len2, maxcount);
9762 : 16850 : break;
9763 : 2440 : case PyUnicode_4BYTE_KIND:
9764 : 2440 : out = ucs4lib_split(
9765 : : self, buf1, len1, buf2, len2, maxcount);
9766 : 2440 : break;
9767 : 0 : default:
9768 : 0 : out = NULL;
9769 : : }
9770 : : assert((kind2 != kind1) == (buf2 != PyUnicode_DATA(substring)));
9771 [ + + ]: 1905790 : if (kind2 != kind1)
9772 : 19276 : PyMem_Free((void *)buf2);
9773 : 1905790 : return out;
9774 : : }
9775 : :
9776 : : static PyObject *
9777 : 3830 : rsplit(PyObject *self,
9778 : : PyObject *substring,
9779 : : Py_ssize_t maxcount)
9780 : : {
9781 : : int kind1, kind2;
9782 : : const void *buf1, *buf2;
9783 : : Py_ssize_t len1, len2;
9784 : : PyObject* out;
9785 : :
9786 [ + + ]: 3830 : if (maxcount < 0)
9787 : 112 : maxcount = PY_SSIZE_T_MAX;
9788 : :
9789 [ + + ]: 3830 : if (substring == NULL)
9790 [ + - - - ]: 76 : switch (PyUnicode_KIND(self)) {
9791 : 76 : case PyUnicode_1BYTE_KIND:
9792 [ + - ]: 76 : if (PyUnicode_IS_ASCII(self))
9793 : 152 : return asciilib_rsplit_whitespace(
9794 : 76 : self, PyUnicode_1BYTE_DATA(self),
9795 : : PyUnicode_GET_LENGTH(self), maxcount
9796 : : );
9797 : : else
9798 : 0 : return ucs1lib_rsplit_whitespace(
9799 : 0 : self, PyUnicode_1BYTE_DATA(self),
9800 : : PyUnicode_GET_LENGTH(self), maxcount
9801 : : );
9802 : 0 : case PyUnicode_2BYTE_KIND:
9803 : 0 : return ucs2lib_rsplit_whitespace(
9804 : 0 : self, PyUnicode_2BYTE_DATA(self),
9805 : : PyUnicode_GET_LENGTH(self), maxcount
9806 : : );
9807 : 0 : case PyUnicode_4BYTE_KIND:
9808 : 0 : return ucs4lib_rsplit_whitespace(
9809 : 0 : self, PyUnicode_4BYTE_DATA(self),
9810 : : PyUnicode_GET_LENGTH(self), maxcount
9811 : : );
9812 : 0 : default:
9813 : 0 : Py_UNREACHABLE();
9814 : : }
9815 : :
9816 : 3754 : kind1 = PyUnicode_KIND(self);
9817 : 3754 : kind2 = PyUnicode_KIND(substring);
9818 : 3754 : len1 = PyUnicode_GET_LENGTH(self);
9819 : 3754 : len2 = PyUnicode_GET_LENGTH(substring);
9820 [ + + + + ]: 3754 : if (kind1 < kind2 || len1 < len2) {
9821 : 13 : out = PyList_New(1);
9822 [ - + ]: 13 : if (out == NULL)
9823 : 0 : return NULL;
9824 : 13 : Py_INCREF(self);
9825 : 13 : PyList_SET_ITEM(out, 0, self);
9826 : 13 : return out;
9827 : : }
9828 : 3741 : buf1 = PyUnicode_DATA(self);
9829 : 3741 : buf2 = PyUnicode_DATA(substring);
9830 [ + + ]: 3741 : if (kind2 != kind1) {
9831 : 12 : buf2 = unicode_askind(kind2, buf2, len2, kind1);
9832 [ - + ]: 12 : if (!buf2)
9833 : 0 : return NULL;
9834 : : }
9835 : :
9836 [ + + + - ]: 3741 : switch (kind1) {
9837 : 3715 : case PyUnicode_1BYTE_KIND:
9838 [ + + + - ]: 3715 : if (PyUnicode_IS_ASCII(self) && PyUnicode_IS_ASCII(substring))
9839 : 3712 : out = asciilib_rsplit(
9840 : : self, buf1, len1, buf2, len2, maxcount);
9841 : : else
9842 : 3 : out = ucs1lib_rsplit(
9843 : : self, buf1, len1, buf2, len2, maxcount);
9844 : 3715 : break;
9845 : 10 : case PyUnicode_2BYTE_KIND:
9846 : 10 : out = ucs2lib_rsplit(
9847 : : self, buf1, len1, buf2, len2, maxcount);
9848 : 10 : break;
9849 : 16 : case PyUnicode_4BYTE_KIND:
9850 : 16 : out = ucs4lib_rsplit(
9851 : : self, buf1, len1, buf2, len2, maxcount);
9852 : 16 : break;
9853 : 0 : default:
9854 : 0 : out = NULL;
9855 : : }
9856 : : assert((kind2 != kind1) == (buf2 != PyUnicode_DATA(substring)));
9857 [ + + ]: 3741 : if (kind2 != kind1)
9858 : 12 : PyMem_Free((void *)buf2);
9859 : 3741 : return out;
9860 : : }
9861 : :
9862 : : static Py_ssize_t
9863 : 559255 : anylib_find(int kind, PyObject *str1, const void *buf1, Py_ssize_t len1,
9864 : : PyObject *str2, const void *buf2, Py_ssize_t len2, Py_ssize_t offset)
9865 : : {
9866 [ + + + - ]: 559255 : switch (kind) {
9867 : 558905 : case PyUnicode_1BYTE_KIND:
9868 [ + + + - ]: 558905 : if (PyUnicode_IS_ASCII(str1) && PyUnicode_IS_ASCII(str2))
9869 : 546778 : return asciilib_find(buf1, len1, buf2, len2, offset);
9870 : : else
9871 : 12127 : return ucs1lib_find(buf1, len1, buf2, len2, offset);
9872 : 329 : case PyUnicode_2BYTE_KIND:
9873 : 329 : return ucs2lib_find(buf1, len1, buf2, len2, offset);
9874 : 21 : case PyUnicode_4BYTE_KIND:
9875 : 21 : return ucs4lib_find(buf1, len1, buf2, len2, offset);
9876 : : }
9877 : 0 : Py_UNREACHABLE();
9878 : : }
9879 : :
9880 : : static Py_ssize_t
9881 : 2357978 : anylib_count(int kind, PyObject *sstr, const void* sbuf, Py_ssize_t slen,
9882 : : PyObject *str1, const void *buf1, Py_ssize_t len1, Py_ssize_t maxcount)
9883 : : {
9884 [ + + + - ]: 2357978 : switch (kind) {
9885 : 2354810 : case PyUnicode_1BYTE_KIND:
9886 [ + + + - ]: 2354810 : if (PyUnicode_IS_ASCII(sstr) && PyUnicode_IS_ASCII(str1))
9887 : 2351458 : return asciilib_count(sbuf, slen, buf1, len1, maxcount);
9888 : : else
9889 : 3352 : return ucs1lib_count(sbuf, slen, buf1, len1, maxcount);
9890 : 2345 : case PyUnicode_2BYTE_KIND:
9891 : 2345 : return ucs2lib_count(sbuf, slen, buf1, len1, maxcount);
9892 : 823 : case PyUnicode_4BYTE_KIND:
9893 : 823 : return ucs4lib_count(sbuf, slen, buf1, len1, maxcount);
9894 : : }
9895 : 0 : Py_UNREACHABLE();
9896 : : }
9897 : :
9898 : : static void
9899 : 47239 : replace_1char_inplace(PyObject *u, Py_ssize_t pos,
9900 : : Py_UCS4 u1, Py_UCS4 u2, Py_ssize_t maxcount)
9901 : : {
9902 : 47239 : int kind = PyUnicode_KIND(u);
9903 : 47239 : void *data = PyUnicode_DATA(u);
9904 : 47239 : Py_ssize_t len = PyUnicode_GET_LENGTH(u);
9905 [ + + ]: 47239 : if (kind == PyUnicode_1BYTE_KIND) {
9906 : 47206 : ucs1lib_replace_1char_inplace((Py_UCS1 *)data + pos,
9907 : : (Py_UCS1 *)data + len,
9908 : : u1, u2, maxcount);
9909 : : }
9910 [ + + ]: 33 : else if (kind == PyUnicode_2BYTE_KIND) {
9911 : 14 : ucs2lib_replace_1char_inplace((Py_UCS2 *)data + pos,
9912 : 14 : (Py_UCS2 *)data + len,
9913 : : u1, u2, maxcount);
9914 : : }
9915 : : else {
9916 : : assert(kind == PyUnicode_4BYTE_KIND);
9917 : 19 : ucs4lib_replace_1char_inplace((Py_UCS4 *)data + pos,
9918 : 19 : (Py_UCS4 *)data + len,
9919 : : u1, u2, maxcount);
9920 : : }
9921 : 47239 : }
9922 : :
9923 : : static PyObject *
9924 : 3276629 : replace(PyObject *self, PyObject *str1,
9925 : : PyObject *str2, Py_ssize_t maxcount)
9926 : : {
9927 : : PyObject *u;
9928 : 3276629 : const char *sbuf = PyUnicode_DATA(self);
9929 : 3276629 : const void *buf1 = PyUnicode_DATA(str1);
9930 : 3276629 : const void *buf2 = PyUnicode_DATA(str2);
9931 : 3276629 : int srelease = 0, release1 = 0, release2 = 0;
9932 : 3276629 : int skind = PyUnicode_KIND(self);
9933 : 3276629 : int kind1 = PyUnicode_KIND(str1);
9934 : 3276629 : int kind2 = PyUnicode_KIND(str2);
9935 : 3276629 : Py_ssize_t slen = PyUnicode_GET_LENGTH(self);
9936 : 3276629 : Py_ssize_t len1 = PyUnicode_GET_LENGTH(str1);
9937 : 3276629 : Py_ssize_t len2 = PyUnicode_GET_LENGTH(str2);
9938 : : int mayshrink;
9939 : : Py_UCS4 maxchar, maxchar_str1, maxchar_str2;
9940 : :
9941 [ + + ]: 3276629 : if (slen < len1)
9942 : 769590 : goto nothing;
9943 : :
9944 [ + + ]: 2507039 : if (maxcount < 0)
9945 : 2506898 : maxcount = PY_SSIZE_T_MAX;
9946 [ + + ]: 141 : else if (maxcount == 0)
9947 : 33 : goto nothing;
9948 : :
9949 [ + + ]: 2507006 : if (str1 == str2)
9950 : 3452 : goto nothing;
9951 : :
9952 : 2503554 : maxchar = PyUnicode_MAX_CHAR_VALUE(self);
9953 : 2503554 : maxchar_str1 = PyUnicode_MAX_CHAR_VALUE(str1);
9954 [ + + ]: 2503554 : if (maxchar < maxchar_str1)
9955 : : /* substring too wide to be present */
9956 : 40 : goto nothing;
9957 : 2503514 : maxchar_str2 = PyUnicode_MAX_CHAR_VALUE(str2);
9958 : : /* Replacing str1 with str2 may cause a maxchar reduction in the
9959 : : result string. */
9960 [ + + + + ]: 2503514 : mayshrink = (maxchar_str2 < maxchar_str1) && (maxchar == maxchar_str1);
9961 : 2503514 : maxchar = Py_MAX(maxchar, maxchar_str2);
9962 : :
9963 [ + + ]: 2503514 : if (len1 == len2) {
9964 : : /* same length */
9965 [ - + ]: 145536 : if (len1 == 0)
9966 : 0 : goto nothing;
9967 [ + + ]: 145536 : if (len1 == 1) {
9968 : : /* replace characters */
9969 : : Py_UCS4 u1, u2;
9970 : : Py_ssize_t pos;
9971 : :
9972 : 144137 : u1 = PyUnicode_READ(kind1, buf1, 0);
9973 : 144137 : pos = findchar(sbuf, skind, slen, u1, 1);
9974 [ + + ]: 144137 : if (pos < 0)
9975 : 96898 : goto nothing;
9976 : 47239 : u2 = PyUnicode_READ(kind2, buf2, 0);
9977 : 47239 : u = PyUnicode_New(slen, maxchar);
9978 [ - + ]: 47239 : if (!u)
9979 : 0 : goto error;
9980 : :
9981 : 47239 : _PyUnicode_FastCopyCharacters(u, 0, self, 0, slen);
9982 : 47239 : replace_1char_inplace(u, pos, u1, u2, maxcount);
9983 : : }
9984 : : else {
9985 : 1399 : int rkind = skind;
9986 : : char *res;
9987 : : Py_ssize_t i;
9988 : :
9989 [ - + ]: 1399 : if (kind1 < rkind) {
9990 : : /* widen substring */
9991 : 0 : buf1 = unicode_askind(kind1, buf1, len1, rkind);
9992 [ # # ]: 0 : if (!buf1) goto error;
9993 : 0 : release1 = 1;
9994 : : }
9995 : 1399 : i = anylib_find(rkind, self, sbuf, slen, str1, buf1, len1, 0);
9996 [ + + ]: 1399 : if (i < 0)
9997 : 941 : goto nothing;
9998 [ - + ]: 458 : if (rkind > kind2) {
9999 : : /* widen replacement */
10000 : 0 : buf2 = unicode_askind(kind2, buf2, len2, rkind);
10001 [ # # ]: 0 : if (!buf2) goto error;
10002 : 0 : release2 = 1;
10003 : : }
10004 [ - + ]: 458 : else if (rkind < kind2) {
10005 : : /* widen self and buf1 */
10006 : 0 : rkind = kind2;
10007 [ # # ]: 0 : if (release1) {
10008 : : assert(buf1 != PyUnicode_DATA(str1));
10009 : 0 : PyMem_Free((void *)buf1);
10010 : 0 : buf1 = PyUnicode_DATA(str1);
10011 : 0 : release1 = 0;
10012 : : }
10013 : 0 : sbuf = unicode_askind(skind, sbuf, slen, rkind);
10014 [ # # ]: 0 : if (!sbuf) goto error;
10015 : 0 : srelease = 1;
10016 : 0 : buf1 = unicode_askind(kind1, buf1, len1, rkind);
10017 [ # # ]: 0 : if (!buf1) goto error;
10018 : 0 : release1 = 1;
10019 : : }
10020 : 458 : u = PyUnicode_New(slen, maxchar);
10021 [ - + ]: 458 : if (!u)
10022 : 0 : goto error;
10023 : : assert(PyUnicode_KIND(u) == rkind);
10024 : 458 : res = PyUnicode_DATA(u);
10025 : :
10026 : 458 : memcpy(res, sbuf, rkind * slen);
10027 : : /* change everything in-place, starting with this one */
10028 : 458 : memcpy(res + rkind * i,
10029 : : buf2,
10030 : 458 : rkind * len2);
10031 : 458 : i += len1;
10032 : :
10033 [ + + ]: 485 : while ( --maxcount > 0) {
10034 : 479 : i = anylib_find(rkind, self,
10035 : 479 : sbuf+rkind*i, slen-i,
10036 : : str1, buf1, len1, i);
10037 [ + + ]: 479 : if (i == -1)
10038 : 452 : break;
10039 : 27 : memcpy(res + rkind * i,
10040 : : buf2,
10041 : 27 : rkind * len2);
10042 : 27 : i += len1;
10043 : : }
10044 : : }
10045 : : }
10046 : : else {
10047 : : Py_ssize_t n, i, j, ires;
10048 : : Py_ssize_t new_size;
10049 : 2357978 : int rkind = skind;
10050 : : char *res;
10051 : :
10052 [ + + ]: 2357978 : if (kind1 < rkind) {
10053 : : /* widen substring */
10054 : 2832 : buf1 = unicode_askind(kind1, buf1, len1, rkind);
10055 [ - + ]: 2832 : if (!buf1) goto error;
10056 : 2832 : release1 = 1;
10057 : : }
10058 : 2357978 : n = anylib_count(rkind, self, sbuf, slen, str1, buf1, len1, maxcount);
10059 [ + + ]: 2357978 : if (n == 0)
10060 : 2092281 : goto nothing;
10061 [ + + ]: 265697 : if (kind2 < rkind) {
10062 : : /* widen replacement */
10063 : 410 : buf2 = unicode_askind(kind2, buf2, len2, rkind);
10064 [ - + ]: 410 : if (!buf2) goto error;
10065 : 410 : release2 = 1;
10066 : : }
10067 [ + + ]: 265287 : else if (kind2 > rkind) {
10068 : : /* widen self and buf1 */
10069 : 5 : rkind = kind2;
10070 : 5 : sbuf = unicode_askind(skind, sbuf, slen, rkind);
10071 [ - + ]: 5 : if (!sbuf) goto error;
10072 : 5 : srelease = 1;
10073 [ + + ]: 5 : if (release1) {
10074 : : assert(buf1 != PyUnicode_DATA(str1));
10075 : 1 : PyMem_Free((void *)buf1);
10076 : 1 : buf1 = PyUnicode_DATA(str1);
10077 : 1 : release1 = 0;
10078 : : }
10079 : 5 : buf1 = unicode_askind(kind1, buf1, len1, rkind);
10080 [ - + ]: 5 : if (!buf1) goto error;
10081 : 5 : release1 = 1;
10082 : : }
10083 : : /* new_size = PyUnicode_GET_LENGTH(self) + n * (PyUnicode_GET_LENGTH(str2) -
10084 : : PyUnicode_GET_LENGTH(str1)); */
10085 [ + + - + ]: 265697 : if (len1 < len2 && len2 - len1 > (PY_SSIZE_T_MAX - slen) / n) {
10086 : 0 : PyErr_SetString(PyExc_OverflowError,
10087 : : "replace string is too long");
10088 : 0 : goto error;
10089 : : }
10090 : 265697 : new_size = slen + n * (len2 - len1);
10091 [ + + ]: 265697 : if (new_size == 0) {
10092 : 10429 : u = unicode_new_empty();
10093 : 10429 : goto done;
10094 : : }
10095 [ - + ]: 255268 : if (new_size > (PY_SSIZE_T_MAX / rkind)) {
10096 : 0 : PyErr_SetString(PyExc_OverflowError,
10097 : : "replace string is too long");
10098 : 0 : goto error;
10099 : : }
10100 : 255268 : u = PyUnicode_New(new_size, maxchar);
10101 [ - + ]: 255268 : if (!u)
10102 : 0 : goto error;
10103 : : assert(PyUnicode_KIND(u) == rkind);
10104 : 255268 : res = PyUnicode_DATA(u);
10105 : 255268 : ires = i = 0;
10106 [ + + ]: 255268 : if (len1 > 0) {
10107 [ + + ]: 812617 : while (n-- > 0) {
10108 : : /* look for next match */
10109 : 557377 : j = anylib_find(rkind, self,
10110 : 557377 : sbuf + rkind * i, slen-i,
10111 : : str1, buf1, len1, i);
10112 [ - + ]: 557377 : if (j == -1)
10113 : 0 : break;
10114 [ + + ]: 557377 : else if (j > i) {
10115 : : /* copy unchanged part [i:j] */
10116 : 522631 : memcpy(res + rkind * ires,
10117 : 522631 : sbuf + rkind * i,
10118 : 522631 : rkind * (j-i));
10119 : 522631 : ires += j - i;
10120 : : }
10121 : : /* copy substitution string */
10122 [ + + ]: 557377 : if (len2 > 0) {
10123 : 291409 : memcpy(res + rkind * ires,
10124 : : buf2,
10125 : 291409 : rkind * len2);
10126 : 291409 : ires += len2;
10127 : : }
10128 : 557377 : i = j + len1;
10129 : : }
10130 [ + + ]: 255240 : if (i < slen)
10131 : : /* copy tail [i:] */
10132 : 71275 : memcpy(res + rkind * ires,
10133 : 71275 : sbuf + rkind * i,
10134 : 71275 : rkind * (slen-i));
10135 : : }
10136 : : else {
10137 : : /* interleave */
10138 [ + - ]: 66 : while (n > 0) {
10139 : 66 : memcpy(res + rkind * ires,
10140 : : buf2,
10141 : 66 : rkind * len2);
10142 : 66 : ires += len2;
10143 [ + + ]: 66 : if (--n <= 0)
10144 : 28 : break;
10145 : 38 : memcpy(res + rkind * ires,
10146 : 38 : sbuf + rkind * i,
10147 : : rkind);
10148 : 38 : ires++;
10149 : 38 : i++;
10150 : : }
10151 : 28 : memcpy(res + rkind * ires,
10152 : 28 : sbuf + rkind * i,
10153 : 28 : rkind * (slen-i));
10154 : : }
10155 : : }
10156 : :
10157 [ + + ]: 302965 : if (mayshrink) {
10158 : 141 : unicode_adjust_maxchar(&u);
10159 [ + - ]: 141 : if (u == NULL)
10160 : 0 : goto error;
10161 : : }
10162 : :
10163 : 302965 : done:
10164 : : assert(srelease == (sbuf != PyUnicode_DATA(self)));
10165 : : assert(release1 == (buf1 != PyUnicode_DATA(str1)));
10166 : : assert(release2 == (buf2 != PyUnicode_DATA(str2)));
10167 [ + + ]: 313394 : if (srelease)
10168 : 5 : PyMem_Free((void *)sbuf);
10169 [ + + ]: 313394 : if (release1)
10170 : 101 : PyMem_Free((void *)buf1);
10171 [ + + ]: 313394 : if (release2)
10172 : 410 : PyMem_Free((void *)buf2);
10173 : : assert(_PyUnicode_CheckConsistency(u, 1));
10174 : 313394 : return u;
10175 : :
10176 : 2963235 : nothing:
10177 : : /* nothing to replace; return original string (when possible) */
10178 : : assert(srelease == (sbuf != PyUnicode_DATA(self)));
10179 : : assert(release1 == (buf1 != PyUnicode_DATA(str1)));
10180 : : assert(release2 == (buf2 != PyUnicode_DATA(str2)));
10181 [ - + ]: 2963235 : if (srelease)
10182 : 0 : PyMem_Free((void *)sbuf);
10183 [ + + ]: 2963235 : if (release1)
10184 : 2735 : PyMem_Free((void *)buf1);
10185 [ - + ]: 2963235 : if (release2)
10186 : 0 : PyMem_Free((void *)buf2);
10187 : 2963235 : return unicode_result_unchanged(self);
10188 : :
10189 : 0 : error:
10190 : : assert(srelease == (sbuf != PyUnicode_DATA(self)));
10191 : : assert(release1 == (buf1 != PyUnicode_DATA(str1)));
10192 : : assert(release2 == (buf2 != PyUnicode_DATA(str2)));
10193 [ # # ]: 0 : if (srelease)
10194 : 0 : PyMem_Free((void *)sbuf);
10195 [ # # ]: 0 : if (release1)
10196 : 0 : PyMem_Free((void *)buf1);
10197 [ # # ]: 0 : if (release2)
10198 : 0 : PyMem_Free((void *)buf2);
10199 : 0 : return NULL;
10200 : : }
10201 : :
10202 : : /* --- Unicode Object Methods --------------------------------------------- */
10203 : :
10204 : : /*[clinic input]
10205 : : str.title as unicode_title
10206 : :
10207 : : Return a version of the string where each word is titlecased.
10208 : :
10209 : : More specifically, words start with uppercased characters and all remaining
10210 : : cased characters have lower case.
10211 : : [clinic start generated code]*/
10212 : :
10213 : : static PyObject *
10214 : 4458340 : unicode_title_impl(PyObject *self)
10215 : : /*[clinic end generated code: output=c75ae03809574902 input=fa945d669b26e683]*/
10216 : : {
10217 : 4458340 : return case_operation(self, do_title);
10218 : : }
10219 : :
10220 : : /*[clinic input]
10221 : : str.capitalize as unicode_capitalize
10222 : :
10223 : : Return a capitalized version of the string.
10224 : :
10225 : : More specifically, make the first character have upper case and the rest lower
10226 : : case.
10227 : : [clinic start generated code]*/
10228 : :
10229 : : static PyObject *
10230 : 24187 : unicode_capitalize_impl(PyObject *self)
10231 : : /*[clinic end generated code: output=e49a4c333cdb7667 input=f4cbf1016938da6d]*/
10232 : : {
10233 [ + + ]: 24187 : if (PyUnicode_GET_LENGTH(self) == 0)
10234 : 3 : return unicode_result_unchanged(self);
10235 : 24184 : return case_operation(self, do_capitalize);
10236 : : }
10237 : :
10238 : : /*[clinic input]
10239 : : str.casefold as unicode_casefold
10240 : :
10241 : : Return a version of the string suitable for caseless comparisons.
10242 : : [clinic start generated code]*/
10243 : :
10244 : : static PyObject *
10245 : 700 : unicode_casefold_impl(PyObject *self)
10246 : : /*[clinic end generated code: output=0120daf657ca40af input=384d66cc2ae30daf]*/
10247 : : {
10248 [ + + ]: 700 : if (PyUnicode_IS_ASCII(self))
10249 : 694 : return ascii_upper_or_lower(self, 1);
10250 : 6 : return case_operation(self, do_casefold);
10251 : : }
10252 : :
10253 : :
10254 : : /* Argument converter. Accepts a single Unicode character. */
10255 : :
10256 : : static int
10257 : 63 : convert_uc(PyObject *obj, void *addr)
10258 : : {
10259 : 63 : Py_UCS4 *fillcharloc = (Py_UCS4 *)addr;
10260 : :
10261 [ - + ]: 63 : if (!PyUnicode_Check(obj)) {
10262 : 0 : PyErr_Format(PyExc_TypeError,
10263 : : "The fill character must be a unicode character, "
10264 : 0 : "not %.100s", Py_TYPE(obj)->tp_name);
10265 : 0 : return 0;
10266 : : }
10267 [ - + ]: 63 : if (PyUnicode_GET_LENGTH(obj) != 1) {
10268 : 0 : PyErr_SetString(PyExc_TypeError,
10269 : : "The fill character must be exactly one character long");
10270 : 0 : return 0;
10271 : : }
10272 : 63 : *fillcharloc = PyUnicode_READ_CHAR(obj, 0);
10273 : 63 : return 1;
10274 : : }
10275 : :
10276 : : /*[clinic input]
10277 : : str.center as unicode_center
10278 : :
10279 : : width: Py_ssize_t
10280 : : fillchar: Py_UCS4 = ' '
10281 : : /
10282 : :
10283 : : Return a centered string of length width.
10284 : :
10285 : : Padding is done using the specified fill character (default is a space).
10286 : : [clinic start generated code]*/
10287 : :
10288 : : static PyObject *
10289 : 7866 : unicode_center_impl(PyObject *self, Py_ssize_t width, Py_UCS4 fillchar)
10290 : : /*[clinic end generated code: output=420c8859effc7c0c input=b42b247eb26e6519]*/
10291 : : {
10292 : : Py_ssize_t marg, left;
10293 : :
10294 [ + + ]: 7866 : if (PyUnicode_GET_LENGTH(self) >= width)
10295 : 6241 : return unicode_result_unchanged(self);
10296 : :
10297 : 1625 : marg = width - PyUnicode_GET_LENGTH(self);
10298 : 1625 : left = marg / 2 + (marg & width & 1);
10299 : :
10300 : 1625 : return pad(self, left, marg - left, fillchar);
10301 : : }
10302 : :
10303 : : /* This function assumes that str1 and str2 are readied by the caller. */
10304 : :
10305 : : static int
10306 : 2412302 : unicode_compare(PyObject *str1, PyObject *str2)
10307 : : {
10308 : : #define COMPARE(TYPE1, TYPE2) \
10309 : : do { \
10310 : : TYPE1* p1 = (TYPE1 *)data1; \
10311 : : TYPE2* p2 = (TYPE2 *)data2; \
10312 : : TYPE1* end = p1 + len; \
10313 : : Py_UCS4 c1, c2; \
10314 : : for (; p1 != end; p1++, p2++) { \
10315 : : c1 = *p1; \
10316 : : c2 = *p2; \
10317 : : if (c1 != c2) \
10318 : : return (c1 < c2) ? -1 : 1; \
10319 : : } \
10320 : : } \
10321 : : while (0)
10322 : :
10323 : : int kind1, kind2;
10324 : : const void *data1, *data2;
10325 : : Py_ssize_t len1, len2, len;
10326 : :
10327 : 2412302 : kind1 = PyUnicode_KIND(str1);
10328 : 2412302 : kind2 = PyUnicode_KIND(str2);
10329 : 2412302 : data1 = PyUnicode_DATA(str1);
10330 : 2412302 : data2 = PyUnicode_DATA(str2);
10331 : 2412302 : len1 = PyUnicode_GET_LENGTH(str1);
10332 : 2412302 : len2 = PyUnicode_GET_LENGTH(str2);
10333 : 2412302 : len = Py_MIN(len1, len2);
10334 : :
10335 [ + + + - ]: 2412302 : switch(kind1) {
10336 [ + + + - ]: 2329214 : case PyUnicode_1BYTE_KIND:
10337 : : {
10338 : : switch(kind2) {
10339 : 2324453 : case PyUnicode_1BYTE_KIND:
10340 : : {
10341 : 2324453 : int cmp = memcmp(data1, data2, len);
10342 : : /* normalize result of memcmp() into the range [-1; 1] */
10343 [ + + ]: 2324453 : if (cmp < 0)
10344 : 1143750 : return -1;
10345 [ + + ]: 1180703 : if (cmp > 0)
10346 : 982843 : return 1;
10347 : 197860 : break;
10348 : : }
10349 : 4757 : case PyUnicode_2BYTE_KIND:
10350 [ + - + + : 4757 : COMPARE(Py_UCS1, Py_UCS2);
+ - ]
10351 : 0 : break;
10352 : 4 : case PyUnicode_4BYTE_KIND:
10353 [ + - + - : 4 : COMPARE(Py_UCS1, Py_UCS4);
+ - ]
10354 : 0 : break;
10355 : 0 : default:
10356 : 0 : Py_UNREACHABLE();
10357 : : }
10358 : 197860 : break;
10359 : : }
10360 [ + + + - ]: 82189 : case PyUnicode_2BYTE_KIND:
10361 : : {
10362 : : switch(kind2) {
10363 : 1218 : case PyUnicode_1BYTE_KIND:
10364 [ + - + + : 1218 : COMPARE(Py_UCS2, Py_UCS1);
+ - ]
10365 : 0 : break;
10366 : 80969 : case PyUnicode_2BYTE_KIND:
10367 : : {
10368 [ + + + + : 92546 : COMPARE(Py_UCS2, Py_UCS2);
+ + ]
10369 : 2485 : break;
10370 : : }
10371 : 2 : case PyUnicode_4BYTE_KIND:
10372 [ + - + - : 2 : COMPARE(Py_UCS2, Py_UCS4);
+ - ]
10373 : 0 : break;
10374 : 0 : default:
10375 : 0 : Py_UNREACHABLE();
10376 : : }
10377 : 2485 : break;
10378 : : }
10379 [ + + + - ]: 899 : case PyUnicode_4BYTE_KIND:
10380 : : {
10381 : : switch(kind2) {
10382 : 8 : case PyUnicode_1BYTE_KIND:
10383 [ + - + + : 8 : COMPARE(Py_UCS4, Py_UCS1);
+ - ]
10384 : 0 : break;
10385 : 7 : case PyUnicode_2BYTE_KIND:
10386 [ + - + + : 7 : COMPARE(Py_UCS4, Py_UCS2);
+ - ]
10387 : 0 : break;
10388 : 884 : case PyUnicode_4BYTE_KIND:
10389 : : {
10390 : : #if defined(HAVE_WMEMCMP) && SIZEOF_WCHAR_T == 4
10391 : 884 : int cmp = wmemcmp((wchar_t *)data1, (wchar_t *)data2, len);
10392 : : /* normalize result of wmemcmp() into the range [-1; 1] */
10393 [ + + ]: 884 : if (cmp < 0)
10394 : 2 : return -1;
10395 [ - + ]: 882 : if (cmp > 0)
10396 : 0 : return 1;
10397 : : #else
10398 : : COMPARE(Py_UCS4, Py_UCS4);
10399 : : #endif
10400 : 882 : break;
10401 : : }
10402 : 0 : default:
10403 : 0 : Py_UNREACHABLE();
10404 : : }
10405 : 882 : break;
10406 : : }
10407 : 0 : default:
10408 : 0 : Py_UNREACHABLE();
10409 : : }
10410 : :
10411 [ + + ]: 201227 : if (len1 == len2)
10412 : 182173 : return 0;
10413 [ + + ]: 19054 : if (len1 < len2)
10414 : 3023 : return -1;
10415 : : else
10416 : 16031 : return 1;
10417 : :
10418 : : #undef COMPARE
10419 : : }
10420 : :
10421 : : static int
10422 : 69356440 : unicode_compare_eq(PyObject *str1, PyObject *str2)
10423 : : {
10424 : : int kind;
10425 : : const void *data1, *data2;
10426 : : Py_ssize_t len;
10427 : : int cmp;
10428 : :
10429 : 69356440 : len = PyUnicode_GET_LENGTH(str1);
10430 [ + + ]: 69356440 : if (PyUnicode_GET_LENGTH(str2) != len)
10431 : 21434370 : return 0;
10432 : 47922070 : kind = PyUnicode_KIND(str1);
10433 [ + + ]: 47922070 : if (PyUnicode_KIND(str2) != kind)
10434 : 17712 : return 0;
10435 : 47904358 : data1 = PyUnicode_DATA(str1);
10436 : 47904358 : data2 = PyUnicode_DATA(str2);
10437 : :
10438 : 47904358 : cmp = memcmp(data1, data2, len * kind);
10439 : 47904358 : return (cmp == 0);
10440 : : }
10441 : :
10442 : : int
10443 : 63867734 : _PyUnicode_Equal(PyObject *str1, PyObject *str2)
10444 : : {
10445 : : assert(PyUnicode_CheckExact(str1));
10446 : : assert(PyUnicode_CheckExact(str2));
10447 [ + + ]: 63867734 : if (str1 == str2) {
10448 : 20924984 : return 1;
10449 : : }
10450 : 42942750 : return unicode_compare_eq(str1, str2);
10451 : : }
10452 : :
10453 : :
10454 : : int
10455 : 6111464 : PyUnicode_Compare(PyObject *left, PyObject *right)
10456 : : {
10457 [ + - + - ]: 6111464 : if (PyUnicode_Check(left) && PyUnicode_Check(right)) {
10458 : : /* a string is equal to itself */
10459 [ + + ]: 6111464 : if (left == right)
10460 : 5548593 : return 0;
10461 : :
10462 : 562871 : return unicode_compare(left, right);
10463 : : }
10464 : 0 : PyErr_Format(PyExc_TypeError,
10465 : : "Can't compare %.100s and %.100s",
10466 : 0 : Py_TYPE(left)->tp_name,
10467 : 0 : Py_TYPE(right)->tp_name);
10468 : 0 : return -1;
10469 : : }
10470 : :
10471 : : int
10472 : 14587106 : PyUnicode_CompareWithASCIIString(PyObject* uni, const char* str)
10473 : : {
10474 : : Py_ssize_t i;
10475 : : int kind;
10476 : : Py_UCS4 chr;
10477 : :
10478 : : assert(_PyUnicode_CHECK(uni));
10479 : 14587106 : kind = PyUnicode_KIND(uni);
10480 [ + + ]: 14587106 : if (kind == PyUnicode_1BYTE_KIND) {
10481 : 14587104 : const void *data = PyUnicode_1BYTE_DATA(uni);
10482 : 14587104 : size_t len1 = (size_t)PyUnicode_GET_LENGTH(uni);
10483 : 14587104 : size_t len, len2 = strlen(str);
10484 : : int cmp;
10485 : :
10486 : 14587104 : len = Py_MIN(len1, len2);
10487 : 14587104 : cmp = memcmp(data, str, len);
10488 [ + + ]: 14587104 : if (cmp != 0) {
10489 [ + + ]: 8414225 : if (cmp < 0)
10490 : 2161970 : return -1;
10491 : : else
10492 : 6252255 : return 1;
10493 : : }
10494 [ + + ]: 6172879 : if (len1 > len2)
10495 : 5 : return 1; /* uni is longer */
10496 [ + + ]: 6172874 : if (len1 < len2)
10497 : 24 : return -1; /* str is longer */
10498 : 6172850 : return 0;
10499 : : }
10500 : : else {
10501 : 2 : const void *data = PyUnicode_DATA(uni);
10502 : : /* Compare Unicode string and source character set string */
10503 [ + - + - ]: 2 : for (i = 0; (chr = PyUnicode_READ(kind, data, i)) && str[i]; i++)
10504 [ + - ]: 2 : if (chr != (unsigned char)str[i])
10505 [ + - ]: 2 : return (chr < (unsigned char)(str[i])) ? -1 : 1;
10506 : : /* This check keeps Python strings that end in '\0' from comparing equal
10507 : : to C strings identical up to that point. */
10508 [ # # # # ]: 0 : if (PyUnicode_GET_LENGTH(uni) != i || chr)
10509 : 0 : return 1; /* uni is longer */
10510 [ # # ]: 0 : if (str[i])
10511 : 0 : return -1; /* str is longer */
10512 : 0 : return 0;
10513 : : }
10514 : : }
10515 : :
10516 : : int
10517 : 17966675 : _PyUnicode_EqualToASCIIString(PyObject *unicode, const char *str)
10518 : : {
10519 : : size_t len;
10520 : : assert(_PyUnicode_CHECK(unicode));
10521 : : assert(str);
10522 : : #ifndef NDEBUG
10523 : : for (const char *p = str; *p; p++) {
10524 : : assert((unsigned char)*p < 128);
10525 : : }
10526 : : #endif
10527 [ + + ]: 17966675 : if (!PyUnicode_IS_ASCII(unicode))
10528 : 1486 : return 0;
10529 : 17965189 : len = (size_t)PyUnicode_GET_LENGTH(unicode);
10530 [ + + ]: 19509802 : return strlen(str) == len &&
10531 [ + + ]: 1544613 : memcmp(PyUnicode_1BYTE_DATA(unicode), str, len) == 0;
10532 : : }
10533 : :
10534 : : int
10535 : 0 : _PyUnicode_EqualToASCIIId(PyObject *left, _Py_Identifier *right)
10536 : : {
10537 : : PyObject *right_uni;
10538 : :
10539 : : assert(_PyUnicode_CHECK(left));
10540 : : assert(right->string);
10541 : : #ifndef NDEBUG
10542 : : for (const char *p = right->string; *p; p++) {
10543 : : assert((unsigned char)*p < 128);
10544 : : }
10545 : : #endif
10546 : :
10547 [ # # ]: 0 : if (!PyUnicode_IS_ASCII(left))
10548 : 0 : return 0;
10549 : :
10550 : 0 : right_uni = _PyUnicode_FromId(right); /* borrowed */
10551 [ # # ]: 0 : if (right_uni == NULL) {
10552 : : /* memory error or bad data */
10553 : 0 : PyErr_Clear();
10554 : 0 : return _PyUnicode_EqualToASCIIString(left, right->string);
10555 : : }
10556 : :
10557 [ # # ]: 0 : if (left == right_uni)
10558 : 0 : return 1;
10559 : :
10560 [ # # ]: 0 : if (PyUnicode_CHECK_INTERNED(left))
10561 : 0 : return 0;
10562 : :
10563 : : assert(_PyUnicode_HASH(right_uni) != -1);
10564 : 0 : Py_hash_t hash = _PyUnicode_HASH(left);
10565 [ # # # # ]: 0 : if (hash != -1 && hash != _PyUnicode_HASH(right_uni)) {
10566 : 0 : return 0;
10567 : : }
10568 : :
10569 : 0 : return unicode_compare_eq(left, right_uni);
10570 : : }
10571 : :
10572 : : PyObject *
10573 : 36542452 : PyUnicode_RichCompare(PyObject *left, PyObject *right, int op)
10574 : : {
10575 : : int result;
10576 : :
10577 [ + - + + ]: 36542452 : if (!PyUnicode_Check(left) || !PyUnicode_Check(right))
10578 : 2323815 : Py_RETURN_NOTIMPLEMENTED;
10579 : :
10580 [ + + ]: 34218637 : if (left == right) {
10581 [ + + - ]: 5955516 : switch (op) {
10582 : 5762885 : case Py_EQ:
10583 : : case Py_LE:
10584 : : case Py_GE:
10585 : : /* a string is equal to itself */
10586 : 5762885 : Py_RETURN_TRUE;
10587 : 192631 : case Py_NE:
10588 : : case Py_LT:
10589 : : case Py_GT:
10590 : 192631 : Py_RETURN_FALSE;
10591 : 0 : default:
10592 : 0 : PyErr_BadArgument();
10593 : 0 : return NULL;
10594 : : }
10595 : : }
10596 [ + + + + ]: 28263121 : else if (op == Py_EQ || op == Py_NE) {
10597 : 26413690 : result = unicode_compare_eq(left, right);
10598 : 26413690 : result ^= (op == Py_NE);
10599 : 26413690 : return PyBool_FromLong(result);
10600 : : }
10601 : : else {
10602 : 1849431 : result = unicode_compare(left, right);
10603 [ - - + + : 1849431 : Py_RETURN_RICHCOMPARE(result, 0, op);
+ + - - -
- - + + +
+ + + +
+ ]
10604 : : }
10605 : : }
10606 : :
10607 : : int
10608 : 1192617 : _PyUnicode_EQ(PyObject *aa, PyObject *bb)
10609 : : {
10610 : 1192617 : return unicode_eq(aa, bb);
10611 : : }
10612 : :
10613 : : int
10614 : 29584915 : PyUnicode_Contains(PyObject *str, PyObject *substr)
10615 : : {
10616 : : int kind1, kind2;
10617 : : const void *buf1, *buf2;
10618 : : Py_ssize_t len1, len2;
10619 : : int result;
10620 : :
10621 [ + + ]: 29584915 : if (!PyUnicode_Check(substr)) {
10622 : 2 : PyErr_Format(PyExc_TypeError,
10623 : : "'in <string>' requires string as left operand, not %.100s",
10624 : 2 : Py_TYPE(substr)->tp_name);
10625 : 2 : return -1;
10626 : : }
10627 [ - + ]: 29584913 : if (ensure_unicode(str) < 0)
10628 : 0 : return -1;
10629 : :
10630 : 29584913 : kind1 = PyUnicode_KIND(str);
10631 : 29584913 : kind2 = PyUnicode_KIND(substr);
10632 [ + + ]: 29584913 : if (kind1 < kind2)
10633 : 2077 : return 0;
10634 : 29582836 : len1 = PyUnicode_GET_LENGTH(str);
10635 : 29582836 : len2 = PyUnicode_GET_LENGTH(substr);
10636 [ + + ]: 29582836 : if (len1 < len2)
10637 : 195822 : return 0;
10638 : 29387014 : buf1 = PyUnicode_DATA(str);
10639 : 29387014 : buf2 = PyUnicode_DATA(substr);
10640 [ + + ]: 29387014 : if (len2 == 1) {
10641 : 27868302 : Py_UCS4 ch = PyUnicode_READ(kind2, buf2, 0);
10642 : 27868302 : result = findchar((const char *)buf1, kind1, len1, ch, 1) != -1;
10643 : 27868302 : return result;
10644 : : }
10645 [ + + ]: 1518712 : if (kind2 != kind1) {
10646 : 85 : buf2 = unicode_askind(kind2, buf2, len2, kind1);
10647 [ - + ]: 85 : if (!buf2)
10648 : 0 : return -1;
10649 : : }
10650 : :
10651 [ + + + - ]: 1518712 : switch (kind1) {
10652 : 1518612 : case PyUnicode_1BYTE_KIND:
10653 : 1518612 : result = ucs1lib_find(buf1, len1, buf2, len2, 0) != -1;
10654 : 1518612 : break;
10655 : 77 : case PyUnicode_2BYTE_KIND:
10656 : 77 : result = ucs2lib_find(buf1, len1, buf2, len2, 0) != -1;
10657 : 77 : break;
10658 : 23 : case PyUnicode_4BYTE_KIND:
10659 : 23 : result = ucs4lib_find(buf1, len1, buf2, len2, 0) != -1;
10660 : 23 : break;
10661 : 0 : default:
10662 : 0 : Py_UNREACHABLE();
10663 : : }
10664 : :
10665 : : assert((kind2 == kind1) == (buf2 == PyUnicode_DATA(substr)));
10666 [ + + ]: 1518712 : if (kind2 != kind1)
10667 : 85 : PyMem_Free((void *)buf2);
10668 : :
10669 : 1518712 : return result;
10670 : : }
10671 : :
10672 : : /* Concat to string or Unicode object giving a new Unicode object. */
10673 : :
10674 : : PyObject *
10675 : 28756927 : PyUnicode_Concat(PyObject *left, PyObject *right)
10676 : : {
10677 : : PyObject *result;
10678 : : Py_UCS4 maxchar, maxchar2;
10679 : : Py_ssize_t left_len, right_len, new_len;
10680 : :
10681 [ - + ]: 28756927 : if (ensure_unicode(left) < 0)
10682 : 0 : return NULL;
10683 : :
10684 [ + + ]: 28756927 : if (!PyUnicode_Check(right)) {
10685 : 93 : PyErr_Format(PyExc_TypeError,
10686 : : "can only concatenate str (not \"%.200s\") to str",
10687 : 93 : Py_TYPE(right)->tp_name);
10688 : 93 : return NULL;
10689 : : }
10690 : :
10691 : : /* Shortcuts */
10692 : 28756834 : PyObject *empty = unicode_get_empty(); // Borrowed reference
10693 [ + + ]: 28756834 : if (left == empty) {
10694 : 713979 : return PyUnicode_FromObject(right);
10695 : : }
10696 [ + + ]: 28042855 : if (right == empty) {
10697 : 505562 : return PyUnicode_FromObject(left);
10698 : : }
10699 : :
10700 : 27537293 : left_len = PyUnicode_GET_LENGTH(left);
10701 : 27537293 : right_len = PyUnicode_GET_LENGTH(right);
10702 [ - + ]: 27537293 : if (left_len > PY_SSIZE_T_MAX - right_len) {
10703 : 0 : PyErr_SetString(PyExc_OverflowError,
10704 : : "strings are too large to concat");
10705 : 0 : return NULL;
10706 : : }
10707 : 27537293 : new_len = left_len + right_len;
10708 : :
10709 : 27537293 : maxchar = PyUnicode_MAX_CHAR_VALUE(left);
10710 : 27537293 : maxchar2 = PyUnicode_MAX_CHAR_VALUE(right);
10711 : 27537293 : maxchar = Py_MAX(maxchar, maxchar2);
10712 : :
10713 : : /* Concat the two Unicode strings */
10714 : 27537293 : result = PyUnicode_New(new_len, maxchar);
10715 [ - + ]: 27537293 : if (result == NULL)
10716 : 0 : return NULL;
10717 : 27537293 : _PyUnicode_FastCopyCharacters(result, 0, left, 0, left_len);
10718 : 27537293 : _PyUnicode_FastCopyCharacters(result, left_len, right, 0, right_len);
10719 : : assert(_PyUnicode_CheckConsistency(result, 1));
10720 : 27537293 : return result;
10721 : : }
10722 : :
10723 : : void
10724 : 3940822 : PyUnicode_Append(PyObject **p_left, PyObject *right)
10725 : : {
10726 : : PyObject *left, *res;
10727 : : Py_UCS4 maxchar, maxchar2;
10728 : : Py_ssize_t left_len, right_len, new_len;
10729 : :
10730 [ - + ]: 3940822 : if (p_left == NULL) {
10731 [ # # ]: 0 : if (!PyErr_Occurred())
10732 : 0 : PyErr_BadInternalCall();
10733 : 0 : return;
10734 : : }
10735 : 3940822 : left = *p_left;
10736 [ + - + - ]: 3940822 : if (right == NULL || left == NULL
10737 [ + - - + ]: 3940822 : || !PyUnicode_Check(left) || !PyUnicode_Check(right)) {
10738 [ # # ]: 0 : if (!PyErr_Occurred())
10739 : 0 : PyErr_BadInternalCall();
10740 : 0 : goto error;
10741 : : }
10742 : :
10743 : : /* Shortcuts */
10744 : 3940822 : PyObject *empty = unicode_get_empty(); // Borrowed reference
10745 [ + + ]: 3940822 : if (left == empty) {
10746 : 307047 : Py_DECREF(left);
10747 : 307047 : Py_INCREF(right);
10748 : 307047 : *p_left = right;
10749 : 307047 : return;
10750 : : }
10751 [ + + ]: 3633775 : if (right == empty) {
10752 : 28953 : return;
10753 : : }
10754 : :
10755 : 3604822 : left_len = PyUnicode_GET_LENGTH(left);
10756 : 3604822 : right_len = PyUnicode_GET_LENGTH(right);
10757 [ - + ]: 3604822 : if (left_len > PY_SSIZE_T_MAX - right_len) {
10758 : 0 : PyErr_SetString(PyExc_OverflowError,
10759 : : "strings are too large to concat");
10760 : 0 : goto error;
10761 : : }
10762 : 3604822 : new_len = left_len + right_len;
10763 : :
10764 [ + + ]: 3604822 : if (unicode_modifiable(left)
10765 [ + - ]: 1405371 : && PyUnicode_CheckExact(right)
10766 [ + + ]: 1405371 : && PyUnicode_KIND(right) <= PyUnicode_KIND(left)
10767 : : /* Don't resize for ascii += latin1. Convert ascii to latin1 requires
10768 : : to change the structure size, but characters are stored just after
10769 : : the structure, and so it requires to move all characters which is
10770 : : not so different than duplicating the string. */
10771 [ + + + + ]: 1404971 : && !(PyUnicode_IS_ASCII(left) && !PyUnicode_IS_ASCII(right)))
10772 : : {
10773 : : /* append inplace */
10774 [ - + ]: 1404430 : if (unicode_resize(p_left, new_len) != 0)
10775 : 0 : goto error;
10776 : :
10777 : : /* copy 'right' into the newly allocated area of 'left' */
10778 : 1404430 : _PyUnicode_FastCopyCharacters(*p_left, left_len, right, 0, right_len);
10779 : : }
10780 : : else {
10781 : 2200392 : maxchar = PyUnicode_MAX_CHAR_VALUE(left);
10782 : 2200392 : maxchar2 = PyUnicode_MAX_CHAR_VALUE(right);
10783 : 2200392 : maxchar = Py_MAX(maxchar, maxchar2);
10784 : :
10785 : : /* Concat the two Unicode strings */
10786 : 2200392 : res = PyUnicode_New(new_len, maxchar);
10787 [ - + ]: 2200392 : if (res == NULL)
10788 : 0 : goto error;
10789 : 2200392 : _PyUnicode_FastCopyCharacters(res, 0, left, 0, left_len);
10790 : 2200392 : _PyUnicode_FastCopyCharacters(res, left_len, right, 0, right_len);
10791 : 2200392 : Py_DECREF(left);
10792 : 2200392 : *p_left = res;
10793 : : }
10794 : : assert(_PyUnicode_CheckConsistency(*p_left, 1));
10795 : 3604822 : return;
10796 : :
10797 : 0 : error:
10798 [ # # ]: 0 : Py_CLEAR(*p_left);
10799 : : }
10800 : :
10801 : : void
10802 : 85004 : PyUnicode_AppendAndDel(PyObject **pleft, PyObject *right)
10803 : : {
10804 : 85004 : PyUnicode_Append(pleft, right);
10805 : 85004 : Py_XDECREF(right);
10806 : 85004 : }
10807 : :
10808 : : /*
10809 : : Wraps asciilib_parse_args_finds() and additionally ensures that the
10810 : : first argument is a unicode object.
10811 : : */
10812 : :
10813 : : static inline int
10814 : 2829838 : parse_args_finds_unicode(const char * function_name, PyObject *args,
10815 : : PyObject **substring,
10816 : : Py_ssize_t *start, Py_ssize_t *end)
10817 : : {
10818 [ + + ]: 2829838 : if (asciilib_parse_args_finds(function_name, args, substring, start, end)) {
10819 [ + + ]: 2829822 : if (ensure_unicode(*substring) < 0)
10820 : 11 : return 0;
10821 : 2829811 : return 1;
10822 : : }
10823 : 16 : return 0;
10824 : : }
10825 : :
10826 : : PyDoc_STRVAR(count__doc__,
10827 : : "S.count(sub[, start[, end]]) -> int\n\
10828 : : \n\
10829 : : Return the number of non-overlapping occurrences of substring sub in\n\
10830 : : string S[start:end]. Optional arguments start and end are\n\
10831 : : interpreted as in slice notation.");
10832 : :
10833 : : static PyObject *
10834 : 536426 : unicode_count(PyObject *self, PyObject *args)
10835 : : {
10836 : 536426 : PyObject *substring = NULL; /* initialize to fix a compiler warning */
10837 : 536426 : Py_ssize_t start = 0;
10838 : 536426 : Py_ssize_t end = PY_SSIZE_T_MAX;
10839 : : PyObject *result;
10840 : : int kind1, kind2;
10841 : : const void *buf1, *buf2;
10842 : : Py_ssize_t len1, len2, iresult;
10843 : :
10844 [ + + ]: 536426 : if (!parse_args_finds_unicode("count", args, &substring, &start, &end))
10845 : 5 : return NULL;
10846 : :
10847 : 536421 : kind1 = PyUnicode_KIND(self);
10848 : 536421 : kind2 = PyUnicode_KIND(substring);
10849 [ + + ]: 536421 : if (kind1 < kind2)
10850 : 6 : return PyLong_FromLong(0);
10851 : :
10852 : 536415 : len1 = PyUnicode_GET_LENGTH(self);
10853 : 536415 : len2 = PyUnicode_GET_LENGTH(substring);
10854 [ + + + + : 536415 : ADJUST_INDICES(start, end, len1);
+ + + + +
+ ]
10855 [ + + ]: 536415 : if (end - start < len2)
10856 : 104553 : return PyLong_FromLong(0);
10857 : :
10858 : 431862 : buf1 = PyUnicode_DATA(self);
10859 : 431862 : buf2 = PyUnicode_DATA(substring);
10860 [ + + ]: 431862 : if (kind2 != kind1) {
10861 : 11889 : buf2 = unicode_askind(kind2, buf2, len2, kind1);
10862 [ - + ]: 11889 : if (!buf2)
10863 : 0 : return NULL;
10864 : : }
10865 [ + + + - ]: 431862 : switch (kind1) {
10866 : 419969 : case PyUnicode_1BYTE_KIND:
10867 : 419969 : iresult = ucs1lib_count(
10868 : : ((const Py_UCS1*)buf1) + start, end - start,
10869 : : buf2, len2, PY_SSIZE_T_MAX
10870 : : );
10871 : 419969 : break;
10872 : 11883 : case PyUnicode_2BYTE_KIND:
10873 : 11883 : iresult = ucs2lib_count(
10874 : 11883 : ((const Py_UCS2*)buf1) + start, end - start,
10875 : : buf2, len2, PY_SSIZE_T_MAX
10876 : : );
10877 : 11883 : break;
10878 : 10 : case PyUnicode_4BYTE_KIND:
10879 : 10 : iresult = ucs4lib_count(
10880 : 10 : ((const Py_UCS4*)buf1) + start, end - start,
10881 : : buf2, len2, PY_SSIZE_T_MAX
10882 : : );
10883 : 10 : break;
10884 : 0 : default:
10885 : 0 : Py_UNREACHABLE();
10886 : : }
10887 : :
10888 : 431862 : result = PyLong_FromSsize_t(iresult);
10889 : :
10890 : : assert((kind2 == kind1) == (buf2 == PyUnicode_DATA(substring)));
10891 [ + + ]: 431862 : if (kind2 != kind1)
10892 : 11889 : PyMem_Free((void *)buf2);
10893 : :
10894 : 431862 : return result;
10895 : : }
10896 : :
10897 : : /*[clinic input]
10898 : : str.encode as unicode_encode
10899 : :
10900 : : encoding: str(c_default="NULL") = 'utf-8'
10901 : : The encoding in which to encode the string.
10902 : : errors: str(c_default="NULL") = 'strict'
10903 : : The error handling scheme to use for encoding errors.
10904 : : The default is 'strict' meaning that encoding errors raise a
10905 : : UnicodeEncodeError. Other possible values are 'ignore', 'replace' and
10906 : : 'xmlcharrefreplace' as well as any other name registered with
10907 : : codecs.register_error that can handle UnicodeEncodeErrors.
10908 : :
10909 : : Encode the string using the codec registered for encoding.
10910 : : [clinic start generated code]*/
10911 : :
10912 : : static PyObject *
10913 : 5176736 : unicode_encode_impl(PyObject *self, const char *encoding, const char *errors)
10914 : : /*[clinic end generated code: output=bf78b6e2a9470e3c input=f0a9eb293d08fe02]*/
10915 : : {
10916 : 5176736 : return PyUnicode_AsEncodedString(self, encoding, errors);
10917 : : }
10918 : :
10919 : : /*[clinic input]
10920 : : str.expandtabs as unicode_expandtabs
10921 : :
10922 : : tabsize: int = 8
10923 : :
10924 : : Return a copy where all tab characters are expanded using spaces.
10925 : :
10926 : : If tabsize is not given, a tab size of 8 characters is assumed.
10927 : : [clinic start generated code]*/
10928 : :
10929 : : static PyObject *
10930 : 52043 : unicode_expandtabs_impl(PyObject *self, int tabsize)
10931 : : /*[clinic end generated code: output=3457c5dcee26928f input=8a01914034af4c85]*/
10932 : : {
10933 : : Py_ssize_t i, j, line_pos, src_len, incr;
10934 : : Py_UCS4 ch;
10935 : : PyObject *u;
10936 : : const void *src_data;
10937 : : void *dest_data;
10938 : : int kind;
10939 : : int found;
10940 : :
10941 : : /* First pass: determine size of output string */
10942 : 52043 : src_len = PyUnicode_GET_LENGTH(self);
10943 : 52043 : i = j = line_pos = 0;
10944 : 52043 : kind = PyUnicode_KIND(self);
10945 : 52043 : src_data = PyUnicode_DATA(self);
10946 : 52043 : found = 0;
10947 [ + + ]: 3137043 : for (; i < src_len; i++) {
10948 : 3085000 : ch = PyUnicode_READ(kind, src_data, i);
10949 [ + + ]: 3085000 : if (ch == '\t') {
10950 : 797 : found = 1;
10951 [ + - ]: 797 : if (tabsize > 0) {
10952 : 797 : incr = tabsize - (line_pos % tabsize); /* cannot overflow */
10953 [ - + ]: 797 : if (j > PY_SSIZE_T_MAX - incr)
10954 : 0 : goto overflow;
10955 : 797 : line_pos += incr;
10956 : 797 : j += incr;
10957 : : }
10958 : : }
10959 : : else {
10960 [ - + ]: 3084203 : if (j > PY_SSIZE_T_MAX - 1)
10961 : 0 : goto overflow;
10962 : 3084203 : line_pos++;
10963 : 3084203 : j++;
10964 [ + + + + ]: 3084203 : if (ch == '\n' || ch == '\r')
10965 : 84590 : line_pos = 0;
10966 : : }
10967 : : }
10968 [ + + ]: 52043 : if (!found)
10969 : 51971 : return unicode_result_unchanged(self);
10970 : :
10971 : : /* Second pass: create output string and fill it */
10972 : 72 : u = PyUnicode_New(j, PyUnicode_MAX_CHAR_VALUE(self));
10973 [ - + ]: 72 : if (!u)
10974 : 0 : return NULL;
10975 : 72 : dest_data = PyUnicode_DATA(u);
10976 : :
10977 : 72 : i = j = line_pos = 0;
10978 : :
10979 [ + + ]: 7049 : for (; i < src_len; i++) {
10980 : 6977 : ch = PyUnicode_READ(kind, src_data, i);
10981 [ + + ]: 6977 : if (ch == '\t') {
10982 [ + - ]: 797 : if (tabsize > 0) {
10983 : 797 : incr = tabsize - (line_pos % tabsize);
10984 : 797 : line_pos += incr;
10985 : 797 : unicode_fill(kind, dest_data, ' ', j, incr);
10986 : 797 : j += incr;
10987 : : }
10988 : : }
10989 : : else {
10990 : 6180 : line_pos++;
10991 : 6180 : PyUnicode_WRITE(kind, dest_data, j, ch);
10992 : 6180 : j++;
10993 [ + + + + ]: 6180 : if (ch == '\n' || ch == '\r')
10994 : 118 : line_pos = 0;
10995 : : }
10996 : : }
10997 : : assert (j == PyUnicode_GET_LENGTH(u));
10998 : 72 : return unicode_result(u);
10999 : :
11000 : 0 : overflow:
11001 : 0 : PyErr_SetString(PyExc_OverflowError, "new string is too long");
11002 : 0 : return NULL;
11003 : : }
11004 : :
11005 : : PyDoc_STRVAR(find__doc__,
11006 : : "S.find(sub[, start[, end]]) -> int\n\
11007 : : \n\
11008 : : Return the lowest index in S where substring sub is found,\n\
11009 : : such that sub is contained within S[start:end]. Optional\n\
11010 : : arguments start and end are interpreted as in slice notation.\n\
11011 : : \n\
11012 : : Return -1 on failure.");
11013 : :
11014 : : static PyObject *
11015 : 870411 : unicode_find(PyObject *self, PyObject *args)
11016 : : {
11017 : : /* initialize variables to prevent gcc warning */
11018 : 870411 : PyObject *substring = NULL;
11019 : 870411 : Py_ssize_t start = 0;
11020 : 870411 : Py_ssize_t end = 0;
11021 : : Py_ssize_t result;
11022 : :
11023 [ + + ]: 870411 : if (!parse_args_finds_unicode("find", args, &substring, &start, &end))
11024 : 7 : return NULL;
11025 : :
11026 : 870404 : result = any_find_slice(self, substring, start, end, 1);
11027 : :
11028 [ - + ]: 870404 : if (result == -2)
11029 : 0 : return NULL;
11030 : :
11031 : 870404 : return PyLong_FromSsize_t(result);
11032 : : }
11033 : :
11034 : : static PyObject *
11035 : 55444778 : unicode_getitem(PyObject *self, Py_ssize_t index)
11036 : : {
11037 : : const void *data;
11038 : : int kind;
11039 : : Py_UCS4 ch;
11040 : :
11041 [ - + ]: 55444778 : if (!PyUnicode_Check(self)) {
11042 : 0 : PyErr_BadArgument();
11043 : 0 : return NULL;
11044 : : }
11045 [ + + + + ]: 55444778 : if (index < 0 || index >= PyUnicode_GET_LENGTH(self)) {
11046 : 56617 : PyErr_SetString(PyExc_IndexError, "string index out of range");
11047 : 56617 : return NULL;
11048 : : }
11049 : 55388161 : kind = PyUnicode_KIND(self);
11050 : 55388161 : data = PyUnicode_DATA(self);
11051 : 55388161 : ch = PyUnicode_READ(kind, data, index);
11052 : 55388161 : return unicode_char(ch);
11053 : : }
11054 : :
11055 : : /* Believe it or not, this produces the same value for ASCII strings
11056 : : as bytes_hash(). */
11057 : : static Py_hash_t
11058 : 182512643 : unicode_hash(PyObject *self)
11059 : : {
11060 : : Py_uhash_t x; /* Unsigned for defined overflow behavior. */
11061 : :
11062 : : #ifdef Py_DEBUG
11063 : : assert(_Py_HashSecret_Initialized);
11064 : : #endif
11065 [ + + ]: 182512643 : if (_PyUnicode_HASH(self) != -1)
11066 : 71760930 : return _PyUnicode_HASH(self);
11067 : :
11068 : 110751713 : x = _Py_HashBytes(PyUnicode_DATA(self),
11069 : 110751713 : PyUnicode_GET_LENGTH(self) * PyUnicode_KIND(self));
11070 : 110751713 : _PyUnicode_HASH(self) = x;
11071 : 110751713 : return x;
11072 : : }
11073 : :
11074 : : PyDoc_STRVAR(index__doc__,
11075 : : "S.index(sub[, start[, end]]) -> int\n\
11076 : : \n\
11077 : : Return the lowest index in S where substring sub is found,\n\
11078 : : such that sub is contained within S[start:end]. Optional\n\
11079 : : arguments start and end are interpreted as in slice notation.\n\
11080 : : \n\
11081 : : Raises ValueError when the substring is not found.");
11082 : :
11083 : : static PyObject *
11084 : 23685 : unicode_index(PyObject *self, PyObject *args)
11085 : : {
11086 : : /* initialize variables to prevent gcc warning */
11087 : : Py_ssize_t result;
11088 : 23685 : PyObject *substring = NULL;
11089 : 23685 : Py_ssize_t start = 0;
11090 : 23685 : Py_ssize_t end = 0;
11091 : :
11092 [ + + ]: 23685 : if (!parse_args_finds_unicode("index", args, &substring, &start, &end))
11093 : 5 : return NULL;
11094 : :
11095 : 23680 : result = any_find_slice(self, substring, start, end, 1);
11096 : :
11097 [ - + ]: 23680 : if (result == -2)
11098 : 0 : return NULL;
11099 : :
11100 [ + + ]: 23680 : if (result < 0) {
11101 : 1429 : PyErr_SetString(PyExc_ValueError, "substring not found");
11102 : 1429 : return NULL;
11103 : : }
11104 : :
11105 : 22251 : return PyLong_FromSsize_t(result);
11106 : : }
11107 : :
11108 : : /*[clinic input]
11109 : : str.isascii as unicode_isascii
11110 : :
11111 : : Return True if all characters in the string are ASCII, False otherwise.
11112 : :
11113 : : ASCII characters have code points in the range U+0000-U+007F.
11114 : : Empty string is ASCII too.
11115 : : [clinic start generated code]*/
11116 : :
11117 : : static PyObject *
11118 : 102012 : unicode_isascii_impl(PyObject *self)
11119 : : /*[clinic end generated code: output=c5910d64b5a8003f input=5a43cbc6399621d5]*/
11120 : : {
11121 : 102012 : return PyBool_FromLong(PyUnicode_IS_ASCII(self));
11122 : : }
11123 : :
11124 : : /*[clinic input]
11125 : : str.islower as unicode_islower
11126 : :
11127 : : Return True if the string is a lowercase string, False otherwise.
11128 : :
11129 : : A string is lowercase if all cased characters in the string are lowercase and
11130 : : there is at least one cased character in the string.
11131 : : [clinic start generated code]*/
11132 : :
11133 : : static PyObject *
11134 : 2233428 : unicode_islower_impl(PyObject *self)
11135 : : /*[clinic end generated code: output=dbd41995bd005b81 input=acec65ac6821ae47]*/
11136 : : {
11137 : : Py_ssize_t i, length;
11138 : : int kind;
11139 : : const void *data;
11140 : : int cased;
11141 : :
11142 : 2233428 : length = PyUnicode_GET_LENGTH(self);
11143 : 2233428 : kind = PyUnicode_KIND(self);
11144 : 2233428 : data = PyUnicode_DATA(self);
11145 : :
11146 : : /* Shortcut for single character strings */
11147 [ + + ]: 2233428 : if (length == 1)
11148 : 1115019 : return PyBool_FromLong(
11149 : 1115019 : Py_UNICODE_ISLOWER(PyUnicode_READ(kind, data, 0)));
11150 : :
11151 : : /* Special case for empty strings */
11152 [ + + ]: 1118409 : if (length == 0)
11153 : 2 : Py_RETURN_FALSE;
11154 : :
11155 : 1118407 : cased = 0;
11156 [ + + ]: 5604061 : for (i = 0; i < length; i++) {
11157 : 4488232 : const Py_UCS4 ch = PyUnicode_READ(kind, data, i);
11158 : :
11159 [ + + + + ]: 4488232 : if (Py_UNICODE_ISUPPER(ch) || Py_UNICODE_ISTITLE(ch))
11160 : 2578 : Py_RETURN_FALSE;
11161 [ + + + + ]: 4485654 : else if (!cased && Py_UNICODE_ISLOWER(ch))
11162 : 1115896 : cased = 1;
11163 : : }
11164 : 1115829 : return PyBool_FromLong(cased);
11165 : : }
11166 : :
11167 : : /*[clinic input]
11168 : : str.isupper as unicode_isupper
11169 : :
11170 : : Return True if the string is an uppercase string, False otherwise.
11171 : :
11172 : : A string is uppercase if all cased characters in the string are uppercase and
11173 : : there is at least one cased character in the string.
11174 : : [clinic start generated code]*/
11175 : :
11176 : : static PyObject *
11177 : 3627593 : unicode_isupper_impl(PyObject *self)
11178 : : /*[clinic end generated code: output=049209c8e7f15f59 input=e9b1feda5d17f2d3]*/
11179 : : {
11180 : : Py_ssize_t i, length;
11181 : : int kind;
11182 : : const void *data;
11183 : : int cased;
11184 : :
11185 : 3627593 : length = PyUnicode_GET_LENGTH(self);
11186 : 3627593 : kind = PyUnicode_KIND(self);
11187 : 3627593 : data = PyUnicode_DATA(self);
11188 : :
11189 : : /* Shortcut for single character strings */
11190 [ + + ]: 3627593 : if (length == 1)
11191 : 1116188 : return PyBool_FromLong(
11192 : 1116188 : Py_UNICODE_ISUPPER(PyUnicode_READ(kind, data, 0)) != 0);
11193 : :
11194 : : /* Special case for empty strings */
11195 [ + + ]: 2511405 : if (length == 0)
11196 : 2 : Py_RETURN_FALSE;
11197 : :
11198 : 2511403 : cased = 0;
11199 [ + + ]: 22151023 : for (i = 0; i < length; i++) {
11200 : 19863233 : const Py_UCS4 ch = PyUnicode_READ(kind, data, i);
11201 : :
11202 [ + + + + ]: 19863233 : if (Py_UNICODE_ISLOWER(ch) || Py_UNICODE_ISTITLE(ch))
11203 : 223613 : Py_RETURN_FALSE;
11204 [ + + + + ]: 19639620 : else if (!cased && Py_UNICODE_ISUPPER(ch))
11205 : 2307788 : cased = 1;
11206 : : }
11207 : 2287790 : return PyBool_FromLong(cased);
11208 : : }
11209 : :
11210 : : /*[clinic input]
11211 : : str.istitle as unicode_istitle
11212 : :
11213 : : Return True if the string is a title-cased string, False otherwise.
11214 : :
11215 : : In a title-cased string, upper- and title-case characters may only
11216 : : follow uncased characters and lowercase characters only cased ones.
11217 : : [clinic start generated code]*/
11218 : :
11219 : : static PyObject *
11220 : 2228271 : unicode_istitle_impl(PyObject *self)
11221 : : /*[clinic end generated code: output=e9bf6eb91f5d3f0e input=98d32bd2e1f06f8c]*/
11222 : : {
11223 : : Py_ssize_t i, length;
11224 : : int kind;
11225 : : const void *data;
11226 : : int cased, previous_is_cased;
11227 : :
11228 : 2228271 : length = PyUnicode_GET_LENGTH(self);
11229 : 2228271 : kind = PyUnicode_KIND(self);
11230 : 2228271 : data = PyUnicode_DATA(self);
11231 : :
11232 : : /* Shortcut for single character strings */
11233 [ + + ]: 2228271 : if (length == 1) {
11234 : 1114127 : Py_UCS4 ch = PyUnicode_READ(kind, data, 0);
11235 [ + + + + ]: 2228222 : return PyBool_FromLong((Py_UNICODE_ISTITLE(ch) != 0) ||
11236 : 1114095 : (Py_UNICODE_ISUPPER(ch) != 0));
11237 : : }
11238 : :
11239 : : /* Special case for empty strings */
11240 [ + + ]: 1114144 : if (length == 0)
11241 : 2 : Py_RETURN_FALSE;
11242 : :
11243 : 1114142 : cased = 0;
11244 : 1114142 : previous_is_cased = 0;
11245 [ + + ]: 2247372 : for (i = 0; i < length; i++) {
11246 : 2245373 : const Py_UCS4 ch = PyUnicode_READ(kind, data, i);
11247 : :
11248 [ + + + + ]: 2245373 : if (Py_UNICODE_ISUPPER(ch) || Py_UNICODE_ISTITLE(ch)) {
11249 [ + + ]: 2030 : if (previous_is_cased)
11250 : 3 : Py_RETURN_FALSE;
11251 : 2027 : previous_is_cased = 1;
11252 : 2027 : cased = 1;
11253 : : }
11254 [ + + ]: 2243343 : else if (Py_UNICODE_ISLOWER(ch)) {
11255 [ + + ]: 1133627 : if (!previous_is_cased)
11256 : 1112140 : Py_RETURN_FALSE;
11257 : 21487 : previous_is_cased = 1;
11258 : 21487 : cased = 1;
11259 : : }
11260 : : else
11261 : 1109716 : previous_is_cased = 0;
11262 : : }
11263 : 1999 : return PyBool_FromLong(cased);
11264 : : }
11265 : :
11266 : : /*[clinic input]
11267 : : str.isspace as unicode_isspace
11268 : :
11269 : : Return True if the string is a whitespace string, False otherwise.
11270 : :
11271 : : A string is whitespace if all characters in the string are whitespace and there
11272 : : is at least one character in the string.
11273 : : [clinic start generated code]*/
11274 : :
11275 : : static PyObject *
11276 : 3418282 : unicode_isspace_impl(PyObject *self)
11277 : : /*[clinic end generated code: output=163a63bfa08ac2b9 input=fe462cb74f8437d8]*/
11278 : : {
11279 : : Py_ssize_t i, length;
11280 : : int kind;
11281 : : const void *data;
11282 : :
11283 : 3418282 : length = PyUnicode_GET_LENGTH(self);
11284 : 3418282 : kind = PyUnicode_KIND(self);
11285 : 3418282 : data = PyUnicode_DATA(self);
11286 : :
11287 : : /* Shortcut for single character strings */
11288 [ + + ]: 3418282 : if (length == 1)
11289 : 2294757 : return PyBool_FromLong(
11290 : 2294757 : Py_UNICODE_ISSPACE(PyUnicode_READ(kind, data, 0)));
11291 : :
11292 : : /* Special case for empty strings */
11293 [ + + ]: 1123525 : if (length == 0)
11294 : 8693 : Py_RETURN_FALSE;
11295 : :
11296 [ + + ]: 1127917 : for (i = 0; i < length; i++) {
11297 : 1127884 : const Py_UCS4 ch = PyUnicode_READ(kind, data, i);
11298 [ + + ]: 1127884 : if (!Py_UNICODE_ISSPACE(ch))
11299 : 1114799 : Py_RETURN_FALSE;
11300 : : }
11301 : 33 : Py_RETURN_TRUE;
11302 : : }
11303 : :
11304 : : /*[clinic input]
11305 : : str.isalpha as unicode_isalpha
11306 : :
11307 : : Return True if the string is an alphabetic string, False otherwise.
11308 : :
11309 : : A string is alphabetic if all characters in the string are alphabetic and there
11310 : : is at least one character in the string.
11311 : : [clinic start generated code]*/
11312 : :
11313 : : static PyObject *
11314 : 2272295 : unicode_isalpha_impl(PyObject *self)
11315 : : /*[clinic end generated code: output=cc81b9ac3883ec4f input=d0fd18a96cbca5eb]*/
11316 : : {
11317 : : Py_ssize_t i, length;
11318 : : int kind;
11319 : : const void *data;
11320 : :
11321 : 2272295 : length = PyUnicode_GET_LENGTH(self);
11322 : 2272295 : kind = PyUnicode_KIND(self);
11323 : 2272295 : data = PyUnicode_DATA(self);
11324 : :
11325 : : /* Shortcut for single character strings */
11326 [ + + ]: 2272295 : if (length == 1)
11327 : 1158165 : return PyBool_FromLong(
11328 : 1158165 : Py_UNICODE_ISALPHA(PyUnicode_READ(kind, data, 0)));
11329 : :
11330 : : /* Special case for empty strings */
11331 [ + + ]: 1114130 : if (length == 0)
11332 : 2 : Py_RETURN_FALSE;
11333 : :
11334 [ + + ]: 1651485 : for (i = 0; i < length; i++) {
11335 [ + + ]: 1519725 : if (!Py_UNICODE_ISALPHA(PyUnicode_READ(kind, data, i)))
11336 : 982368 : Py_RETURN_FALSE;
11337 : : }
11338 : 131760 : Py_RETURN_TRUE;
11339 : : }
11340 : :
11341 : : /*[clinic input]
11342 : : str.isalnum as unicode_isalnum
11343 : :
11344 : : Return True if the string is an alpha-numeric string, False otherwise.
11345 : :
11346 : : A string is alpha-numeric if all characters in the string are alpha-numeric and
11347 : : there is at least one character in the string.
11348 : : [clinic start generated code]*/
11349 : :
11350 : : static PyObject *
11351 : 2332685 : unicode_isalnum_impl(PyObject *self)
11352 : : /*[clinic end generated code: output=a5a23490ffc3660c input=5c6579bf2e04758c]*/
11353 : : {
11354 : : int kind;
11355 : : const void *data;
11356 : : Py_ssize_t len, i;
11357 : :
11358 : 2332685 : kind = PyUnicode_KIND(self);
11359 : 2332685 : data = PyUnicode_DATA(self);
11360 : 2332685 : len = PyUnicode_GET_LENGTH(self);
11361 : :
11362 : : /* Shortcut for single character strings */
11363 [ + + ]: 2332685 : if (len == 1) {
11364 : 1218465 : const Py_UCS4 ch = PyUnicode_READ(kind, data, 0);
11365 : 1218465 : return PyBool_FromLong(Py_UNICODE_ISALNUM(ch));
11366 : : }
11367 : :
11368 : : /* Special case for empty strings */
11369 [ + + ]: 1114220 : if (len == 0)
11370 : 4 : Py_RETURN_FALSE;
11371 : :
11372 [ + + ]: 1659278 : for (i = 0; i < len; i++) {
11373 : 1525641 : const Py_UCS4 ch = PyUnicode_READ(kind, data, i);
11374 [ + + ]: 1525641 : if (!Py_UNICODE_ISALNUM(ch))
11375 : 980579 : Py_RETURN_FALSE;
11376 : : }
11377 : 133637 : Py_RETURN_TRUE;
11378 : : }
11379 : :
11380 : : /*[clinic input]
11381 : : str.isdecimal as unicode_isdecimal
11382 : :
11383 : : Return True if the string is a decimal string, False otherwise.
11384 : :
11385 : : A string is a decimal string if all characters in the string are decimal and
11386 : : there is at least one character in the string.
11387 : : [clinic start generated code]*/
11388 : :
11389 : : static PyObject *
11390 : 2228410 : unicode_isdecimal_impl(PyObject *self)
11391 : : /*[clinic end generated code: output=fb2dcdb62d3fc548 input=336bc97ab4c8268f]*/
11392 : : {
11393 : : Py_ssize_t i, length;
11394 : : int kind;
11395 : : const void *data;
11396 : :
11397 : 2228410 : length = PyUnicode_GET_LENGTH(self);
11398 : 2228410 : kind = PyUnicode_KIND(self);
11399 : 2228410 : data = PyUnicode_DATA(self);
11400 : :
11401 : : /* Shortcut for single character strings */
11402 [ + + ]: 2228410 : if (length == 1)
11403 : 1114251 : return PyBool_FromLong(
11404 : 1114251 : Py_UNICODE_ISDECIMAL(PyUnicode_READ(kind, data, 0)));
11405 : :
11406 : : /* Special case for empty strings */
11407 [ + + ]: 1114159 : if (length == 0)
11408 : 1 : Py_RETURN_FALSE;
11409 : :
11410 [ + + ]: 1116864 : for (i = 0; i < length; i++) {
11411 [ + + ]: 1116194 : if (!Py_UNICODE_ISDECIMAL(PyUnicode_READ(kind, data, i)))
11412 : 1113488 : Py_RETURN_FALSE;
11413 : : }
11414 : 670 : Py_RETURN_TRUE;
11415 : : }
11416 : :
11417 : : /*[clinic input]
11418 : : str.isdigit as unicode_isdigit
11419 : :
11420 : : Return True if the string is a digit string, False otherwise.
11421 : :
11422 : : A string is a digit string if all characters in the string are digits and there
11423 : : is at least one character in the string.
11424 : : [clinic start generated code]*/
11425 : :
11426 : : static PyObject *
11427 : 2250464 : unicode_isdigit_impl(PyObject *self)
11428 : : /*[clinic end generated code: output=10a6985311da6858 input=901116c31deeea4c]*/
11429 : : {
11430 : : Py_ssize_t i, length;
11431 : : int kind;
11432 : : const void *data;
11433 : :
11434 : 2250464 : length = PyUnicode_GET_LENGTH(self);
11435 : 2250464 : kind = PyUnicode_KIND(self);
11436 : 2250464 : data = PyUnicode_DATA(self);
11437 : :
11438 : : /* Shortcut for single character strings */
11439 [ + + ]: 2250464 : if (length == 1) {
11440 : 1133868 : const Py_UCS4 ch = PyUnicode_READ(kind, data, 0);
11441 : 1133868 : return PyBool_FromLong(Py_UNICODE_ISDIGIT(ch));
11442 : : }
11443 : :
11444 : : /* Special case for empty strings */
11445 [ + + ]: 1116596 : if (length == 0)
11446 : 6 : Py_RETURN_FALSE;
11447 : :
11448 [ + + ]: 1134943 : for (i = 0; i < length; i++) {
11449 [ + + ]: 1132475 : if (!Py_UNICODE_ISDIGIT(PyUnicode_READ(kind, data, i)))
11450 : 1114122 : Py_RETURN_FALSE;
11451 : : }
11452 : 2468 : Py_RETURN_TRUE;
11453 : : }
11454 : :
11455 : : /*[clinic input]
11456 : : str.isnumeric as unicode_isnumeric
11457 : :
11458 : : Return True if the string is a numeric string, False otherwise.
11459 : :
11460 : : A string is numeric if all characters in the string are numeric and there is at
11461 : : least one character in the string.
11462 : : [clinic start generated code]*/
11463 : :
11464 : : static PyObject *
11465 : 2228253 : unicode_isnumeric_impl(PyObject *self)
11466 : : /*[clinic end generated code: output=9172a32d9013051a input=722507db976f826c]*/
11467 : : {
11468 : : Py_ssize_t i, length;
11469 : : int kind;
11470 : : const void *data;
11471 : :
11472 : 2228253 : length = PyUnicode_GET_LENGTH(self);
11473 : 2228253 : kind = PyUnicode_KIND(self);
11474 : 2228253 : data = PyUnicode_DATA(self);
11475 : :
11476 : : /* Shortcut for single character strings */
11477 [ + + ]: 2228253 : if (length == 1)
11478 : 1114130 : return PyBool_FromLong(
11479 : 1114130 : Py_UNICODE_ISNUMERIC(PyUnicode_READ(kind, data, 0)));
11480 : :
11481 : : /* Special case for empty strings */
11482 [ + + ]: 1114123 : if (length == 0)
11483 : 1 : Py_RETURN_FALSE;
11484 : :
11485 [ + + ]: 1121634 : for (i = 0; i < length; i++) {
11486 [ + + ]: 1119760 : if (!Py_UNICODE_ISNUMERIC(PyUnicode_READ(kind, data, i)))
11487 : 1112248 : Py_RETURN_FALSE;
11488 : : }
11489 : 1874 : Py_RETURN_TRUE;
11490 : : }
11491 : :
11492 : : Py_ssize_t
11493 : 6112063 : _PyUnicode_ScanIdentifier(PyObject *self)
11494 : : {
11495 : : Py_ssize_t i;
11496 : 6112063 : Py_ssize_t len = PyUnicode_GET_LENGTH(self);
11497 [ + + ]: 6112063 : if (len == 0) {
11498 : : /* an empty string is not a valid identifier */
11499 : 13 : return 0;
11500 : : }
11501 : :
11502 : 6112050 : int kind = PyUnicode_KIND(self);
11503 : 6112050 : const void *data = PyUnicode_DATA(self);
11504 : 6112050 : Py_UCS4 ch = PyUnicode_READ(kind, data, 0);
11505 : : /* PEP 3131 says that the first character must be in
11506 : : XID_Start and subsequent characters in XID_Continue,
11507 : : and for the ASCII range, the 2.x rules apply (i.e
11508 : : start with letters and underscore, continue with
11509 : : letters, digits, underscore). However, given the current
11510 : : definition of XID_Start and XID_Continue, it is sufficient
11511 : : to check just for these, except that _ must be allowed
11512 : : as starting an identifier. */
11513 [ + + + + ]: 6112050 : if (!_PyUnicode_IsXidStart(ch) && ch != 0x5F /* LOW LINE */) {
11514 : 3292648 : return 0;
11515 : : }
11516 : :
11517 [ + + ]: 5028726 : for (i = 1; i < len; i++) {
11518 : 2209843 : ch = PyUnicode_READ(kind, data, i);
11519 [ + + ]: 2209843 : if (!_PyUnicode_IsXidContinue(ch)) {
11520 : 519 : return i;
11521 : : }
11522 : : }
11523 : 2818883 : return i;
11524 : : }
11525 : :
11526 : : int
11527 : 6111849 : PyUnicode_IsIdentifier(PyObject *self)
11528 : : {
11529 : 6111849 : Py_ssize_t i = _PyUnicode_ScanIdentifier(self);
11530 : 6111849 : Py_ssize_t len = PyUnicode_GET_LENGTH(self);
11531 : : /* an empty string is not a valid identifier */
11532 [ + + + + ]: 6111849 : return len && i == len;
11533 : : }
11534 : :
11535 : : /*[clinic input]
11536 : : str.isidentifier as unicode_isidentifier
11537 : :
11538 : : Return True if the string is a valid Python identifier, False otherwise.
11539 : :
11540 : : Call keyword.iskeyword(s) to test whether string s is a reserved identifier,
11541 : : such as "def" or "class".
11542 : : [clinic start generated code]*/
11543 : :
11544 : : static PyObject *
11545 : 5969044 : unicode_isidentifier_impl(PyObject *self)
11546 : : /*[clinic end generated code: output=fe585a9666572905 input=2d807a104f21c0c5]*/
11547 : : {
11548 : 5969044 : return PyBool_FromLong(PyUnicode_IsIdentifier(self));
11549 : : }
11550 : :
11551 : : /*[clinic input]
11552 : : str.isprintable as unicode_isprintable
11553 : :
11554 : : Return True if the string is printable, False otherwise.
11555 : :
11556 : : A string is printable if all of its characters are considered printable in
11557 : : repr() or if it is empty.
11558 : : [clinic start generated code]*/
11559 : :
11560 : : static PyObject *
11561 : 1422395 : unicode_isprintable_impl(PyObject *self)
11562 : : /*[clinic end generated code: output=3ab9626cd32dd1a0 input=98a0e1c2c1813209]*/
11563 : : {
11564 : : Py_ssize_t i, length;
11565 : : int kind;
11566 : : const void *data;
11567 : :
11568 : 1422395 : length = PyUnicode_GET_LENGTH(self);
11569 : 1422395 : kind = PyUnicode_KIND(self);
11570 : 1422395 : data = PyUnicode_DATA(self);
11571 : :
11572 : : /* Shortcut for single character strings */
11573 [ + + ]: 1422395 : if (length == 1)
11574 : 1422386 : return PyBool_FromLong(
11575 : 1422386 : Py_UNICODE_ISPRINTABLE(PyUnicode_READ(kind, data, 0)));
11576 : :
11577 [ + + ]: 27 : for (i = 0; i < length; i++) {
11578 [ + + ]: 25 : if (!Py_UNICODE_ISPRINTABLE(PyUnicode_READ(kind, data, i))) {
11579 : 7 : Py_RETURN_FALSE;
11580 : : }
11581 : : }
11582 : 2 : Py_RETURN_TRUE;
11583 : : }
11584 : :
11585 : : /*[clinic input]
11586 : : str.join as unicode_join
11587 : :
11588 : : iterable: object
11589 : : /
11590 : :
11591 : : Concatenate any number of strings.
11592 : :
11593 : : The string whose method is called is inserted in between each given string.
11594 : : The result is returned as a new string.
11595 : :
11596 : : Example: '.'.join(['ab', 'pq', 'rs']) -> 'ab.pq.rs'
11597 : : [clinic start generated code]*/
11598 : :
11599 : : static PyObject *
11600 : 6094174 : unicode_join(PyObject *self, PyObject *iterable)
11601 : : /*[clinic end generated code: output=6857e7cecfe7bf98 input=2f70422bfb8fa189]*/
11602 : : {
11603 : 6094174 : return PyUnicode_Join(self, iterable);
11604 : : }
11605 : :
11606 : : static Py_ssize_t
11607 : 24042227 : unicode_length(PyObject *self)
11608 : : {
11609 : 24042227 : return PyUnicode_GET_LENGTH(self);
11610 : : }
11611 : :
11612 : : /*[clinic input]
11613 : : str.ljust as unicode_ljust
11614 : :
11615 : : width: Py_ssize_t
11616 : : fillchar: Py_UCS4 = ' '
11617 : : /
11618 : :
11619 : : Return a left-justified string of length width.
11620 : :
11621 : : Padding is done using the specified fill character (default is a space).
11622 : : [clinic start generated code]*/
11623 : :
11624 : : static PyObject *
11625 : 25593 : unicode_ljust_impl(PyObject *self, Py_ssize_t width, Py_UCS4 fillchar)
11626 : : /*[clinic end generated code: output=1cce0e0e0a0b84b3 input=3ab599e335e60a32]*/
11627 : : {
11628 [ + + ]: 25593 : if (PyUnicode_GET_LENGTH(self) >= width)
11629 : 110 : return unicode_result_unchanged(self);
11630 : :
11631 : 25483 : return pad(self, 0, width - PyUnicode_GET_LENGTH(self), fillchar);
11632 : : }
11633 : :
11634 : : /*[clinic input]
11635 : : str.lower as unicode_lower
11636 : :
11637 : : Return a copy of the string converted to lowercase.
11638 : : [clinic start generated code]*/
11639 : :
11640 : : static PyObject *
11641 : 4095028 : unicode_lower_impl(PyObject *self)
11642 : : /*[clinic end generated code: output=84ef9ed42efad663 input=60a2984b8beff23a]*/
11643 : : {
11644 [ + + ]: 4095028 : if (PyUnicode_IS_ASCII(self))
11645 : 740356 : return ascii_upper_or_lower(self, 1);
11646 : 3354672 : return case_operation(self, do_lower);
11647 : : }
11648 : :
11649 : : #define LEFTSTRIP 0
11650 : : #define RIGHTSTRIP 1
11651 : : #define BOTHSTRIP 2
11652 : :
11653 : : /* Arrays indexed by above */
11654 : : static const char *stripfuncnames[] = {"lstrip", "rstrip", "strip"};
11655 : :
11656 : : #define STRIPNAME(i) (stripfuncnames[i])
11657 : :
11658 : : /* externally visible for str.strip(unicode) */
11659 : : PyObject *
11660 : 5538473 : _PyUnicode_XStrip(PyObject *self, int striptype, PyObject *sepobj)
11661 : : {
11662 : : const void *data;
11663 : : int kind;
11664 : : Py_ssize_t i, j, len;
11665 : : BLOOM_MASK sepmask;
11666 : : Py_ssize_t seplen;
11667 : :
11668 : 5538473 : kind = PyUnicode_KIND(self);
11669 : 5538473 : data = PyUnicode_DATA(self);
11670 : 5538473 : len = PyUnicode_GET_LENGTH(self);
11671 : 5538473 : seplen = PyUnicode_GET_LENGTH(sepobj);
11672 : 5538473 : sepmask = make_bloom_mask(PyUnicode_KIND(sepobj),
11673 : 5538473 : PyUnicode_DATA(sepobj),
11674 : : seplen);
11675 : :
11676 : 5538473 : i = 0;
11677 [ + + ]: 5538473 : if (striptype != RIGHTSTRIP) {
11678 [ + + ]: 717596 : while (i < len) {
11679 : 707444 : Py_UCS4 ch = PyUnicode_READ(kind, data, i);
11680 [ + + ]: 707444 : if (!BLOOM(sepmask, ch))
11681 : 226981 : break;
11682 [ + + ]: 480463 : if (PyUnicode_FindChar(sepobj, ch, 0, seplen, 1) < 0)
11683 : 2601 : break;
11684 : 477862 : i++;
11685 : : }
11686 : : }
11687 : :
11688 : 5538473 : j = len;
11689 [ + + ]: 5538473 : if (striptype != LEFTSTRIP) {
11690 : 5337653 : j--;
11691 [ + + ]: 5829707 : while (j >= i) {
11692 : 5816328 : Py_UCS4 ch = PyUnicode_READ(kind, data, j);
11693 [ + + ]: 5816328 : if (!BLOOM(sepmask, ch))
11694 : 4022826 : break;
11695 [ + + ]: 1793502 : if (PyUnicode_FindChar(sepobj, ch, 0, seplen, 1) < 0)
11696 : 1301448 : break;
11697 : 492054 : j--;
11698 : : }
11699 : :
11700 : 5337653 : j++;
11701 : : }
11702 : :
11703 : 5538473 : return PyUnicode_Substring(self, i, j);
11704 : : }
11705 : :
11706 : : PyObject*
11707 : 27794506 : PyUnicode_Substring(PyObject *self, Py_ssize_t start, Py_ssize_t end)
11708 : : {
11709 : : const unsigned char *data;
11710 : : int kind;
11711 : : Py_ssize_t length;
11712 : :
11713 : 27794506 : length = PyUnicode_GET_LENGTH(self);
11714 : 27794506 : end = Py_MIN(end, length);
11715 : :
11716 [ + + + + ]: 27794506 : if (start == 0 && end == length)
11717 : 5717832 : return unicode_result_unchanged(self);
11718 : :
11719 [ + - - + ]: 22076674 : if (start < 0 || end < 0) {
11720 : 0 : PyErr_SetString(PyExc_IndexError, "string index out of range");
11721 : 0 : return NULL;
11722 : : }
11723 [ + + - + ]: 22076674 : if (start >= length || end < start)
11724 : 29919 : _Py_RETURN_UNICODE_EMPTY();
11725 : :
11726 : 22046755 : length = end - start;
11727 [ + + ]: 22046755 : if (PyUnicode_IS_ASCII(self)) {
11728 : 21751041 : data = PyUnicode_1BYTE_DATA(self);
11729 : 21751041 : return _PyUnicode_FromASCII((const char*)(data + start), length);
11730 : : }
11731 : : else {
11732 : 295714 : kind = PyUnicode_KIND(self);
11733 : 295714 : data = PyUnicode_1BYTE_DATA(self);
11734 : 295714 : return PyUnicode_FromKindAndData(kind,
11735 : 295714 : data + kind * start,
11736 : : length);
11737 : : }
11738 : : }
11739 : :
11740 : : static PyObject *
11741 : 1195001 : do_strip(PyObject *self, int striptype)
11742 : : {
11743 : : Py_ssize_t len, i, j;
11744 : :
11745 : 1195001 : len = PyUnicode_GET_LENGTH(self);
11746 : :
11747 [ + + ]: 1195001 : if (PyUnicode_IS_ASCII(self)) {
11748 : 1194089 : const Py_UCS1 *data = PyUnicode_1BYTE_DATA(self);
11749 : :
11750 : 1194089 : i = 0;
11751 [ + + ]: 1194089 : if (striptype != RIGHTSTRIP) {
11752 [ + + ]: 3088553 : while (i < len) {
11753 : 3025599 : Py_UCS1 ch = data[i];
11754 [ + + ]: 3025599 : if (!_Py_ascii_whitespace[ch])
11755 : 1056811 : break;
11756 : 1968788 : i++;
11757 : : }
11758 : : }
11759 : :
11760 : 1194089 : j = len;
11761 [ + + ]: 1194089 : if (striptype != LEFTSTRIP) {
11762 : 1165240 : j--;
11763 [ + + ]: 2062370 : while (j >= i) {
11764 : 1999787 : Py_UCS1 ch = data[j];
11765 [ + + ]: 1999787 : if (!_Py_ascii_whitespace[ch])
11766 : 1102657 : break;
11767 : 897130 : j--;
11768 : : }
11769 : 1165240 : j++;
11770 : : }
11771 : : }
11772 : : else {
11773 : 912 : int kind = PyUnicode_KIND(self);
11774 : 912 : const void *data = PyUnicode_DATA(self);
11775 : :
11776 : 912 : i = 0;
11777 [ + + ]: 912 : if (striptype != RIGHTSTRIP) {
11778 [ + + ]: 1530 : while (i < len) {
11779 : 1528 : Py_UCS4 ch = PyUnicode_READ(kind, data, i);
11780 [ + + ]: 1528 : if (!Py_UNICODE_ISSPACE(ch))
11781 : 801 : break;
11782 : 727 : i++;
11783 : : }
11784 : : }
11785 : :
11786 : 912 : j = len;
11787 [ + + ]: 912 : if (striptype != LEFTSTRIP) {
11788 : 432 : j--;
11789 [ + + ]: 686 : while (j >= i) {
11790 : 684 : Py_UCS4 ch = PyUnicode_READ(kind, data, j);
11791 [ + + ]: 684 : if (!Py_UNICODE_ISSPACE(ch))
11792 : 430 : break;
11793 : 254 : j--;
11794 : : }
11795 : 432 : j++;
11796 : : }
11797 : : }
11798 : :
11799 : 1195001 : return PyUnicode_Substring(self, i, j);
11800 : : }
11801 : :
11802 : :
11803 : : static PyObject *
11804 : 6733474 : do_argstrip(PyObject *self, int striptype, PyObject *sep)
11805 : : {
11806 [ + + ]: 6733474 : if (sep != Py_None) {
11807 [ + - ]: 5538473 : if (PyUnicode_Check(sep))
11808 : 5538473 : return _PyUnicode_XStrip(self, striptype, sep);
11809 : : else {
11810 : 0 : PyErr_Format(PyExc_TypeError,
11811 : : "%s arg must be None or str",
11812 : : STRIPNAME(striptype));
11813 : 0 : return NULL;
11814 : : }
11815 : : }
11816 : :
11817 : 1195001 : return do_strip(self, striptype);
11818 : : }
11819 : :
11820 : :
11821 : : /*[clinic input]
11822 : : str.strip as unicode_strip
11823 : :
11824 : : chars: object = None
11825 : : /
11826 : :
11827 : : Return a copy of the string with leading and trailing whitespace removed.
11828 : :
11829 : : If chars is given and not None, remove characters in chars instead.
11830 : : [clinic start generated code]*/
11831 : :
11832 : : static PyObject *
11833 : 1130153 : unicode_strip_impl(PyObject *self, PyObject *chars)
11834 : : /*[clinic end generated code: output=ca19018454345d57 input=385289c6f423b954]*/
11835 : : {
11836 : 1130153 : return do_argstrip(self, BOTHSTRIP, chars);
11837 : : }
11838 : :
11839 : :
11840 : : /*[clinic input]
11841 : : str.lstrip as unicode_lstrip
11842 : :
11843 : : chars: object = None
11844 : : /
11845 : :
11846 : : Return a copy of the string with leading whitespace removed.
11847 : :
11848 : : If chars is given and not None, remove characters in chars instead.
11849 : : [clinic start generated code]*/
11850 : :
11851 : : static PyObject *
11852 : 230149 : unicode_lstrip_impl(PyObject *self, PyObject *chars)
11853 : : /*[clinic end generated code: output=3b43683251f79ca7 input=529f9f3834448671]*/
11854 : : {
11855 : 230149 : return do_argstrip(self, LEFTSTRIP, chars);
11856 : : }
11857 : :
11858 : :
11859 : : /*[clinic input]
11860 : : str.rstrip as unicode_rstrip
11861 : :
11862 : : chars: object = None
11863 : : /
11864 : :
11865 : : Return a copy of the string with trailing whitespace removed.
11866 : :
11867 : : If chars is given and not None, remove characters in chars instead.
11868 : : [clinic start generated code]*/
11869 : :
11870 : : static PyObject *
11871 : 5373172 : unicode_rstrip_impl(PyObject *self, PyObject *chars)
11872 : : /*[clinic end generated code: output=4a59230017cc3b7a input=62566c627916557f]*/
11873 : : {
11874 : 5373172 : return do_argstrip(self, RIGHTSTRIP, chars);
11875 : : }
11876 : :
11877 : :
11878 : : static PyObject*
11879 : 1644695 : unicode_repeat(PyObject *str, Py_ssize_t len)
11880 : : {
11881 : : PyObject *u;
11882 : : Py_ssize_t nchars, n;
11883 : :
11884 [ + + ]: 1644695 : if (len < 1)
11885 : 130038 : _Py_RETURN_UNICODE_EMPTY();
11886 : :
11887 : : /* no repeat, return original string */
11888 [ + + ]: 1514657 : if (len == 1)
11889 : 537182 : return unicode_result_unchanged(str);
11890 : :
11891 [ - + ]: 977475 : if (PyUnicode_GET_LENGTH(str) > PY_SSIZE_T_MAX / len) {
11892 : 0 : PyErr_SetString(PyExc_OverflowError,
11893 : : "repeated string is too long");
11894 : 0 : return NULL;
11895 : : }
11896 : 977475 : nchars = len * PyUnicode_GET_LENGTH(str);
11897 : :
11898 : 977475 : u = PyUnicode_New(nchars, PyUnicode_MAX_CHAR_VALUE(str));
11899 [ + + ]: 977475 : if (!u)
11900 : 8 : return NULL;
11901 : : assert(PyUnicode_KIND(u) == PyUnicode_KIND(str));
11902 : :
11903 [ + + ]: 977467 : if (PyUnicode_GET_LENGTH(str) == 1) {
11904 : 613420 : int kind = PyUnicode_KIND(str);
11905 : 613420 : Py_UCS4 fill_char = PyUnicode_READ(kind, PyUnicode_DATA(str), 0);
11906 [ + + ]: 613420 : if (kind == PyUnicode_1BYTE_KIND) {
11907 : 613041 : void *to = PyUnicode_DATA(u);
11908 : 613041 : memset(to, (unsigned char)fill_char, len);
11909 : : }
11910 [ + + ]: 379 : else if (kind == PyUnicode_2BYTE_KIND) {
11911 : 256 : Py_UCS2 *ucs2 = PyUnicode_2BYTE_DATA(u);
11912 [ + + ]: 69172 : for (n = 0; n < len; ++n)
11913 : 68916 : ucs2[n] = fill_char;
11914 : : } else {
11915 : 123 : Py_UCS4 *ucs4 = PyUnicode_4BYTE_DATA(u);
11916 : : assert(kind == PyUnicode_4BYTE_KIND);
11917 [ + + ]: 11587 : for (n = 0; n < len; ++n)
11918 : 11464 : ucs4[n] = fill_char;
11919 : : }
11920 : : }
11921 : : else {
11922 : 364047 : Py_ssize_t char_size = PyUnicode_KIND(str);
11923 : 364047 : char *to = (char *) PyUnicode_DATA(u);
11924 : 364047 : _PyBytes_Repeat(to, nchars * char_size, PyUnicode_DATA(str),
11925 : 364047 : PyUnicode_GET_LENGTH(str) * char_size);
11926 : : }
11927 : :
11928 : : assert(_PyUnicode_CheckConsistency(u, 1));
11929 : 977467 : return u;
11930 : : }
11931 : :
11932 : : PyObject *
11933 : 356 : PyUnicode_Replace(PyObject *str,
11934 : : PyObject *substr,
11935 : : PyObject *replstr,
11936 : : Py_ssize_t maxcount)
11937 : : {
11938 [ + - + - : 712 : if (ensure_unicode(str) < 0 || ensure_unicode(substr) < 0 ||
- + ]
11939 : 356 : ensure_unicode(replstr) < 0)
11940 : 0 : return NULL;
11941 : 356 : return replace(str, substr, replstr, maxcount);
11942 : : }
11943 : :
11944 : : /*[clinic input]
11945 : : str.replace as unicode_replace
11946 : :
11947 : : old: unicode
11948 : : new: unicode
11949 : : count: Py_ssize_t = -1
11950 : : Maximum number of occurrences to replace.
11951 : : -1 (the default value) means replace all occurrences.
11952 : : /
11953 : :
11954 : : Return a copy with all occurrences of substring old replaced by new.
11955 : :
11956 : : If the optional argument count is given, only the first count occurrences are
11957 : : replaced.
11958 : : [clinic start generated code]*/
11959 : :
11960 : : static PyObject *
11961 : 3276273 : unicode_replace_impl(PyObject *self, PyObject *old, PyObject *new,
11962 : : Py_ssize_t count)
11963 : : /*[clinic end generated code: output=b63f1a8b5eebf448 input=147d12206276ebeb]*/
11964 : : {
11965 : 3276273 : return replace(self, old, new, count);
11966 : : }
11967 : :
11968 : : /*[clinic input]
11969 : : str.removeprefix as unicode_removeprefix
11970 : :
11971 : : prefix: unicode
11972 : : /
11973 : :
11974 : : Return a str with the given prefix string removed if present.
11975 : :
11976 : : If the string starts with the prefix string, return string[len(prefix):].
11977 : : Otherwise, return a copy of the original string.
11978 : : [clinic start generated code]*/
11979 : :
11980 : : static PyObject *
11981 : 30314 : unicode_removeprefix_impl(PyObject *self, PyObject *prefix)
11982 : : /*[clinic end generated code: output=f1e5945e9763bcb9 input=27ec40b99a37eb88]*/
11983 : : {
11984 : 30314 : int match = tailmatch(self, prefix, 0, PY_SSIZE_T_MAX, -1);
11985 [ - + ]: 30314 : if (match == -1) {
11986 : 0 : return NULL;
11987 : : }
11988 [ + + ]: 30314 : if (match) {
11989 : 30016 : return PyUnicode_Substring(self, PyUnicode_GET_LENGTH(prefix),
11990 : : PyUnicode_GET_LENGTH(self));
11991 : : }
11992 : 298 : return unicode_result_unchanged(self);
11993 : : }
11994 : :
11995 : : /*[clinic input]
11996 : : str.removesuffix as unicode_removesuffix
11997 : :
11998 : : suffix: unicode
11999 : : /
12000 : :
12001 : : Return a str with the given suffix string removed if present.
12002 : :
12003 : : If the string ends with the suffix string and that suffix is not empty,
12004 : : return string[:-len(suffix)]. Otherwise, return a copy of the original
12005 : : string.
12006 : : [clinic start generated code]*/
12007 : :
12008 : : static PyObject *
12009 : 28 : unicode_removesuffix_impl(PyObject *self, PyObject *suffix)
12010 : : /*[clinic end generated code: output=d36629e227636822 input=12cc32561e769be4]*/
12011 : : {
12012 : 28 : int match = tailmatch(self, suffix, 0, PY_SSIZE_T_MAX, +1);
12013 [ - + ]: 28 : if (match == -1) {
12014 : 0 : return NULL;
12015 : : }
12016 [ + + ]: 28 : if (match) {
12017 : 32 : return PyUnicode_Substring(self, 0, PyUnicode_GET_LENGTH(self)
12018 : 16 : - PyUnicode_GET_LENGTH(suffix));
12019 : : }
12020 : 12 : return unicode_result_unchanged(self);
12021 : : }
12022 : :
12023 : : static PyObject *
12024 : 645309 : unicode_repr(PyObject *unicode)
12025 : : {
12026 : : PyObject *repr;
12027 : : Py_ssize_t isize;
12028 : : Py_ssize_t osize, squote, dquote, i, o;
12029 : : Py_UCS4 max, quote;
12030 : : int ikind, okind, unchanged;
12031 : : const void *idata;
12032 : : void *odata;
12033 : :
12034 : 645309 : isize = PyUnicode_GET_LENGTH(unicode);
12035 : 645309 : idata = PyUnicode_DATA(unicode);
12036 : :
12037 : : /* Compute length of output, quote characters, and
12038 : : maximum character */
12039 : 645309 : osize = 0;
12040 : 645309 : max = 127;
12041 : 645309 : squote = dquote = 0;
12042 : 645309 : ikind = PyUnicode_KIND(unicode);
12043 [ + + ]: 12739274 : for (i = 0; i < isize; i++) {
12044 : 12093965 : Py_UCS4 ch = PyUnicode_READ(ikind, idata, i);
12045 : 12093965 : Py_ssize_t incr = 1;
12046 [ + + + + ]: 12093965 : switch (ch) {
12047 : 37302 : case '\'': squote++; break;
12048 : 40125 : case '"': dquote++; break;
12049 : 83060 : case '\\': case '\t': case '\r': case '\n':
12050 : 83060 : incr = 2;
12051 : 83060 : break;
12052 : 11933478 : default:
12053 : : /* Fast-path ASCII */
12054 [ + + + + ]: 11933478 : if (ch < ' ' || ch == 0x7f)
12055 : 8855 : incr = 4; /* \xHH */
12056 [ + + ]: 11924623 : else if (ch < 0x7f)
12057 : : ;
12058 [ + + ]: 93769 : else if (Py_UNICODE_ISPRINTABLE(ch))
12059 : 54330 : max = ch > max ? ch : max;
12060 [ + + ]: 39439 : else if (ch < 0x100)
12061 : 319 : incr = 4; /* \xHH */
12062 [ + + ]: 39120 : else if (ch < 0x10000)
12063 : 28611 : incr = 6; /* \uHHHH */
12064 : : else
12065 : 10509 : incr = 10; /* \uHHHHHHHH */
12066 : : }
12067 [ - + ]: 12093965 : if (osize > PY_SSIZE_T_MAX - incr) {
12068 : 0 : PyErr_SetString(PyExc_OverflowError,
12069 : : "string is too long to generate repr");
12070 : 0 : return NULL;
12071 : : }
12072 : 12093965 : osize += incr;
12073 : : }
12074 : :
12075 : 645309 : quote = '\'';
12076 : 645309 : unchanged = (osize == isize);
12077 [ + + ]: 645309 : if (squote) {
12078 : 21815 : unchanged = 0;
12079 [ + + ]: 21815 : if (dquote)
12080 : : /* Both squote and dquote present. Use squote,
12081 : : and escape them */
12082 : 4085 : osize += squote;
12083 : : else
12084 : 17730 : quote = '"';
12085 : : }
12086 : 645309 : osize += 2; /* quotes */
12087 : :
12088 : 645309 : repr = PyUnicode_New(osize, max);
12089 [ - + ]: 645309 : if (repr == NULL)
12090 : 0 : return NULL;
12091 : 645309 : okind = PyUnicode_KIND(repr);
12092 : 645309 : odata = PyUnicode_DATA(repr);
12093 : :
12094 : 645309 : PyUnicode_WRITE(okind, odata, 0, quote);
12095 : 645309 : PyUnicode_WRITE(okind, odata, osize-1, quote);
12096 [ + + ]: 645309 : if (unchanged) {
12097 : 600488 : _PyUnicode_FastCopyCharacters(repr, 1,
12098 : : unicode, 0,
12099 : : isize);
12100 : : }
12101 : : else {
12102 [ + + ]: 2378566 : for (i = 0, o = 1; i < isize; i++) {
12103 : 2333745 : Py_UCS4 ch = PyUnicode_READ(ikind, idata, i);
12104 : :
12105 : : /* Escape quotes and backslashes */
12106 [ + + + + ]: 2333745 : if ((ch == quote) || (ch == '\\')) {
12107 : 21001 : PyUnicode_WRITE(okind, odata, o++, '\\');
12108 : 21001 : PyUnicode_WRITE(okind, odata, o++, ch);
12109 : 21001 : continue;
12110 : : }
12111 : :
12112 : : /* Map special whitespace to '\t', \n', '\r' */
12113 [ + + ]: 2312744 : if (ch == '\t') {
12114 : 22461 : PyUnicode_WRITE(okind, odata, o++, '\\');
12115 : 22461 : PyUnicode_WRITE(okind, odata, o++, 't');
12116 : : }
12117 [ + + ]: 2290283 : else if (ch == '\n') {
12118 : 49828 : PyUnicode_WRITE(okind, odata, o++, '\\');
12119 : 49828 : PyUnicode_WRITE(okind, odata, o++, 'n');
12120 : : }
12121 [ + + ]: 2240455 : else if (ch == '\r') {
12122 : 1153 : PyUnicode_WRITE(okind, odata, o++, '\\');
12123 : 1153 : PyUnicode_WRITE(okind, odata, o++, 'r');
12124 : : }
12125 : :
12126 : : /* Map non-printable US ASCII to '\xhh' */
12127 [ + + + + ]: 2239302 : else if (ch < ' ' || ch == 0x7F) {
12128 : 8855 : PyUnicode_WRITE(okind, odata, o++, '\\');
12129 : 8855 : PyUnicode_WRITE(okind, odata, o++, 'x');
12130 : 8855 : PyUnicode_WRITE(okind, odata, o++, Py_hexdigits[(ch >> 4) & 0x000F]);
12131 : 8855 : PyUnicode_WRITE(okind, odata, o++, Py_hexdigits[ch & 0x000F]);
12132 : : }
12133 : :
12134 : : /* Copy ASCII characters as-is */
12135 [ + + ]: 2230447 : else if (ch < 0x7F) {
12136 : 2168202 : PyUnicode_WRITE(okind, odata, o++, ch);
12137 : : }
12138 : :
12139 : : /* Non-ASCII characters */
12140 : : else {
12141 : : /* Map Unicode whitespace and control characters
12142 : : (categories Z* and C* except ASCII space)
12143 : : */
12144 [ + + ]: 62245 : if (!Py_UNICODE_ISPRINTABLE(ch)) {
12145 : 39439 : PyUnicode_WRITE(okind, odata, o++, '\\');
12146 : : /* Map 8-bit characters to '\xhh' */
12147 [ + + ]: 39439 : if (ch <= 0xff) {
12148 : 319 : PyUnicode_WRITE(okind, odata, o++, 'x');
12149 : 319 : PyUnicode_WRITE(okind, odata, o++, Py_hexdigits[(ch >> 4) & 0x000F]);
12150 : 319 : PyUnicode_WRITE(okind, odata, o++, Py_hexdigits[ch & 0x000F]);
12151 : : }
12152 : : /* Map 16-bit characters to '\uxxxx' */
12153 [ + + ]: 39120 : else if (ch <= 0xffff) {
12154 : 28611 : PyUnicode_WRITE(okind, odata, o++, 'u');
12155 : 28611 : PyUnicode_WRITE(okind, odata, o++, Py_hexdigits[(ch >> 12) & 0xF]);
12156 : 28611 : PyUnicode_WRITE(okind, odata, o++, Py_hexdigits[(ch >> 8) & 0xF]);
12157 : 28611 : PyUnicode_WRITE(okind, odata, o++, Py_hexdigits[(ch >> 4) & 0xF]);
12158 : 28611 : PyUnicode_WRITE(okind, odata, o++, Py_hexdigits[ch & 0xF]);
12159 : : }
12160 : : /* Map 21-bit characters to '\U00xxxxxx' */
12161 : : else {
12162 : 10509 : PyUnicode_WRITE(okind, odata, o++, 'U');
12163 : 10509 : PyUnicode_WRITE(okind, odata, o++, Py_hexdigits[(ch >> 28) & 0xF]);
12164 : 10509 : PyUnicode_WRITE(okind, odata, o++, Py_hexdigits[(ch >> 24) & 0xF]);
12165 : 10509 : PyUnicode_WRITE(okind, odata, o++, Py_hexdigits[(ch >> 20) & 0xF]);
12166 : 10509 : PyUnicode_WRITE(okind, odata, o++, Py_hexdigits[(ch >> 16) & 0xF]);
12167 : 10509 : PyUnicode_WRITE(okind, odata, o++, Py_hexdigits[(ch >> 12) & 0xF]);
12168 : 10509 : PyUnicode_WRITE(okind, odata, o++, Py_hexdigits[(ch >> 8) & 0xF]);
12169 : 10509 : PyUnicode_WRITE(okind, odata, o++, Py_hexdigits[(ch >> 4) & 0xF]);
12170 : 10509 : PyUnicode_WRITE(okind, odata, o++, Py_hexdigits[ch & 0xF]);
12171 : : }
12172 : : }
12173 : : /* Copy characters as-is */
12174 : : else {
12175 : 22806 : PyUnicode_WRITE(okind, odata, o++, ch);
12176 : : }
12177 : : }
12178 : : }
12179 : : }
12180 : : /* Closing quote already added at the beginning */
12181 : : assert(_PyUnicode_CheckConsistency(repr, 1));
12182 : 645309 : return repr;
12183 : : }
12184 : :
12185 : : PyDoc_STRVAR(rfind__doc__,
12186 : : "S.rfind(sub[, start[, end]]) -> int\n\
12187 : : \n\
12188 : : Return the highest index in S where substring sub is found,\n\
12189 : : such that sub is contained within S[start:end]. Optional\n\
12190 : : arguments start and end are interpreted as in slice notation.\n\
12191 : : \n\
12192 : : Return -1 on failure.");
12193 : :
12194 : : static PyObject *
12195 : 1399118 : unicode_rfind(PyObject *self, PyObject *args)
12196 : : {
12197 : : /* initialize variables to prevent gcc warning */
12198 : 1399118 : PyObject *substring = NULL;
12199 : 1399118 : Py_ssize_t start = 0;
12200 : 1399118 : Py_ssize_t end = 0;
12201 : : Py_ssize_t result;
12202 : :
12203 [ + + ]: 1399118 : if (!parse_args_finds_unicode("rfind", args, &substring, &start, &end))
12204 : 5 : return NULL;
12205 : :
12206 : 1399113 : result = any_find_slice(self, substring, start, end, -1);
12207 : :
12208 [ - + ]: 1399113 : if (result == -2)
12209 : 0 : return NULL;
12210 : :
12211 : 1399113 : return PyLong_FromSsize_t(result);
12212 : : }
12213 : :
12214 : : PyDoc_STRVAR(rindex__doc__,
12215 : : "S.rindex(sub[, start[, end]]) -> int\n\
12216 : : \n\
12217 : : Return the highest index in S where substring sub is found,\n\
12218 : : such that sub is contained within S[start:end]. Optional\n\
12219 : : arguments start and end are interpreted as in slice notation.\n\
12220 : : \n\
12221 : : Raises ValueError when the substring is not found.");
12222 : :
12223 : : static PyObject *
12224 : 198 : unicode_rindex(PyObject *self, PyObject *args)
12225 : : {
12226 : : /* initialize variables to prevent gcc warning */
12227 : 198 : PyObject *substring = NULL;
12228 : 198 : Py_ssize_t start = 0;
12229 : 198 : Py_ssize_t end = 0;
12230 : : Py_ssize_t result;
12231 : :
12232 [ + + ]: 198 : if (!parse_args_finds_unicode("rindex", args, &substring, &start, &end))
12233 : 5 : return NULL;
12234 : :
12235 : 193 : result = any_find_slice(self, substring, start, end, -1);
12236 : :
12237 [ - + ]: 193 : if (result == -2)
12238 : 0 : return NULL;
12239 : :
12240 [ + + ]: 193 : if (result < 0) {
12241 : 25 : PyErr_SetString(PyExc_ValueError, "substring not found");
12242 : 25 : return NULL;
12243 : : }
12244 : :
12245 : 168 : return PyLong_FromSsize_t(result);
12246 : : }
12247 : :
12248 : : /*[clinic input]
12249 : : str.rjust as unicode_rjust
12250 : :
12251 : : width: Py_ssize_t
12252 : : fillchar: Py_UCS4 = ' '
12253 : : /
12254 : :
12255 : : Return a right-justified string of length width.
12256 : :
12257 : : Padding is done using the specified fill character (default is a space).
12258 : : [clinic start generated code]*/
12259 : :
12260 : : static PyObject *
12261 : 48168 : unicode_rjust_impl(PyObject *self, Py_ssize_t width, Py_UCS4 fillchar)
12262 : : /*[clinic end generated code: output=804a1a57fbe8d5cf input=d05f550b5beb1f72]*/
12263 : : {
12264 [ + + ]: 48168 : if (PyUnicode_GET_LENGTH(self) >= width)
12265 : 7226 : return unicode_result_unchanged(self);
12266 : :
12267 : 40942 : return pad(self, width - PyUnicode_GET_LENGTH(self), 0, fillchar);
12268 : : }
12269 : :
12270 : : PyObject *
12271 : 197563 : PyUnicode_Split(PyObject *s, PyObject *sep, Py_ssize_t maxsplit)
12272 : : {
12273 [ + - + - : 197563 : if (ensure_unicode(s) < 0 || (sep != NULL && ensure_unicode(sep) < 0))
- + ]
12274 : 0 : return NULL;
12275 : :
12276 : 197563 : return split(s, sep, maxsplit);
12277 : : }
12278 : :
12279 : : /*[clinic input]
12280 : : str.split as unicode_split
12281 : :
12282 : : sep: object = None
12283 : : The separator used to split the string.
12284 : :
12285 : : When set to None (the default value), will split on any whitespace
12286 : : character (including \\n \\r \\t \\f and spaces) and will discard
12287 : : empty strings from the result.
12288 : : maxsplit: Py_ssize_t = -1
12289 : : Maximum number of splits (starting from the left).
12290 : : -1 (the default value) means no limit.
12291 : :
12292 : : Return a list of the substrings in the string, using sep as the separator string.
12293 : :
12294 : : Note, str.split() is mainly useful for data that has been intentionally
12295 : : delimited. With natural text that includes punctuation, consider using
12296 : : the regular expression module.
12297 : :
12298 : : [clinic start generated code]*/
12299 : :
12300 : : static PyObject *
12301 : 2217863 : unicode_split_impl(PyObject *self, PyObject *sep, Py_ssize_t maxsplit)
12302 : : /*[clinic end generated code: output=3a65b1db356948dc input=906d953b44efc43b]*/
12303 : : {
12304 [ + + ]: 2217863 : if (sep == Py_None)
12305 : 491440 : return split(self, NULL, maxsplit);
12306 [ + + ]: 1726423 : if (PyUnicode_Check(sep))
12307 : 1726418 : return split(self, sep, maxsplit);
12308 : :
12309 : 5 : PyErr_Format(PyExc_TypeError,
12310 : : "must be str or None, not %.100s",
12311 : 5 : Py_TYPE(sep)->tp_name);
12312 : 5 : return NULL;
12313 : : }
12314 : :
12315 : : PyObject *
12316 : 178473 : PyUnicode_Partition(PyObject *str_obj, PyObject *sep_obj)
12317 : : {
12318 : : PyObject* out;
12319 : : int kind1, kind2;
12320 : : const void *buf1, *buf2;
12321 : : Py_ssize_t len1, len2;
12322 : :
12323 [ + - + + ]: 178473 : if (ensure_unicode(str_obj) < 0 || ensure_unicode(sep_obj) < 0)
12324 : 2 : return NULL;
12325 : :
12326 : 178471 : kind1 = PyUnicode_KIND(str_obj);
12327 : 178471 : kind2 = PyUnicode_KIND(sep_obj);
12328 : 178471 : len1 = PyUnicode_GET_LENGTH(str_obj);
12329 : 178471 : len2 = PyUnicode_GET_LENGTH(sep_obj);
12330 [ + + + + ]: 178471 : if (kind1 < kind2 || len1 < len2) {
12331 : 3814 : PyObject *empty = unicode_get_empty(); // Borrowed reference
12332 : 3814 : return PyTuple_Pack(3, str_obj, empty, empty);
12333 : : }
12334 : 174657 : buf1 = PyUnicode_DATA(str_obj);
12335 : 174657 : buf2 = PyUnicode_DATA(sep_obj);
12336 [ + + ]: 174657 : if (kind2 != kind1) {
12337 : 46 : buf2 = unicode_askind(kind2, buf2, len2, kind1);
12338 [ - + ]: 46 : if (!buf2)
12339 : 0 : return NULL;
12340 : : }
12341 : :
12342 [ + + + - ]: 174657 : switch (kind1) {
12343 : 174597 : case PyUnicode_1BYTE_KIND:
12344 [ + + + - ]: 174597 : if (PyUnicode_IS_ASCII(str_obj) && PyUnicode_IS_ASCII(sep_obj))
12345 : 164985 : out = asciilib_partition(str_obj, buf1, len1, sep_obj, buf2, len2);
12346 : : else
12347 : 9612 : out = ucs1lib_partition(str_obj, buf1, len1, sep_obj, buf2, len2);
12348 : 174597 : break;
12349 : 44 : case PyUnicode_2BYTE_KIND:
12350 : 44 : out = ucs2lib_partition(str_obj, buf1, len1, sep_obj, buf2, len2);
12351 : 44 : break;
12352 : 16 : case PyUnicode_4BYTE_KIND:
12353 : 16 : out = ucs4lib_partition(str_obj, buf1, len1, sep_obj, buf2, len2);
12354 : 16 : break;
12355 : 0 : default:
12356 : 0 : Py_UNREACHABLE();
12357 : : }
12358 : :
12359 : : assert((kind2 == kind1) == (buf2 == PyUnicode_DATA(sep_obj)));
12360 [ + + ]: 174657 : if (kind2 != kind1)
12361 : 46 : PyMem_Free((void *)buf2);
12362 : :
12363 : 174657 : return out;
12364 : : }
12365 : :
12366 : :
12367 : : PyObject *
12368 : 1608713 : PyUnicode_RPartition(PyObject *str_obj, PyObject *sep_obj)
12369 : : {
12370 : : PyObject* out;
12371 : : int kind1, kind2;
12372 : : const void *buf1, *buf2;
12373 : : Py_ssize_t len1, len2;
12374 : :
12375 [ + - + + ]: 1608713 : if (ensure_unicode(str_obj) < 0 || ensure_unicode(sep_obj) < 0)
12376 : 2 : return NULL;
12377 : :
12378 : 1608711 : kind1 = PyUnicode_KIND(str_obj);
12379 : 1608711 : kind2 = PyUnicode_KIND(sep_obj);
12380 : 1608711 : len1 = PyUnicode_GET_LENGTH(str_obj);
12381 : 1608711 : len2 = PyUnicode_GET_LENGTH(sep_obj);
12382 [ + + + + ]: 1608711 : if (kind1 < kind2 || len1 < len2) {
12383 : 143 : PyObject *empty = unicode_get_empty(); // Borrowed reference
12384 : 143 : return PyTuple_Pack(3, empty, empty, str_obj);
12385 : : }
12386 : 1608568 : buf1 = PyUnicode_DATA(str_obj);
12387 : 1608568 : buf2 = PyUnicode_DATA(sep_obj);
12388 [ + + ]: 1608568 : if (kind2 != kind1) {
12389 : 77 : buf2 = unicode_askind(kind2, buf2, len2, kind1);
12390 [ - + ]: 77 : if (!buf2)
12391 : 0 : return NULL;
12392 : : }
12393 : :
12394 [ + + + - ]: 1608568 : switch (kind1) {
12395 : 1608477 : case PyUnicode_1BYTE_KIND:
12396 [ + + + - ]: 1608477 : if (PyUnicode_IS_ASCII(str_obj) && PyUnicode_IS_ASCII(sep_obj))
12397 : 1607987 : out = asciilib_rpartition(str_obj, buf1, len1, sep_obj, buf2, len2);
12398 : : else
12399 : 490 : out = ucs1lib_rpartition(str_obj, buf1, len1, sep_obj, buf2, len2);
12400 : 1608477 : break;
12401 : 75 : case PyUnicode_2BYTE_KIND:
12402 : 75 : out = ucs2lib_rpartition(str_obj, buf1, len1, sep_obj, buf2, len2);
12403 : 75 : break;
12404 : 16 : case PyUnicode_4BYTE_KIND:
12405 : 16 : out = ucs4lib_rpartition(str_obj, buf1, len1, sep_obj, buf2, len2);
12406 : 16 : break;
12407 : 0 : default:
12408 : 0 : Py_UNREACHABLE();
12409 : : }
12410 : :
12411 : : assert((kind2 == kind1) == (buf2 == PyUnicode_DATA(sep_obj)));
12412 [ + + ]: 1608568 : if (kind2 != kind1)
12413 : 77 : PyMem_Free((void *)buf2);
12414 : :
12415 : 1608568 : return out;
12416 : : }
12417 : :
12418 : : /*[clinic input]
12419 : : str.partition as unicode_partition
12420 : :
12421 : : sep: object
12422 : : /
12423 : :
12424 : : Partition the string into three parts using the given separator.
12425 : :
12426 : : This will search for the separator in the string. If the separator is found,
12427 : : returns a 3-tuple containing the part before the separator, the separator
12428 : : itself, and the part after it.
12429 : :
12430 : : If the separator is not found, returns a 3-tuple containing the original string
12431 : : and two empty strings.
12432 : : [clinic start generated code]*/
12433 : :
12434 : : static PyObject *
12435 : 178473 : unicode_partition(PyObject *self, PyObject *sep)
12436 : : /*[clinic end generated code: output=e4ced7bd253ca3c4 input=f29b8d06c63e50be]*/
12437 : : {
12438 : 178473 : return PyUnicode_Partition(self, sep);
12439 : : }
12440 : :
12441 : : /*[clinic input]
12442 : : str.rpartition as unicode_rpartition = str.partition
12443 : :
12444 : : Partition the string into three parts using the given separator.
12445 : :
12446 : : This will search for the separator in the string, starting at the end. If
12447 : : the separator is found, returns a 3-tuple containing the part before the
12448 : : separator, the separator itself, and the part after it.
12449 : :
12450 : : If the separator is not found, returns a 3-tuple containing two empty strings
12451 : : and the original string.
12452 : : [clinic start generated code]*/
12453 : :
12454 : : static PyObject *
12455 : 1608713 : unicode_rpartition(PyObject *self, PyObject *sep)
12456 : : /*[clinic end generated code: output=1aa13cf1156572aa input=c4b7db3ef5cf336a]*/
12457 : : {
12458 : 1608713 : return PyUnicode_RPartition(self, sep);
12459 : : }
12460 : :
12461 : : PyObject *
12462 : 0 : PyUnicode_RSplit(PyObject *s, PyObject *sep, Py_ssize_t maxsplit)
12463 : : {
12464 [ # # # # : 0 : if (ensure_unicode(s) < 0 || (sep != NULL && ensure_unicode(sep) < 0))
# # ]
12465 : 0 : return NULL;
12466 : :
12467 : 0 : return rsplit(s, sep, maxsplit);
12468 : : }
12469 : :
12470 : : /*[clinic input]
12471 : : str.rsplit as unicode_rsplit = str.split
12472 : :
12473 : : Return a list of the substrings in the string, using sep as the separator string.
12474 : :
12475 : : Splitting starts at the end of the string and works to the front.
12476 : : [clinic start generated code]*/
12477 : :
12478 : : static PyObject *
12479 : 3830 : unicode_rsplit_impl(PyObject *self, PyObject *sep, Py_ssize_t maxsplit)
12480 : : /*[clinic end generated code: output=c2b815c63bcabffc input=ea78406060fce33c]*/
12481 : : {
12482 [ + + ]: 3830 : if (sep == Py_None)
12483 : 76 : return rsplit(self, NULL, maxsplit);
12484 [ + - ]: 3754 : if (PyUnicode_Check(sep))
12485 : 3754 : return rsplit(self, sep, maxsplit);
12486 : :
12487 : 0 : PyErr_Format(PyExc_TypeError,
12488 : : "must be str or None, not %.100s",
12489 : 0 : Py_TYPE(sep)->tp_name);
12490 : 0 : return NULL;
12491 : : }
12492 : :
12493 : : /*[clinic input]
12494 : : str.splitlines as unicode_splitlines
12495 : :
12496 : : keepends: bool(accept={int}) = False
12497 : :
12498 : : Return a list of the lines in the string, breaking at line boundaries.
12499 : :
12500 : : Line breaks are not included in the resulting list unless keepends is given and
12501 : : true.
12502 : : [clinic start generated code]*/
12503 : :
12504 : : static PyObject *
12505 : 287350 : unicode_splitlines_impl(PyObject *self, int keepends)
12506 : : /*[clinic end generated code: output=f664dcdad153ec40 input=b508e180459bdd8b]*/
12507 : : {
12508 : 287350 : return PyUnicode_Splitlines(self, keepends);
12509 : : }
12510 : :
12511 : : static
12512 : 61346 : PyObject *unicode_str(PyObject *self)
12513 : : {
12514 : 61346 : return unicode_result_unchanged(self);
12515 : : }
12516 : :
12517 : : /*[clinic input]
12518 : : str.swapcase as unicode_swapcase
12519 : :
12520 : : Convert uppercase characters to lowercase and lowercase characters to uppercase.
12521 : : [clinic start generated code]*/
12522 : :
12523 : : static PyObject *
12524 : 29 : unicode_swapcase_impl(PyObject *self)
12525 : : /*[clinic end generated code: output=5d28966bf6d7b2af input=3f3ef96d5798a7bb]*/
12526 : : {
12527 : 29 : return case_operation(self, do_swapcase);
12528 : : }
12529 : :
12530 : : /*[clinic input]
12531 : :
12532 : : @staticmethod
12533 : : str.maketrans as unicode_maketrans
12534 : :
12535 : : x: object
12536 : :
12537 : : y: unicode=NULL
12538 : :
12539 : : z: unicode=NULL
12540 : :
12541 : : /
12542 : :
12543 : : Return a translation table usable for str.translate().
12544 : :
12545 : : If there is only one argument, it must be a dictionary mapping Unicode
12546 : : ordinals (integers) or characters to Unicode ordinals, strings or None.
12547 : : Character keys will be then converted to ordinals.
12548 : : If there are two arguments, they must be strings of equal length, and
12549 : : in the resulting dictionary, each character in x will be mapped to the
12550 : : character at the same position in y. If there is a third argument, it
12551 : : must be a string, whose characters will be mapped to None in the result.
12552 : : [clinic start generated code]*/
12553 : :
12554 : : static PyObject *
12555 : 138 : unicode_maketrans_impl(PyObject *x, PyObject *y, PyObject *z)
12556 : : /*[clinic end generated code: output=a925c89452bd5881 input=7bfbf529a293c6c5]*/
12557 : : {
12558 : 138 : PyObject *new = NULL, *key, *value;
12559 : 138 : Py_ssize_t i = 0;
12560 : : int res;
12561 : :
12562 : 138 : new = PyDict_New();
12563 [ - + ]: 138 : if (!new)
12564 : 0 : return NULL;
12565 [ + + ]: 138 : if (y != NULL) {
12566 : : int x_kind, y_kind, z_kind;
12567 : : const void *x_data, *y_data, *z_data;
12568 : :
12569 : : /* x must be a string too, of equal length */
12570 [ + + ]: 27 : if (!PyUnicode_Check(x)) {
12571 : 1 : PyErr_SetString(PyExc_TypeError, "first maketrans argument must "
12572 : : "be a string if there is a second argument");
12573 : 1 : goto err;
12574 : : }
12575 [ + + ]: 26 : if (PyUnicode_GET_LENGTH(x) != PyUnicode_GET_LENGTH(y)) {
12576 : 1 : PyErr_SetString(PyExc_ValueError, "the first two maketrans "
12577 : : "arguments must have equal length");
12578 : 1 : goto err;
12579 : : }
12580 : : /* create entries for translating chars in x to those in y */
12581 : 25 : x_kind = PyUnicode_KIND(x);
12582 : 25 : y_kind = PyUnicode_KIND(y);
12583 : 25 : x_data = PyUnicode_DATA(x);
12584 : 25 : y_data = PyUnicode_DATA(y);
12585 [ + + ]: 57 : for (i = 0; i < PyUnicode_GET_LENGTH(x); i++) {
12586 : 32 : key = PyLong_FromLong(PyUnicode_READ(x_kind, x_data, i));
12587 [ - + ]: 32 : if (!key)
12588 : 0 : goto err;
12589 : 32 : value = PyLong_FromLong(PyUnicode_READ(y_kind, y_data, i));
12590 [ - + ]: 32 : if (!value) {
12591 : 0 : Py_DECREF(key);
12592 : 0 : goto err;
12593 : : }
12594 : 32 : res = PyDict_SetItem(new, key, value);
12595 : 32 : Py_DECREF(key);
12596 : 32 : Py_DECREF(value);
12597 [ - + ]: 32 : if (res < 0)
12598 : 0 : goto err;
12599 : : }
12600 : : /* create entries for deleting chars in z */
12601 [ + + ]: 25 : if (z != NULL) {
12602 : 2 : z_kind = PyUnicode_KIND(z);
12603 : 2 : z_data = PyUnicode_DATA(z);
12604 [ + + ]: 6 : for (i = 0; i < PyUnicode_GET_LENGTH(z); i++) {
12605 : 4 : key = PyLong_FromLong(PyUnicode_READ(z_kind, z_data, i));
12606 [ - + ]: 4 : if (!key)
12607 : 0 : goto err;
12608 : 4 : res = PyDict_SetItem(new, key, Py_None);
12609 : 4 : Py_DECREF(key);
12610 [ - + ]: 4 : if (res < 0)
12611 : 0 : goto err;
12612 : : }
12613 : : }
12614 : : } else {
12615 : : int kind;
12616 : : const void *data;
12617 : :
12618 : : /* x must be a dict */
12619 [ - + ]: 111 : if (!PyDict_CheckExact(x)) {
12620 : 0 : PyErr_SetString(PyExc_TypeError, "if you give only one argument "
12621 : : "to maketrans it must be a dict");
12622 : 0 : goto err;
12623 : : }
12624 : : /* copy entries into the new dict, converting string keys to int keys */
12625 [ + + ]: 749 : while (PyDict_Next(x, &i, &key, &value)) {
12626 [ + + ]: 640 : if (PyUnicode_Check(key)) {
12627 : : /* convert string keys to integer keys */
12628 : : PyObject *newkey;
12629 [ + + ]: 639 : if (PyUnicode_GET_LENGTH(key) != 1) {
12630 : 1 : PyErr_SetString(PyExc_ValueError, "string keys in translate "
12631 : : "table must be of length 1");
12632 : 1 : goto err;
12633 : : }
12634 : 638 : kind = PyUnicode_KIND(key);
12635 : 638 : data = PyUnicode_DATA(key);
12636 : 638 : newkey = PyLong_FromLong(PyUnicode_READ(kind, data, 0));
12637 [ - + ]: 638 : if (!newkey)
12638 : 0 : goto err;
12639 : 638 : res = PyDict_SetItem(new, newkey, value);
12640 : 638 : Py_DECREF(newkey);
12641 [ - + ]: 638 : if (res < 0)
12642 : 0 : goto err;
12643 [ - + ]: 1 : } else if (PyLong_Check(key)) {
12644 : : /* just keep integer keys */
12645 [ # # ]: 0 : if (PyDict_SetItem(new, key, value) < 0)
12646 : 0 : goto err;
12647 : : } else {
12648 : 1 : PyErr_SetString(PyExc_TypeError, "keys in translate table must "
12649 : : "be strings or integers");
12650 : 1 : goto err;
12651 : : }
12652 : : }
12653 : : }
12654 : 134 : return new;
12655 : 4 : err:
12656 : 4 : Py_DECREF(new);
12657 : 4 : return NULL;
12658 : : }
12659 : :
12660 : : /*[clinic input]
12661 : : str.translate as unicode_translate
12662 : :
12663 : : table: object
12664 : : Translation table, which must be a mapping of Unicode ordinals to
12665 : : Unicode ordinals, strings, or None.
12666 : : /
12667 : :
12668 : : Replace each character in the string using the given translation table.
12669 : :
12670 : : The table must implement lookup/indexing via __getitem__, for instance a
12671 : : dictionary or list. If this operation raises LookupError, the character is
12672 : : left untouched. Characters mapped to None are deleted.
12673 : : [clinic start generated code]*/
12674 : :
12675 : : static PyObject *
12676 : 98282 : unicode_translate(PyObject *self, PyObject *table)
12677 : : /*[clinic end generated code: output=3cb448ff2fd96bf3 input=6d38343db63d8eb0]*/
12678 : : {
12679 : 98282 : return _PyUnicode_TranslateCharmap(self, table, "ignore");
12680 : : }
12681 : :
12682 : : /*[clinic input]
12683 : : str.upper as unicode_upper
12684 : :
12685 : : Return a copy of the string converted to uppercase.
12686 : : [clinic start generated code]*/
12687 : :
12688 : : static PyObject *
12689 : 3411960 : unicode_upper_impl(PyObject *self)
12690 : : /*[clinic end generated code: output=1b7ddd16bbcdc092 input=db3d55682dfe2e6c]*/
12691 : : {
12692 [ + + ]: 3411960 : if (PyUnicode_IS_ASCII(self))
12693 : 62907 : return ascii_upper_or_lower(self, 0);
12694 : 3349053 : return case_operation(self, do_upper);
12695 : : }
12696 : :
12697 : : /*[clinic input]
12698 : : str.zfill as unicode_zfill
12699 : :
12700 : : width: Py_ssize_t
12701 : : /
12702 : :
12703 : : Pad a numeric string with zeros on the left, to fill a field of the given width.
12704 : :
12705 : : The string is never truncated.
12706 : : [clinic start generated code]*/
12707 : :
12708 : : static PyObject *
12709 : 176 : unicode_zfill_impl(PyObject *self, Py_ssize_t width)
12710 : : /*[clinic end generated code: output=e13fb6bdf8e3b9df input=c6b2f772c6f27799]*/
12711 : : {
12712 : : Py_ssize_t fill;
12713 : : PyObject *u;
12714 : : int kind;
12715 : : const void *data;
12716 : : Py_UCS4 chr;
12717 : :
12718 [ + + ]: 176 : if (PyUnicode_GET_LENGTH(self) >= width)
12719 : 21 : return unicode_result_unchanged(self);
12720 : :
12721 : 155 : fill = width - PyUnicode_GET_LENGTH(self);
12722 : :
12723 : 155 : u = pad(self, fill, 0, '0');
12724 : :
12725 [ - + ]: 155 : if (u == NULL)
12726 : 0 : return NULL;
12727 : :
12728 : 155 : kind = PyUnicode_KIND(u);
12729 : 155 : data = PyUnicode_DATA(u);
12730 : 155 : chr = PyUnicode_READ(kind, data, fill);
12731 : :
12732 [ + + + + ]: 155 : if (chr == '+' || chr == '-') {
12733 : : /* move sign to beginning of string */
12734 : 5 : PyUnicode_WRITE(kind, data, 0, chr);
12735 : 5 : PyUnicode_WRITE(kind, data, fill, '0');
12736 : : }
12737 : :
12738 : : assert(_PyUnicode_CheckConsistency(u, 1));
12739 : 155 : return u;
12740 : : }
12741 : :
12742 : : PyDoc_STRVAR(startswith__doc__,
12743 : : "S.startswith(prefix[, start[, end]]) -> bool\n\
12744 : : \n\
12745 : : Return True if S starts with the specified prefix, False otherwise.\n\
12746 : : With optional start, test S beginning at that position.\n\
12747 : : With optional end, stop comparing S at that position.\n\
12748 : : prefix can also be a tuple of strings to try.");
12749 : :
12750 : : static PyObject *
12751 : 8983485 : unicode_startswith(PyObject *self,
12752 : : PyObject *args)
12753 : : {
12754 : : PyObject *subobj;
12755 : : PyObject *substring;
12756 : 8983485 : Py_ssize_t start = 0;
12757 : 8983485 : Py_ssize_t end = PY_SSIZE_T_MAX;
12758 : : int result;
12759 : :
12760 [ + + ]: 8983485 : if (!asciilib_parse_args_finds("startswith", args, &subobj, &start, &end))
12761 : 3 : return NULL;
12762 [ + + ]: 8983482 : if (PyTuple_Check(subobj)) {
12763 : : Py_ssize_t i;
12764 [ + + ]: 394795 : for (i = 0; i < PyTuple_GET_SIZE(subobj); i++) {
12765 : 283191 : substring = PyTuple_GET_ITEM(subobj, i);
12766 [ + + ]: 283191 : if (!PyUnicode_Check(substring)) {
12767 : 2 : PyErr_Format(PyExc_TypeError,
12768 : : "tuple for startswith must only contain str, "
12769 : : "not %.100s",
12770 : 2 : Py_TYPE(substring)->tp_name);
12771 : 2 : return NULL;
12772 : : }
12773 : 283189 : result = tailmatch(self, substring, start, end, -1);
12774 [ - + ]: 283189 : if (result == -1)
12775 : 0 : return NULL;
12776 [ + + ]: 283189 : if (result) {
12777 : 1820 : Py_RETURN_TRUE;
12778 : : }
12779 : : }
12780 : : /* nothing matched */
12781 : 111604 : Py_RETURN_FALSE;
12782 : : }
12783 [ + + ]: 8870056 : if (!PyUnicode_Check(subobj)) {
12784 : 32 : PyErr_Format(PyExc_TypeError,
12785 : : "startswith first arg must be str or "
12786 : 32 : "a tuple of str, not %.100s", Py_TYPE(subobj)->tp_name);
12787 : 32 : return NULL;
12788 : : }
12789 : 8870024 : result = tailmatch(self, subobj, start, end, -1);
12790 [ - + ]: 8870024 : if (result == -1)
12791 : 0 : return NULL;
12792 : 8870024 : return PyBool_FromLong(result);
12793 : : }
12794 : :
12795 : :
12796 : : PyDoc_STRVAR(endswith__doc__,
12797 : : "S.endswith(suffix[, start[, end]]) -> bool\n\
12798 : : \n\
12799 : : Return True if S ends with the specified suffix, False otherwise.\n\
12800 : : With optional start, test S beginning at that position.\n\
12801 : : With optional end, stop comparing S at that position.\n\
12802 : : suffix can also be a tuple of strings to try.");
12803 : :
12804 : : static PyObject *
12805 : 1827148 : unicode_endswith(PyObject *self,
12806 : : PyObject *args)
12807 : : {
12808 : : PyObject *subobj;
12809 : : PyObject *substring;
12810 : 1827148 : Py_ssize_t start = 0;
12811 : 1827148 : Py_ssize_t end = PY_SSIZE_T_MAX;
12812 : : int result;
12813 : :
12814 [ + + ]: 1827148 : if (!asciilib_parse_args_finds("endswith", args, &subobj, &start, &end))
12815 : 3 : return NULL;
12816 [ + + ]: 1827145 : if (PyTuple_Check(subobj)) {
12817 : : Py_ssize_t i;
12818 [ + + ]: 302163 : for (i = 0; i < PyTuple_GET_SIZE(subobj); i++) {
12819 : 241010 : substring = PyTuple_GET_ITEM(subobj, i);
12820 [ + + ]: 241010 : if (!PyUnicode_Check(substring)) {
12821 : 2 : PyErr_Format(PyExc_TypeError,
12822 : : "tuple for endswith must only contain str, "
12823 : : "not %.100s",
12824 : 2 : Py_TYPE(substring)->tp_name);
12825 : 2 : return NULL;
12826 : : }
12827 : 241008 : result = tailmatch(self, substring, start, end, +1);
12828 [ - + ]: 241008 : if (result == -1)
12829 : 0 : return NULL;
12830 [ + + ]: 241008 : if (result) {
12831 : 176166 : Py_RETURN_TRUE;
12832 : : }
12833 : : }
12834 : 61153 : Py_RETURN_FALSE;
12835 : : }
12836 [ + + ]: 1589824 : if (!PyUnicode_Check(subobj)) {
12837 : 3 : PyErr_Format(PyExc_TypeError,
12838 : : "endswith first arg must be str or "
12839 : 3 : "a tuple of str, not %.100s", Py_TYPE(subobj)->tp_name);
12840 : 3 : return NULL;
12841 : : }
12842 : 1589821 : result = tailmatch(self, subobj, start, end, +1);
12843 [ - + ]: 1589821 : if (result == -1)
12844 : 0 : return NULL;
12845 : 1589821 : return PyBool_FromLong(result);
12846 : : }
12847 : :
12848 : : static inline void
12849 : 15262806 : _PyUnicodeWriter_Update(_PyUnicodeWriter *writer)
12850 : : {
12851 : 15262806 : writer->maxchar = PyUnicode_MAX_CHAR_VALUE(writer->buffer);
12852 : 15262806 : writer->data = PyUnicode_DATA(writer->buffer);
12853 : :
12854 [ + + ]: 15262806 : if (!writer->readonly) {
12855 : 11627066 : writer->kind = PyUnicode_KIND(writer->buffer);
12856 : 11627066 : writer->size = PyUnicode_GET_LENGTH(writer->buffer);
12857 : : }
12858 : : else {
12859 : : /* use a value smaller than PyUnicode_1BYTE_KIND() so
12860 : : _PyUnicodeWriter_PrepareKind() will copy the buffer. */
12861 : 3635740 : writer->kind = 0;
12862 : : assert(writer->kind <= PyUnicode_1BYTE_KIND);
12863 : :
12864 : : /* Copy-on-write mode: set buffer size to 0 so
12865 : : * _PyUnicodeWriter_Prepare() will copy (and enlarge) the buffer on
12866 : : * next write. */
12867 : 3635740 : writer->size = 0;
12868 : : }
12869 : 15262806 : }
12870 : :
12871 : : void
12872 : 13847415 : _PyUnicodeWriter_Init(_PyUnicodeWriter *writer)
12873 : : {
12874 : 13847415 : memset(writer, 0, sizeof(*writer));
12875 : :
12876 : : /* ASCII is the bare minimum */
12877 : 13847415 : writer->min_char = 127;
12878 : :
12879 : : /* use a value smaller than PyUnicode_1BYTE_KIND() so
12880 : : _PyUnicodeWriter_PrepareKind() will copy the buffer. */
12881 : 13847415 : writer->kind = 0;
12882 : : assert(writer->kind <= PyUnicode_1BYTE_KIND);
12883 : 13847415 : }
12884 : :
12885 : : // Initialize _PyUnicodeWriter with initial buffer
12886 : : static inline void
12887 : 498098 : _PyUnicodeWriter_InitWithBuffer(_PyUnicodeWriter *writer, PyObject *buffer)
12888 : : {
12889 : 498098 : memset(writer, 0, sizeof(*writer));
12890 : 498098 : writer->buffer = buffer;
12891 : 498098 : _PyUnicodeWriter_Update(writer);
12892 : 498098 : writer->min_length = writer->size;
12893 : 498098 : }
12894 : :
12895 : : int
12896 : 11128970 : _PyUnicodeWriter_PrepareInternal(_PyUnicodeWriter *writer,
12897 : : Py_ssize_t length, Py_UCS4 maxchar)
12898 : : {
12899 : : Py_ssize_t newlen;
12900 : : PyObject *newbuffer;
12901 : :
12902 : : assert(maxchar <= MAX_UNICODE);
12903 : :
12904 : : /* ensure that the _PyUnicodeWriter_Prepare macro was used */
12905 : : assert((maxchar > writer->maxchar && length >= 0)
12906 : : || length > 0);
12907 : :
12908 [ - + ]: 11128970 : if (length > PY_SSIZE_T_MAX - writer->pos) {
12909 : : PyErr_NoMemory();
12910 : 0 : return -1;
12911 : : }
12912 : 11128970 : newlen = writer->pos + length;
12913 : :
12914 : 11128970 : maxchar = Py_MAX(maxchar, writer->min_char);
12915 : :
12916 [ + + ]: 11128970 : if (writer->buffer == NULL) {
12917 : : assert(!writer->readonly);
12918 [ + + ]: 10163531 : if (writer->overallocate
12919 [ + - ]: 8659693 : && newlen <= (PY_SSIZE_T_MAX - newlen / OVERALLOCATE_FACTOR)) {
12920 : : /* overallocate to limit the number of realloc() */
12921 : 8659693 : newlen += newlen / OVERALLOCATE_FACTOR;
12922 : : }
12923 [ + + ]: 10163531 : if (newlen < writer->min_length)
12924 : 9233814 : newlen = writer->min_length;
12925 : :
12926 : 10163531 : writer->buffer = PyUnicode_New(newlen, maxchar);
12927 [ + + ]: 10163531 : if (writer->buffer == NULL)
12928 : 2 : return -1;
12929 : : }
12930 [ + + ]: 965439 : else if (newlen > writer->size) {
12931 [ + + ]: 396496 : if (writer->overallocate
12932 [ + - ]: 296955 : && newlen <= (PY_SSIZE_T_MAX - newlen / OVERALLOCATE_FACTOR)) {
12933 : : /* overallocate to limit the number of realloc() */
12934 : 296955 : newlen += newlen / OVERALLOCATE_FACTOR;
12935 : : }
12936 [ - + ]: 396496 : if (newlen < writer->min_length)
12937 : 0 : newlen = writer->min_length;
12938 : :
12939 [ + + + + ]: 396496 : if (maxchar > writer->maxchar || writer->readonly) {
12940 : : /* resize + widen */
12941 : 830 : maxchar = Py_MAX(maxchar, writer->maxchar);
12942 : 830 : newbuffer = PyUnicode_New(newlen, maxchar);
12943 [ - + ]: 830 : if (newbuffer == NULL)
12944 : 0 : return -1;
12945 : 830 : _PyUnicode_FastCopyCharacters(newbuffer, 0,
12946 : : writer->buffer, 0, writer->pos);
12947 : 830 : Py_DECREF(writer->buffer);
12948 : 830 : writer->readonly = 0;
12949 : : }
12950 : : else {
12951 : 395666 : newbuffer = resize_compact(writer->buffer, newlen);
12952 [ - + ]: 395666 : if (newbuffer == NULL)
12953 : 0 : return -1;
12954 : : }
12955 : 396496 : writer->buffer = newbuffer;
12956 : : }
12957 [ + - ]: 568943 : else if (maxchar > writer->maxchar) {
12958 : : assert(!writer->readonly);
12959 : 568943 : newbuffer = PyUnicode_New(writer->size, maxchar);
12960 [ - + ]: 568943 : if (newbuffer == NULL)
12961 : 0 : return -1;
12962 : 568943 : _PyUnicode_FastCopyCharacters(newbuffer, 0,
12963 : : writer->buffer, 0, writer->pos);
12964 : 568943 : Py_SETREF(writer->buffer, newbuffer);
12965 : : }
12966 : 11128968 : _PyUnicodeWriter_Update(writer);
12967 : 11128968 : return 0;
12968 : :
12969 : : #undef OVERALLOCATE_FACTOR
12970 : : }
12971 : :
12972 : : int
12973 : 7926 : _PyUnicodeWriter_PrepareKindInternal(_PyUnicodeWriter *writer,
12974 : : int kind)
12975 : : {
12976 : : Py_UCS4 maxchar;
12977 : :
12978 : : /* ensure that the _PyUnicodeWriter_PrepareKind macro was used */
12979 : : assert(writer->kind < kind);
12980 : :
12981 [ - + - - ]: 7926 : switch (kind)
12982 : : {
12983 : 0 : case PyUnicode_1BYTE_KIND: maxchar = 0xff; break;
12984 : 7926 : case PyUnicode_2BYTE_KIND: maxchar = 0xffff; break;
12985 : 0 : case PyUnicode_4BYTE_KIND: maxchar = MAX_UNICODE; break;
12986 : 0 : default:
12987 : 0 : Py_UNREACHABLE();
12988 : : }
12989 : :
12990 : 7926 : return _PyUnicodeWriter_PrepareInternal(writer, 0, maxchar);
12991 : : }
12992 : :
12993 : : static inline int
12994 : 2585746 : _PyUnicodeWriter_WriteCharInline(_PyUnicodeWriter *writer, Py_UCS4 ch)
12995 : : {
12996 : : assert(ch <= MAX_UNICODE);
12997 [ + + + + : 2585746 : if (_PyUnicodeWriter_Prepare(writer, 1, ch) < 0)
- + ]
12998 : 0 : return -1;
12999 : 2585746 : PyUnicode_WRITE(writer->kind, writer->data, writer->pos, ch);
13000 : 2585746 : writer->pos++;
13001 : 2585746 : return 0;
13002 : : }
13003 : :
13004 : : int
13005 : 1614710 : _PyUnicodeWriter_WriteChar(_PyUnicodeWriter *writer, Py_UCS4 ch)
13006 : : {
13007 : 1614710 : return _PyUnicodeWriter_WriteCharInline(writer, ch);
13008 : : }
13009 : :
13010 : : int
13011 : 18240355 : _PyUnicodeWriter_WriteStr(_PyUnicodeWriter *writer, PyObject *str)
13012 : : {
13013 : : Py_UCS4 maxchar;
13014 : : Py_ssize_t len;
13015 : :
13016 : 18240355 : len = PyUnicode_GET_LENGTH(str);
13017 [ + + ]: 18240355 : if (len == 0)
13018 : 111616 : return 0;
13019 : 18128739 : maxchar = PyUnicode_MAX_CHAR_VALUE(str);
13020 [ + + + + ]: 18128739 : if (maxchar > writer->maxchar || len > writer->size - writer->pos) {
13021 [ + + + + ]: 1098765 : if (writer->buffer == NULL && !writer->overallocate) {
13022 : : assert(_PyUnicode_CheckConsistency(str, 1));
13023 : 283101 : writer->readonly = 1;
13024 : 283101 : Py_INCREF(str);
13025 : 283101 : writer->buffer = str;
13026 : 283101 : _PyUnicodeWriter_Update(writer);
13027 : 283101 : writer->pos += len;
13028 : 283101 : return 0;
13029 : : }
13030 [ - + ]: 815664 : if (_PyUnicodeWriter_PrepareInternal(writer, len, maxchar) == -1)
13031 : 0 : return -1;
13032 : : }
13033 : 17845638 : _PyUnicode_FastCopyCharacters(writer->buffer, writer->pos,
13034 : : str, 0, len);
13035 : 17845638 : writer->pos += len;
13036 : 17845638 : return 0;
13037 : : }
13038 : :
13039 : : int
13040 : 2449847 : _PyUnicodeWriter_WriteSubstring(_PyUnicodeWriter *writer, PyObject *str,
13041 : : Py_ssize_t start, Py_ssize_t end)
13042 : : {
13043 : : Py_UCS4 maxchar;
13044 : : Py_ssize_t len;
13045 : :
13046 : : assert(0 <= start);
13047 : : assert(end <= PyUnicode_GET_LENGTH(str));
13048 : : assert(start <= end);
13049 : :
13050 [ - + ]: 2449847 : if (end == 0)
13051 : 0 : return 0;
13052 : :
13053 [ + + + + ]: 2449847 : if (start == 0 && end == PyUnicode_GET_LENGTH(str))
13054 : 940 : return _PyUnicodeWriter_WriteStr(writer, str);
13055 : :
13056 [ + + ]: 2448907 : if (PyUnicode_MAX_CHAR_VALUE(str) > writer->maxchar)
13057 : 833186 : maxchar = _PyUnicode_FindMaxChar(str, start, end);
13058 : : else
13059 : 1615721 : maxchar = writer->maxchar;
13060 : 2448907 : len = end - start;
13061 : :
13062 [ + + + + : 2448907 : if (_PyUnicodeWriter_Prepare(writer, len, maxchar) < 0)
+ - - + ]
13063 : 0 : return -1;
13064 : :
13065 : 2448907 : _PyUnicode_FastCopyCharacters(writer->buffer, writer->pos,
13066 : : str, start, len);
13067 : 2448907 : writer->pos += len;
13068 : 2448907 : return 0;
13069 : : }
13070 : :
13071 : : int
13072 : 26970248 : _PyUnicodeWriter_WriteASCIIString(_PyUnicodeWriter *writer,
13073 : : const char *ascii, Py_ssize_t len)
13074 : : {
13075 [ + + ]: 26970248 : if (len == -1)
13076 : 7883 : len = strlen(ascii);
13077 : :
13078 : : assert(ucs1lib_find_max_char((const Py_UCS1*)ascii, (const Py_UCS1*)ascii + len) < 128);
13079 : :
13080 [ + + + + ]: 26970248 : if (writer->buffer == NULL && !writer->overallocate) {
13081 : : PyObject *str;
13082 : :
13083 : 3352639 : str = _PyUnicode_FromASCII(ascii, len);
13084 [ - + ]: 3352639 : if (str == NULL)
13085 : 0 : return -1;
13086 : :
13087 : 3352639 : writer->readonly = 1;
13088 : 3352639 : writer->buffer = str;
13089 : 3352639 : _PyUnicodeWriter_Update(writer);
13090 : 3352639 : writer->pos += len;
13091 : 3352639 : return 0;
13092 : : }
13093 : :
13094 [ + + + + : 23617609 : if (_PyUnicodeWriter_Prepare(writer, len, 127) == -1)
+ - + + ]
13095 : 2 : return -1;
13096 : :
13097 [ + + + - ]: 23617607 : switch (writer->kind)
13098 : : {
13099 : 23616590 : case PyUnicode_1BYTE_KIND:
13100 : : {
13101 : 23616590 : const Py_UCS1 *str = (const Py_UCS1 *)ascii;
13102 : 23616590 : Py_UCS1 *data = writer->data;
13103 : :
13104 : 23616590 : memcpy(data + writer->pos, str, len);
13105 : 23616590 : break;
13106 : : }
13107 : 817 : case PyUnicode_2BYTE_KIND:
13108 : : {
13109 [ + + + + ]: 2451 : _PyUnicode_CONVERT_BYTES(
13110 : : Py_UCS1, Py_UCS2,
13111 : : ascii, ascii + len,
13112 : : (Py_UCS2 *)writer->data + writer->pos);
13113 : 817 : break;
13114 : : }
13115 : 200 : case PyUnicode_4BYTE_KIND:
13116 : : {
13117 [ + + + + ]: 574 : _PyUnicode_CONVERT_BYTES(
13118 : : Py_UCS1, Py_UCS4,
13119 : : ascii, ascii + len,
13120 : : (Py_UCS4 *)writer->data + writer->pos);
13121 : 200 : break;
13122 : : }
13123 : 0 : default:
13124 : 0 : Py_UNREACHABLE();
13125 : : }
13126 : :
13127 : 23617607 : writer->pos += len;
13128 : 23617607 : return 0;
13129 : : }
13130 : :
13131 : : int
13132 : 3 : _PyUnicodeWriter_WriteLatin1String(_PyUnicodeWriter *writer,
13133 : : const char *str, Py_ssize_t len)
13134 : : {
13135 : : Py_UCS4 maxchar;
13136 : :
13137 : 3 : maxchar = ucs1lib_find_max_char((const Py_UCS1*)str, (const Py_UCS1*)str + len);
13138 [ - + - - : 3 : if (_PyUnicodeWriter_Prepare(writer, len, maxchar) == -1)
+ - - + ]
13139 : 0 : return -1;
13140 : 3 : unicode_write_cstr(writer->buffer, writer->pos, str, len);
13141 : 3 : writer->pos += len;
13142 : 3 : return 0;
13143 : : }
13144 : :
13145 : : PyObject *
13146 : 14301495 : _PyUnicodeWriter_Finish(_PyUnicodeWriter *writer)
13147 : : {
13148 : : PyObject *str;
13149 : :
13150 [ + + ]: 14301495 : if (writer->pos == 0) {
13151 [ + + ]: 58487 : Py_CLEAR(writer->buffer);
13152 : 58487 : _Py_RETURN_UNICODE_EMPTY();
13153 : : }
13154 : :
13155 : 14243008 : str = writer->buffer;
13156 : 14243008 : writer->buffer = NULL;
13157 : :
13158 [ + + ]: 14243008 : if (writer->readonly) {
13159 : : assert(PyUnicode_GET_LENGTH(str) == writer->pos);
13160 : 3635539 : return str;
13161 : : }
13162 : :
13163 [ + + ]: 10607469 : if (PyUnicode_GET_LENGTH(str) != writer->pos) {
13164 : : PyObject *str2;
13165 : 9772092 : str2 = resize_compact(str, writer->pos);
13166 [ - + ]: 9772092 : if (str2 == NULL) {
13167 : 0 : Py_DECREF(str);
13168 : 0 : return NULL;
13169 : : }
13170 : 9772092 : str = str2;
13171 : : }
13172 : :
13173 : : assert(_PyUnicode_CheckConsistency(str, 1));
13174 : 10607469 : return unicode_result(str);
13175 : : }
13176 : :
13177 : : void
13178 : 10230 : _PyUnicodeWriter_Dealloc(_PyUnicodeWriter *writer)
13179 : : {
13180 [ + + ]: 10230 : Py_CLEAR(writer->buffer);
13181 : 10230 : }
13182 : :
13183 : : #include "stringlib/unicode_format.h"
13184 : :
13185 : : PyDoc_STRVAR(format__doc__,
13186 : : "S.format(*args, **kwargs) -> str\n\
13187 : : \n\
13188 : : Return a formatted version of S, using substitutions from args and kwargs.\n\
13189 : : The substitutions are identified by braces ('{' and '}').");
13190 : :
13191 : : PyDoc_STRVAR(format_map__doc__,
13192 : : "S.format_map(mapping) -> str\n\
13193 : : \n\
13194 : : Return a formatted version of S, using substitutions from mapping.\n\
13195 : : The substitutions are identified by braces ('{' and '}').");
13196 : :
13197 : : /*[clinic input]
13198 : : str.__format__ as unicode___format__
13199 : :
13200 : : format_spec: unicode
13201 : : /
13202 : :
13203 : : Return a formatted version of the string as described by format_spec.
13204 : : [clinic start generated code]*/
13205 : :
13206 : : static PyObject *
13207 : 7931 : unicode___format___impl(PyObject *self, PyObject *format_spec)
13208 : : /*[clinic end generated code: output=45fceaca6d2ba4c8 input=5e135645d167a214]*/
13209 : : {
13210 : : _PyUnicodeWriter writer;
13211 : : int ret;
13212 : :
13213 : 7931 : _PyUnicodeWriter_Init(&writer);
13214 : 7931 : ret = _PyUnicode_FormatAdvancedWriter(&writer,
13215 : : self, format_spec, 0,
13216 : : PyUnicode_GET_LENGTH(format_spec));
13217 [ + + ]: 7931 : if (ret == -1) {
13218 : 6 : _PyUnicodeWriter_Dealloc(&writer);
13219 : 6 : return NULL;
13220 : : }
13221 : 7925 : return _PyUnicodeWriter_Finish(&writer);
13222 : : }
13223 : :
13224 : : /*[clinic input]
13225 : : str.__sizeof__ as unicode_sizeof
13226 : :
13227 : : Return the size of the string in memory, in bytes.
13228 : : [clinic start generated code]*/
13229 : :
13230 : : static PyObject *
13231 : 12 : unicode_sizeof_impl(PyObject *self)
13232 : : /*[clinic end generated code: output=6dbc2f5a408b6d4f input=6dd011c108e33fb0]*/
13233 : : {
13234 : : Py_ssize_t size;
13235 : :
13236 : : /* If it's a compact object, account for base structure +
13237 : : character data. */
13238 [ + + ]: 12 : if (PyUnicode_IS_COMPACT_ASCII(self)) {
13239 : 2 : size = sizeof(PyASCIIObject) + PyUnicode_GET_LENGTH(self) + 1;
13240 : : }
13241 [ + - ]: 10 : else if (PyUnicode_IS_COMPACT(self)) {
13242 : 10 : size = sizeof(PyCompactUnicodeObject) +
13243 : 10 : (PyUnicode_GET_LENGTH(self) + 1) * PyUnicode_KIND(self);
13244 : : }
13245 : : else {
13246 : : /* If it is a two-block object, account for base object, and
13247 : : for character block if present. */
13248 : 0 : size = sizeof(PyUnicodeObject);
13249 [ # # ]: 0 : if (_PyUnicode_DATA_ANY(self))
13250 : 0 : size += (PyUnicode_GET_LENGTH(self) + 1) *
13251 : 0 : PyUnicode_KIND(self);
13252 : : }
13253 [ + + + + : 12 : if (_PyUnicode_HAS_UTF8_MEMORY(self))
+ - ]
13254 [ - + ]: 1 : size += PyUnicode_UTF8_LENGTH(self) + 1;
13255 : :
13256 : 12 : return PyLong_FromSsize_t(size);
13257 : : }
13258 : :
13259 : : static PyObject *
13260 : 121 : unicode_getnewargs(PyObject *v, PyObject *Py_UNUSED(ignored))
13261 : : {
13262 : 121 : PyObject *copy = _PyUnicode_Copy(v);
13263 [ - + ]: 121 : if (!copy)
13264 : 0 : return NULL;
13265 : 121 : return Py_BuildValue("(N)", copy);
13266 : : }
13267 : :
13268 : : static PyMethodDef unicode_methods[] = {
13269 : : UNICODE_ENCODE_METHODDEF
13270 : : UNICODE_REPLACE_METHODDEF
13271 : : UNICODE_SPLIT_METHODDEF
13272 : : UNICODE_RSPLIT_METHODDEF
13273 : : UNICODE_JOIN_METHODDEF
13274 : : UNICODE_CAPITALIZE_METHODDEF
13275 : : UNICODE_CASEFOLD_METHODDEF
13276 : : UNICODE_TITLE_METHODDEF
13277 : : UNICODE_CENTER_METHODDEF
13278 : : {"count", (PyCFunction) unicode_count, METH_VARARGS, count__doc__},
13279 : : UNICODE_EXPANDTABS_METHODDEF
13280 : : {"find", (PyCFunction) unicode_find, METH_VARARGS, find__doc__},
13281 : : UNICODE_PARTITION_METHODDEF
13282 : : {"index", (PyCFunction) unicode_index, METH_VARARGS, index__doc__},
13283 : : UNICODE_LJUST_METHODDEF
13284 : : UNICODE_LOWER_METHODDEF
13285 : : UNICODE_LSTRIP_METHODDEF
13286 : : {"rfind", (PyCFunction) unicode_rfind, METH_VARARGS, rfind__doc__},
13287 : : {"rindex", (PyCFunction) unicode_rindex, METH_VARARGS, rindex__doc__},
13288 : : UNICODE_RJUST_METHODDEF
13289 : : UNICODE_RSTRIP_METHODDEF
13290 : : UNICODE_RPARTITION_METHODDEF
13291 : : UNICODE_SPLITLINES_METHODDEF
13292 : : UNICODE_STRIP_METHODDEF
13293 : : UNICODE_SWAPCASE_METHODDEF
13294 : : UNICODE_TRANSLATE_METHODDEF
13295 : : UNICODE_UPPER_METHODDEF
13296 : : {"startswith", (PyCFunction) unicode_startswith, METH_VARARGS, startswith__doc__},
13297 : : {"endswith", (PyCFunction) unicode_endswith, METH_VARARGS, endswith__doc__},
13298 : : UNICODE_REMOVEPREFIX_METHODDEF
13299 : : UNICODE_REMOVESUFFIX_METHODDEF
13300 : : UNICODE_ISASCII_METHODDEF
13301 : : UNICODE_ISLOWER_METHODDEF
13302 : : UNICODE_ISUPPER_METHODDEF
13303 : : UNICODE_ISTITLE_METHODDEF
13304 : : UNICODE_ISSPACE_METHODDEF
13305 : : UNICODE_ISDECIMAL_METHODDEF
13306 : : UNICODE_ISDIGIT_METHODDEF
13307 : : UNICODE_ISNUMERIC_METHODDEF
13308 : : UNICODE_ISALPHA_METHODDEF
13309 : : UNICODE_ISALNUM_METHODDEF
13310 : : UNICODE_ISIDENTIFIER_METHODDEF
13311 : : UNICODE_ISPRINTABLE_METHODDEF
13312 : : UNICODE_ZFILL_METHODDEF
13313 : : {"format", _PyCFunction_CAST(do_string_format), METH_VARARGS | METH_KEYWORDS, format__doc__},
13314 : : {"format_map", (PyCFunction) do_string_format_map, METH_O, format_map__doc__},
13315 : : UNICODE___FORMAT___METHODDEF
13316 : : UNICODE_MAKETRANS_METHODDEF
13317 : : UNICODE_SIZEOF_METHODDEF
13318 : : {"__getnewargs__", unicode_getnewargs, METH_NOARGS},
13319 : : {NULL, NULL}
13320 : : };
13321 : :
13322 : : static PyObject *
13323 : 1226230 : unicode_mod(PyObject *v, PyObject *w)
13324 : : {
13325 [ - + ]: 1226230 : if (!PyUnicode_Check(v))
13326 : 0 : Py_RETURN_NOTIMPLEMENTED;
13327 : 1226230 : return PyUnicode_Format(v, w);
13328 : : }
13329 : :
13330 : : static PyNumberMethods unicode_as_number = {
13331 : : 0, /*nb_add*/
13332 : : 0, /*nb_subtract*/
13333 : : 0, /*nb_multiply*/
13334 : : unicode_mod, /*nb_remainder*/
13335 : : };
13336 : :
13337 : : static PySequenceMethods unicode_as_sequence = {
13338 : : (lenfunc) unicode_length, /* sq_length */
13339 : : PyUnicode_Concat, /* sq_concat */
13340 : : (ssizeargfunc) unicode_repeat, /* sq_repeat */
13341 : : (ssizeargfunc) unicode_getitem, /* sq_item */
13342 : : 0, /* sq_slice */
13343 : : 0, /* sq_ass_item */
13344 : : 0, /* sq_ass_slice */
13345 : : PyUnicode_Contains, /* sq_contains */
13346 : : };
13347 : :
13348 : : static PyObject*
13349 : 80298900 : unicode_subscript(PyObject* self, PyObject* item)
13350 : : {
13351 [ + + ]: 80298900 : if (_PyIndex_Check(item)) {
13352 : 55444481 : Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError);
13353 [ + + + + ]: 55444481 : if (i == -1 && PyErr_Occurred())
13354 : 2 : return NULL;
13355 [ + + ]: 55444479 : if (i < 0)
13356 : 992285 : i += PyUnicode_GET_LENGTH(self);
13357 : 55444479 : return unicode_getitem(self, i);
13358 [ + + ]: 24854419 : } else if (PySlice_Check(item)) {
13359 : : Py_ssize_t start, stop, step, slicelength, i;
13360 : : size_t cur;
13361 : : PyObject *result;
13362 : : const void *src_data;
13363 : : void *dest_data;
13364 : : int src_kind, dest_kind;
13365 : : Py_UCS4 ch, max_char, kind_limit;
13366 : :
13367 [ + + ]: 24854407 : if (PySlice_Unpack(item, &start, &stop, &step) < 0) {
13368 : 2 : return NULL;
13369 : : }
13370 : 24854405 : slicelength = PySlice_AdjustIndices(PyUnicode_GET_LENGTH(self),
13371 : : &start, &stop, step);
13372 : :
13373 [ + + ]: 24854405 : if (slicelength <= 0) {
13374 : 250164 : _Py_RETURN_UNICODE_EMPTY();
13375 [ + + + + : 39516581 : } else if (start == 0 && step == 1 &&
+ + ]
13376 : 14912340 : slicelength == PyUnicode_GET_LENGTH(self)) {
13377 : 8422426 : return unicode_result_unchanged(self);
13378 [ + + ]: 16181815 : } else if (step == 1) {
13379 : 16180308 : return PyUnicode_Substring(self,
13380 : : start, start + slicelength);
13381 : : }
13382 : : /* General case */
13383 : 1507 : src_kind = PyUnicode_KIND(self);
13384 : 1507 : src_data = PyUnicode_DATA(self);
13385 [ + + ]: 1507 : if (!PyUnicode_IS_ASCII(self)) {
13386 : 9 : kind_limit = kind_maxchar_limit(src_kind);
13387 : 9 : max_char = 0;
13388 [ + - ]: 9 : for (cur = start, i = 0; i < slicelength; cur += step, i++) {
13389 : 9 : ch = PyUnicode_READ(src_kind, src_data, cur);
13390 [ + - ]: 9 : if (ch > max_char) {
13391 : 9 : max_char = ch;
13392 [ + - ]: 9 : if (max_char >= kind_limit)
13393 : 9 : break;
13394 : : }
13395 : : }
13396 : : }
13397 : : else
13398 : 1498 : max_char = 127;
13399 : 1507 : result = PyUnicode_New(slicelength, max_char);
13400 [ - + ]: 1507 : if (result == NULL)
13401 : 0 : return NULL;
13402 : 1507 : dest_kind = PyUnicode_KIND(result);
13403 : 1507 : dest_data = PyUnicode_DATA(result);
13404 : :
13405 [ + + ]: 11529 : for (cur = start, i = 0; i < slicelength; cur += step, i++) {
13406 : 10022 : Py_UCS4 ch = PyUnicode_READ(src_kind, src_data, cur);
13407 : 10022 : PyUnicode_WRITE(dest_kind, dest_data, i, ch);
13408 : : }
13409 : : assert(_PyUnicode_CheckConsistency(result, 1));
13410 : 1507 : return result;
13411 : : } else {
13412 : 12 : PyErr_Format(PyExc_TypeError, "string indices must be integers, not '%.200s'",
13413 : 12 : Py_TYPE(item)->tp_name);
13414 : 12 : return NULL;
13415 : : }
13416 : : }
13417 : :
13418 : : static PyMappingMethods unicode_as_mapping = {
13419 : : (lenfunc)unicode_length, /* mp_length */
13420 : : (binaryfunc)unicode_subscript, /* mp_subscript */
13421 : : (objobjargproc)0, /* mp_ass_subscript */
13422 : : };
13423 : :
13424 : :
13425 : : /* Helpers for PyUnicode_Format() */
13426 : :
13427 : : struct unicode_formatter_t {
13428 : : PyObject *args;
13429 : : int args_owned;
13430 : : Py_ssize_t arglen, argidx;
13431 : : PyObject *dict;
13432 : :
13433 : : int fmtkind;
13434 : : Py_ssize_t fmtcnt, fmtpos;
13435 : : const void *fmtdata;
13436 : : PyObject *fmtstr;
13437 : :
13438 : : _PyUnicodeWriter writer;
13439 : : };
13440 : :
13441 : : struct unicode_format_arg_t {
13442 : : Py_UCS4 ch;
13443 : : int flags;
13444 : : Py_ssize_t width;
13445 : : int prec;
13446 : : int sign;
13447 : : };
13448 : :
13449 : : static PyObject *
13450 : 1814785 : unicode_format_getnextarg(struct unicode_formatter_t *ctx)
13451 : : {
13452 : 1814785 : Py_ssize_t argidx = ctx->argidx;
13453 : :
13454 [ + + ]: 1814785 : if (argidx < ctx->arglen) {
13455 : 1814765 : ctx->argidx++;
13456 [ + + ]: 1814765 : if (ctx->arglen < 0)
13457 : 990529 : return ctx->args;
13458 : : else
13459 : 824236 : return PyTuple_GetItem(ctx->args, argidx);
13460 : : }
13461 : 20 : PyErr_SetString(PyExc_TypeError,
13462 : : "not enough arguments for format string");
13463 : 20 : return NULL;
13464 : : }
13465 : :
13466 : : /* Returns a new reference to a PyUnicode object, or NULL on failure. */
13467 : :
13468 : : /* Format a float into the writer if the writer is not NULL, or into *p_output
13469 : : otherwise.
13470 : :
13471 : : Return 0 on success, raise an exception and return -1 on error. */
13472 : : static int
13473 : 44192 : formatfloat(PyObject *v, struct unicode_format_arg_t *arg,
13474 : : PyObject **p_output,
13475 : : _PyUnicodeWriter *writer)
13476 : : {
13477 : : char *p;
13478 : : double x;
13479 : : Py_ssize_t len;
13480 : : int prec;
13481 : 44192 : int dtoa_flags = 0;
13482 : :
13483 : 44192 : x = PyFloat_AsDouble(v);
13484 [ + + + + ]: 44192 : if (x == -1.0 && PyErr_Occurred())
13485 : 2 : return -1;
13486 : :
13487 : 44190 : prec = arg->prec;
13488 [ + + ]: 44190 : if (prec < 0)
13489 : 8976 : prec = 6;
13490 : :
13491 [ + + ]: 44190 : if (arg->flags & F_ALT)
13492 : 10974 : dtoa_flags |= Py_DTSF_ALT;
13493 [ - + ]: 44190 : if (arg->flags & F_NO_NEG_0)
13494 : 0 : dtoa_flags |= Py_DTSF_NO_NEG_0;
13495 : 44190 : p = PyOS_double_to_string(x, arg->ch, prec, dtoa_flags, NULL);
13496 [ - + ]: 44190 : if (p == NULL)
13497 : 0 : return -1;
13498 : 44190 : len = strlen(p);
13499 [ + + ]: 44190 : if (writer) {
13500 [ - + ]: 4700 : if (_PyUnicodeWriter_WriteASCIIString(writer, p, len) < 0) {
13501 : 0 : PyMem_Free(p);
13502 : 0 : return -1;
13503 : : }
13504 : : }
13505 : : else
13506 : 39490 : *p_output = _PyUnicode_FromASCII(p, len);
13507 : 44190 : PyMem_Free(p);
13508 : 44190 : return 0;
13509 : : }
13510 : :
13511 : : /* formatlong() emulates the format codes d, u, o, x and X, and
13512 : : * the F_ALT flag, for Python's long (unbounded) ints. It's not used for
13513 : : * Python's regular ints.
13514 : : * Return value: a new PyUnicodeObject*, or NULL if error.
13515 : : * The output string is of the form
13516 : : * "-"? ("0x" | "0X")? digit+
13517 : : * "0x"/"0X" are present only for x and X conversions, with F_ALT
13518 : : * set in flags. The case of hex digits will be correct,
13519 : : * There will be at least prec digits, zero-filled on the left if
13520 : : * necessary to get that many.
13521 : : * val object to be converted
13522 : : * flags bitmask of format flags; only F_ALT is looked at
13523 : : * prec minimum number of digits; 0-fill on left if needed
13524 : : * type a character in [duoxX]; u acts the same as d
13525 : : *
13526 : : * CAUTION: o, x and X conversions on regular ints can never
13527 : : * produce a '-' sign, but can for Python's unbounded ints.
13528 : : */
13529 : : PyObject *
13530 : 550422 : _PyUnicode_FormatLong(PyObject *val, int alt, int prec, int type)
13531 : : {
13532 : 550422 : PyObject *result = NULL;
13533 : : char *buf;
13534 : : Py_ssize_t i;
13535 : : int sign; /* 1 if '-', else 0 */
13536 : : int len; /* number of characters */
13537 : : Py_ssize_t llen;
13538 : : int numdigits; /* len == numnondigits + numdigits */
13539 : 550422 : int numnondigits = 0;
13540 : :
13541 : : /* Avoid exceeding SSIZE_T_MAX */
13542 [ - + ]: 550422 : if (prec > INT_MAX-3) {
13543 : 0 : PyErr_SetString(PyExc_OverflowError,
13544 : : "precision too large");
13545 : 0 : return NULL;
13546 : : }
13547 : :
13548 : : assert(PyLong_Check(val));
13549 : :
13550 [ - + + + ]: 550422 : switch (type) {
13551 : 0 : default:
13552 : 0 : Py_UNREACHABLE();
13553 : 78824 : case 'd':
13554 : : case 'i':
13555 : : case 'u':
13556 : : /* int and int subclasses should print numerically when a numeric */
13557 : : /* format code is used (see issue18780) */
13558 : 78824 : result = PyNumber_ToBase(val, 10);
13559 : 78824 : break;
13560 : 16147 : case 'o':
13561 : 16147 : numnondigits = 2;
13562 : 16147 : result = PyNumber_ToBase(val, 8);
13563 : 16147 : break;
13564 : 455451 : case 'x':
13565 : : case 'X':
13566 : 455451 : numnondigits = 2;
13567 : 455451 : result = PyNumber_ToBase(val, 16);
13568 : 455451 : break;
13569 : : }
13570 [ - + ]: 550422 : if (!result)
13571 : 0 : return NULL;
13572 : :
13573 : : assert(unicode_modifiable(result));
13574 : : assert(PyUnicode_IS_ASCII(result));
13575 : :
13576 : : /* To modify the string in-place, there can only be one reference. */
13577 [ - + ]: 550422 : if (Py_REFCNT(result) != 1) {
13578 : 0 : Py_DECREF(result);
13579 : 0 : PyErr_BadInternalCall();
13580 : 0 : return NULL;
13581 : : }
13582 : 550422 : buf = PyUnicode_DATA(result);
13583 : 550422 : llen = PyUnicode_GET_LENGTH(result);
13584 [ - + ]: 550422 : if (llen > INT_MAX) {
13585 : 0 : Py_DECREF(result);
13586 : 0 : PyErr_SetString(PyExc_ValueError,
13587 : : "string too large in _PyUnicode_FormatLong");
13588 : 0 : return NULL;
13589 : : }
13590 : 550422 : len = (int)llen;
13591 : 550422 : sign = buf[0] == '-';
13592 : 550422 : numnondigits += sign;
13593 : 550422 : numdigits = len - numnondigits;
13594 : : assert(numdigits > 0);
13595 : :
13596 : : /* Get rid of base marker unless F_ALT */
13597 [ + + + + ]: 550422 : if (((alt) == 0 &&
13598 [ + + + + ]: 527087 : (type == 'o' || type == 'x' || type == 'X'))) {
13599 : : assert(buf[sign] == '0');
13600 : : assert(buf[sign+1] == 'x' || buf[sign+1] == 'X' ||
13601 : : buf[sign+1] == 'o');
13602 : 468804 : numnondigits -= 2;
13603 : 468804 : buf += 2;
13604 : 468804 : len -= 2;
13605 [ + + ]: 468804 : if (sign)
13606 : 1370 : buf[0] = '-';
13607 : : assert(len == numnondigits + numdigits);
13608 : : assert(numdigits > 0);
13609 : : }
13610 : :
13611 : : /* Fill with leading zeroes to meet minimum width. */
13612 [ + + ]: 550422 : if (prec > numdigits) {
13613 : 6520 : PyObject *r1 = PyBytes_FromStringAndSize(NULL,
13614 : 6520 : numnondigits + prec);
13615 : : char *b1;
13616 [ - + ]: 6520 : if (!r1) {
13617 : 0 : Py_DECREF(result);
13618 : 0 : return NULL;
13619 : : }
13620 : 6520 : b1 = PyBytes_AS_STRING(r1);
13621 [ + + ]: 8620 : for (i = 0; i < numnondigits; ++i)
13622 : 2100 : *b1++ = *buf++;
13623 [ + + ]: 95526 : for (i = 0; i < prec - numdigits; i++)
13624 : 89006 : *b1++ = '0';
13625 [ + + ]: 30261 : for (i = 0; i < numdigits; i++)
13626 : 23741 : *b1++ = *buf++;
13627 : 6520 : *b1 = '\0';
13628 : 6520 : Py_DECREF(result);
13629 : 6520 : result = r1;
13630 : 6520 : buf = PyBytes_AS_STRING(result);
13631 : 6520 : len = numnondigits + prec;
13632 : : }
13633 : :
13634 : : /* Fix up case for hex conversions. */
13635 [ + + ]: 550422 : if (type == 'X') {
13636 : : /* Need to convert all lower case letters to upper case.
13637 : : and need to convert 0x to 0X (and -0x to -0X). */
13638 [ + + ]: 81951 : for (i = 0; i < len; i++)
13639 [ + + + - ]: 59025 : if (buf[i] >= 'a' && buf[i] <= 'x')
13640 : 18755 : buf[i] -= 'a'-'A';
13641 : : }
13642 [ + + ]: 550422 : if (!PyUnicode_Check(result)
13643 [ + + ]: 543902 : || buf != PyUnicode_DATA(result)) {
13644 : : PyObject *unicode;
13645 : 470820 : unicode = _PyUnicode_FromASCII(buf, len);
13646 : 470820 : Py_DECREF(result);
13647 : 470820 : result = unicode;
13648 : : }
13649 [ - + ]: 79602 : else if (len != PyUnicode_GET_LENGTH(result)) {
13650 [ # # ]: 0 : if (PyUnicode_Resize(&result, len) < 0)
13651 [ # # ]: 0 : Py_CLEAR(result);
13652 : : }
13653 : 550422 : return result;
13654 : : }
13655 : :
13656 : : /* Format an integer or a float as an integer.
13657 : : * Return 1 if the number has been formatted into the writer,
13658 : : * 0 if the number has been formatted into *p_output
13659 : : * -1 and raise an exception on error */
13660 : : static int
13661 : 1061633 : mainformatlong(PyObject *v,
13662 : : struct unicode_format_arg_t *arg,
13663 : : PyObject **p_output,
13664 : : _PyUnicodeWriter *writer)
13665 : : {
13666 : : PyObject *iobj, *res;
13667 : 1061633 : char type = (char)arg->ch;
13668 : :
13669 [ + + ]: 1061633 : if (!PyNumber_Check(v))
13670 : 112 : goto wrongtype;
13671 : :
13672 : : /* make sure number is a type of integer for o, x, and X */
13673 [ + + ]: 1061521 : if (!PyLong_Check(v)) {
13674 [ + + + + : 6519 : if (type == 'o' || type == 'x' || type == 'X') {
+ + ]
13675 : 9 : iobj = _PyNumber_Index(v);
13676 : : }
13677 : : else {
13678 : 6510 : iobj = PyNumber_Long(v);
13679 : : }
13680 [ + + ]: 6519 : if (iobj == NULL ) {
13681 [ + - ]: 8 : if (PyErr_ExceptionMatches(PyExc_TypeError))
13682 : 8 : goto wrongtype;
13683 : 0 : return -1;
13684 : : }
13685 : : assert(PyLong_Check(iobj));
13686 : : }
13687 : : else {
13688 : 1055002 : iobj = v;
13689 : 1055002 : Py_INCREF(iobj);
13690 : : }
13691 : :
13692 [ + + ]: 1061513 : if (PyLong_CheckExact(v)
13693 [ + + + + ]: 1054827 : && arg->width == -1 && arg->prec == -1
13694 [ + + ]: 524850 : && !(arg->flags & (F_SIGN | F_BLANK))
13695 [ + + ]: 511364 : && type != 'X')
13696 : : {
13697 : : /* Fast path */
13698 : 511277 : int alternate = arg->flags & F_ALT;
13699 : : int base;
13700 : :
13701 [ - + + + ]: 511277 : switch(type)
13702 : : {
13703 : 0 : default:
13704 : 0 : Py_UNREACHABLE();
13705 : 479426 : case 'd':
13706 : : case 'i':
13707 : : case 'u':
13708 : 479426 : base = 10;
13709 : 479426 : break;
13710 : 628 : case 'o':
13711 : 628 : base = 8;
13712 : 628 : break;
13713 : 31223 : case 'x':
13714 : : case 'X':
13715 : 31223 : base = 16;
13716 : 31223 : break;
13717 : : }
13718 : :
13719 [ - + ]: 511277 : if (_PyLong_FormatWriter(writer, v, base, alternate) == -1) {
13720 : 0 : Py_DECREF(iobj);
13721 : 0 : return -1;
13722 : : }
13723 : 511277 : Py_DECREF(iobj);
13724 : 511277 : return 1;
13725 : : }
13726 : :
13727 : 550236 : res = _PyUnicode_FormatLong(iobj, arg->flags & F_ALT, arg->prec, type);
13728 : 550236 : Py_DECREF(iobj);
13729 [ - + ]: 550236 : if (res == NULL)
13730 : 0 : return -1;
13731 : 550236 : *p_output = res;
13732 : 550236 : return 0;
13733 : :
13734 : 120 : wrongtype:
13735 [ + + ]: 120 : switch(type)
13736 : : {
13737 : 8 : case 'o':
13738 : : case 'x':
13739 : : case 'X':
13740 : 8 : PyErr_Format(PyExc_TypeError,
13741 : : "%%%c format: an integer is required, "
13742 : : "not %.200s",
13743 : 8 : type, Py_TYPE(v)->tp_name);
13744 : 8 : break;
13745 : 112 : default:
13746 : 112 : PyErr_Format(PyExc_TypeError,
13747 : : "%%%c format: a real number is required, "
13748 : : "not %.200s",
13749 : 112 : type, Py_TYPE(v)->tp_name);
13750 : 112 : break;
13751 : : }
13752 : 120 : return -1;
13753 : : }
13754 : :
13755 : : static Py_UCS4
13756 : 2255 : formatchar(PyObject *v)
13757 : : {
13758 : : /* presume that the buffer is at least 3 characters long */
13759 [ + + ]: 2255 : if (PyUnicode_Check(v)) {
13760 [ + + ]: 1521 : if (PyUnicode_GET_LENGTH(v) == 1) {
13761 : 1519 : return PyUnicode_READ_CHAR(v, 0);
13762 : : }
13763 : 2 : goto onError;
13764 : : }
13765 : : else {
13766 : : int overflow;
13767 : 734 : long x = PyLong_AsLongAndOverflow(v, &overflow);
13768 [ + + + + ]: 734 : if (x == -1 && PyErr_Occurred()) {
13769 [ + - ]: 5 : if (PyErr_ExceptionMatches(PyExc_TypeError)) {
13770 : 5 : goto onError;
13771 : : }
13772 : 729 : return (Py_UCS4) -1;
13773 : : }
13774 : :
13775 [ + + + + ]: 729 : if (x < 0 || x > MAX_UNICODE) {
13776 : : /* this includes an overflow in converting to C long */
13777 : 7 : PyErr_SetString(PyExc_OverflowError,
13778 : : "%c arg not in range(0x110000)");
13779 : 7 : return (Py_UCS4) -1;
13780 : : }
13781 : :
13782 : 722 : return (Py_UCS4) x;
13783 : : }
13784 : :
13785 : 7 : onError:
13786 : 7 : PyErr_SetString(PyExc_TypeError,
13787 : : "%c requires int or char");
13788 : 7 : return (Py_UCS4) -1;
13789 : : }
13790 : :
13791 : : /* Parse options of an argument: flags, width, precision.
13792 : : Handle also "%(name)" syntax.
13793 : :
13794 : : Return 0 if the argument has been formatted into arg->str.
13795 : : Return 1 if the argument has been written into ctx->writer,
13796 : : Raise an exception and return -1 on error. */
13797 : : static int
13798 : 1789378 : unicode_format_arg_parse(struct unicode_formatter_t *ctx,
13799 : : struct unicode_format_arg_t *arg)
13800 : : {
13801 : : #define FORMAT_READ(ctx) \
13802 : : PyUnicode_READ((ctx)->fmtkind, (ctx)->fmtdata, (ctx)->fmtpos)
13803 : :
13804 : : PyObject *v;
13805 : :
13806 [ + + ]: 1789378 : if (arg->ch == '(') {
13807 : : /* Get argument value from a dictionary. Example: "%(name)s". */
13808 : : Py_ssize_t keystart;
13809 : : Py_ssize_t keylen;
13810 : : PyObject *key;
13811 : 32982 : int pcount = 1;
13812 : :
13813 [ + + ]: 32982 : if (ctx->dict == NULL) {
13814 : 5 : PyErr_SetString(PyExc_TypeError,
13815 : : "format requires a mapping");
13816 : 5 : return -1;
13817 : : }
13818 : 32977 : ++ctx->fmtpos;
13819 : 32977 : --ctx->fmtcnt;
13820 : 32977 : keystart = ctx->fmtpos;
13821 : : /* Skip over balanced parentheses */
13822 [ + + + + ]: 217959 : while (pcount > 0 && --ctx->fmtcnt >= 0) {
13823 : 184982 : arg->ch = FORMAT_READ(ctx);
13824 [ + + ]: 184982 : if (arg->ch == ')')
13825 : 32976 : --pcount;
13826 [ + + ]: 152006 : else if (arg->ch == '(')
13827 : 2 : ++pcount;
13828 : 184982 : ctx->fmtpos++;
13829 : : }
13830 : 32977 : keylen = ctx->fmtpos - keystart - 1;
13831 [ + + - + ]: 32977 : if (ctx->fmtcnt < 0 || pcount > 0) {
13832 : 3 : PyErr_SetString(PyExc_ValueError,
13833 : : "incomplete format key");
13834 : 3 : return -1;
13835 : : }
13836 : 32974 : key = PyUnicode_Substring(ctx->fmtstr,
13837 : : keystart, keystart + keylen);
13838 [ - + ]: 32974 : if (key == NULL)
13839 : 0 : return -1;
13840 [ + + ]: 32974 : if (ctx->args_owned) {
13841 : 21988 : ctx->args_owned = 0;
13842 : 21988 : Py_DECREF(ctx->args);
13843 : : }
13844 : 32974 : ctx->args = PyObject_GetItem(ctx->dict, key);
13845 : 32974 : Py_DECREF(key);
13846 [ + + ]: 32974 : if (ctx->args == NULL)
13847 : 3 : return -1;
13848 : 32971 : ctx->args_owned = 1;
13849 : 32971 : ctx->arglen = -1;
13850 : 32971 : ctx->argidx = -2;
13851 : : }
13852 : :
13853 : : /* Parse flags. Example: "%+i" => flags=F_SIGN. */
13854 [ + + ]: 2333312 : while (--ctx->fmtcnt >= 0) {
13855 : 2333306 : arg->ch = FORMAT_READ(ctx);
13856 : 2333306 : ctx->fmtpos++;
13857 [ + + + + : 2333306 : switch (arg->ch) {
+ + ]
13858 : 21790 : case '-': arg->flags |= F_LJUST; continue;
13859 : 33816 : case '+': arg->flags |= F_SIGN; continue;
13860 : 20887 : case ' ': arg->flags |= F_BLANK; continue;
13861 : 21834 : case '#': arg->flags |= F_ALT; continue;
13862 : 445618 : case '0': arg->flags |= F_ZERO; continue;
13863 : : }
13864 : 1789361 : break;
13865 : : }
13866 : :
13867 : : /* Parse width. Example: "%10s" => width=10 */
13868 [ + + ]: 1789367 : if (arg->ch == '*') {
13869 : 25394 : v = unicode_format_getnextarg(ctx);
13870 [ - + ]: 25394 : if (v == NULL)
13871 : 0 : return -1;
13872 [ + + ]: 25394 : if (!PyLong_Check(v)) {
13873 : 4 : PyErr_SetString(PyExc_TypeError,
13874 : : "* wants int");
13875 : 4 : return -1;
13876 : : }
13877 : 25390 : arg->width = PyLong_AsSsize_t(v);
13878 [ + + + - ]: 25390 : if (arg->width == -1 && PyErr_Occurred())
13879 : 6 : return -1;
13880 [ + + ]: 25384 : if (arg->width < 0) {
13881 : 1 : arg->flags |= F_LJUST;
13882 : 1 : arg->width = -arg->width;
13883 : : }
13884 [ + - ]: 25384 : if (--ctx->fmtcnt >= 0) {
13885 : 25384 : arg->ch = FORMAT_READ(ctx);
13886 : 25384 : ctx->fmtpos++;
13887 : : }
13888 : : }
13889 [ + + + + ]: 1763973 : else if (arg->ch >= '0' && arg->ch <= '9') {
13890 : 463190 : arg->width = arg->ch - '0';
13891 [ + + ]: 481530 : while (--ctx->fmtcnt >= 0) {
13892 : 481528 : arg->ch = FORMAT_READ(ctx);
13893 : 481528 : ctx->fmtpos++;
13894 [ + + + + ]: 481528 : if (arg->ch < '0' || arg->ch > '9')
13895 : : break;
13896 : : /* Since arg->ch is unsigned, the RHS would end up as unsigned,
13897 : : mixing signed and unsigned comparison. Since arg->ch is between
13898 : : '0' and '9', casting to int is safe. */
13899 [ + + ]: 18343 : if (arg->width > (PY_SSIZE_T_MAX - ((int)arg->ch - '0')) / 10) {
13900 : 3 : PyErr_SetString(PyExc_ValueError,
13901 : : "width too big");
13902 : 3 : return -1;
13903 : : }
13904 : 18340 : arg->width = arg->width*10 + (arg->ch - '0');
13905 : : }
13906 : : }
13907 : :
13908 : : /* Parse precision. Example: "%.3f" => prec=3 */
13909 [ + + ]: 1789354 : if (arg->ch == '.') {
13910 : 116660 : arg->prec = 0;
13911 [ + - ]: 116660 : if (--ctx->fmtcnt >= 0) {
13912 : 116660 : arg->ch = FORMAT_READ(ctx);
13913 : 116660 : ctx->fmtpos++;
13914 : : }
13915 [ + + ]: 116660 : if (arg->ch == '*') {
13916 : 58 : v = unicode_format_getnextarg(ctx);
13917 [ - + ]: 58 : if (v == NULL)
13918 : 0 : return -1;
13919 [ + + ]: 58 : if (!PyLong_Check(v)) {
13920 : 2 : PyErr_SetString(PyExc_TypeError,
13921 : : "* wants int");
13922 : 2 : return -1;
13923 : : }
13924 : 56 : arg->prec = _PyLong_AsInt(v);
13925 [ + + + - ]: 56 : if (arg->prec == -1 && PyErr_Occurred())
13926 : 7 : return -1;
13927 [ - + ]: 49 : if (arg->prec < 0)
13928 : 0 : arg->prec = 0;
13929 [ + - ]: 49 : if (--ctx->fmtcnt >= 0) {
13930 : 49 : arg->ch = FORMAT_READ(ctx);
13931 : 49 : ctx->fmtpos++;
13932 : : }
13933 : : }
13934 [ + - + + ]: 116602 : else if (arg->ch >= '0' && arg->ch <= '9') {
13935 : 107662 : arg->prec = arg->ch - '0';
13936 [ + - ]: 124578 : while (--ctx->fmtcnt >= 0) {
13937 : 124578 : arg->ch = FORMAT_READ(ctx);
13938 : 124578 : ctx->fmtpos++;
13939 [ + - + + ]: 124578 : if (arg->ch < '0' || arg->ch > '9')
13940 : : break;
13941 [ + + ]: 16920 : if (arg->prec > (INT_MAX - ((int)arg->ch - '0')) / 10) {
13942 : 4 : PyErr_SetString(PyExc_ValueError,
13943 : : "precision too big");
13944 : 4 : return -1;
13945 : : }
13946 : 16916 : arg->prec = arg->prec*10 + (arg->ch - '0');
13947 : : }
13948 : : }
13949 : : }
13950 : :
13951 : : /* Ignore "h", "l" and "L" format prefix (ex: "%hi" or "%ls") */
13952 [ + + ]: 1789341 : if (ctx->fmtcnt >= 0) {
13953 [ + - + + : 1789333 : if (arg->ch == 'h' || arg->ch == 'l' || arg->ch == 'L') {
- + ]
13954 [ + - ]: 2 : if (--ctx->fmtcnt >= 0) {
13955 : 2 : arg->ch = FORMAT_READ(ctx);
13956 : 2 : ctx->fmtpos++;
13957 : : }
13958 : : }
13959 : : }
13960 [ + + ]: 1789341 : if (ctx->fmtcnt < 0) {
13961 : 8 : PyErr_SetString(PyExc_ValueError,
13962 : : "incomplete format");
13963 : 8 : return -1;
13964 : : }
13965 : 1789333 : return 0;
13966 : :
13967 : : #undef FORMAT_READ
13968 : : }
13969 : :
13970 : : /* Format one argument. Supported conversion specifiers:
13971 : :
13972 : : - "s", "r", "a": any type
13973 : : - "i", "d", "u": int or float
13974 : : - "o", "x", "X": int
13975 : : - "e", "E", "f", "F", "g", "G": float
13976 : : - "c": int or str (1 character)
13977 : :
13978 : : When possible, the output is written directly into the Unicode writer
13979 : : (ctx->writer). A string is created when padding is required.
13980 : :
13981 : : Return 0 if the argument has been formatted into *p_str,
13982 : : 1 if the argument has been written into ctx->writer,
13983 : : -1 on error. */
13984 : : static int
13985 : 1789333 : unicode_format_arg_format(struct unicode_formatter_t *ctx,
13986 : : struct unicode_format_arg_t *arg,
13987 : : PyObject **p_str)
13988 : : {
13989 : : PyObject *v;
13990 : 1789333 : _PyUnicodeWriter *writer = &ctx->writer;
13991 : :
13992 [ + + ]: 1789333 : if (ctx->fmtcnt == 0)
13993 : 808726 : ctx->writer.overallocate = 0;
13994 : :
13995 : 1789333 : v = unicode_format_getnextarg(ctx);
13996 [ + + ]: 1789333 : if (v == NULL)
13997 : 20 : return -1;
13998 : :
13999 : :
14000 [ + + + + : 1789313 : switch (arg->ch) {
+ ]
14001 : 681228 : case 's':
14002 : : case 'r':
14003 : : case 'a':
14004 [ + + + - : 681228 : if (PyLong_CheckExact(v) && arg->width == -1 && arg->prec == -1) {
+ - ]
14005 : : /* Fast path */
14006 [ - + ]: 19324 : if (_PyLong_FormatWriter(writer, v, 10, arg->flags & F_ALT) == -1)
14007 : 0 : return -1;
14008 : 19324 : return 1;
14009 : : }
14010 : :
14011 [ + + + + ]: 661904 : if (PyUnicode_CheckExact(v) && arg->ch == 's') {
14012 : 619290 : *p_str = v;
14013 : 619290 : Py_INCREF(*p_str);
14014 : : }
14015 : : else {
14016 [ + + ]: 42614 : if (arg->ch == 's')
14017 : 13803 : *p_str = PyObject_Str(v);
14018 [ + + ]: 28811 : else if (arg->ch == 'r')
14019 : 27257 : *p_str = PyObject_Repr(v);
14020 : : else
14021 : 1554 : *p_str = PyObject_ASCII(v);
14022 : : }
14023 : 661904 : break;
14024 : :
14025 : 1061633 : case 'i':
14026 : : case 'd':
14027 : : case 'u':
14028 : : case 'o':
14029 : : case 'x':
14030 : : case 'X':
14031 : : {
14032 : 1061633 : int ret = mainformatlong(v, arg, p_str, writer);
14033 [ + + ]: 1061633 : if (ret != 0)
14034 : 511397 : return ret;
14035 : 550236 : arg->sign = 1;
14036 : 550236 : break;
14037 : : }
14038 : :
14039 : 44192 : case 'e':
14040 : : case 'E':
14041 : : case 'f':
14042 : : case 'F':
14043 : : case 'g':
14044 : : case 'G':
14045 [ + + + + ]: 44192 : if (arg->width == -1 && arg->prec == -1
14046 [ + + ]: 5906 : && !(arg->flags & (F_SIGN | F_BLANK)))
14047 : : {
14048 : : /* Fast path */
14049 [ + + ]: 4702 : if (formatfloat(v, arg, NULL, writer) == -1)
14050 : 2 : return -1;
14051 : 4700 : return 1;
14052 : : }
14053 : :
14054 : 39490 : arg->sign = 1;
14055 [ - + ]: 39490 : if (formatfloat(v, arg, p_str, NULL) == -1)
14056 : 0 : return -1;
14057 : 39490 : break;
14058 : :
14059 : 2255 : case 'c':
14060 : : {
14061 : 2255 : Py_UCS4 ch = formatchar(v);
14062 [ + + ]: 2255 : if (ch == (Py_UCS4) -1)
14063 : 14 : return -1;
14064 [ + - + - ]: 2241 : if (arg->width == -1 && arg->prec == -1) {
14065 : : /* Fast path */
14066 [ - + ]: 2241 : if (_PyUnicodeWriter_WriteCharInline(writer, ch) < 0)
14067 : 0 : return -1;
14068 : 2241 : return 1;
14069 : : }
14070 : 0 : *p_str = PyUnicode_FromOrdinal(ch);
14071 : 0 : break;
14072 : : }
14073 : :
14074 : 5 : default:
14075 : 5 : PyErr_Format(PyExc_ValueError,
14076 : : "unsupported format character '%c' (0x%x) "
14077 : : "at index %zd",
14078 [ + + ]: 5 : (31<=arg->ch && arg->ch<=126) ? (char)arg->ch : '?',
14079 : 5 : (int)arg->ch,
14080 [ + - ]: 5 : ctx->fmtpos - 1);
14081 : 5 : return -1;
14082 : : }
14083 [ + + ]: 1251630 : if (*p_str == NULL)
14084 : 484 : return -1;
14085 : : assert (PyUnicode_Check(*p_str));
14086 : 1251146 : return 0;
14087 : : }
14088 : :
14089 : : static int
14090 : 1251146 : unicode_format_arg_output(struct unicode_formatter_t *ctx,
14091 : : struct unicode_format_arg_t *arg,
14092 : : PyObject *str)
14093 : : {
14094 : : Py_ssize_t len;
14095 : : int kind;
14096 : : const void *pbuf;
14097 : : Py_ssize_t pindex;
14098 : : Py_UCS4 signchar;
14099 : : Py_ssize_t buflen;
14100 : : Py_UCS4 maxchar;
14101 : : Py_ssize_t sublen;
14102 : 1251146 : _PyUnicodeWriter *writer = &ctx->writer;
14103 : : Py_UCS4 fill;
14104 : :
14105 : 1251146 : fill = ' ';
14106 [ + + + + ]: 1251146 : if (arg->sign && arg->flags & F_ZERO)
14107 : 443330 : fill = '0';
14108 : :
14109 : 1251146 : len = PyUnicode_GET_LENGTH(str);
14110 [ + + + + ]: 1251146 : if ((arg->width == -1 || arg->width <= len)
14111 [ + + + + ]: 1088142 : && (arg->prec == -1 || arg->prec >= len)
14112 [ + + ]: 1052487 : && !(arg->flags & (F_SIGN | F_BLANK)))
14113 : : {
14114 : : /* Fast path */
14115 [ - + ]: 1033365 : if (_PyUnicodeWriter_WriteStr(writer, str) == -1)
14116 : 0 : return -1;
14117 : 1033365 : return 0;
14118 : : }
14119 : :
14120 : : /* Truncate the string for "s", "r" and "a" formats
14121 : : if the precision is set */
14122 [ + + + + : 217781 : if (arg->ch == 's' || arg->ch == 'r' || arg->ch == 'a') {
+ + ]
14123 [ + + + + ]: 5758 : if (arg->prec >= 0 && len > arg->prec)
14124 : 2115 : len = arg->prec;
14125 : : }
14126 : :
14127 : : /* Adjust sign and width */
14128 : 217781 : kind = PyUnicode_KIND(str);
14129 : 217781 : pbuf = PyUnicode_DATA(str);
14130 : 217781 : pindex = 0;
14131 : 217781 : signchar = '\0';
14132 [ + + ]: 217781 : if (arg->sign) {
14133 : 212023 : Py_UCS4 ch = PyUnicode_READ(kind, pbuf, pindex);
14134 [ + + - + ]: 212023 : if (ch == '-' || ch == '+') {
14135 : 26135 : signchar = ch;
14136 : 26135 : len--;
14137 : 26135 : pindex++;
14138 : : }
14139 [ + + ]: 185888 : else if (arg->flags & F_SIGN)
14140 : 15834 : signchar = '+';
14141 [ + + ]: 170054 : else if (arg->flags & F_BLANK)
14142 : 4746 : signchar = ' ';
14143 : : else
14144 : 165308 : arg->sign = 0;
14145 : : }
14146 [ + + ]: 217781 : if (arg->width < len)
14147 : 54260 : arg->width = len;
14148 : :
14149 : : /* Prepare the writer */
14150 : 217781 : maxchar = writer->maxchar;
14151 [ + + ]: 217781 : if (!(arg->flags & F_LJUST)) {
14152 [ + + ]: 197210 : if (arg->sign) {
14153 [ + + ]: 30621 : if ((arg->width-1) > len)
14154 : 5301 : maxchar = Py_MAX(maxchar, fill);
14155 : : }
14156 : : else {
14157 [ + + ]: 166589 : if (arg->width > len)
14158 : 150658 : maxchar = Py_MAX(maxchar, fill);
14159 : : }
14160 : : }
14161 [ + + ]: 217781 : if (PyUnicode_MAX_CHAR_VALUE(str) > maxchar) {
14162 : 195112 : Py_UCS4 strmaxchar = _PyUnicode_FindMaxChar(str, 0, pindex+len);
14163 : 195112 : maxchar = Py_MAX(maxchar, strmaxchar);
14164 : : }
14165 : :
14166 : 217781 : buflen = arg->width;
14167 [ + + + + ]: 217781 : if (arg->sign && len == arg->width)
14168 : 36360 : buflen++;
14169 [ + + - + : 217781 : if (_PyUnicodeWriter_Prepare(writer, buflen, maxchar) == -1)
+ + - + ]
14170 : 0 : return -1;
14171 : :
14172 : : /* Write the sign if needed */
14173 [ + + ]: 217781 : if (arg->sign) {
14174 [ + + ]: 46715 : if (fill != ' ') {
14175 : 17096 : PyUnicode_WRITE(writer->kind, writer->data, writer->pos, signchar);
14176 : 17096 : writer->pos += 1;
14177 : : }
14178 [ + + ]: 46715 : if (arg->width > len)
14179 : 10355 : arg->width--;
14180 : : }
14181 : :
14182 : : /* Write the numeric prefix for "x", "X" and "o" formats
14183 : : if the alternate form is used.
14184 : : For example, write "0x" for the "%#x" format. */
14185 [ + + + + : 217781 : if ((arg->flags & F_ALT) && (arg->ch == 'x' || arg->ch == 'X' || arg->ch == 'o')) {
+ + + + ]
14186 : : assert(PyUnicode_READ(kind, pbuf, pindex) == '0');
14187 : : assert(PyUnicode_READ(kind, pbuf, pindex + 1) == arg->ch);
14188 [ + + ]: 2628 : if (fill != ' ') {
14189 : 1305 : PyUnicode_WRITE(writer->kind, writer->data, writer->pos, '0');
14190 : 1305 : PyUnicode_WRITE(writer->kind, writer->data, writer->pos+1, arg->ch);
14191 : 1305 : writer->pos += 2;
14192 : 1305 : pindex += 2;
14193 : : }
14194 : 2628 : arg->width -= 2;
14195 [ - + ]: 2628 : if (arg->width < 0)
14196 : 0 : arg->width = 0;
14197 : 2628 : len -= 2;
14198 : : }
14199 : :
14200 : : /* Pad left with the fill character if needed */
14201 [ + + + + ]: 217781 : if (arg->width > len && !(arg->flags & F_LJUST)) {
14202 : 155959 : sublen = arg->width - len;
14203 : 155959 : unicode_fill(writer->kind, writer->data, fill, writer->pos, sublen);
14204 : 155959 : writer->pos += sublen;
14205 : 155959 : arg->width = len;
14206 : : }
14207 : :
14208 : : /* If padding with spaces: write sign if needed and/or numeric prefix if
14209 : : the alternate form is used */
14210 [ + + ]: 217781 : if (fill == ' ') {
14211 [ + + ]: 71139 : if (arg->sign) {
14212 : 29619 : PyUnicode_WRITE(writer->kind, writer->data, writer->pos, signchar);
14213 : 29619 : writer->pos += 1;
14214 : : }
14215 [ + + + + : 71139 : if ((arg->flags & F_ALT) && (arg->ch == 'x' || arg->ch == 'X' || arg->ch == 'o')) {
+ + + + ]
14216 : : assert(PyUnicode_READ(kind, pbuf, pindex) == '0');
14217 : : assert(PyUnicode_READ(kind, pbuf, pindex+1) == arg->ch);
14218 : 1323 : PyUnicode_WRITE(writer->kind, writer->data, writer->pos, '0');
14219 : 1323 : PyUnicode_WRITE(writer->kind, writer->data, writer->pos+1, arg->ch);
14220 : 1323 : writer->pos += 2;
14221 : 1323 : pindex += 2;
14222 : : }
14223 : : }
14224 : :
14225 : : /* Write characters */
14226 [ + + ]: 217781 : if (len) {
14227 : 214688 : _PyUnicode_FastCopyCharacters(writer->buffer, writer->pos,
14228 : : str, pindex, len);
14229 : 214688 : writer->pos += len;
14230 : : }
14231 : :
14232 : : /* Pad right with the fill character if needed */
14233 [ + + ]: 217781 : if (arg->width > len) {
14234 : 7557 : sublen = arg->width - len;
14235 : 7557 : unicode_fill(writer->kind, writer->data, ' ', writer->pos, sublen);
14236 : 7557 : writer->pos += sublen;
14237 : : }
14238 : 217781 : return 0;
14239 : : }
14240 : :
14241 : : /* Helper of PyUnicode_Format(): format one arg.
14242 : : Return 0 on success, raise an exception and return -1 on error. */
14243 : : static int
14244 : 1793787 : unicode_format_arg(struct unicode_formatter_t *ctx)
14245 : : {
14246 : : struct unicode_format_arg_t arg;
14247 : : PyObject *str;
14248 : : int ret;
14249 : :
14250 : 1793787 : arg.ch = PyUnicode_READ(ctx->fmtkind, ctx->fmtdata, ctx->fmtpos);
14251 [ + + ]: 1793787 : if (arg.ch == '%') {
14252 : 4409 : ctx->fmtpos++;
14253 : 4409 : ctx->fmtcnt--;
14254 [ - + ]: 4409 : if (_PyUnicodeWriter_WriteCharInline(&ctx->writer, '%') < 0)
14255 : 0 : return -1;
14256 : 4409 : return 0;
14257 : : }
14258 : 1789378 : arg.flags = 0;
14259 : 1789378 : arg.width = -1;
14260 : 1789378 : arg.prec = -1;
14261 : 1789378 : arg.sign = 0;
14262 : 1789378 : str = NULL;
14263 : :
14264 : 1789378 : ret = unicode_format_arg_parse(ctx, &arg);
14265 [ + + ]: 1789378 : if (ret == -1)
14266 : 45 : return -1;
14267 : :
14268 : 1789333 : ret = unicode_format_arg_format(ctx, &arg, &str);
14269 [ + + ]: 1789333 : if (ret == -1)
14270 : 645 : return -1;
14271 : :
14272 [ + + ]: 1788688 : if (ret != 1) {
14273 : 1251146 : ret = unicode_format_arg_output(ctx, &arg, str);
14274 : 1251146 : Py_DECREF(str);
14275 [ - + ]: 1251146 : if (ret == -1)
14276 : 0 : return -1;
14277 : : }
14278 : :
14279 [ + + - + ]: 1788688 : if (ctx->dict && (ctx->argidx < ctx->arglen)) {
14280 : 0 : PyErr_SetString(PyExc_TypeError,
14281 : : "not all arguments converted during string formatting");
14282 : 0 : return -1;
14283 : : }
14284 : 1788688 : return 0;
14285 : : }
14286 : :
14287 : : PyObject *
14288 : 1226230 : PyUnicode_Format(PyObject *format, PyObject *args)
14289 : : {
14290 : : struct unicode_formatter_t ctx;
14291 : :
14292 [ + - - + ]: 1226230 : if (format == NULL || args == NULL) {
14293 : 0 : PyErr_BadInternalCall();
14294 : 0 : return NULL;
14295 : : }
14296 : :
14297 [ - + ]: 1226230 : if (ensure_unicode(format) < 0)
14298 : 0 : return NULL;
14299 : :
14300 : 1226230 : ctx.fmtstr = format;
14301 : 1226230 : ctx.fmtdata = PyUnicode_DATA(ctx.fmtstr);
14302 : 1226230 : ctx.fmtkind = PyUnicode_KIND(ctx.fmtstr);
14303 : 1226230 : ctx.fmtcnt = PyUnicode_GET_LENGTH(ctx.fmtstr);
14304 : 1226230 : ctx.fmtpos = 0;
14305 : :
14306 : 1226230 : _PyUnicodeWriter_Init(&ctx.writer);
14307 : 1226230 : ctx.writer.min_length = ctx.fmtcnt + 100;
14308 : 1226230 : ctx.writer.overallocate = 1;
14309 : :
14310 [ + + ]: 1226230 : if (PyTuple_Check(args)) {
14311 : 256911 : ctx.arglen = PyTuple_Size(args);
14312 : 256911 : ctx.argidx = 0;
14313 : : }
14314 : : else {
14315 : 969319 : ctx.arglen = -1;
14316 : 969319 : ctx.argidx = -2;
14317 : : }
14318 : 1226230 : ctx.args_owned = 0;
14319 [ + + + + : 1226230 : if (PyMapping_Check(args) && !PyTuple_Check(args) && !PyUnicode_Check(args))
+ + ]
14320 : 13311 : ctx.dict = args;
14321 : : else
14322 : 1212919 : ctx.dict = NULL;
14323 : 1226230 : ctx.args = args;
14324 : :
14325 [ + + ]: 4356757 : while (--ctx.fmtcnt >= 0) {
14326 [ + + ]: 3131217 : if (PyUnicode_READ(ctx.fmtkind, ctx.fmtdata, ctx.fmtpos) != '%') {
14327 : : Py_ssize_t nonfmtpos;
14328 : :
14329 : 1337430 : nonfmtpos = ctx.fmtpos++;
14330 [ + + + + ]: 15958430 : while (ctx.fmtcnt >= 0 &&
14331 : 7772784 : PyUnicode_READ(ctx.fmtkind, ctx.fmtdata, ctx.fmtpos) != '%') {
14332 : 6848216 : ctx.fmtpos++;
14333 : 6848216 : ctx.fmtcnt--;
14334 : : }
14335 [ + + ]: 1337430 : if (ctx.fmtcnt < 0) {
14336 : 412862 : ctx.fmtpos--;
14337 : 412862 : ctx.writer.overallocate = 0;
14338 : : }
14339 : :
14340 [ - + ]: 1337430 : if (_PyUnicodeWriter_WriteSubstring(&ctx.writer, ctx.fmtstr,
14341 : : nonfmtpos, ctx.fmtpos) < 0)
14342 : 0 : goto onError;
14343 : : }
14344 : : else {
14345 : 1793787 : ctx.fmtpos++;
14346 [ + + ]: 1793787 : if (unicode_format_arg(&ctx) == -1)
14347 : 690 : goto onError;
14348 : : }
14349 : : }
14350 : :
14351 [ + + + + ]: 1225540 : if (ctx.argidx < ctx.arglen && !ctx.dict) {
14352 : 19 : PyErr_SetString(PyExc_TypeError,
14353 : : "not all arguments converted during string formatting");
14354 : 19 : goto onError;
14355 : : }
14356 : :
14357 [ + + ]: 1225521 : if (ctx.args_owned) {
14358 : 10980 : Py_DECREF(ctx.args);
14359 : : }
14360 : 1225521 : return _PyUnicodeWriter_Finish(&ctx.writer);
14361 : :
14362 : 709 : onError:
14363 : 709 : _PyUnicodeWriter_Dealloc(&ctx.writer);
14364 [ + + ]: 709 : if (ctx.args_owned) {
14365 : 3 : Py_DECREF(ctx.args);
14366 : : }
14367 : 709 : return NULL;
14368 : : }
14369 : :
14370 : : static PyObject *
14371 : : unicode_subtype_new(PyTypeObject *type, PyObject *unicode);
14372 : :
14373 : : /*[clinic input]
14374 : : @classmethod
14375 : : str.__new__ as unicode_new
14376 : :
14377 : : object as x: object = NULL
14378 : : encoding: str = NULL
14379 : : errors: str = NULL
14380 : :
14381 : : [clinic start generated code]*/
14382 : :
14383 : : static PyObject *
14384 : 1199234 : unicode_new_impl(PyTypeObject *type, PyObject *x, const char *encoding,
14385 : : const char *errors)
14386 : : /*[clinic end generated code: output=fc72d4878b0b57e9 input=e81255e5676d174e]*/
14387 : : {
14388 : : PyObject *unicode;
14389 [ + + ]: 1199234 : if (x == NULL) {
14390 : 15098 : unicode = unicode_new_empty();
14391 : : }
14392 [ + + + + ]: 1184136 : else if (encoding == NULL && errors == NULL) {
14393 : 724847 : unicode = PyObject_Str(x);
14394 : : }
14395 : : else {
14396 : 459289 : unicode = PyUnicode_FromEncodedObject(x, encoding, errors);
14397 : : }
14398 : :
14399 [ + + + + ]: 1199234 : if (unicode != NULL && type != &PyUnicode_Type) {
14400 : 128611 : Py_SETREF(unicode, unicode_subtype_new(type, unicode));
14401 : : }
14402 : 1199234 : return unicode;
14403 : : }
14404 : :
14405 : : static PyObject *
14406 : 128611 : unicode_subtype_new(PyTypeObject *type, PyObject *unicode)
14407 : : {
14408 : : PyObject *self;
14409 : : Py_ssize_t length, char_size;
14410 : : int share_utf8;
14411 : : int kind;
14412 : : void *data;
14413 : :
14414 : : assert(PyType_IsSubtype(type, &PyUnicode_Type));
14415 : : assert(_PyUnicode_CHECK(unicode));
14416 : :
14417 : 128611 : self = type->tp_alloc(type, 0);
14418 [ - + ]: 128611 : if (self == NULL) {
14419 : 0 : return NULL;
14420 : : }
14421 : 128611 : kind = PyUnicode_KIND(unicode);
14422 : 128611 : length = PyUnicode_GET_LENGTH(unicode);
14423 : :
14424 : 128611 : _PyUnicode_LENGTH(self) = length;
14425 : : #ifdef Py_DEBUG
14426 : : _PyUnicode_HASH(self) = -1;
14427 : : #else
14428 : 128611 : _PyUnicode_HASH(self) = _PyUnicode_HASH(unicode);
14429 : : #endif
14430 : 128611 : _PyUnicode_STATE(self).interned = 0;
14431 : 128611 : _PyUnicode_STATE(self).kind = kind;
14432 : 128611 : _PyUnicode_STATE(self).compact = 0;
14433 : 128611 : _PyUnicode_STATE(self).ascii = _PyUnicode_STATE(unicode).ascii;
14434 : 128611 : _PyUnicode_UTF8_LENGTH(self) = 0;
14435 : 128611 : _PyUnicode_UTF8(self) = NULL;
14436 : 128611 : _PyUnicode_DATA_ANY(self) = NULL;
14437 : :
14438 : 128611 : share_utf8 = 0;
14439 [ + + ]: 128611 : if (kind == PyUnicode_1BYTE_KIND) {
14440 : 128358 : char_size = 1;
14441 [ + + ]: 128358 : if (PyUnicode_MAX_CHAR_VALUE(unicode) < 128)
14442 : 127563 : share_utf8 = 1;
14443 : : }
14444 [ + + ]: 253 : else if (kind == PyUnicode_2BYTE_KIND) {
14445 : 232 : char_size = 2;
14446 : : }
14447 : : else {
14448 : : assert(kind == PyUnicode_4BYTE_KIND);
14449 : 21 : char_size = 4;
14450 : : }
14451 : :
14452 : : /* Ensure we won't overflow the length. */
14453 [ - + ]: 128611 : if (length > (PY_SSIZE_T_MAX / char_size - 1)) {
14454 : : PyErr_NoMemory();
14455 : 0 : goto onError;
14456 : : }
14457 : 128611 : data = PyObject_Malloc((length + 1) * char_size);
14458 [ - + ]: 128611 : if (data == NULL) {
14459 : : PyErr_NoMemory();
14460 : 0 : goto onError;
14461 : : }
14462 : :
14463 : 128611 : _PyUnicode_DATA_ANY(self) = data;
14464 [ + + ]: 128611 : if (share_utf8) {
14465 : 127563 : _PyUnicode_UTF8_LENGTH(self) = length;
14466 : 127563 : _PyUnicode_UTF8(self) = data;
14467 : : }
14468 : :
14469 : 128611 : memcpy(data, PyUnicode_DATA(unicode), kind * (length + 1));
14470 : : assert(_PyUnicode_CheckConsistency(self, 1));
14471 : : #ifdef Py_DEBUG
14472 : : _PyUnicode_HASH(self) = _PyUnicode_HASH(unicode);
14473 : : #endif
14474 : 128611 : return self;
14475 : :
14476 : 0 : onError:
14477 : 0 : Py_DECREF(self);
14478 : 0 : return NULL;
14479 : : }
14480 : :
14481 : : void
14482 : 4049312 : _PyUnicode_ExactDealloc(PyObject *op)
14483 : : {
14484 : : assert(PyUnicode_CheckExact(op));
14485 : 4049312 : unicode_dealloc(op);
14486 : 4049312 : }
14487 : :
14488 : : PyDoc_STRVAR(unicode_doc,
14489 : : "str(object='') -> str\n\
14490 : : str(bytes_or_buffer[, encoding[, errors]]) -> str\n\
14491 : : \n\
14492 : : Create a new string object from the given object. If encoding or\n\
14493 : : errors is specified, then the object must expose a data buffer\n\
14494 : : that will be decoded using the given encoding and error handler.\n\
14495 : : Otherwise, returns the result of object.__str__() (if defined)\n\
14496 : : or repr(object).\n\
14497 : : encoding defaults to sys.getdefaultencoding().\n\
14498 : : errors defaults to 'strict'.");
14499 : :
14500 : : static PyObject *unicode_iter(PyObject *seq);
14501 : :
14502 : : PyTypeObject PyUnicode_Type = {
14503 : : PyVarObject_HEAD_INIT(&PyType_Type, 0)
14504 : : "str", /* tp_name */
14505 : : sizeof(PyUnicodeObject), /* tp_basicsize */
14506 : : 0, /* tp_itemsize */
14507 : : /* Slots */
14508 : : (destructor)unicode_dealloc, /* tp_dealloc */
14509 : : 0, /* tp_vectorcall_offset */
14510 : : 0, /* tp_getattr */
14511 : : 0, /* tp_setattr */
14512 : : 0, /* tp_as_async */
14513 : : unicode_repr, /* tp_repr */
14514 : : &unicode_as_number, /* tp_as_number */
14515 : : &unicode_as_sequence, /* tp_as_sequence */
14516 : : &unicode_as_mapping, /* tp_as_mapping */
14517 : : (hashfunc) unicode_hash, /* tp_hash*/
14518 : : 0, /* tp_call*/
14519 : : (reprfunc) unicode_str, /* tp_str */
14520 : : PyObject_GenericGetAttr, /* tp_getattro */
14521 : : 0, /* tp_setattro */
14522 : : 0, /* tp_as_buffer */
14523 : : Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE |
14524 : : Py_TPFLAGS_UNICODE_SUBCLASS |
14525 : : _Py_TPFLAGS_MATCH_SELF, /* tp_flags */
14526 : : unicode_doc, /* tp_doc */
14527 : : 0, /* tp_traverse */
14528 : : 0, /* tp_clear */
14529 : : PyUnicode_RichCompare, /* tp_richcompare */
14530 : : 0, /* tp_weaklistoffset */
14531 : : unicode_iter, /* tp_iter */
14532 : : 0, /* tp_iternext */
14533 : : unicode_methods, /* tp_methods */
14534 : : 0, /* tp_members */
14535 : : 0, /* tp_getset */
14536 : : 0, /* tp_base */
14537 : : 0, /* tp_dict */
14538 : : 0, /* tp_descr_get */
14539 : : 0, /* tp_descr_set */
14540 : : 0, /* tp_dictoffset */
14541 : : 0, /* tp_init */
14542 : : 0, /* tp_alloc */
14543 : : unicode_new, /* tp_new */
14544 : : PyObject_Del, /* tp_free */
14545 : : };
14546 : :
14547 : : /* Initialize the Unicode implementation */
14548 : :
14549 : : void
14550 : 3138 : _PyUnicode_InitState(PyInterpreterState *interp)
14551 : : {
14552 [ + + ]: 3138 : if (!_Py_IsMainInterpreter(interp)) {
14553 : 171 : return;
14554 : : }
14555 : :
14556 : : /* initialize the linebreak bloom filter */
14557 : 2967 : const Py_UCS2 linebreak[] = {
14558 : : 0x000A, /* LINE FEED */
14559 : : 0x000D, /* CARRIAGE RETURN */
14560 : : 0x001C, /* FILE SEPARATOR */
14561 : : 0x001D, /* GROUP SEPARATOR */
14562 : : 0x001E, /* RECORD SEPARATOR */
14563 : : 0x0085, /* NEXT LINE */
14564 : : 0x2028, /* LINE SEPARATOR */
14565 : : 0x2029, /* PARAGRAPH SEPARATOR */
14566 : : };
14567 : 2967 : bloom_linebreak = make_bloom_mask(
14568 : : PyUnicode_2BYTE_KIND, linebreak,
14569 : : Py_ARRAY_LENGTH(linebreak));
14570 : : }
14571 : :
14572 : :
14573 : : PyStatus
14574 : 3138 : _PyUnicode_InitGlobalObjects(PyInterpreterState *interp)
14575 : : {
14576 [ + + ]: 3138 : if (!_Py_IsMainInterpreter(interp)) {
14577 : 171 : return _PyStatus_OK();
14578 : : }
14579 : :
14580 : : /* Intern statically allocated string identifiers and deepfreeze strings.
14581 : : * This must be done before any module initialization so that statically
14582 : : * allocated string identifiers are used instead of heap allocated strings.
14583 : : * Deepfreeze uses the interned identifiers if present to save space
14584 : : * else generates them and they are interned to speed up dict lookups.
14585 : : */
14586 : 2967 : _PyUnicode_InitStaticStrings();
14587 : :
14588 : : #ifdef Py_DEBUG
14589 : : assert(_PyUnicode_CheckConsistency(&_Py_STR(empty), 1));
14590 : :
14591 : : for (int i = 0; i < 256; i++) {
14592 : : assert(_PyUnicode_CheckConsistency(LATIN1(i), 1));
14593 : : }
14594 : : #endif
14595 : :
14596 : 2967 : return _PyStatus_OK();
14597 : : }
14598 : :
14599 : :
14600 : : PyStatus
14601 : 3138 : _PyUnicode_InitTypes(PyInterpreterState *interp)
14602 : : {
14603 [ + + ]: 3138 : if (!_Py_IsMainInterpreter(interp)) {
14604 : 171 : return _PyStatus_OK();
14605 : : }
14606 : :
14607 [ - + ]: 2967 : if (PyType_Ready(&EncodingMapType) < 0) {
14608 : 0 : goto error;
14609 : : }
14610 [ - + ]: 2967 : if (PyType_Ready(&PyFieldNameIter_Type) < 0) {
14611 : 0 : goto error;
14612 : : }
14613 [ - + ]: 2967 : if (PyType_Ready(&PyFormatterIter_Type) < 0) {
14614 : 0 : goto error;
14615 : : }
14616 : 2967 : return _PyStatus_OK();
14617 : :
14618 : 0 : error:
14619 : 0 : return _PyStatus_ERR("Can't initialize unicode types");
14620 : : }
14621 : :
14622 : :
14623 : : void
14624 : 264603632 : PyUnicode_InternInPlace(PyObject **p)
14625 : : {
14626 : 264603632 : PyObject *s = *p;
14627 : : #ifdef Py_DEBUG
14628 : : assert(s != NULL);
14629 : : assert(_PyUnicode_CHECK(s));
14630 : : #else
14631 [ + - - + ]: 264603632 : if (s == NULL || !PyUnicode_Check(s)) {
14632 : 0 : return;
14633 : : }
14634 : : #endif
14635 : :
14636 : : /* If it's a subclass, we don't really know what putting
14637 : : it in the interned dict might do. */
14638 [ + + ]: 264603632 : if (!PyUnicode_CheckExact(s)) {
14639 : 4 : return;
14640 : : }
14641 : :
14642 [ + + ]: 264603628 : if (PyUnicode_CHECK_INTERNED(s)) {
14643 : 176359447 : return;
14644 : : }
14645 : :
14646 [ + + ]: 88244181 : if (interned == NULL) {
14647 : 2967 : interned = PyDict_New();
14648 [ - + ]: 2967 : if (interned == NULL) {
14649 : 0 : PyErr_Clear(); /* Don't leave an exception */
14650 : 0 : return;
14651 : : }
14652 : : }
14653 : :
14654 : 88244181 : PyObject *t = PyDict_SetDefault(interned, s, s);
14655 [ - + ]: 88244181 : if (t == NULL) {
14656 : 0 : PyErr_Clear();
14657 : 0 : return;
14658 : : }
14659 : :
14660 [ + + ]: 88244181 : if (t != s) {
14661 : 63310030 : Py_INCREF(t);
14662 : 63310030 : Py_SETREF(*p, t);
14663 : 63310030 : return;
14664 : : }
14665 : :
14666 : : /* The two references in interned dict (key and value) are not counted by
14667 : : refcnt. unicode_dealloc() and _PyUnicode_ClearInterned() take care of
14668 : : this. */
14669 : 24934151 : Py_SET_REFCNT(s, Py_REFCNT(s) - 2);
14670 : 24934151 : _PyUnicode_STATE(s).interned = 1;
14671 : : }
14672 : :
14673 : : // Function kept for the stable ABI.
14674 : : PyAPI_FUNC(void) PyUnicode_InternImmortal(PyObject **);
14675 : : void
14676 : 0 : PyUnicode_InternImmortal(PyObject **p)
14677 : : {
14678 : 0 : PyUnicode_InternInPlace(p);
14679 : : // Leak a reference on purpose
14680 : 0 : Py_INCREF(*p);
14681 : 0 : }
14682 : :
14683 : : PyObject *
14684 : 10898447 : PyUnicode_InternFromString(const char *cp)
14685 : : {
14686 : 10898447 : PyObject *s = PyUnicode_FromString(cp);
14687 [ - + ]: 10898447 : if (s == NULL)
14688 : 0 : return NULL;
14689 : 10898447 : PyUnicode_InternInPlace(&s);
14690 : 10898447 : return s;
14691 : : }
14692 : :
14693 : :
14694 : : void
14695 : 3125 : _PyUnicode_ClearInterned(PyInterpreterState *interp)
14696 : : {
14697 [ + + ]: 3125 : if (!_Py_IsMainInterpreter(interp)) {
14698 : : // interned dict is shared by all interpreters
14699 : 169 : return;
14700 : : }
14701 : :
14702 [ - + ]: 2956 : if (interned == NULL) {
14703 : 0 : return;
14704 : : }
14705 : : assert(PyDict_CheckExact(interned));
14706 : :
14707 : : /* Interned unicode strings are not forcibly deallocated; rather, we give
14708 : : them their stolen references back, and then clear and DECREF the
14709 : : interned dict. */
14710 : :
14711 : : #ifdef INTERNED_STATS
14712 : : fprintf(stderr, "releasing %zd interned strings\n",
14713 : : PyDict_GET_SIZE(interned));
14714 : :
14715 : : Py_ssize_t total_length = 0;
14716 : : #endif
14717 : 2956 : Py_ssize_t pos = 0;
14718 : : PyObject *s, *ignored_value;
14719 [ + + ]: 5634216 : while (PyDict_Next(interned, &pos, &s, &ignored_value)) {
14720 : : assert(PyUnicode_CHECK_INTERNED(s));
14721 : : // Restore the two references (key and value) ignored
14722 : : // by PyUnicode_InternInPlace().
14723 : 5631260 : Py_SET_REFCNT(s, Py_REFCNT(s) + 2);
14724 : : #ifdef INTERNED_STATS
14725 : : total_length += PyUnicode_GET_LENGTH(s);
14726 : : #endif
14727 : :
14728 : 5631260 : _PyUnicode_STATE(s).interned = 0;
14729 : : }
14730 : : #ifdef INTERNED_STATS
14731 : : fprintf(stderr,
14732 : : "total length of all interned strings: %zd characters\n",
14733 : : total_length);
14734 : : #endif
14735 : :
14736 : 2956 : PyDict_Clear(interned);
14737 [ + - ]: 2956 : Py_CLEAR(interned);
14738 : : }
14739 : :
14740 : :
14741 : : /********************* Unicode Iterator **************************/
14742 : :
14743 : : typedef struct {
14744 : : PyObject_HEAD
14745 : : Py_ssize_t it_index;
14746 : : PyObject *it_seq; /* Set to NULL when iterator is exhausted */
14747 : : } unicodeiterobject;
14748 : :
14749 : : static void
14750 : 995404 : unicodeiter_dealloc(unicodeiterobject *it)
14751 : : {
14752 : 995404 : _PyObject_GC_UNTRACK(it);
14753 : 995404 : Py_XDECREF(it->it_seq);
14754 : 995404 : PyObject_GC_Del(it);
14755 : 995404 : }
14756 : :
14757 : : static int
14758 : 1024 : unicodeiter_traverse(unicodeiterobject *it, visitproc visit, void *arg)
14759 : : {
14760 [ + + - + ]: 1024 : Py_VISIT(it->it_seq);
14761 : 1024 : return 0;
14762 : : }
14763 : :
14764 : : static PyObject *
14765 : 392008 : unicodeiter_next(unicodeiterobject *it)
14766 : : {
14767 : : PyObject *seq;
14768 : :
14769 : : assert(it != NULL);
14770 : 392008 : seq = it->it_seq;
14771 [ + + ]: 392008 : if (seq == NULL)
14772 : 43 : return NULL;
14773 : : assert(_PyUnicode_CHECK(seq));
14774 : :
14775 [ + + ]: 391965 : if (it->it_index < PyUnicode_GET_LENGTH(seq)) {
14776 : 387038 : int kind = PyUnicode_KIND(seq);
14777 : 387038 : const void *data = PyUnicode_DATA(seq);
14778 : 387038 : Py_UCS4 chr = PyUnicode_READ(kind, data, it->it_index);
14779 : 387038 : it->it_index++;
14780 : 387038 : return unicode_char(chr);
14781 : : }
14782 : :
14783 : 4927 : it->it_seq = NULL;
14784 : 4927 : Py_DECREF(seq);
14785 : 4927 : return NULL;
14786 : : }
14787 : :
14788 : : static PyObject *
14789 : 4972673 : unicode_ascii_iter_next(unicodeiterobject *it)
14790 : : {
14791 : : assert(it != NULL);
14792 : 4972673 : PyObject *seq = it->it_seq;
14793 [ + + ]: 4972673 : if (seq == NULL) {
14794 : 227 : return NULL;
14795 : : }
14796 : : assert(_PyUnicode_CHECK(seq));
14797 : : assert(PyUnicode_IS_COMPACT_ASCII(seq));
14798 [ + + ]: 4972446 : if (it->it_index < PyUnicode_GET_LENGTH(seq)) {
14799 : 3989053 : const void *data = ((void*)(_PyASCIIObject_CAST(seq) + 1));
14800 : 3989053 : Py_UCS1 chr = (Py_UCS1)PyUnicode_READ(PyUnicode_1BYTE_KIND,
14801 : : data, it->it_index);
14802 : 3989053 : it->it_index++;
14803 : 3989053 : PyObject *item = (PyObject*)&_Py_SINGLETON(strings).ascii[chr];
14804 : 3989053 : return Py_NewRef(item);
14805 : : }
14806 : 983393 : it->it_seq = NULL;
14807 : 983393 : Py_DECREF(seq);
14808 : 983393 : return NULL;
14809 : : }
14810 : :
14811 : : static PyObject *
14812 : 12055 : unicodeiter_len(unicodeiterobject *it, PyObject *Py_UNUSED(ignored))
14813 : : {
14814 : 12055 : Py_ssize_t len = 0;
14815 [ + + ]: 12055 : if (it->it_seq)
14816 : 12054 : len = PyUnicode_GET_LENGTH(it->it_seq) - it->it_index;
14817 : 12055 : return PyLong_FromSsize_t(len);
14818 : : }
14819 : :
14820 : : PyDoc_STRVAR(length_hint_doc, "Private method returning an estimate of len(list(it)).");
14821 : :
14822 : : static PyObject *
14823 : 438 : unicodeiter_reduce(unicodeiterobject *it, PyObject *Py_UNUSED(ignored))
14824 : : {
14825 [ + + ]: 438 : if (it->it_seq != NULL) {
14826 : 432 : return Py_BuildValue("N(O)n", _PyEval_GetBuiltin(&_Py_ID(iter)),
14827 : : it->it_seq, it->it_index);
14828 : : } else {
14829 : 6 : PyObject *u = unicode_new_empty();
14830 [ - + ]: 6 : if (u == NULL)
14831 : 0 : return NULL;
14832 : 6 : return Py_BuildValue("N(N)", _PyEval_GetBuiltin(&_Py_ID(iter)), u);
14833 : : }
14834 : : }
14835 : :
14836 : : PyDoc_STRVAR(reduce_doc, "Return state information for pickling.");
14837 : :
14838 : : static PyObject *
14839 : 564 : unicodeiter_setstate(unicodeiterobject *it, PyObject *state)
14840 : : {
14841 : 564 : Py_ssize_t index = PyLong_AsSsize_t(state);
14842 [ - + - - ]: 564 : if (index == -1 && PyErr_Occurred())
14843 : 0 : return NULL;
14844 [ + - ]: 564 : if (it->it_seq != NULL) {
14845 [ - + ]: 564 : if (index < 0)
14846 : 0 : index = 0;
14847 [ - + ]: 564 : else if (index > PyUnicode_GET_LENGTH(it->it_seq))
14848 : 0 : index = PyUnicode_GET_LENGTH(it->it_seq); /* iterator truncated */
14849 : 564 : it->it_index = index;
14850 : : }
14851 : 564 : Py_RETURN_NONE;
14852 : : }
14853 : :
14854 : : PyDoc_STRVAR(setstate_doc, "Set state information for unpickling.");
14855 : :
14856 : : static PyMethodDef unicodeiter_methods[] = {
14857 : : {"__length_hint__", (PyCFunction)unicodeiter_len, METH_NOARGS,
14858 : : length_hint_doc},
14859 : : {"__reduce__", (PyCFunction)unicodeiter_reduce, METH_NOARGS,
14860 : : reduce_doc},
14861 : : {"__setstate__", (PyCFunction)unicodeiter_setstate, METH_O,
14862 : : setstate_doc},
14863 : : {NULL, NULL} /* sentinel */
14864 : : };
14865 : :
14866 : : PyTypeObject PyUnicodeIter_Type = {
14867 : : PyVarObject_HEAD_INIT(&PyType_Type, 0)
14868 : : "str_iterator", /* tp_name */
14869 : : sizeof(unicodeiterobject), /* tp_basicsize */
14870 : : 0, /* tp_itemsize */
14871 : : /* methods */
14872 : : (destructor)unicodeiter_dealloc, /* tp_dealloc */
14873 : : 0, /* tp_vectorcall_offset */
14874 : : 0, /* tp_getattr */
14875 : : 0, /* tp_setattr */
14876 : : 0, /* tp_as_async */
14877 : : 0, /* tp_repr */
14878 : : 0, /* tp_as_number */
14879 : : 0, /* tp_as_sequence */
14880 : : 0, /* tp_as_mapping */
14881 : : 0, /* tp_hash */
14882 : : 0, /* tp_call */
14883 : : 0, /* tp_str */
14884 : : PyObject_GenericGetAttr, /* tp_getattro */
14885 : : 0, /* tp_setattro */
14886 : : 0, /* tp_as_buffer */
14887 : : Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,/* tp_flags */
14888 : : 0, /* tp_doc */
14889 : : (traverseproc)unicodeiter_traverse, /* tp_traverse */
14890 : : 0, /* tp_clear */
14891 : : 0, /* tp_richcompare */
14892 : : 0, /* tp_weaklistoffset */
14893 : : PyObject_SelfIter, /* tp_iter */
14894 : : (iternextfunc)unicodeiter_next, /* tp_iternext */
14895 : : unicodeiter_methods, /* tp_methods */
14896 : : 0,
14897 : : };
14898 : :
14899 : : PyTypeObject _PyUnicodeASCIIIter_Type = {
14900 : : PyVarObject_HEAD_INIT(&PyType_Type, 0)
14901 : : .tp_name = "str_ascii_iterator",
14902 : : .tp_basicsize = sizeof(unicodeiterobject),
14903 : : .tp_dealloc = (destructor)unicodeiter_dealloc,
14904 : : .tp_getattro = PyObject_GenericGetAttr,
14905 : : .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,
14906 : : .tp_traverse = (traverseproc)unicodeiter_traverse,
14907 : : .tp_iter = PyObject_SelfIter,
14908 : : .tp_iternext = (iternextfunc)unicode_ascii_iter_next,
14909 : : .tp_methods = unicodeiter_methods,
14910 : : };
14911 : :
14912 : : static PyObject *
14913 : 995404 : unicode_iter(PyObject *seq)
14914 : : {
14915 : : unicodeiterobject *it;
14916 : :
14917 [ - + ]: 995404 : if (!PyUnicode_Check(seq)) {
14918 : 0 : PyErr_BadInternalCall();
14919 : 0 : return NULL;
14920 : : }
14921 [ + + ]: 995404 : if (PyUnicode_IS_COMPACT_ASCII(seq)) {
14922 : 990431 : it = PyObject_GC_New(unicodeiterobject, &_PyUnicodeASCIIIter_Type);
14923 : : }
14924 : : else {
14925 : 4973 : it = PyObject_GC_New(unicodeiterobject, &PyUnicodeIter_Type);
14926 : : }
14927 [ - + ]: 995404 : if (it == NULL)
14928 : 0 : return NULL;
14929 : 995404 : it->it_index = 0;
14930 : 995404 : Py_INCREF(seq);
14931 : 995404 : it->it_seq = seq;
14932 : 995404 : _PyObject_GC_TRACK(it);
14933 : 995404 : return (PyObject *)it;
14934 : : }
14935 : :
14936 : : static int
14937 : 12536 : encode_wstr_utf8(wchar_t *wstr, char **str, const char *name)
14938 : : {
14939 : : int res;
14940 : 12536 : res = _Py_EncodeUTF8Ex(wstr, str, NULL, NULL, 1, _Py_ERROR_STRICT);
14941 [ - + ]: 12536 : if (res == -2) {
14942 : 0 : PyErr_Format(PyExc_RuntimeWarning, "cannot decode %s", name);
14943 : 0 : return -1;
14944 : : }
14945 [ - + ]: 12536 : if (res < 0) {
14946 : : PyErr_NoMemory();
14947 : 0 : return -1;
14948 : : }
14949 : 12536 : return 0;
14950 : : }
14951 : :
14952 : :
14953 : : static int
14954 : 6268 : config_get_codec_name(wchar_t **config_encoding)
14955 : : {
14956 : : char *encoding;
14957 [ - + ]: 6268 : if (encode_wstr_utf8(*config_encoding, &encoding, "stdio_encoding") < 0) {
14958 : 0 : return -1;
14959 : : }
14960 : :
14961 : 6268 : PyObject *name_obj = NULL;
14962 : 6268 : PyObject *codec = _PyCodec_Lookup(encoding);
14963 : 6268 : PyMem_RawFree(encoding);
14964 : :
14965 [ - + ]: 6268 : if (!codec)
14966 : 0 : goto error;
14967 : :
14968 : 6268 : name_obj = PyObject_GetAttrString(codec, "name");
14969 [ + - ]: 6268 : Py_CLEAR(codec);
14970 [ - + ]: 6268 : if (!name_obj) {
14971 : 0 : goto error;
14972 : : }
14973 : :
14974 : 6268 : wchar_t *wname = PyUnicode_AsWideCharString(name_obj, NULL);
14975 : 6268 : Py_DECREF(name_obj);
14976 [ - + ]: 6268 : if (wname == NULL) {
14977 : 0 : goto error;
14978 : : }
14979 : :
14980 : 6268 : wchar_t *raw_wname = _PyMem_RawWcsdup(wname);
14981 [ - + ]: 6268 : if (raw_wname == NULL) {
14982 : 0 : PyMem_Free(wname);
14983 : : PyErr_NoMemory();
14984 : 0 : goto error;
14985 : : }
14986 : :
14987 : 6268 : PyMem_RawFree(*config_encoding);
14988 : 6268 : *config_encoding = raw_wname;
14989 : :
14990 : 6268 : PyMem_Free(wname);
14991 : 6268 : return 0;
14992 : :
14993 : 0 : error:
14994 : 0 : Py_XDECREF(codec);
14995 : 0 : Py_XDECREF(name_obj);
14996 : 0 : return -1;
14997 : : }
14998 : :
14999 : :
15000 : : static PyStatus
15001 : 3134 : init_stdio_encoding(PyInterpreterState *interp)
15002 : : {
15003 : : /* Update the stdio encoding to the normalized Python codec name. */
15004 : 3134 : PyConfig *config = (PyConfig*)_PyInterpreterState_GetConfig(interp);
15005 [ - + ]: 3134 : if (config_get_codec_name(&config->stdio_encoding) < 0) {
15006 : 0 : return _PyStatus_ERR("failed to get the Python codec name "
15007 : : "of the stdio encoding");
15008 : : }
15009 : 3134 : return _PyStatus_OK();
15010 : : }
15011 : :
15012 : :
15013 : : static int
15014 : 3134 : init_fs_codec(PyInterpreterState *interp)
15015 : : {
15016 : 3134 : const PyConfig *config = _PyInterpreterState_GetConfig(interp);
15017 : :
15018 : : _Py_error_handler error_handler;
15019 : 3134 : error_handler = get_error_handler_wide(config->filesystem_errors);
15020 [ - + ]: 3134 : if (error_handler == _Py_ERROR_UNKNOWN) {
15021 : 0 : PyErr_SetString(PyExc_RuntimeError, "unknown filesystem error handler");
15022 : 0 : return -1;
15023 : : }
15024 : :
15025 : : char *encoding, *errors;
15026 [ - + ]: 3134 : if (encode_wstr_utf8(config->filesystem_encoding,
15027 : : &encoding,
15028 : : "filesystem_encoding") < 0) {
15029 : 0 : return -1;
15030 : : }
15031 : :
15032 [ - + ]: 3134 : if (encode_wstr_utf8(config->filesystem_errors,
15033 : : &errors,
15034 : : "filesystem_errors") < 0) {
15035 : 0 : PyMem_RawFree(encoding);
15036 : 0 : return -1;
15037 : : }
15038 : :
15039 : 3134 : struct _Py_unicode_fs_codec *fs_codec = &interp->unicode.fs_codec;
15040 : 3134 : PyMem_RawFree(fs_codec->encoding);
15041 : 3134 : fs_codec->encoding = encoding;
15042 : : /* encoding has been normalized by init_fs_encoding() */
15043 : 3134 : fs_codec->utf8 = (strcmp(encoding, "utf-8") == 0);
15044 : 3134 : PyMem_RawFree(fs_codec->errors);
15045 : 3134 : fs_codec->errors = errors;
15046 : 3134 : fs_codec->error_handler = error_handler;
15047 : :
15048 : : #ifdef _Py_FORCE_UTF8_FS_ENCODING
15049 : : assert(fs_codec->utf8 == 1);
15050 : : #endif
15051 : :
15052 : : /* At this point, PyUnicode_EncodeFSDefault() and
15053 : : PyUnicode_DecodeFSDefault() can now use the Python codec rather than
15054 : : the C implementation of the filesystem encoding. */
15055 : :
15056 : : /* Set Py_FileSystemDefaultEncoding and Py_FileSystemDefaultEncodeErrors
15057 : : global configuration variables. */
15058 [ - + ]: 3134 : if (_Py_SetFileSystemEncoding(fs_codec->encoding,
15059 : 3134 : fs_codec->errors) < 0) {
15060 : : PyErr_NoMemory();
15061 : 0 : return -1;
15062 : : }
15063 : 3134 : return 0;
15064 : : }
15065 : :
15066 : :
15067 : : static PyStatus
15068 : 3134 : init_fs_encoding(PyThreadState *tstate)
15069 : : {
15070 : 3134 : PyInterpreterState *interp = tstate->interp;
15071 : :
15072 : : /* Update the filesystem encoding to the normalized Python codec name.
15073 : : For example, replace "ANSI_X3.4-1968" (locale encoding) with "ascii"
15074 : : (Python codec name). */
15075 : 3134 : PyConfig *config = (PyConfig*)_PyInterpreterState_GetConfig(interp);
15076 [ - + ]: 3134 : if (config_get_codec_name(&config->filesystem_encoding) < 0) {
15077 : 0 : _Py_DumpPathConfig(tstate);
15078 : 0 : return _PyStatus_ERR("failed to get the Python codec "
15079 : : "of the filesystem encoding");
15080 : : }
15081 : :
15082 [ - + ]: 3134 : if (init_fs_codec(interp) < 0) {
15083 : 0 : return _PyStatus_ERR("cannot initialize filesystem codec");
15084 : : }
15085 : 3134 : return _PyStatus_OK();
15086 : : }
15087 : :
15088 : :
15089 : : PyStatus
15090 : 3134 : _PyUnicode_InitEncodings(PyThreadState *tstate)
15091 : : {
15092 : 3134 : PyStatus status = init_fs_encoding(tstate);
15093 [ - + ]: 3134 : if (_PyStatus_EXCEPTION(status)) {
15094 : 0 : return status;
15095 : : }
15096 : :
15097 : 3134 : return init_stdio_encoding(tstate->interp);
15098 : : }
15099 : :
15100 : :
15101 : : static void
15102 : 3125 : _PyUnicode_FiniEncodings(struct _Py_unicode_fs_codec *fs_codec)
15103 : : {
15104 : 3125 : PyMem_RawFree(fs_codec->encoding);
15105 : 3125 : fs_codec->encoding = NULL;
15106 : 3125 : fs_codec->utf8 = 0;
15107 : 3125 : PyMem_RawFree(fs_codec->errors);
15108 : 3125 : fs_codec->errors = NULL;
15109 : 3125 : fs_codec->error_handler = _Py_ERROR_UNKNOWN;
15110 : 3125 : }
15111 : :
15112 : :
15113 : : #ifdef MS_WINDOWS
15114 : : int
15115 : : _PyUnicode_EnableLegacyWindowsFSEncoding(void)
15116 : : {
15117 : : PyInterpreterState *interp = _PyInterpreterState_GET();
15118 : : PyConfig *config = (PyConfig *)_PyInterpreterState_GetConfig(interp);
15119 : :
15120 : : /* Set the filesystem encoding to mbcs/replace (PEP 529) */
15121 : : wchar_t *encoding = _PyMem_RawWcsdup(L"mbcs");
15122 : : wchar_t *errors = _PyMem_RawWcsdup(L"replace");
15123 : : if (encoding == NULL || errors == NULL) {
15124 : : PyMem_RawFree(encoding);
15125 : : PyMem_RawFree(errors);
15126 : : PyErr_NoMemory();
15127 : : return -1;
15128 : : }
15129 : :
15130 : : PyMem_RawFree(config->filesystem_encoding);
15131 : : config->filesystem_encoding = encoding;
15132 : : PyMem_RawFree(config->filesystem_errors);
15133 : : config->filesystem_errors = errors;
15134 : :
15135 : : return init_fs_codec(interp);
15136 : : }
15137 : : #endif
15138 : :
15139 : :
15140 : : #ifdef Py_DEBUG
15141 : : static inline int
15142 : : unicode_is_finalizing(void)
15143 : : {
15144 : : return (interned == NULL);
15145 : : }
15146 : : #endif
15147 : :
15148 : :
15149 : : void
15150 : 3125 : _PyUnicode_FiniTypes(PyInterpreterState *interp)
15151 : : {
15152 [ + + ]: 3125 : if (!_Py_IsMainInterpreter(interp)) {
15153 : 169 : return;
15154 : : }
15155 : :
15156 : 2956 : _PyStaticType_Dealloc(&EncodingMapType);
15157 : 2956 : _PyStaticType_Dealloc(&PyFieldNameIter_Type);
15158 : 2956 : _PyStaticType_Dealloc(&PyFormatterIter_Type);
15159 : : }
15160 : :
15161 : :
15162 : 8378170 : static void unicode_static_dealloc(PyObject *op)
15163 : : {
15164 : 8378170 : PyASCIIObject *ascii = _PyASCIIObject_CAST(op);
15165 : :
15166 : : assert(ascii->state.compact);
15167 : :
15168 [ + + ]: 8378170 : if (!ascii->state.ascii) {
15169 : 417610 : PyCompactUnicodeObject* compact = (PyCompactUnicodeObject*)op;
15170 [ + + ]: 417610 : if (compact->utf8) {
15171 : 274 : PyObject_Free(compact->utf8);
15172 : 274 : compact->utf8 = NULL;
15173 : 274 : compact->utf8_length = 0;
15174 : : }
15175 : : }
15176 : 8378170 : }
15177 : :
15178 : :
15179 : : void
15180 : 3125 : _PyUnicode_Fini(PyInterpreterState *interp)
15181 : : {
15182 : 3125 : struct _Py_unicode_state *state = &interp->unicode;
15183 : :
15184 [ + + ]: 3125 : if (_Py_IsMainInterpreter(interp)) {
15185 : : // _PyUnicode_ClearInterned() must be called before _PyUnicode_Fini()
15186 : : assert(interned == NULL);
15187 : : // bpo-47182: force a unicodedata CAPI capsule re-import on
15188 : : // subsequent initialization of main interpreter.
15189 : 2956 : ucnhash_capi = NULL;
15190 : : }
15191 : :
15192 : 3125 : _PyUnicode_FiniEncodings(&state->fs_codec);
15193 : :
15194 : 3125 : unicode_clear_identifiers(state);
15195 : :
15196 : : // Clear the single character singletons
15197 [ + + ]: 403125 : for (int i = 0; i < 128; i++) {
15198 : 400000 : unicode_static_dealloc((PyObject*)&_Py_SINGLETON(strings).ascii[i]);
15199 : : }
15200 [ + + ]: 403125 : for (int i = 0; i < 128; i++) {
15201 : 400000 : unicode_static_dealloc((PyObject*)&_Py_SINGLETON(strings).latin1[i]);
15202 : : }
15203 : 3125 : }
15204 : :
15205 : :
15206 : : void
15207 : 7578170 : _PyStaticUnicode_Dealloc(PyObject *op)
15208 : : {
15209 : 7578170 : unicode_static_dealloc(op);
15210 : 7578170 : }
15211 : :
15212 : :
15213 : : /* A _string module, to export formatter_parser and formatter_field_name_split
15214 : : to the string.Formatter class implemented in Python. */
15215 : :
15216 : : static PyMethodDef _string_methods[] = {
15217 : : {"formatter_field_name_split", (PyCFunction) formatter_field_name_split,
15218 : : METH_O, PyDoc_STR("split the argument as a field name")},
15219 : : {"formatter_parser", (PyCFunction) formatter_parser,
15220 : : METH_O, PyDoc_STR("parse the argument as a format string")},
15221 : : {NULL, NULL}
15222 : : };
15223 : :
15224 : : static struct PyModuleDef _string_module = {
15225 : : PyModuleDef_HEAD_INIT,
15226 : : .m_name = "_string",
15227 : : .m_doc = PyDoc_STR("string helper module"),
15228 : : .m_size = 0,
15229 : : .m_methods = _string_methods,
15230 : : };
15231 : :
15232 : : PyMODINIT_FUNC
15233 : 717 : PyInit__string(void)
15234 : : {
15235 : 717 : return PyModuleDef_Init(&_string_module);
15236 : : }
15237 : :
15238 : :
15239 : : #ifdef __cplusplus
15240 : : }
15241 : : #endif
|
