Branch data Line data Source code
1 : : /*[clinic input]
2 : : preserve
3 : : [clinic start generated code]*/
4 : :
5 : : PyDoc_STRVAR(_codecs_register__doc__,
6 : : "register($module, search_function, /)\n"
7 : : "--\n"
8 : : "\n"
9 : : "Register a codec search function.\n"
10 : : "\n"
11 : : "Search functions are expected to take one argument, the encoding name in\n"
12 : : "all lower case letters, and either return None, or a tuple of functions\n"
13 : : "(encoder, decoder, stream_reader, stream_writer) (or a CodecInfo object).");
14 : :
15 : : #define _CODECS_REGISTER_METHODDEF \
16 : : {"register", (PyCFunction)_codecs_register, METH_O, _codecs_register__doc__},
17 : :
18 : : PyDoc_STRVAR(_codecs_unregister__doc__,
19 : : "unregister($module, search_function, /)\n"
20 : : "--\n"
21 : : "\n"
22 : : "Unregister a codec search function and clear the registry\'s cache.\n"
23 : : "\n"
24 : : "If the search function is not registered, do nothing.");
25 : :
26 : : #define _CODECS_UNREGISTER_METHODDEF \
27 : : {"unregister", (PyCFunction)_codecs_unregister, METH_O, _codecs_unregister__doc__},
28 : :
29 : : PyDoc_STRVAR(_codecs_lookup__doc__,
30 : : "lookup($module, encoding, /)\n"
31 : : "--\n"
32 : : "\n"
33 : : "Looks up a codec tuple in the Python codec registry and returns a CodecInfo object.");
34 : :
35 : : #define _CODECS_LOOKUP_METHODDEF \
36 : : {"lookup", (PyCFunction)_codecs_lookup, METH_O, _codecs_lookup__doc__},
37 : :
38 : : static PyObject *
39 : : _codecs_lookup_impl(PyObject *module, const char *encoding);
40 : :
41 : : static PyObject *
42 : 20523 : _codecs_lookup(PyObject *module, PyObject *arg)
43 : : {
44 : 20523 : PyObject *return_value = NULL;
45 : : const char *encoding;
46 : :
47 [ - + ]: 20523 : if (!PyUnicode_Check(arg)) {
48 : 0 : _PyArg_BadArgument("lookup", "argument", "str", arg);
49 : 0 : goto exit;
50 : : }
51 : : Py_ssize_t encoding_length;
52 : 20523 : encoding = PyUnicode_AsUTF8AndSize(arg, &encoding_length);
53 [ - + ]: 20523 : if (encoding == NULL) {
54 : 0 : goto exit;
55 : : }
56 [ - + ]: 20523 : if (strlen(encoding) != (size_t)encoding_length) {
57 : 0 : PyErr_SetString(PyExc_ValueError, "embedded null character");
58 : 0 : goto exit;
59 : : }
60 : 20523 : return_value = _codecs_lookup_impl(module, encoding);
61 : :
62 : 20523 : exit:
63 : 20523 : return return_value;
64 : : }
65 : :
66 : : PyDoc_STRVAR(_codecs_encode__doc__,
67 : : "encode($module, /, obj, encoding=\'utf-8\', errors=\'strict\')\n"
68 : : "--\n"
69 : : "\n"
70 : : "Encodes obj using the codec registered for encoding.\n"
71 : : "\n"
72 : : "The default encoding is \'utf-8\'. errors may be given to set a\n"
73 : : "different error handling scheme. Default is \'strict\' meaning that encoding\n"
74 : : "errors raise a ValueError. Other possible values are \'ignore\', \'replace\'\n"
75 : : "and \'backslashreplace\' as well as any other name registered with\n"
76 : : "codecs.register_error that can handle ValueErrors.");
77 : :
78 : : #define _CODECS_ENCODE_METHODDEF \
79 : : {"encode", _PyCFunction_CAST(_codecs_encode), METH_FASTCALL|METH_KEYWORDS, _codecs_encode__doc__},
80 : :
81 : : static PyObject *
82 : : _codecs_encode_impl(PyObject *module, PyObject *obj, const char *encoding,
83 : : const char *errors);
84 : :
85 : : static PyObject *
86 : 9988 : _codecs_encode(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
87 : : {
88 : 9988 : PyObject *return_value = NULL;
89 : : static const char * const _keywords[] = {"obj", "encoding", "errors", NULL};
90 : : static _PyArg_Parser _parser = {NULL, _keywords, "encode", 0};
91 : : PyObject *argsbuf[3];
92 [ + + ]: 9988 : Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
93 : : PyObject *obj;
94 : 9988 : const char *encoding = NULL;
95 : 9988 : const char *errors = NULL;
96 : :
97 [ + + + + : 9988 : args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 3, 0, argsbuf);
+ - - + ]
98 [ + + ]: 9988 : if (!args) {
99 : 1 : goto exit;
100 : : }
101 : 9987 : obj = args[0];
102 [ + + ]: 9987 : if (!noptargs) {
103 : 1 : goto skip_optional_pos;
104 : : }
105 [ + - ]: 9986 : if (args[1]) {
106 [ - + ]: 9986 : if (!PyUnicode_Check(args[1])) {
107 : 0 : _PyArg_BadArgument("encode", "argument 'encoding'", "str", args[1]);
108 : 0 : goto exit;
109 : : }
110 : : Py_ssize_t encoding_length;
111 : 9986 : encoding = PyUnicode_AsUTF8AndSize(args[1], &encoding_length);
112 [ - + ]: 9986 : if (encoding == NULL) {
113 : 0 : goto exit;
114 : : }
115 [ - + ]: 9986 : if (strlen(encoding) != (size_t)encoding_length) {
116 : 0 : PyErr_SetString(PyExc_ValueError, "embedded null character");
117 : 0 : goto exit;
118 : : }
119 [ + + ]: 9986 : if (!--noptargs) {
120 : 9981 : goto skip_optional_pos;
121 : : }
122 : : }
123 [ - + ]: 5 : if (!PyUnicode_Check(args[2])) {
124 : 0 : _PyArg_BadArgument("encode", "argument 'errors'", "str", args[2]);
125 : 0 : goto exit;
126 : : }
127 : : Py_ssize_t errors_length;
128 : 5 : errors = PyUnicode_AsUTF8AndSize(args[2], &errors_length);
129 [ - + ]: 5 : if (errors == NULL) {
130 : 0 : goto exit;
131 : : }
132 [ - + ]: 5 : if (strlen(errors) != (size_t)errors_length) {
133 : 0 : PyErr_SetString(PyExc_ValueError, "embedded null character");
134 : 0 : goto exit;
135 : : }
136 : 5 : skip_optional_pos:
137 : 9987 : return_value = _codecs_encode_impl(module, obj, encoding, errors);
138 : :
139 : 9988 : exit:
140 : 9988 : return return_value;
141 : : }
142 : :
143 : : PyDoc_STRVAR(_codecs_decode__doc__,
144 : : "decode($module, /, obj, encoding=\'utf-8\', errors=\'strict\')\n"
145 : : "--\n"
146 : : "\n"
147 : : "Decodes obj using the codec registered for encoding.\n"
148 : : "\n"
149 : : "Default encoding is \'utf-8\'. errors may be given to set a\n"
150 : : "different error handling scheme. Default is \'strict\' meaning that encoding\n"
151 : : "errors raise a ValueError. Other possible values are \'ignore\', \'replace\'\n"
152 : : "and \'backslashreplace\' as well as any other name registered with\n"
153 : : "codecs.register_error that can handle ValueErrors.");
154 : :
155 : : #define _CODECS_DECODE_METHODDEF \
156 : : {"decode", _PyCFunction_CAST(_codecs_decode), METH_FASTCALL|METH_KEYWORDS, _codecs_decode__doc__},
157 : :
158 : : static PyObject *
159 : : _codecs_decode_impl(PyObject *module, PyObject *obj, const char *encoding,
160 : : const char *errors);
161 : :
162 : : static PyObject *
163 : 42 : _codecs_decode(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
164 : : {
165 : 42 : PyObject *return_value = NULL;
166 : : static const char * const _keywords[] = {"obj", "encoding", "errors", NULL};
167 : : static _PyArg_Parser _parser = {NULL, _keywords, "decode", 0};
168 : : PyObject *argsbuf[3];
169 [ + + ]: 42 : Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
170 : : PyObject *obj;
171 : 42 : const char *encoding = NULL;
172 : 42 : const char *errors = NULL;
173 : :
174 [ + + + + : 42 : args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 3, 0, argsbuf);
+ - - + ]
175 [ + + ]: 42 : if (!args) {
176 : 1 : goto exit;
177 : : }
178 : 41 : obj = args[0];
179 [ + + ]: 41 : if (!noptargs) {
180 : 1 : goto skip_optional_pos;
181 : : }
182 [ + - ]: 40 : if (args[1]) {
183 [ - + ]: 40 : if (!PyUnicode_Check(args[1])) {
184 : 0 : _PyArg_BadArgument("decode", "argument 'encoding'", "str", args[1]);
185 : 0 : goto exit;
186 : : }
187 : : Py_ssize_t encoding_length;
188 : 40 : encoding = PyUnicode_AsUTF8AndSize(args[1], &encoding_length);
189 [ - + ]: 40 : if (encoding == NULL) {
190 : 0 : goto exit;
191 : : }
192 [ - + ]: 40 : if (strlen(encoding) != (size_t)encoding_length) {
193 : 0 : PyErr_SetString(PyExc_ValueError, "embedded null character");
194 : 0 : goto exit;
195 : : }
196 [ + + ]: 40 : if (!--noptargs) {
197 : 35 : goto skip_optional_pos;
198 : : }
199 : : }
200 [ - + ]: 5 : if (!PyUnicode_Check(args[2])) {
201 : 0 : _PyArg_BadArgument("decode", "argument 'errors'", "str", args[2]);
202 : 0 : goto exit;
203 : : }
204 : : Py_ssize_t errors_length;
205 : 5 : errors = PyUnicode_AsUTF8AndSize(args[2], &errors_length);
206 [ - + ]: 5 : if (errors == NULL) {
207 : 0 : goto exit;
208 : : }
209 [ - + ]: 5 : if (strlen(errors) != (size_t)errors_length) {
210 : 0 : PyErr_SetString(PyExc_ValueError, "embedded null character");
211 : 0 : goto exit;
212 : : }
213 : 5 : skip_optional_pos:
214 : 41 : return_value = _codecs_decode_impl(module, obj, encoding, errors);
215 : :
216 : 42 : exit:
217 : 42 : return return_value;
218 : : }
219 : :
220 : : PyDoc_STRVAR(_codecs_escape_decode__doc__,
221 : : "escape_decode($module, data, errors=None, /)\n"
222 : : "--\n"
223 : : "\n");
224 : :
225 : : #define _CODECS_ESCAPE_DECODE_METHODDEF \
226 : : {"escape_decode", _PyCFunction_CAST(_codecs_escape_decode), METH_FASTCALL, _codecs_escape_decode__doc__},
227 : :
228 : : static PyObject *
229 : : _codecs_escape_decode_impl(PyObject *module, Py_buffer *data,
230 : : const char *errors);
231 : :
232 : : static PyObject *
233 : 8353 : _codecs_escape_decode(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
234 : : {
235 : 8353 : PyObject *return_value = NULL;
236 : 8353 : Py_buffer data = {NULL, NULL};
237 : 8353 : const char *errors = NULL;
238 : :
239 [ + - - + : 8353 : if (!_PyArg_CheckPositional("escape_decode", nargs, 1, 2)) {
- - ]
240 : 0 : goto exit;
241 : : }
242 [ - + ]: 8353 : if (PyUnicode_Check(args[0])) {
243 : : Py_ssize_t len;
244 : 0 : const char *ptr = PyUnicode_AsUTF8AndSize(args[0], &len);
245 [ # # ]: 0 : if (ptr == NULL) {
246 : 0 : goto exit;
247 : : }
248 : 0 : PyBuffer_FillInfo(&data, args[0], (void *)ptr, len, 1, 0);
249 : : }
250 : : else { /* any bytes-like object */
251 [ - + ]: 8353 : if (PyObject_GetBuffer(args[0], &data, PyBUF_SIMPLE) != 0) {
252 : 0 : goto exit;
253 : : }
254 [ - + ]: 8353 : if (!PyBuffer_IsContiguous(&data, 'C')) {
255 : 0 : _PyArg_BadArgument("escape_decode", "argument 1", "contiguous buffer", args[0]);
256 : 0 : goto exit;
257 : : }
258 : : }
259 [ + + ]: 8353 : if (nargs < 2) {
260 : 8349 : goto skip_optional;
261 : : }
262 [ - + ]: 4 : if (args[1] == Py_None) {
263 : 0 : errors = NULL;
264 : : }
265 [ + - ]: 4 : else if (PyUnicode_Check(args[1])) {
266 : : Py_ssize_t errors_length;
267 : 4 : errors = PyUnicode_AsUTF8AndSize(args[1], &errors_length);
268 [ - + ]: 4 : if (errors == NULL) {
269 : 0 : goto exit;
270 : : }
271 [ - + ]: 4 : if (strlen(errors) != (size_t)errors_length) {
272 : 0 : PyErr_SetString(PyExc_ValueError, "embedded null character");
273 : 0 : goto exit;
274 : : }
275 : : }
276 : : else {
277 : 0 : _PyArg_BadArgument("escape_decode", "argument 2", "str or None", args[1]);
278 : 0 : goto exit;
279 : : }
280 : 8353 : skip_optional:
281 : 8353 : return_value = _codecs_escape_decode_impl(module, &data, errors);
282 : :
283 : 8353 : exit:
284 : : /* Cleanup for data */
285 [ + - ]: 8353 : if (data.obj) {
286 : 8353 : PyBuffer_Release(&data);
287 : : }
288 : :
289 : 8353 : return return_value;
290 : : }
291 : :
292 : : PyDoc_STRVAR(_codecs_escape_encode__doc__,
293 : : "escape_encode($module, data, errors=None, /)\n"
294 : : "--\n"
295 : : "\n");
296 : :
297 : : #define _CODECS_ESCAPE_ENCODE_METHODDEF \
298 : : {"escape_encode", _PyCFunction_CAST(_codecs_escape_encode), METH_FASTCALL, _codecs_escape_encode__doc__},
299 : :
300 : : static PyObject *
301 : : _codecs_escape_encode_impl(PyObject *module, PyObject *data,
302 : : const char *errors);
303 : :
304 : : static PyObject *
305 : 10 : _codecs_escape_encode(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
306 : : {
307 : 10 : PyObject *return_value = NULL;
308 : : PyObject *data;
309 : 10 : const char *errors = NULL;
310 : :
311 [ + - - + : 10 : if (!_PyArg_CheckPositional("escape_encode", nargs, 1, 2)) {
- - ]
312 : 0 : goto exit;
313 : : }
314 [ + + ]: 10 : if (!PyBytes_Check(args[0])) {
315 : 2 : _PyArg_BadArgument("escape_encode", "argument 1", "bytes", args[0]);
316 : 2 : goto exit;
317 : : }
318 : 8 : data = args[0];
319 [ + - ]: 8 : if (nargs < 2) {
320 : 8 : goto skip_optional;
321 : : }
322 [ # # ]: 0 : if (args[1] == Py_None) {
323 : 0 : errors = NULL;
324 : : }
325 [ # # ]: 0 : else if (PyUnicode_Check(args[1])) {
326 : : Py_ssize_t errors_length;
327 : 0 : errors = PyUnicode_AsUTF8AndSize(args[1], &errors_length);
328 [ # # ]: 0 : if (errors == NULL) {
329 : 0 : goto exit;
330 : : }
331 [ # # ]: 0 : if (strlen(errors) != (size_t)errors_length) {
332 : 0 : PyErr_SetString(PyExc_ValueError, "embedded null character");
333 : 0 : goto exit;
334 : : }
335 : : }
336 : : else {
337 : 0 : _PyArg_BadArgument("escape_encode", "argument 2", "str or None", args[1]);
338 : 0 : goto exit;
339 : : }
340 : 8 : skip_optional:
341 : 8 : return_value = _codecs_escape_encode_impl(module, data, errors);
342 : :
343 : 10 : exit:
344 : 10 : return return_value;
345 : : }
346 : :
347 : : PyDoc_STRVAR(_codecs_utf_7_decode__doc__,
348 : : "utf_7_decode($module, data, errors=None, final=False, /)\n"
349 : : "--\n"
350 : : "\n");
351 : :
352 : : #define _CODECS_UTF_7_DECODE_METHODDEF \
353 : : {"utf_7_decode", _PyCFunction_CAST(_codecs_utf_7_decode), METH_FASTCALL, _codecs_utf_7_decode__doc__},
354 : :
355 : : static PyObject *
356 : : _codecs_utf_7_decode_impl(PyObject *module, Py_buffer *data,
357 : : const char *errors, int final);
358 : :
359 : : static PyObject *
360 : 5664 : _codecs_utf_7_decode(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
361 : : {
362 : 5664 : PyObject *return_value = NULL;
363 : 5664 : Py_buffer data = {NULL, NULL};
364 : 5664 : const char *errors = NULL;
365 : 5664 : int final = 0;
366 : :
367 [ + - - + : 5664 : if (!_PyArg_CheckPositional("utf_7_decode", nargs, 1, 3)) {
- - ]
368 : 0 : goto exit;
369 : : }
370 [ + + ]: 5664 : if (PyObject_GetBuffer(args[0], &data, PyBUF_SIMPLE) != 0) {
371 : 2 : goto exit;
372 : : }
373 [ - + ]: 5662 : if (!PyBuffer_IsContiguous(&data, 'C')) {
374 : 0 : _PyArg_BadArgument("utf_7_decode", "argument 1", "contiguous buffer", args[0]);
375 : 0 : goto exit;
376 : : }
377 [ - + ]: 5662 : if (nargs < 2) {
378 : 0 : goto skip_optional;
379 : : }
380 [ - + ]: 5662 : if (args[1] == Py_None) {
381 : 0 : errors = NULL;
382 : : }
383 [ + - ]: 5662 : else if (PyUnicode_Check(args[1])) {
384 : : Py_ssize_t errors_length;
385 : 5662 : errors = PyUnicode_AsUTF8AndSize(args[1], &errors_length);
386 [ - + ]: 5662 : if (errors == NULL) {
387 : 0 : goto exit;
388 : : }
389 [ - + ]: 5662 : if (strlen(errors) != (size_t)errors_length) {
390 : 0 : PyErr_SetString(PyExc_ValueError, "embedded null character");
391 : 0 : goto exit;
392 : : }
393 : : }
394 : : else {
395 : 0 : _PyArg_BadArgument("utf_7_decode", "argument 2", "str or None", args[1]);
396 : 0 : goto exit;
397 : : }
398 [ + + ]: 5662 : if (nargs < 3) {
399 : 4284 : goto skip_optional;
400 : : }
401 : 1378 : final = _PyLong_AsInt(args[2]);
402 [ - + - - ]: 1378 : if (final == -1 && PyErr_Occurred()) {
403 : 0 : goto exit;
404 : : }
405 : 1378 : skip_optional:
406 : 5662 : return_value = _codecs_utf_7_decode_impl(module, &data, errors, final);
407 : :
408 : 5664 : exit:
409 : : /* Cleanup for data */
410 [ + + ]: 5664 : if (data.obj) {
411 : 5662 : PyBuffer_Release(&data);
412 : : }
413 : :
414 : 5664 : return return_value;
415 : : }
416 : :
417 : : PyDoc_STRVAR(_codecs_utf_8_decode__doc__,
418 : : "utf_8_decode($module, data, errors=None, final=False, /)\n"
419 : : "--\n"
420 : : "\n");
421 : :
422 : : #define _CODECS_UTF_8_DECODE_METHODDEF \
423 : : {"utf_8_decode", _PyCFunction_CAST(_codecs_utf_8_decode), METH_FASTCALL, _codecs_utf_8_decode__doc__},
424 : :
425 : : static PyObject *
426 : : _codecs_utf_8_decode_impl(PyObject *module, Py_buffer *data,
427 : : const char *errors, int final);
428 : :
429 : : static PyObject *
430 : 241762 : _codecs_utf_8_decode(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
431 : : {
432 : 241762 : PyObject *return_value = NULL;
433 : 241762 : Py_buffer data = {NULL, NULL};
434 : 241762 : const char *errors = NULL;
435 : 241762 : int final = 0;
436 : :
437 [ + - - + : 241762 : if (!_PyArg_CheckPositional("utf_8_decode", nargs, 1, 3)) {
- - ]
438 : 0 : goto exit;
439 : : }
440 [ + + ]: 241762 : if (PyObject_GetBuffer(args[0], &data, PyBUF_SIMPLE) != 0) {
441 : 2 : goto exit;
442 : : }
443 [ - + ]: 241760 : if (!PyBuffer_IsContiguous(&data, 'C')) {
444 : 0 : _PyArg_BadArgument("utf_8_decode", "argument 1", "contiguous buffer", args[0]);
445 : 0 : goto exit;
446 : : }
447 [ - + ]: 241760 : if (nargs < 2) {
448 : 0 : goto skip_optional;
449 : : }
450 [ - + ]: 241760 : if (args[1] == Py_None) {
451 : 0 : errors = NULL;
452 : : }
453 [ + - ]: 241760 : else if (PyUnicode_Check(args[1])) {
454 : : Py_ssize_t errors_length;
455 : 241760 : errors = PyUnicode_AsUTF8AndSize(args[1], &errors_length);
456 [ - + ]: 241760 : if (errors == NULL) {
457 : 0 : goto exit;
458 : : }
459 [ - + ]: 241760 : if (strlen(errors) != (size_t)errors_length) {
460 : 0 : PyErr_SetString(PyExc_ValueError, "embedded null character");
461 : 0 : goto exit;
462 : : }
463 : : }
464 : : else {
465 : 0 : _PyArg_BadArgument("utf_8_decode", "argument 2", "str or None", args[1]);
466 : 0 : goto exit;
467 : : }
468 [ + + ]: 241760 : if (nargs < 3) {
469 : 199830 : goto skip_optional;
470 : : }
471 : 41930 : final = _PyLong_AsInt(args[2]);
472 [ - + - - ]: 41930 : if (final == -1 && PyErr_Occurred()) {
473 : 0 : goto exit;
474 : : }
475 : 41930 : skip_optional:
476 : 241760 : return_value = _codecs_utf_8_decode_impl(module, &data, errors, final);
477 : :
478 : 241762 : exit:
479 : : /* Cleanup for data */
480 [ + + ]: 241762 : if (data.obj) {
481 : 241760 : PyBuffer_Release(&data);
482 : : }
483 : :
484 : 241762 : return return_value;
485 : : }
486 : :
487 : : PyDoc_STRVAR(_codecs_utf_16_decode__doc__,
488 : : "utf_16_decode($module, data, errors=None, final=False, /)\n"
489 : : "--\n"
490 : : "\n");
491 : :
492 : : #define _CODECS_UTF_16_DECODE_METHODDEF \
493 : : {"utf_16_decode", _PyCFunction_CAST(_codecs_utf_16_decode), METH_FASTCALL, _codecs_utf_16_decode__doc__},
494 : :
495 : : static PyObject *
496 : : _codecs_utf_16_decode_impl(PyObject *module, Py_buffer *data,
497 : : const char *errors, int final);
498 : :
499 : : static PyObject *
500 : 5 : _codecs_utf_16_decode(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
501 : : {
502 : 5 : PyObject *return_value = NULL;
503 : 5 : Py_buffer data = {NULL, NULL};
504 : 5 : const char *errors = NULL;
505 : 5 : int final = 0;
506 : :
507 [ + - - + : 5 : if (!_PyArg_CheckPositional("utf_16_decode", nargs, 1, 3)) {
- - ]
508 : 0 : goto exit;
509 : : }
510 [ + + ]: 5 : if (PyObject_GetBuffer(args[0], &data, PyBUF_SIMPLE) != 0) {
511 : 1 : goto exit;
512 : : }
513 [ - + ]: 4 : if (!PyBuffer_IsContiguous(&data, 'C')) {
514 : 0 : _PyArg_BadArgument("utf_16_decode", "argument 1", "contiguous buffer", args[0]);
515 : 0 : goto exit;
516 : : }
517 [ - + ]: 4 : if (nargs < 2) {
518 : 0 : goto skip_optional;
519 : : }
520 [ - + ]: 4 : if (args[1] == Py_None) {
521 : 0 : errors = NULL;
522 : : }
523 [ + - ]: 4 : else if (PyUnicode_Check(args[1])) {
524 : : Py_ssize_t errors_length;
525 : 4 : errors = PyUnicode_AsUTF8AndSize(args[1], &errors_length);
526 [ - + ]: 4 : if (errors == NULL) {
527 : 0 : goto exit;
528 : : }
529 [ - + ]: 4 : if (strlen(errors) != (size_t)errors_length) {
530 : 0 : PyErr_SetString(PyExc_ValueError, "embedded null character");
531 : 0 : goto exit;
532 : : }
533 : : }
534 : : else {
535 : 0 : _PyArg_BadArgument("utf_16_decode", "argument 2", "str or None", args[1]);
536 : 0 : goto exit;
537 : : }
538 [ - + ]: 4 : if (nargs < 3) {
539 : 0 : goto skip_optional;
540 : : }
541 : 4 : final = _PyLong_AsInt(args[2]);
542 [ - + - - ]: 4 : if (final == -1 && PyErr_Occurred()) {
543 : 0 : goto exit;
544 : : }
545 : 4 : skip_optional:
546 : 4 : return_value = _codecs_utf_16_decode_impl(module, &data, errors, final);
547 : :
548 : 5 : exit:
549 : : /* Cleanup for data */
550 [ + + ]: 5 : if (data.obj) {
551 : 4 : PyBuffer_Release(&data);
552 : : }
553 : :
554 : 5 : return return_value;
555 : : }
556 : :
557 : : PyDoc_STRVAR(_codecs_utf_16_le_decode__doc__,
558 : : "utf_16_le_decode($module, data, errors=None, final=False, /)\n"
559 : : "--\n"
560 : : "\n");
561 : :
562 : : #define _CODECS_UTF_16_LE_DECODE_METHODDEF \
563 : : {"utf_16_le_decode", _PyCFunction_CAST(_codecs_utf_16_le_decode), METH_FASTCALL, _codecs_utf_16_le_decode__doc__},
564 : :
565 : : static PyObject *
566 : : _codecs_utf_16_le_decode_impl(PyObject *module, Py_buffer *data,
567 : : const char *errors, int final);
568 : :
569 : : static PyObject *
570 : 20588 : _codecs_utf_16_le_decode(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
571 : : {
572 : 20588 : PyObject *return_value = NULL;
573 : 20588 : Py_buffer data = {NULL, NULL};
574 : 20588 : const char *errors = NULL;
575 : 20588 : int final = 0;
576 : :
577 [ + - - + : 20588 : if (!_PyArg_CheckPositional("utf_16_le_decode", nargs, 1, 3)) {
- - ]
578 : 0 : goto exit;
579 : : }
580 [ + + ]: 20588 : if (PyObject_GetBuffer(args[0], &data, PyBUF_SIMPLE) != 0) {
581 : 2 : goto exit;
582 : : }
583 [ - + ]: 20586 : if (!PyBuffer_IsContiguous(&data, 'C')) {
584 : 0 : _PyArg_BadArgument("utf_16_le_decode", "argument 1", "contiguous buffer", args[0]);
585 : 0 : goto exit;
586 : : }
587 [ - + ]: 20586 : if (nargs < 2) {
588 : 0 : goto skip_optional;
589 : : }
590 [ - + ]: 20586 : if (args[1] == Py_None) {
591 : 0 : errors = NULL;
592 : : }
593 [ + - ]: 20586 : else if (PyUnicode_Check(args[1])) {
594 : : Py_ssize_t errors_length;
595 : 20586 : errors = PyUnicode_AsUTF8AndSize(args[1], &errors_length);
596 [ - + ]: 20586 : if (errors == NULL) {
597 : 0 : goto exit;
598 : : }
599 [ - + ]: 20586 : if (strlen(errors) != (size_t)errors_length) {
600 : 0 : PyErr_SetString(PyExc_ValueError, "embedded null character");
601 : 0 : goto exit;
602 : : }
603 : : }
604 : : else {
605 : 0 : _PyArg_BadArgument("utf_16_le_decode", "argument 2", "str or None", args[1]);
606 : 0 : goto exit;
607 : : }
608 [ + + ]: 20586 : if (nargs < 3) {
609 : 15173 : goto skip_optional;
610 : : }
611 : 5413 : final = _PyLong_AsInt(args[2]);
612 [ - + - - ]: 5413 : if (final == -1 && PyErr_Occurred()) {
613 : 0 : goto exit;
614 : : }
615 : 5413 : skip_optional:
616 : 20586 : return_value = _codecs_utf_16_le_decode_impl(module, &data, errors, final);
617 : :
618 : 20588 : exit:
619 : : /* Cleanup for data */
620 [ + + ]: 20588 : if (data.obj) {
621 : 20586 : PyBuffer_Release(&data);
622 : : }
623 : :
624 : 20588 : return return_value;
625 : : }
626 : :
627 : : PyDoc_STRVAR(_codecs_utf_16_be_decode__doc__,
628 : : "utf_16_be_decode($module, data, errors=None, final=False, /)\n"
629 : : "--\n"
630 : : "\n");
631 : :
632 : : #define _CODECS_UTF_16_BE_DECODE_METHODDEF \
633 : : {"utf_16_be_decode", _PyCFunction_CAST(_codecs_utf_16_be_decode), METH_FASTCALL, _codecs_utf_16_be_decode__doc__},
634 : :
635 : : static PyObject *
636 : : _codecs_utf_16_be_decode_impl(PyObject *module, Py_buffer *data,
637 : : const char *errors, int final);
638 : :
639 : : static PyObject *
640 : 11232 : _codecs_utf_16_be_decode(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
641 : : {
642 : 11232 : PyObject *return_value = NULL;
643 : 11232 : Py_buffer data = {NULL, NULL};
644 : 11232 : const char *errors = NULL;
645 : 11232 : int final = 0;
646 : :
647 [ + - - + : 11232 : if (!_PyArg_CheckPositional("utf_16_be_decode", nargs, 1, 3)) {
- - ]
648 : 0 : goto exit;
649 : : }
650 [ + + ]: 11232 : if (PyObject_GetBuffer(args[0], &data, PyBUF_SIMPLE) != 0) {
651 : 2 : goto exit;
652 : : }
653 [ - + ]: 11230 : if (!PyBuffer_IsContiguous(&data, 'C')) {
654 : 0 : _PyArg_BadArgument("utf_16_be_decode", "argument 1", "contiguous buffer", args[0]);
655 : 0 : goto exit;
656 : : }
657 [ - + ]: 11230 : if (nargs < 2) {
658 : 0 : goto skip_optional;
659 : : }
660 [ - + ]: 11230 : if (args[1] == Py_None) {
661 : 0 : errors = NULL;
662 : : }
663 [ + - ]: 11230 : else if (PyUnicode_Check(args[1])) {
664 : : Py_ssize_t errors_length;
665 : 11230 : errors = PyUnicode_AsUTF8AndSize(args[1], &errors_length);
666 [ - + ]: 11230 : if (errors == NULL) {
667 : 0 : goto exit;
668 : : }
669 [ - + ]: 11230 : if (strlen(errors) != (size_t)errors_length) {
670 : 0 : PyErr_SetString(PyExc_ValueError, "embedded null character");
671 : 0 : goto exit;
672 : : }
673 : : }
674 : : else {
675 : 0 : _PyArg_BadArgument("utf_16_be_decode", "argument 2", "str or None", args[1]);
676 : 0 : goto exit;
677 : : }
678 [ + + ]: 11230 : if (nargs < 3) {
679 : 7907 : goto skip_optional;
680 : : }
681 : 3323 : final = _PyLong_AsInt(args[2]);
682 [ - + - - ]: 3323 : if (final == -1 && PyErr_Occurred()) {
683 : 0 : goto exit;
684 : : }
685 : 3323 : skip_optional:
686 : 11230 : return_value = _codecs_utf_16_be_decode_impl(module, &data, errors, final);
687 : :
688 : 11232 : exit:
689 : : /* Cleanup for data */
690 [ + + ]: 11232 : if (data.obj) {
691 : 11230 : PyBuffer_Release(&data);
692 : : }
693 : :
694 : 11232 : return return_value;
695 : : }
696 : :
697 : : PyDoc_STRVAR(_codecs_utf_16_ex_decode__doc__,
698 : : "utf_16_ex_decode($module, data, errors=None, byteorder=0, final=False,\n"
699 : : " /)\n"
700 : : "--\n"
701 : : "\n");
702 : :
703 : : #define _CODECS_UTF_16_EX_DECODE_METHODDEF \
704 : : {"utf_16_ex_decode", _PyCFunction_CAST(_codecs_utf_16_ex_decode), METH_FASTCALL, _codecs_utf_16_ex_decode__doc__},
705 : :
706 : : static PyObject *
707 : : _codecs_utf_16_ex_decode_impl(PyObject *module, Py_buffer *data,
708 : : const char *errors, int byteorder, int final);
709 : :
710 : : static PyObject *
711 : 973 : _codecs_utf_16_ex_decode(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
712 : : {
713 : 973 : PyObject *return_value = NULL;
714 : 973 : Py_buffer data = {NULL, NULL};
715 : 973 : const char *errors = NULL;
716 : 973 : int byteorder = 0;
717 : 973 : int final = 0;
718 : :
719 [ + + - + : 973 : if (!_PyArg_CheckPositional("utf_16_ex_decode", nargs, 1, 4)) {
+ - ]
720 : 1 : goto exit;
721 : : }
722 [ + + ]: 972 : if (PyObject_GetBuffer(args[0], &data, PyBUF_SIMPLE) != 0) {
723 : 1 : goto exit;
724 : : }
725 [ - + ]: 971 : if (!PyBuffer_IsContiguous(&data, 'C')) {
726 : 0 : _PyArg_BadArgument("utf_16_ex_decode", "argument 1", "contiguous buffer", args[0]);
727 : 0 : goto exit;
728 : : }
729 [ - + ]: 971 : if (nargs < 2) {
730 : 0 : goto skip_optional;
731 : : }
732 [ - + ]: 971 : if (args[1] == Py_None) {
733 : 0 : errors = NULL;
734 : : }
735 [ + - ]: 971 : else if (PyUnicode_Check(args[1])) {
736 : : Py_ssize_t errors_length;
737 : 971 : errors = PyUnicode_AsUTF8AndSize(args[1], &errors_length);
738 [ - + ]: 971 : if (errors == NULL) {
739 : 0 : goto exit;
740 : : }
741 [ - + ]: 971 : if (strlen(errors) != (size_t)errors_length) {
742 : 0 : PyErr_SetString(PyExc_ValueError, "embedded null character");
743 : 0 : goto exit;
744 : : }
745 : : }
746 : : else {
747 : 0 : _PyArg_BadArgument("utf_16_ex_decode", "argument 2", "str or None", args[1]);
748 : 0 : goto exit;
749 : : }
750 [ - + ]: 971 : if (nargs < 3) {
751 : 0 : goto skip_optional;
752 : : }
753 : 971 : byteorder = _PyLong_AsInt(args[2]);
754 [ - + - - ]: 971 : if (byteorder == -1 && PyErr_Occurred()) {
755 : 0 : goto exit;
756 : : }
757 [ - + ]: 971 : if (nargs < 4) {
758 : 0 : goto skip_optional;
759 : : }
760 : 971 : final = _PyLong_AsInt(args[3]);
761 [ - + - - ]: 971 : if (final == -1 && PyErr_Occurred()) {
762 : 0 : goto exit;
763 : : }
764 : 971 : skip_optional:
765 : 971 : return_value = _codecs_utf_16_ex_decode_impl(module, &data, errors, byteorder, final);
766 : :
767 : 973 : exit:
768 : : /* Cleanup for data */
769 [ + + ]: 973 : if (data.obj) {
770 : 971 : PyBuffer_Release(&data);
771 : : }
772 : :
773 : 973 : return return_value;
774 : : }
775 : :
776 : : PyDoc_STRVAR(_codecs_utf_32_decode__doc__,
777 : : "utf_32_decode($module, data, errors=None, final=False, /)\n"
778 : : "--\n"
779 : : "\n");
780 : :
781 : : #define _CODECS_UTF_32_DECODE_METHODDEF \
782 : : {"utf_32_decode", _PyCFunction_CAST(_codecs_utf_32_decode), METH_FASTCALL, _codecs_utf_32_decode__doc__},
783 : :
784 : : static PyObject *
785 : : _codecs_utf_32_decode_impl(PyObject *module, Py_buffer *data,
786 : : const char *errors, int final);
787 : :
788 : : static PyObject *
789 : 6 : _codecs_utf_32_decode(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
790 : : {
791 : 6 : PyObject *return_value = NULL;
792 : 6 : Py_buffer data = {NULL, NULL};
793 : 6 : const char *errors = NULL;
794 : 6 : int final = 0;
795 : :
796 [ + - - + : 6 : if (!_PyArg_CheckPositional("utf_32_decode", nargs, 1, 3)) {
- - ]
797 : 0 : goto exit;
798 : : }
799 [ + + ]: 6 : if (PyObject_GetBuffer(args[0], &data, PyBUF_SIMPLE) != 0) {
800 : 1 : goto exit;
801 : : }
802 [ - + ]: 5 : if (!PyBuffer_IsContiguous(&data, 'C')) {
803 : 0 : _PyArg_BadArgument("utf_32_decode", "argument 1", "contiguous buffer", args[0]);
804 : 0 : goto exit;
805 : : }
806 [ + + ]: 5 : if (nargs < 2) {
807 : 2 : goto skip_optional;
808 : : }
809 [ - + ]: 3 : if (args[1] == Py_None) {
810 : 0 : errors = NULL;
811 : : }
812 [ + - ]: 3 : else if (PyUnicode_Check(args[1])) {
813 : : Py_ssize_t errors_length;
814 : 3 : errors = PyUnicode_AsUTF8AndSize(args[1], &errors_length);
815 [ - + ]: 3 : if (errors == NULL) {
816 : 0 : goto exit;
817 : : }
818 [ - + ]: 3 : if (strlen(errors) != (size_t)errors_length) {
819 : 0 : PyErr_SetString(PyExc_ValueError, "embedded null character");
820 : 0 : goto exit;
821 : : }
822 : : }
823 : : else {
824 : 0 : _PyArg_BadArgument("utf_32_decode", "argument 2", "str or None", args[1]);
825 : 0 : goto exit;
826 : : }
827 [ - + ]: 3 : if (nargs < 3) {
828 : 0 : goto skip_optional;
829 : : }
830 : 3 : final = _PyLong_AsInt(args[2]);
831 [ - + - - ]: 3 : if (final == -1 && PyErr_Occurred()) {
832 : 0 : goto exit;
833 : : }
834 : 3 : skip_optional:
835 : 5 : return_value = _codecs_utf_32_decode_impl(module, &data, errors, final);
836 : :
837 : 6 : exit:
838 : : /* Cleanup for data */
839 [ + + ]: 6 : if (data.obj) {
840 : 5 : PyBuffer_Release(&data);
841 : : }
842 : :
843 : 6 : return return_value;
844 : : }
845 : :
846 : : PyDoc_STRVAR(_codecs_utf_32_le_decode__doc__,
847 : : "utf_32_le_decode($module, data, errors=None, final=False, /)\n"
848 : : "--\n"
849 : : "\n");
850 : :
851 : : #define _CODECS_UTF_32_LE_DECODE_METHODDEF \
852 : : {"utf_32_le_decode", _PyCFunction_CAST(_codecs_utf_32_le_decode), METH_FASTCALL, _codecs_utf_32_le_decode__doc__},
853 : :
854 : : static PyObject *
855 : : _codecs_utf_32_le_decode_impl(PyObject *module, Py_buffer *data,
856 : : const char *errors, int final);
857 : :
858 : : static PyObject *
859 : 37697 : _codecs_utf_32_le_decode(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
860 : : {
861 : 37697 : PyObject *return_value = NULL;
862 : 37697 : Py_buffer data = {NULL, NULL};
863 : 37697 : const char *errors = NULL;
864 : 37697 : int final = 0;
865 : :
866 [ + - - + : 37697 : if (!_PyArg_CheckPositional("utf_32_le_decode", nargs, 1, 3)) {
- - ]
867 : 0 : goto exit;
868 : : }
869 [ + + ]: 37697 : if (PyObject_GetBuffer(args[0], &data, PyBUF_SIMPLE) != 0) {
870 : 1 : goto exit;
871 : : }
872 [ - + ]: 37696 : if (!PyBuffer_IsContiguous(&data, 'C')) {
873 : 0 : _PyArg_BadArgument("utf_32_le_decode", "argument 1", "contiguous buffer", args[0]);
874 : 0 : goto exit;
875 : : }
876 [ + + ]: 37696 : if (nargs < 2) {
877 : 1 : goto skip_optional;
878 : : }
879 [ - + ]: 37695 : if (args[1] == Py_None) {
880 : 0 : errors = NULL;
881 : : }
882 [ + - ]: 37695 : else if (PyUnicode_Check(args[1])) {
883 : : Py_ssize_t errors_length;
884 : 37695 : errors = PyUnicode_AsUTF8AndSize(args[1], &errors_length);
885 [ - + ]: 37695 : if (errors == NULL) {
886 : 0 : goto exit;
887 : : }
888 [ - + ]: 37695 : if (strlen(errors) != (size_t)errors_length) {
889 : 0 : PyErr_SetString(PyExc_ValueError, "embedded null character");
890 : 0 : goto exit;
891 : : }
892 : : }
893 : : else {
894 : 0 : _PyArg_BadArgument("utf_32_le_decode", "argument 2", "str or None", args[1]);
895 : 0 : goto exit;
896 : : }
897 [ + + ]: 37695 : if (nargs < 3) {
898 : 30198 : goto skip_optional;
899 : : }
900 : 7497 : final = _PyLong_AsInt(args[2]);
901 [ - + - - ]: 7497 : if (final == -1 && PyErr_Occurred()) {
902 : 0 : goto exit;
903 : : }
904 : 7497 : skip_optional:
905 : 37696 : return_value = _codecs_utf_32_le_decode_impl(module, &data, errors, final);
906 : :
907 : 37697 : exit:
908 : : /* Cleanup for data */
909 [ + + ]: 37697 : if (data.obj) {
910 : 37696 : PyBuffer_Release(&data);
911 : : }
912 : :
913 : 37697 : return return_value;
914 : : }
915 : :
916 : : PyDoc_STRVAR(_codecs_utf_32_be_decode__doc__,
917 : : "utf_32_be_decode($module, data, errors=None, final=False, /)\n"
918 : : "--\n"
919 : : "\n");
920 : :
921 : : #define _CODECS_UTF_32_BE_DECODE_METHODDEF \
922 : : {"utf_32_be_decode", _PyCFunction_CAST(_codecs_utf_32_be_decode), METH_FASTCALL, _codecs_utf_32_be_decode__doc__},
923 : :
924 : : static PyObject *
925 : : _codecs_utf_32_be_decode_impl(PyObject *module, Py_buffer *data,
926 : : const char *errors, int final);
927 : :
928 : : static PyObject *
929 : 19232 : _codecs_utf_32_be_decode(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
930 : : {
931 : 19232 : PyObject *return_value = NULL;
932 : 19232 : Py_buffer data = {NULL, NULL};
933 : 19232 : const char *errors = NULL;
934 : 19232 : int final = 0;
935 : :
936 [ + - - + : 19232 : if (!_PyArg_CheckPositional("utf_32_be_decode", nargs, 1, 3)) {
- - ]
937 : 0 : goto exit;
938 : : }
939 [ + + ]: 19232 : if (PyObject_GetBuffer(args[0], &data, PyBUF_SIMPLE) != 0) {
940 : 1 : goto exit;
941 : : }
942 [ - + ]: 19231 : if (!PyBuffer_IsContiguous(&data, 'C')) {
943 : 0 : _PyArg_BadArgument("utf_32_be_decode", "argument 1", "contiguous buffer", args[0]);
944 : 0 : goto exit;
945 : : }
946 [ + + ]: 19231 : if (nargs < 2) {
947 : 1 : goto skip_optional;
948 : : }
949 [ - + ]: 19230 : if (args[1] == Py_None) {
950 : 0 : errors = NULL;
951 : : }
952 [ + - ]: 19230 : else if (PyUnicode_Check(args[1])) {
953 : : Py_ssize_t errors_length;
954 : 19230 : errors = PyUnicode_AsUTF8AndSize(args[1], &errors_length);
955 [ - + ]: 19230 : if (errors == NULL) {
956 : 0 : goto exit;
957 : : }
958 [ - + ]: 19230 : if (strlen(errors) != (size_t)errors_length) {
959 : 0 : PyErr_SetString(PyExc_ValueError, "embedded null character");
960 : 0 : goto exit;
961 : : }
962 : : }
963 : : else {
964 : 0 : _PyArg_BadArgument("utf_32_be_decode", "argument 2", "str or None", args[1]);
965 : 0 : goto exit;
966 : : }
967 [ + + ]: 19230 : if (nargs < 3) {
968 : 15404 : goto skip_optional;
969 : : }
970 : 3826 : final = _PyLong_AsInt(args[2]);
971 [ - + - - ]: 3826 : if (final == -1 && PyErr_Occurred()) {
972 : 0 : goto exit;
973 : : }
974 : 3826 : skip_optional:
975 : 19231 : return_value = _codecs_utf_32_be_decode_impl(module, &data, errors, final);
976 : :
977 : 19232 : exit:
978 : : /* Cleanup for data */
979 [ + + ]: 19232 : if (data.obj) {
980 : 19231 : PyBuffer_Release(&data);
981 : : }
982 : :
983 : 19232 : return return_value;
984 : : }
985 : :
986 : : PyDoc_STRVAR(_codecs_utf_32_ex_decode__doc__,
987 : : "utf_32_ex_decode($module, data, errors=None, byteorder=0, final=False,\n"
988 : : " /)\n"
989 : : "--\n"
990 : : "\n");
991 : :
992 : : #define _CODECS_UTF_32_EX_DECODE_METHODDEF \
993 : : {"utf_32_ex_decode", _PyCFunction_CAST(_codecs_utf_32_ex_decode), METH_FASTCALL, _codecs_utf_32_ex_decode__doc__},
994 : :
995 : : static PyObject *
996 : : _codecs_utf_32_ex_decode_impl(PyObject *module, Py_buffer *data,
997 : : const char *errors, int byteorder, int final);
998 : :
999 : : static PyObject *
1000 : 1031 : _codecs_utf_32_ex_decode(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
1001 : : {
1002 : 1031 : PyObject *return_value = NULL;
1003 : 1031 : Py_buffer data = {NULL, NULL};
1004 : 1031 : const char *errors = NULL;
1005 : 1031 : int byteorder = 0;
1006 : 1031 : int final = 0;
1007 : :
1008 [ + - - + : 1031 : if (!_PyArg_CheckPositional("utf_32_ex_decode", nargs, 1, 4)) {
- - ]
1009 : 0 : goto exit;
1010 : : }
1011 [ + + ]: 1031 : if (PyObject_GetBuffer(args[0], &data, PyBUF_SIMPLE) != 0) {
1012 : 1 : goto exit;
1013 : : }
1014 [ - + ]: 1030 : if (!PyBuffer_IsContiguous(&data, 'C')) {
1015 : 0 : _PyArg_BadArgument("utf_32_ex_decode", "argument 1", "contiguous buffer", args[0]);
1016 : 0 : goto exit;
1017 : : }
1018 [ - + ]: 1030 : if (nargs < 2) {
1019 : 0 : goto skip_optional;
1020 : : }
1021 [ - + ]: 1030 : if (args[1] == Py_None) {
1022 : 0 : errors = NULL;
1023 : : }
1024 [ + - ]: 1030 : else if (PyUnicode_Check(args[1])) {
1025 : : Py_ssize_t errors_length;
1026 : 1030 : errors = PyUnicode_AsUTF8AndSize(args[1], &errors_length);
1027 [ - + ]: 1030 : if (errors == NULL) {
1028 : 0 : goto exit;
1029 : : }
1030 [ - + ]: 1030 : if (strlen(errors) != (size_t)errors_length) {
1031 : 0 : PyErr_SetString(PyExc_ValueError, "embedded null character");
1032 : 0 : goto exit;
1033 : : }
1034 : : }
1035 : : else {
1036 : 0 : _PyArg_BadArgument("utf_32_ex_decode", "argument 2", "str or None", args[1]);
1037 : 0 : goto exit;
1038 : : }
1039 [ - + ]: 1030 : if (nargs < 3) {
1040 : 0 : goto skip_optional;
1041 : : }
1042 : 1030 : byteorder = _PyLong_AsInt(args[2]);
1043 [ - + - - ]: 1030 : if (byteorder == -1 && PyErr_Occurred()) {
1044 : 0 : goto exit;
1045 : : }
1046 [ - + ]: 1030 : if (nargs < 4) {
1047 : 0 : goto skip_optional;
1048 : : }
1049 : 1030 : final = _PyLong_AsInt(args[3]);
1050 [ - + - - ]: 1030 : if (final == -1 && PyErr_Occurred()) {
1051 : 0 : goto exit;
1052 : : }
1053 : 1030 : skip_optional:
1054 : 1030 : return_value = _codecs_utf_32_ex_decode_impl(module, &data, errors, byteorder, final);
1055 : :
1056 : 1031 : exit:
1057 : : /* Cleanup for data */
1058 [ + + ]: 1031 : if (data.obj) {
1059 : 1030 : PyBuffer_Release(&data);
1060 : : }
1061 : :
1062 : 1031 : return return_value;
1063 : : }
1064 : :
1065 : : PyDoc_STRVAR(_codecs_unicode_escape_decode__doc__,
1066 : : "unicode_escape_decode($module, data, errors=None, final=True, /)\n"
1067 : : "--\n"
1068 : : "\n");
1069 : :
1070 : : #define _CODECS_UNICODE_ESCAPE_DECODE_METHODDEF \
1071 : : {"unicode_escape_decode", _PyCFunction_CAST(_codecs_unicode_escape_decode), METH_FASTCALL, _codecs_unicode_escape_decode__doc__},
1072 : :
1073 : : static PyObject *
1074 : : _codecs_unicode_escape_decode_impl(PyObject *module, Py_buffer *data,
1075 : : const char *errors, int final);
1076 : :
1077 : : static PyObject *
1078 : 6317 : _codecs_unicode_escape_decode(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
1079 : : {
1080 : 6317 : PyObject *return_value = NULL;
1081 : 6317 : Py_buffer data = {NULL, NULL};
1082 : 6317 : const char *errors = NULL;
1083 : 6317 : int final = 1;
1084 : :
1085 [ + + - + : 6317 : if (!_PyArg_CheckPositional("unicode_escape_decode", nargs, 1, 3)) {
+ - ]
1086 : 1 : goto exit;
1087 : : }
1088 [ + + ]: 6316 : if (PyUnicode_Check(args[0])) {
1089 : : Py_ssize_t len;
1090 : 3 : const char *ptr = PyUnicode_AsUTF8AndSize(args[0], &len);
1091 [ - + ]: 3 : if (ptr == NULL) {
1092 : 0 : goto exit;
1093 : : }
1094 : 3 : PyBuffer_FillInfo(&data, args[0], (void *)ptr, len, 1, 0);
1095 : : }
1096 : : else { /* any bytes-like object */
1097 [ + + ]: 6313 : if (PyObject_GetBuffer(args[0], &data, PyBUF_SIMPLE) != 0) {
1098 : 1 : goto exit;
1099 : : }
1100 [ - + ]: 6312 : if (!PyBuffer_IsContiguous(&data, 'C')) {
1101 : 0 : _PyArg_BadArgument("unicode_escape_decode", "argument 1", "contiguous buffer", args[0]);
1102 : 0 : goto exit;
1103 : : }
1104 : : }
1105 [ + + ]: 6315 : if (nargs < 2) {
1106 : 1629 : goto skip_optional;
1107 : : }
1108 [ - + ]: 4686 : if (args[1] == Py_None) {
1109 : 0 : errors = NULL;
1110 : : }
1111 [ + - ]: 4686 : else if (PyUnicode_Check(args[1])) {
1112 : : Py_ssize_t errors_length;
1113 : 4686 : errors = PyUnicode_AsUTF8AndSize(args[1], &errors_length);
1114 [ - + ]: 4686 : if (errors == NULL) {
1115 : 0 : goto exit;
1116 : : }
1117 [ - + ]: 4686 : if (strlen(errors) != (size_t)errors_length) {
1118 : 0 : PyErr_SetString(PyExc_ValueError, "embedded null character");
1119 : 0 : goto exit;
1120 : : }
1121 : : }
1122 : : else {
1123 : 0 : _PyArg_BadArgument("unicode_escape_decode", "argument 2", "str or None", args[1]);
1124 : 0 : goto exit;
1125 : : }
1126 [ + + ]: 4686 : if (nargs < 3) {
1127 : 37 : goto skip_optional;
1128 : : }
1129 : 4649 : final = _PyLong_AsInt(args[2]);
1130 [ - + - - ]: 4649 : if (final == -1 && PyErr_Occurred()) {
1131 : 0 : goto exit;
1132 : : }
1133 : 4649 : skip_optional:
1134 : 6315 : return_value = _codecs_unicode_escape_decode_impl(module, &data, errors, final);
1135 : :
1136 : 6317 : exit:
1137 : : /* Cleanup for data */
1138 [ + + ]: 6317 : if (data.obj) {
1139 : 6315 : PyBuffer_Release(&data);
1140 : : }
1141 : :
1142 : 6317 : return return_value;
1143 : : }
1144 : :
1145 : : PyDoc_STRVAR(_codecs_raw_unicode_escape_decode__doc__,
1146 : : "raw_unicode_escape_decode($module, data, errors=None, final=True, /)\n"
1147 : : "--\n"
1148 : : "\n");
1149 : :
1150 : : #define _CODECS_RAW_UNICODE_ESCAPE_DECODE_METHODDEF \
1151 : : {"raw_unicode_escape_decode", _PyCFunction_CAST(_codecs_raw_unicode_escape_decode), METH_FASTCALL, _codecs_raw_unicode_escape_decode__doc__},
1152 : :
1153 : : static PyObject *
1154 : : _codecs_raw_unicode_escape_decode_impl(PyObject *module, Py_buffer *data,
1155 : : const char *errors, int final);
1156 : :
1157 : : static PyObject *
1158 : 40761 : _codecs_raw_unicode_escape_decode(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
1159 : : {
1160 : 40761 : PyObject *return_value = NULL;
1161 : 40761 : Py_buffer data = {NULL, NULL};
1162 : 40761 : const char *errors = NULL;
1163 : 40761 : int final = 1;
1164 : :
1165 [ + + - + : 40761 : if (!_PyArg_CheckPositional("raw_unicode_escape_decode", nargs, 1, 3)) {
+ - ]
1166 : 1 : goto exit;
1167 : : }
1168 [ + + ]: 40760 : if (PyUnicode_Check(args[0])) {
1169 : : Py_ssize_t len;
1170 : 3 : const char *ptr = PyUnicode_AsUTF8AndSize(args[0], &len);
1171 [ - + ]: 3 : if (ptr == NULL) {
1172 : 0 : goto exit;
1173 : : }
1174 : 3 : PyBuffer_FillInfo(&data, args[0], (void *)ptr, len, 1, 0);
1175 : : }
1176 : : else { /* any bytes-like object */
1177 [ + + ]: 40757 : if (PyObject_GetBuffer(args[0], &data, PyBUF_SIMPLE) != 0) {
1178 : 1 : goto exit;
1179 : : }
1180 [ - + ]: 40756 : if (!PyBuffer_IsContiguous(&data, 'C')) {
1181 : 0 : _PyArg_BadArgument("raw_unicode_escape_decode", "argument 1", "contiguous buffer", args[0]);
1182 : 0 : goto exit;
1183 : : }
1184 : : }
1185 [ + + ]: 40759 : if (nargs < 2) {
1186 : 36254 : goto skip_optional;
1187 : : }
1188 [ - + ]: 4505 : if (args[1] == Py_None) {
1189 : 0 : errors = NULL;
1190 : : }
1191 [ + - ]: 4505 : else if (PyUnicode_Check(args[1])) {
1192 : : Py_ssize_t errors_length;
1193 : 4505 : errors = PyUnicode_AsUTF8AndSize(args[1], &errors_length);
1194 [ - + ]: 4505 : if (errors == NULL) {
1195 : 0 : goto exit;
1196 : : }
1197 [ - + ]: 4505 : if (strlen(errors) != (size_t)errors_length) {
1198 : 0 : PyErr_SetString(PyExc_ValueError, "embedded null character");
1199 : 0 : goto exit;
1200 : : }
1201 : : }
1202 : : else {
1203 : 0 : _PyArg_BadArgument("raw_unicode_escape_decode", "argument 2", "str or None", args[1]);
1204 : 0 : goto exit;
1205 : : }
1206 [ + + ]: 4505 : if (nargs < 3) {
1207 : 24 : goto skip_optional;
1208 : : }
1209 : 4481 : final = _PyLong_AsInt(args[2]);
1210 [ - + - - ]: 4481 : if (final == -1 && PyErr_Occurred()) {
1211 : 0 : goto exit;
1212 : : }
1213 : 4481 : skip_optional:
1214 : 40759 : return_value = _codecs_raw_unicode_escape_decode_impl(module, &data, errors, final);
1215 : :
1216 : 40761 : exit:
1217 : : /* Cleanup for data */
1218 [ + + ]: 40761 : if (data.obj) {
1219 : 40759 : PyBuffer_Release(&data);
1220 : : }
1221 : :
1222 : 40761 : return return_value;
1223 : : }
1224 : :
1225 : : PyDoc_STRVAR(_codecs_latin_1_decode__doc__,
1226 : : "latin_1_decode($module, data, errors=None, /)\n"
1227 : : "--\n"
1228 : : "\n");
1229 : :
1230 : : #define _CODECS_LATIN_1_DECODE_METHODDEF \
1231 : : {"latin_1_decode", _PyCFunction_CAST(_codecs_latin_1_decode), METH_FASTCALL, _codecs_latin_1_decode__doc__},
1232 : :
1233 : : static PyObject *
1234 : : _codecs_latin_1_decode_impl(PyObject *module, Py_buffer *data,
1235 : : const char *errors);
1236 : :
1237 : : static PyObject *
1238 : 1882 : _codecs_latin_1_decode(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
1239 : : {
1240 : 1882 : PyObject *return_value = NULL;
1241 : 1882 : Py_buffer data = {NULL, NULL};
1242 : 1882 : const char *errors = NULL;
1243 : :
1244 [ + + - + : 1882 : if (!_PyArg_CheckPositional("latin_1_decode", nargs, 1, 2)) {
+ - ]
1245 : 2 : goto exit;
1246 : : }
1247 [ + + ]: 1880 : if (PyObject_GetBuffer(args[0], &data, PyBUF_SIMPLE) != 0) {
1248 : 3 : goto exit;
1249 : : }
1250 [ - + ]: 1877 : if (!PyBuffer_IsContiguous(&data, 'C')) {
1251 : 0 : _PyArg_BadArgument("latin_1_decode", "argument 1", "contiguous buffer", args[0]);
1252 : 0 : goto exit;
1253 : : }
1254 [ + + ]: 1877 : if (nargs < 2) {
1255 : 4 : goto skip_optional;
1256 : : }
1257 [ - + ]: 1873 : if (args[1] == Py_None) {
1258 : 0 : errors = NULL;
1259 : : }
1260 [ + - ]: 1873 : else if (PyUnicode_Check(args[1])) {
1261 : : Py_ssize_t errors_length;
1262 : 1873 : errors = PyUnicode_AsUTF8AndSize(args[1], &errors_length);
1263 [ - + ]: 1873 : if (errors == NULL) {
1264 : 0 : goto exit;
1265 : : }
1266 [ - + ]: 1873 : if (strlen(errors) != (size_t)errors_length) {
1267 : 0 : PyErr_SetString(PyExc_ValueError, "embedded null character");
1268 : 0 : goto exit;
1269 : : }
1270 : : }
1271 : : else {
1272 : 0 : _PyArg_BadArgument("latin_1_decode", "argument 2", "str or None", args[1]);
1273 : 0 : goto exit;
1274 : : }
1275 : 1877 : skip_optional:
1276 : 1877 : return_value = _codecs_latin_1_decode_impl(module, &data, errors);
1277 : :
1278 : 1882 : exit:
1279 : : /* Cleanup for data */
1280 [ + + ]: 1882 : if (data.obj) {
1281 : 1877 : PyBuffer_Release(&data);
1282 : : }
1283 : :
1284 : 1882 : return return_value;
1285 : : }
1286 : :
1287 : : PyDoc_STRVAR(_codecs_ascii_decode__doc__,
1288 : : "ascii_decode($module, data, errors=None, /)\n"
1289 : : "--\n"
1290 : : "\n");
1291 : :
1292 : : #define _CODECS_ASCII_DECODE_METHODDEF \
1293 : : {"ascii_decode", _PyCFunction_CAST(_codecs_ascii_decode), METH_FASTCALL, _codecs_ascii_decode__doc__},
1294 : :
1295 : : static PyObject *
1296 : : _codecs_ascii_decode_impl(PyObject *module, Py_buffer *data,
1297 : : const char *errors);
1298 : :
1299 : : static PyObject *
1300 : 1145 : _codecs_ascii_decode(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
1301 : : {
1302 : 1145 : PyObject *return_value = NULL;
1303 : 1145 : Py_buffer data = {NULL, NULL};
1304 : 1145 : const char *errors = NULL;
1305 : :
1306 [ + + - + : 1145 : if (!_PyArg_CheckPositional("ascii_decode", nargs, 1, 2)) {
+ - ]
1307 : 1 : goto exit;
1308 : : }
1309 [ + + ]: 1144 : if (PyObject_GetBuffer(args[0], &data, PyBUF_SIMPLE) != 0) {
1310 : 2 : goto exit;
1311 : : }
1312 [ - + ]: 1142 : if (!PyBuffer_IsContiguous(&data, 'C')) {
1313 : 0 : _PyArg_BadArgument("ascii_decode", "argument 1", "contiguous buffer", args[0]);
1314 : 0 : goto exit;
1315 : : }
1316 [ + + ]: 1142 : if (nargs < 2) {
1317 : 3 : goto skip_optional;
1318 : : }
1319 [ - + ]: 1139 : if (args[1] == Py_None) {
1320 : 0 : errors = NULL;
1321 : : }
1322 [ + - ]: 1139 : else if (PyUnicode_Check(args[1])) {
1323 : : Py_ssize_t errors_length;
1324 : 1139 : errors = PyUnicode_AsUTF8AndSize(args[1], &errors_length);
1325 [ - + ]: 1139 : if (errors == NULL) {
1326 : 0 : goto exit;
1327 : : }
1328 [ - + ]: 1139 : if (strlen(errors) != (size_t)errors_length) {
1329 : 0 : PyErr_SetString(PyExc_ValueError, "embedded null character");
1330 : 0 : goto exit;
1331 : : }
1332 : : }
1333 : : else {
1334 : 0 : _PyArg_BadArgument("ascii_decode", "argument 2", "str or None", args[1]);
1335 : 0 : goto exit;
1336 : : }
1337 : 1142 : skip_optional:
1338 : 1142 : return_value = _codecs_ascii_decode_impl(module, &data, errors);
1339 : :
1340 : 1145 : exit:
1341 : : /* Cleanup for data */
1342 [ + + ]: 1145 : if (data.obj) {
1343 : 1142 : PyBuffer_Release(&data);
1344 : : }
1345 : :
1346 : 1145 : return return_value;
1347 : : }
1348 : :
1349 : : PyDoc_STRVAR(_codecs_charmap_decode__doc__,
1350 : : "charmap_decode($module, data, errors=None, mapping=None, /)\n"
1351 : : "--\n"
1352 : : "\n");
1353 : :
1354 : : #define _CODECS_CHARMAP_DECODE_METHODDEF \
1355 : : {"charmap_decode", _PyCFunction_CAST(_codecs_charmap_decode), METH_FASTCALL, _codecs_charmap_decode__doc__},
1356 : :
1357 : : static PyObject *
1358 : : _codecs_charmap_decode_impl(PyObject *module, Py_buffer *data,
1359 : : const char *errors, PyObject *mapping);
1360 : :
1361 : : static PyObject *
1362 : 23852 : _codecs_charmap_decode(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
1363 : : {
1364 : 23852 : PyObject *return_value = NULL;
1365 : 23852 : Py_buffer data = {NULL, NULL};
1366 : 23852 : const char *errors = NULL;
1367 : 23852 : PyObject *mapping = Py_None;
1368 : :
1369 [ + + - + : 23852 : if (!_PyArg_CheckPositional("charmap_decode", nargs, 1, 3)) {
+ - ]
1370 : 1 : goto exit;
1371 : : }
1372 [ + + ]: 23851 : if (PyObject_GetBuffer(args[0], &data, PyBUF_SIMPLE) != 0) {
1373 : 66 : goto exit;
1374 : : }
1375 [ - + ]: 23785 : if (!PyBuffer_IsContiguous(&data, 'C')) {
1376 : 0 : _PyArg_BadArgument("charmap_decode", "argument 1", "contiguous buffer", args[0]);
1377 : 0 : goto exit;
1378 : : }
1379 [ + + ]: 23785 : if (nargs < 2) {
1380 : 1 : goto skip_optional;
1381 : : }
1382 [ - + ]: 23784 : if (args[1] == Py_None) {
1383 : 0 : errors = NULL;
1384 : : }
1385 [ + - ]: 23784 : else if (PyUnicode_Check(args[1])) {
1386 : : Py_ssize_t errors_length;
1387 : 23784 : errors = PyUnicode_AsUTF8AndSize(args[1], &errors_length);
1388 [ - + ]: 23784 : if (errors == NULL) {
1389 : 0 : goto exit;
1390 : : }
1391 [ - + ]: 23784 : if (strlen(errors) != (size_t)errors_length) {
1392 : 0 : PyErr_SetString(PyExc_ValueError, "embedded null character");
1393 : 0 : goto exit;
1394 : : }
1395 : : }
1396 : : else {
1397 : 0 : _PyArg_BadArgument("charmap_decode", "argument 2", "str or None", args[1]);
1398 : 0 : goto exit;
1399 : : }
1400 [ - + ]: 23784 : if (nargs < 3) {
1401 : 0 : goto skip_optional;
1402 : : }
1403 : 23784 : mapping = args[2];
1404 : 23785 : skip_optional:
1405 : 23785 : return_value = _codecs_charmap_decode_impl(module, &data, errors, mapping);
1406 : :
1407 : 23852 : exit:
1408 : : /* Cleanup for data */
1409 [ + + ]: 23852 : if (data.obj) {
1410 : 23785 : PyBuffer_Release(&data);
1411 : : }
1412 : :
1413 : 23852 : return return_value;
1414 : : }
1415 : :
1416 : : #if defined(MS_WINDOWS)
1417 : :
1418 : : PyDoc_STRVAR(_codecs_mbcs_decode__doc__,
1419 : : "mbcs_decode($module, data, errors=None, final=False, /)\n"
1420 : : "--\n"
1421 : : "\n");
1422 : :
1423 : : #define _CODECS_MBCS_DECODE_METHODDEF \
1424 : : {"mbcs_decode", _PyCFunction_CAST(_codecs_mbcs_decode), METH_FASTCALL, _codecs_mbcs_decode__doc__},
1425 : :
1426 : : static PyObject *
1427 : : _codecs_mbcs_decode_impl(PyObject *module, Py_buffer *data,
1428 : : const char *errors, int final);
1429 : :
1430 : : static PyObject *
1431 : : _codecs_mbcs_decode(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
1432 : : {
1433 : : PyObject *return_value = NULL;
1434 : : Py_buffer data = {NULL, NULL};
1435 : : const char *errors = NULL;
1436 : : int final = 0;
1437 : :
1438 : : if (!_PyArg_CheckPositional("mbcs_decode", nargs, 1, 3)) {
1439 : : goto exit;
1440 : : }
1441 : : if (PyObject_GetBuffer(args[0], &data, PyBUF_SIMPLE) != 0) {
1442 : : goto exit;
1443 : : }
1444 : : if (!PyBuffer_IsContiguous(&data, 'C')) {
1445 : : _PyArg_BadArgument("mbcs_decode", "argument 1", "contiguous buffer", args[0]);
1446 : : goto exit;
1447 : : }
1448 : : if (nargs < 2) {
1449 : : goto skip_optional;
1450 : : }
1451 : : if (args[1] == Py_None) {
1452 : : errors = NULL;
1453 : : }
1454 : : else if (PyUnicode_Check(args[1])) {
1455 : : Py_ssize_t errors_length;
1456 : : errors = PyUnicode_AsUTF8AndSize(args[1], &errors_length);
1457 : : if (errors == NULL) {
1458 : : goto exit;
1459 : : }
1460 : : if (strlen(errors) != (size_t)errors_length) {
1461 : : PyErr_SetString(PyExc_ValueError, "embedded null character");
1462 : : goto exit;
1463 : : }
1464 : : }
1465 : : else {
1466 : : _PyArg_BadArgument("mbcs_decode", "argument 2", "str or None", args[1]);
1467 : : goto exit;
1468 : : }
1469 : : if (nargs < 3) {
1470 : : goto skip_optional;
1471 : : }
1472 : : final = _PyLong_AsInt(args[2]);
1473 : : if (final == -1 && PyErr_Occurred()) {
1474 : : goto exit;
1475 : : }
1476 : : skip_optional:
1477 : : return_value = _codecs_mbcs_decode_impl(module, &data, errors, final);
1478 : :
1479 : : exit:
1480 : : /* Cleanup for data */
1481 : : if (data.obj) {
1482 : : PyBuffer_Release(&data);
1483 : : }
1484 : :
1485 : : return return_value;
1486 : : }
1487 : :
1488 : : #endif /* defined(MS_WINDOWS) */
1489 : :
1490 : : #if defined(MS_WINDOWS)
1491 : :
1492 : : PyDoc_STRVAR(_codecs_oem_decode__doc__,
1493 : : "oem_decode($module, data, errors=None, final=False, /)\n"
1494 : : "--\n"
1495 : : "\n");
1496 : :
1497 : : #define _CODECS_OEM_DECODE_METHODDEF \
1498 : : {"oem_decode", _PyCFunction_CAST(_codecs_oem_decode), METH_FASTCALL, _codecs_oem_decode__doc__},
1499 : :
1500 : : static PyObject *
1501 : : _codecs_oem_decode_impl(PyObject *module, Py_buffer *data,
1502 : : const char *errors, int final);
1503 : :
1504 : : static PyObject *
1505 : : _codecs_oem_decode(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
1506 : : {
1507 : : PyObject *return_value = NULL;
1508 : : Py_buffer data = {NULL, NULL};
1509 : : const char *errors = NULL;
1510 : : int final = 0;
1511 : :
1512 : : if (!_PyArg_CheckPositional("oem_decode", nargs, 1, 3)) {
1513 : : goto exit;
1514 : : }
1515 : : if (PyObject_GetBuffer(args[0], &data, PyBUF_SIMPLE) != 0) {
1516 : : goto exit;
1517 : : }
1518 : : if (!PyBuffer_IsContiguous(&data, 'C')) {
1519 : : _PyArg_BadArgument("oem_decode", "argument 1", "contiguous buffer", args[0]);
1520 : : goto exit;
1521 : : }
1522 : : if (nargs < 2) {
1523 : : goto skip_optional;
1524 : : }
1525 : : if (args[1] == Py_None) {
1526 : : errors = NULL;
1527 : : }
1528 : : else if (PyUnicode_Check(args[1])) {
1529 : : Py_ssize_t errors_length;
1530 : : errors = PyUnicode_AsUTF8AndSize(args[1], &errors_length);
1531 : : if (errors == NULL) {
1532 : : goto exit;
1533 : : }
1534 : : if (strlen(errors) != (size_t)errors_length) {
1535 : : PyErr_SetString(PyExc_ValueError, "embedded null character");
1536 : : goto exit;
1537 : : }
1538 : : }
1539 : : else {
1540 : : _PyArg_BadArgument("oem_decode", "argument 2", "str or None", args[1]);
1541 : : goto exit;
1542 : : }
1543 : : if (nargs < 3) {
1544 : : goto skip_optional;
1545 : : }
1546 : : final = _PyLong_AsInt(args[2]);
1547 : : if (final == -1 && PyErr_Occurred()) {
1548 : : goto exit;
1549 : : }
1550 : : skip_optional:
1551 : : return_value = _codecs_oem_decode_impl(module, &data, errors, final);
1552 : :
1553 : : exit:
1554 : : /* Cleanup for data */
1555 : : if (data.obj) {
1556 : : PyBuffer_Release(&data);
1557 : : }
1558 : :
1559 : : return return_value;
1560 : : }
1561 : :
1562 : : #endif /* defined(MS_WINDOWS) */
1563 : :
1564 : : #if defined(MS_WINDOWS)
1565 : :
1566 : : PyDoc_STRVAR(_codecs_code_page_decode__doc__,
1567 : : "code_page_decode($module, codepage, data, errors=None, final=False, /)\n"
1568 : : "--\n"
1569 : : "\n");
1570 : :
1571 : : #define _CODECS_CODE_PAGE_DECODE_METHODDEF \
1572 : : {"code_page_decode", _PyCFunction_CAST(_codecs_code_page_decode), METH_FASTCALL, _codecs_code_page_decode__doc__},
1573 : :
1574 : : static PyObject *
1575 : : _codecs_code_page_decode_impl(PyObject *module, int codepage,
1576 : : Py_buffer *data, const char *errors, int final);
1577 : :
1578 : : static PyObject *
1579 : : _codecs_code_page_decode(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
1580 : : {
1581 : : PyObject *return_value = NULL;
1582 : : int codepage;
1583 : : Py_buffer data = {NULL, NULL};
1584 : : const char *errors = NULL;
1585 : : int final = 0;
1586 : :
1587 : : if (!_PyArg_CheckPositional("code_page_decode", nargs, 2, 4)) {
1588 : : goto exit;
1589 : : }
1590 : : codepage = _PyLong_AsInt(args[0]);
1591 : : if (codepage == -1 && PyErr_Occurred()) {
1592 : : goto exit;
1593 : : }
1594 : : if (PyObject_GetBuffer(args[1], &data, PyBUF_SIMPLE) != 0) {
1595 : : goto exit;
1596 : : }
1597 : : if (!PyBuffer_IsContiguous(&data, 'C')) {
1598 : : _PyArg_BadArgument("code_page_decode", "argument 2", "contiguous buffer", args[1]);
1599 : : goto exit;
1600 : : }
1601 : : if (nargs < 3) {
1602 : : goto skip_optional;
1603 : : }
1604 : : if (args[2] == Py_None) {
1605 : : errors = NULL;
1606 : : }
1607 : : else if (PyUnicode_Check(args[2])) {
1608 : : Py_ssize_t errors_length;
1609 : : errors = PyUnicode_AsUTF8AndSize(args[2], &errors_length);
1610 : : if (errors == NULL) {
1611 : : goto exit;
1612 : : }
1613 : : if (strlen(errors) != (size_t)errors_length) {
1614 : : PyErr_SetString(PyExc_ValueError, "embedded null character");
1615 : : goto exit;
1616 : : }
1617 : : }
1618 : : else {
1619 : : _PyArg_BadArgument("code_page_decode", "argument 3", "str or None", args[2]);
1620 : : goto exit;
1621 : : }
1622 : : if (nargs < 4) {
1623 : : goto skip_optional;
1624 : : }
1625 : : final = _PyLong_AsInt(args[3]);
1626 : : if (final == -1 && PyErr_Occurred()) {
1627 : : goto exit;
1628 : : }
1629 : : skip_optional:
1630 : : return_value = _codecs_code_page_decode_impl(module, codepage, &data, errors, final);
1631 : :
1632 : : exit:
1633 : : /* Cleanup for data */
1634 : : if (data.obj) {
1635 : : PyBuffer_Release(&data);
1636 : : }
1637 : :
1638 : : return return_value;
1639 : : }
1640 : :
1641 : : #endif /* defined(MS_WINDOWS) */
1642 : :
1643 : : PyDoc_STRVAR(_codecs_readbuffer_encode__doc__,
1644 : : "readbuffer_encode($module, data, errors=None, /)\n"
1645 : : "--\n"
1646 : : "\n");
1647 : :
1648 : : #define _CODECS_READBUFFER_ENCODE_METHODDEF \
1649 : : {"readbuffer_encode", _PyCFunction_CAST(_codecs_readbuffer_encode), METH_FASTCALL, _codecs_readbuffer_encode__doc__},
1650 : :
1651 : : static PyObject *
1652 : : _codecs_readbuffer_encode_impl(PyObject *module, Py_buffer *data,
1653 : : const char *errors);
1654 : :
1655 : : static PyObject *
1656 : 4 : _codecs_readbuffer_encode(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
1657 : : {
1658 : 4 : PyObject *return_value = NULL;
1659 : 4 : Py_buffer data = {NULL, NULL};
1660 : 4 : const char *errors = NULL;
1661 : :
1662 [ + + - + : 4 : if (!_PyArg_CheckPositional("readbuffer_encode", nargs, 1, 2)) {
+ - ]
1663 : 1 : goto exit;
1664 : : }
1665 [ + + ]: 3 : if (PyUnicode_Check(args[0])) {
1666 : : Py_ssize_t len;
1667 : 1 : const char *ptr = PyUnicode_AsUTF8AndSize(args[0], &len);
1668 [ - + ]: 1 : if (ptr == NULL) {
1669 : 0 : goto exit;
1670 : : }
1671 : 1 : PyBuffer_FillInfo(&data, args[0], (void *)ptr, len, 1, 0);
1672 : : }
1673 : : else { /* any bytes-like object */
1674 [ + + ]: 2 : if (PyObject_GetBuffer(args[0], &data, PyBUF_SIMPLE) != 0) {
1675 : 1 : goto exit;
1676 : : }
1677 [ - + ]: 1 : if (!PyBuffer_IsContiguous(&data, 'C')) {
1678 : 0 : _PyArg_BadArgument("readbuffer_encode", "argument 1", "contiguous buffer", args[0]);
1679 : 0 : goto exit;
1680 : : }
1681 : : }
1682 [ + - ]: 2 : if (nargs < 2) {
1683 : 2 : goto skip_optional;
1684 : : }
1685 [ # # ]: 0 : if (args[1] == Py_None) {
1686 : 0 : errors = NULL;
1687 : : }
1688 [ # # ]: 0 : else if (PyUnicode_Check(args[1])) {
1689 : : Py_ssize_t errors_length;
1690 : 0 : errors = PyUnicode_AsUTF8AndSize(args[1], &errors_length);
1691 [ # # ]: 0 : if (errors == NULL) {
1692 : 0 : goto exit;
1693 : : }
1694 [ # # ]: 0 : if (strlen(errors) != (size_t)errors_length) {
1695 : 0 : PyErr_SetString(PyExc_ValueError, "embedded null character");
1696 : 0 : goto exit;
1697 : : }
1698 : : }
1699 : : else {
1700 : 0 : _PyArg_BadArgument("readbuffer_encode", "argument 2", "str or None", args[1]);
1701 : 0 : goto exit;
1702 : : }
1703 : 2 : skip_optional:
1704 : 2 : return_value = _codecs_readbuffer_encode_impl(module, &data, errors);
1705 : :
1706 : 4 : exit:
1707 : : /* Cleanup for data */
1708 [ + + ]: 4 : if (data.obj) {
1709 : 2 : PyBuffer_Release(&data);
1710 : : }
1711 : :
1712 : 4 : return return_value;
1713 : : }
1714 : :
1715 : : PyDoc_STRVAR(_codecs_utf_7_encode__doc__,
1716 : : "utf_7_encode($module, str, errors=None, /)\n"
1717 : : "--\n"
1718 : : "\n");
1719 : :
1720 : : #define _CODECS_UTF_7_ENCODE_METHODDEF \
1721 : : {"utf_7_encode", _PyCFunction_CAST(_codecs_utf_7_encode), METH_FASTCALL, _codecs_utf_7_encode__doc__},
1722 : :
1723 : : static PyObject *
1724 : : _codecs_utf_7_encode_impl(PyObject *module, PyObject *str,
1725 : : const char *errors);
1726 : :
1727 : : static PyObject *
1728 : 1908 : _codecs_utf_7_encode(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
1729 : : {
1730 : 1908 : PyObject *return_value = NULL;
1731 : : PyObject *str;
1732 : 1908 : const char *errors = NULL;
1733 : :
1734 [ + + - + : 1908 : if (!_PyArg_CheckPositional("utf_7_encode", nargs, 1, 2)) {
+ - ]
1735 : 1 : goto exit;
1736 : : }
1737 [ - + ]: 1907 : if (!PyUnicode_Check(args[0])) {
1738 : 0 : _PyArg_BadArgument("utf_7_encode", "argument 1", "str", args[0]);
1739 : 0 : goto exit;
1740 : : }
1741 [ - + ]: 1907 : if (PyUnicode_READY(args[0]) == -1) {
1742 : 0 : goto exit;
1743 : : }
1744 : 1907 : str = args[0];
1745 [ + + ]: 1907 : if (nargs < 2) {
1746 : 1790 : goto skip_optional;
1747 : : }
1748 [ - + ]: 117 : if (args[1] == Py_None) {
1749 : 0 : errors = NULL;
1750 : : }
1751 [ + - ]: 117 : else if (PyUnicode_Check(args[1])) {
1752 : : Py_ssize_t errors_length;
1753 : 117 : errors = PyUnicode_AsUTF8AndSize(args[1], &errors_length);
1754 [ - + ]: 117 : if (errors == NULL) {
1755 : 0 : goto exit;
1756 : : }
1757 [ - + ]: 117 : if (strlen(errors) != (size_t)errors_length) {
1758 : 0 : PyErr_SetString(PyExc_ValueError, "embedded null character");
1759 : 0 : goto exit;
1760 : : }
1761 : : }
1762 : : else {
1763 : 0 : _PyArg_BadArgument("utf_7_encode", "argument 2", "str or None", args[1]);
1764 : 0 : goto exit;
1765 : : }
1766 : 1907 : skip_optional:
1767 : 1907 : return_value = _codecs_utf_7_encode_impl(module, str, errors);
1768 : :
1769 : 1908 : exit:
1770 : 1908 : return return_value;
1771 : : }
1772 : :
1773 : : PyDoc_STRVAR(_codecs_utf_8_encode__doc__,
1774 : : "utf_8_encode($module, str, errors=None, /)\n"
1775 : : "--\n"
1776 : : "\n");
1777 : :
1778 : : #define _CODECS_UTF_8_ENCODE_METHODDEF \
1779 : : {"utf_8_encode", _PyCFunction_CAST(_codecs_utf_8_encode), METH_FASTCALL, _codecs_utf_8_encode__doc__},
1780 : :
1781 : : static PyObject *
1782 : : _codecs_utf_8_encode_impl(PyObject *module, PyObject *str,
1783 : : const char *errors);
1784 : :
1785 : : static PyObject *
1786 : 174613 : _codecs_utf_8_encode(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
1787 : : {
1788 : 174613 : PyObject *return_value = NULL;
1789 : : PyObject *str;
1790 : 174613 : const char *errors = NULL;
1791 : :
1792 [ + + - + : 174613 : if (!_PyArg_CheckPositional("utf_8_encode", nargs, 1, 2)) {
+ - ]
1793 : 1 : goto exit;
1794 : : }
1795 [ - + ]: 174612 : if (!PyUnicode_Check(args[0])) {
1796 : 0 : _PyArg_BadArgument("utf_8_encode", "argument 1", "str", args[0]);
1797 : 0 : goto exit;
1798 : : }
1799 [ - + ]: 174612 : if (PyUnicode_READY(args[0]) == -1) {
1800 : 0 : goto exit;
1801 : : }
1802 : 174612 : str = args[0];
1803 [ + + ]: 174612 : if (nargs < 2) {
1804 : 2 : goto skip_optional;
1805 : : }
1806 [ - + ]: 174610 : if (args[1] == Py_None) {
1807 : 0 : errors = NULL;
1808 : : }
1809 [ + - ]: 174610 : else if (PyUnicode_Check(args[1])) {
1810 : : Py_ssize_t errors_length;
1811 : 174610 : errors = PyUnicode_AsUTF8AndSize(args[1], &errors_length);
1812 [ - + ]: 174610 : if (errors == NULL) {
1813 : 0 : goto exit;
1814 : : }
1815 [ - + ]: 174610 : if (strlen(errors) != (size_t)errors_length) {
1816 : 0 : PyErr_SetString(PyExc_ValueError, "embedded null character");
1817 : 0 : goto exit;
1818 : : }
1819 : : }
1820 : : else {
1821 : 0 : _PyArg_BadArgument("utf_8_encode", "argument 2", "str or None", args[1]);
1822 : 0 : goto exit;
1823 : : }
1824 : 174612 : skip_optional:
1825 : 174612 : return_value = _codecs_utf_8_encode_impl(module, str, errors);
1826 : :
1827 : 174613 : exit:
1828 : 174613 : return return_value;
1829 : : }
1830 : :
1831 : : PyDoc_STRVAR(_codecs_utf_16_encode__doc__,
1832 : : "utf_16_encode($module, str, errors=None, byteorder=0, /)\n"
1833 : : "--\n"
1834 : : "\n");
1835 : :
1836 : : #define _CODECS_UTF_16_ENCODE_METHODDEF \
1837 : : {"utf_16_encode", _PyCFunction_CAST(_codecs_utf_16_encode), METH_FASTCALL, _codecs_utf_16_encode__doc__},
1838 : :
1839 : : static PyObject *
1840 : : _codecs_utf_16_encode_impl(PyObject *module, PyObject *str,
1841 : : const char *errors, int byteorder);
1842 : :
1843 : : static PyObject *
1844 : 34 : _codecs_utf_16_encode(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
1845 : : {
1846 : 34 : PyObject *return_value = NULL;
1847 : : PyObject *str;
1848 : 34 : const char *errors = NULL;
1849 : 34 : int byteorder = 0;
1850 : :
1851 [ + + - + : 34 : if (!_PyArg_CheckPositional("utf_16_encode", nargs, 1, 3)) {
+ - ]
1852 : 1 : goto exit;
1853 : : }
1854 [ - + ]: 33 : if (!PyUnicode_Check(args[0])) {
1855 : 0 : _PyArg_BadArgument("utf_16_encode", "argument 1", "str", args[0]);
1856 : 0 : goto exit;
1857 : : }
1858 [ - + ]: 33 : if (PyUnicode_READY(args[0]) == -1) {
1859 : 0 : goto exit;
1860 : : }
1861 : 33 : str = args[0];
1862 [ + + ]: 33 : if (nargs < 2) {
1863 : 1 : goto skip_optional;
1864 : : }
1865 [ - + ]: 32 : if (args[1] == Py_None) {
1866 : 0 : errors = NULL;
1867 : : }
1868 [ + - ]: 32 : else if (PyUnicode_Check(args[1])) {
1869 : : Py_ssize_t errors_length;
1870 : 32 : errors = PyUnicode_AsUTF8AndSize(args[1], &errors_length);
1871 [ - + ]: 32 : if (errors == NULL) {
1872 : 0 : goto exit;
1873 : : }
1874 [ - + ]: 32 : if (strlen(errors) != (size_t)errors_length) {
1875 : 0 : PyErr_SetString(PyExc_ValueError, "embedded null character");
1876 : 0 : goto exit;
1877 : : }
1878 : : }
1879 : : else {
1880 : 0 : _PyArg_BadArgument("utf_16_encode", "argument 2", "str or None", args[1]);
1881 : 0 : goto exit;
1882 : : }
1883 [ + - ]: 32 : if (nargs < 3) {
1884 : 32 : goto skip_optional;
1885 : : }
1886 : 0 : byteorder = _PyLong_AsInt(args[2]);
1887 [ # # # # ]: 0 : if (byteorder == -1 && PyErr_Occurred()) {
1888 : 0 : goto exit;
1889 : : }
1890 : 0 : skip_optional:
1891 : 33 : return_value = _codecs_utf_16_encode_impl(module, str, errors, byteorder);
1892 : :
1893 : 34 : exit:
1894 : 34 : return return_value;
1895 : : }
1896 : :
1897 : : PyDoc_STRVAR(_codecs_utf_16_le_encode__doc__,
1898 : : "utf_16_le_encode($module, str, errors=None, /)\n"
1899 : : "--\n"
1900 : : "\n");
1901 : :
1902 : : #define _CODECS_UTF_16_LE_ENCODE_METHODDEF \
1903 : : {"utf_16_le_encode", _PyCFunction_CAST(_codecs_utf_16_le_encode), METH_FASTCALL, _codecs_utf_16_le_encode__doc__},
1904 : :
1905 : : static PyObject *
1906 : : _codecs_utf_16_le_encode_impl(PyObject *module, PyObject *str,
1907 : : const char *errors);
1908 : :
1909 : : static PyObject *
1910 : 1910 : _codecs_utf_16_le_encode(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
1911 : : {
1912 : 1910 : PyObject *return_value = NULL;
1913 : : PyObject *str;
1914 : 1910 : const char *errors = NULL;
1915 : :
1916 [ + + - + : 1910 : if (!_PyArg_CheckPositional("utf_16_le_encode", nargs, 1, 2)) {
+ - ]
1917 : 1 : goto exit;
1918 : : }
1919 [ - + ]: 1909 : if (!PyUnicode_Check(args[0])) {
1920 : 0 : _PyArg_BadArgument("utf_16_le_encode", "argument 1", "str", args[0]);
1921 : 0 : goto exit;
1922 : : }
1923 [ - + ]: 1909 : if (PyUnicode_READY(args[0]) == -1) {
1924 : 0 : goto exit;
1925 : : }
1926 : 1909 : str = args[0];
1927 [ + + ]: 1909 : if (nargs < 2) {
1928 : 1737 : goto skip_optional;
1929 : : }
1930 [ - + ]: 172 : if (args[1] == Py_None) {
1931 : 0 : errors = NULL;
1932 : : }
1933 [ + - ]: 172 : else if (PyUnicode_Check(args[1])) {
1934 : : Py_ssize_t errors_length;
1935 : 172 : errors = PyUnicode_AsUTF8AndSize(args[1], &errors_length);
1936 [ - + ]: 172 : if (errors == NULL) {
1937 : 0 : goto exit;
1938 : : }
1939 [ - + ]: 172 : if (strlen(errors) != (size_t)errors_length) {
1940 : 0 : PyErr_SetString(PyExc_ValueError, "embedded null character");
1941 : 0 : goto exit;
1942 : : }
1943 : : }
1944 : : else {
1945 : 0 : _PyArg_BadArgument("utf_16_le_encode", "argument 2", "str or None", args[1]);
1946 : 0 : goto exit;
1947 : : }
1948 : 1909 : skip_optional:
1949 : 1909 : return_value = _codecs_utf_16_le_encode_impl(module, str, errors);
1950 : :
1951 : 1910 : exit:
1952 : 1910 : return return_value;
1953 : : }
1954 : :
1955 : : PyDoc_STRVAR(_codecs_utf_16_be_encode__doc__,
1956 : : "utf_16_be_encode($module, str, errors=None, /)\n"
1957 : : "--\n"
1958 : : "\n");
1959 : :
1960 : : #define _CODECS_UTF_16_BE_ENCODE_METHODDEF \
1961 : : {"utf_16_be_encode", _PyCFunction_CAST(_codecs_utf_16_be_encode), METH_FASTCALL, _codecs_utf_16_be_encode__doc__},
1962 : :
1963 : : static PyObject *
1964 : : _codecs_utf_16_be_encode_impl(PyObject *module, PyObject *str,
1965 : : const char *errors);
1966 : :
1967 : : static PyObject *
1968 : 1849 : _codecs_utf_16_be_encode(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
1969 : : {
1970 : 1849 : PyObject *return_value = NULL;
1971 : : PyObject *str;
1972 : 1849 : const char *errors = NULL;
1973 : :
1974 [ + + - + : 1849 : if (!_PyArg_CheckPositional("utf_16_be_encode", nargs, 1, 2)) {
+ - ]
1975 : 1 : goto exit;
1976 : : }
1977 [ - + ]: 1848 : if (!PyUnicode_Check(args[0])) {
1978 : 0 : _PyArg_BadArgument("utf_16_be_encode", "argument 1", "str", args[0]);
1979 : 0 : goto exit;
1980 : : }
1981 [ - + ]: 1848 : if (PyUnicode_READY(args[0]) == -1) {
1982 : 0 : goto exit;
1983 : : }
1984 : 1848 : str = args[0];
1985 [ + + ]: 1848 : if (nargs < 2) {
1986 : 1740 : goto skip_optional;
1987 : : }
1988 [ - + ]: 108 : if (args[1] == Py_None) {
1989 : 0 : errors = NULL;
1990 : : }
1991 [ + - ]: 108 : else if (PyUnicode_Check(args[1])) {
1992 : : Py_ssize_t errors_length;
1993 : 108 : errors = PyUnicode_AsUTF8AndSize(args[1], &errors_length);
1994 [ - + ]: 108 : if (errors == NULL) {
1995 : 0 : goto exit;
1996 : : }
1997 [ - + ]: 108 : if (strlen(errors) != (size_t)errors_length) {
1998 : 0 : PyErr_SetString(PyExc_ValueError, "embedded null character");
1999 : 0 : goto exit;
2000 : : }
2001 : : }
2002 : : else {
2003 : 0 : _PyArg_BadArgument("utf_16_be_encode", "argument 2", "str or None", args[1]);
2004 : 0 : goto exit;
2005 : : }
2006 : 1848 : skip_optional:
2007 : 1848 : return_value = _codecs_utf_16_be_encode_impl(module, str, errors);
2008 : :
2009 : 1849 : exit:
2010 : 1849 : return return_value;
2011 : : }
2012 : :
2013 : : PyDoc_STRVAR(_codecs_utf_32_encode__doc__,
2014 : : "utf_32_encode($module, str, errors=None, byteorder=0, /)\n"
2015 : : "--\n"
2016 : : "\n");
2017 : :
2018 : : #define _CODECS_UTF_32_ENCODE_METHODDEF \
2019 : : {"utf_32_encode", _PyCFunction_CAST(_codecs_utf_32_encode), METH_FASTCALL, _codecs_utf_32_encode__doc__},
2020 : :
2021 : : static PyObject *
2022 : : _codecs_utf_32_encode_impl(PyObject *module, PyObject *str,
2023 : : const char *errors, int byteorder);
2024 : :
2025 : : static PyObject *
2026 : 18 : _codecs_utf_32_encode(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
2027 : : {
2028 : 18 : PyObject *return_value = NULL;
2029 : : PyObject *str;
2030 : 18 : const char *errors = NULL;
2031 : 18 : int byteorder = 0;
2032 : :
2033 [ + - - + : 18 : if (!_PyArg_CheckPositional("utf_32_encode", nargs, 1, 3)) {
- - ]
2034 : 0 : goto exit;
2035 : : }
2036 [ - + ]: 18 : if (!PyUnicode_Check(args[0])) {
2037 : 0 : _PyArg_BadArgument("utf_32_encode", "argument 1", "str", args[0]);
2038 : 0 : goto exit;
2039 : : }
2040 [ - + ]: 18 : if (PyUnicode_READY(args[0]) == -1) {
2041 : 0 : goto exit;
2042 : : }
2043 : 18 : str = args[0];
2044 [ - + ]: 18 : if (nargs < 2) {
2045 : 0 : goto skip_optional;
2046 : : }
2047 [ - + ]: 18 : if (args[1] == Py_None) {
2048 : 0 : errors = NULL;
2049 : : }
2050 [ + - ]: 18 : else if (PyUnicode_Check(args[1])) {
2051 : : Py_ssize_t errors_length;
2052 : 18 : errors = PyUnicode_AsUTF8AndSize(args[1], &errors_length);
2053 [ - + ]: 18 : if (errors == NULL) {
2054 : 0 : goto exit;
2055 : : }
2056 [ - + ]: 18 : if (strlen(errors) != (size_t)errors_length) {
2057 : 0 : PyErr_SetString(PyExc_ValueError, "embedded null character");
2058 : 0 : goto exit;
2059 : : }
2060 : : }
2061 : : else {
2062 : 0 : _PyArg_BadArgument("utf_32_encode", "argument 2", "str or None", args[1]);
2063 : 0 : goto exit;
2064 : : }
2065 [ + - ]: 18 : if (nargs < 3) {
2066 : 18 : goto skip_optional;
2067 : : }
2068 : 0 : byteorder = _PyLong_AsInt(args[2]);
2069 [ # # # # ]: 0 : if (byteorder == -1 && PyErr_Occurred()) {
2070 : 0 : goto exit;
2071 : : }
2072 : 0 : skip_optional:
2073 : 18 : return_value = _codecs_utf_32_encode_impl(module, str, errors, byteorder);
2074 : :
2075 : 18 : exit:
2076 : 18 : return return_value;
2077 : : }
2078 : :
2079 : : PyDoc_STRVAR(_codecs_utf_32_le_encode__doc__,
2080 : : "utf_32_le_encode($module, str, errors=None, /)\n"
2081 : : "--\n"
2082 : : "\n");
2083 : :
2084 : : #define _CODECS_UTF_32_LE_ENCODE_METHODDEF \
2085 : : {"utf_32_le_encode", _PyCFunction_CAST(_codecs_utf_32_le_encode), METH_FASTCALL, _codecs_utf_32_le_encode__doc__},
2086 : :
2087 : : static PyObject *
2088 : : _codecs_utf_32_le_encode_impl(PyObject *module, PyObject *str,
2089 : : const char *errors);
2090 : :
2091 : : static PyObject *
2092 : 771 : _codecs_utf_32_le_encode(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
2093 : : {
2094 : 771 : PyObject *return_value = NULL;
2095 : : PyObject *str;
2096 : 771 : const char *errors = NULL;
2097 : :
2098 [ + - - + : 771 : if (!_PyArg_CheckPositional("utf_32_le_encode", nargs, 1, 2)) {
- - ]
2099 : 0 : goto exit;
2100 : : }
2101 [ - + ]: 771 : if (!PyUnicode_Check(args[0])) {
2102 : 0 : _PyArg_BadArgument("utf_32_le_encode", "argument 1", "str", args[0]);
2103 : 0 : goto exit;
2104 : : }
2105 [ - + ]: 771 : if (PyUnicode_READY(args[0]) == -1) {
2106 : 0 : goto exit;
2107 : : }
2108 : 771 : str = args[0];
2109 [ + + ]: 771 : if (nargs < 2) {
2110 : 697 : goto skip_optional;
2111 : : }
2112 [ - + ]: 74 : if (args[1] == Py_None) {
2113 : 0 : errors = NULL;
2114 : : }
2115 [ + - ]: 74 : else if (PyUnicode_Check(args[1])) {
2116 : : Py_ssize_t errors_length;
2117 : 74 : errors = PyUnicode_AsUTF8AndSize(args[1], &errors_length);
2118 [ - + ]: 74 : if (errors == NULL) {
2119 : 0 : goto exit;
2120 : : }
2121 [ - + ]: 74 : if (strlen(errors) != (size_t)errors_length) {
2122 : 0 : PyErr_SetString(PyExc_ValueError, "embedded null character");
2123 : 0 : goto exit;
2124 : : }
2125 : : }
2126 : : else {
2127 : 0 : _PyArg_BadArgument("utf_32_le_encode", "argument 2", "str or None", args[1]);
2128 : 0 : goto exit;
2129 : : }
2130 : 771 : skip_optional:
2131 : 771 : return_value = _codecs_utf_32_le_encode_impl(module, str, errors);
2132 : :
2133 : 771 : exit:
2134 : 771 : return return_value;
2135 : : }
2136 : :
2137 : : PyDoc_STRVAR(_codecs_utf_32_be_encode__doc__,
2138 : : "utf_32_be_encode($module, str, errors=None, /)\n"
2139 : : "--\n"
2140 : : "\n");
2141 : :
2142 : : #define _CODECS_UTF_32_BE_ENCODE_METHODDEF \
2143 : : {"utf_32_be_encode", _PyCFunction_CAST(_codecs_utf_32_be_encode), METH_FASTCALL, _codecs_utf_32_be_encode__doc__},
2144 : :
2145 : : static PyObject *
2146 : : _codecs_utf_32_be_encode_impl(PyObject *module, PyObject *str,
2147 : : const char *errors);
2148 : :
2149 : : static PyObject *
2150 : 754 : _codecs_utf_32_be_encode(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
2151 : : {
2152 : 754 : PyObject *return_value = NULL;
2153 : : PyObject *str;
2154 : 754 : const char *errors = NULL;
2155 : :
2156 [ + - - + : 754 : if (!_PyArg_CheckPositional("utf_32_be_encode", nargs, 1, 2)) {
- - ]
2157 : 0 : goto exit;
2158 : : }
2159 [ - + ]: 754 : if (!PyUnicode_Check(args[0])) {
2160 : 0 : _PyArg_BadArgument("utf_32_be_encode", "argument 1", "str", args[0]);
2161 : 0 : goto exit;
2162 : : }
2163 [ - + ]: 754 : if (PyUnicode_READY(args[0]) == -1) {
2164 : 0 : goto exit;
2165 : : }
2166 : 754 : str = args[0];
2167 [ + + ]: 754 : if (nargs < 2) {
2168 : 700 : goto skip_optional;
2169 : : }
2170 [ - + ]: 54 : if (args[1] == Py_None) {
2171 : 0 : errors = NULL;
2172 : : }
2173 [ + - ]: 54 : else if (PyUnicode_Check(args[1])) {
2174 : : Py_ssize_t errors_length;
2175 : 54 : errors = PyUnicode_AsUTF8AndSize(args[1], &errors_length);
2176 [ - + ]: 54 : if (errors == NULL) {
2177 : 0 : goto exit;
2178 : : }
2179 [ - + ]: 54 : if (strlen(errors) != (size_t)errors_length) {
2180 : 0 : PyErr_SetString(PyExc_ValueError, "embedded null character");
2181 : 0 : goto exit;
2182 : : }
2183 : : }
2184 : : else {
2185 : 0 : _PyArg_BadArgument("utf_32_be_encode", "argument 2", "str or None", args[1]);
2186 : 0 : goto exit;
2187 : : }
2188 : 754 : skip_optional:
2189 : 754 : return_value = _codecs_utf_32_be_encode_impl(module, str, errors);
2190 : :
2191 : 754 : exit:
2192 : 754 : return return_value;
2193 : : }
2194 : :
2195 : : PyDoc_STRVAR(_codecs_unicode_escape_encode__doc__,
2196 : : "unicode_escape_encode($module, str, errors=None, /)\n"
2197 : : "--\n"
2198 : : "\n");
2199 : :
2200 : : #define _CODECS_UNICODE_ESCAPE_ENCODE_METHODDEF \
2201 : : {"unicode_escape_encode", _PyCFunction_CAST(_codecs_unicode_escape_encode), METH_FASTCALL, _codecs_unicode_escape_encode__doc__},
2202 : :
2203 : : static PyObject *
2204 : : _codecs_unicode_escape_encode_impl(PyObject *module, PyObject *str,
2205 : : const char *errors);
2206 : :
2207 : : static PyObject *
2208 : 3763 : _codecs_unicode_escape_encode(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
2209 : : {
2210 : 3763 : PyObject *return_value = NULL;
2211 : : PyObject *str;
2212 : 3763 : const char *errors = NULL;
2213 : :
2214 [ + + - + : 3763 : if (!_PyArg_CheckPositional("unicode_escape_encode", nargs, 1, 2)) {
+ - ]
2215 : 1 : goto exit;
2216 : : }
2217 [ - + ]: 3762 : if (!PyUnicode_Check(args[0])) {
2218 : 0 : _PyArg_BadArgument("unicode_escape_encode", "argument 1", "str", args[0]);
2219 : 0 : goto exit;
2220 : : }
2221 [ - + ]: 3762 : if (PyUnicode_READY(args[0]) == -1) {
2222 : 0 : goto exit;
2223 : : }
2224 : 3762 : str = args[0];
2225 [ + + ]: 3762 : if (nargs < 2) {
2226 : 3699 : goto skip_optional;
2227 : : }
2228 [ - + ]: 63 : if (args[1] == Py_None) {
2229 : 0 : errors = NULL;
2230 : : }
2231 [ + - ]: 63 : else if (PyUnicode_Check(args[1])) {
2232 : : Py_ssize_t errors_length;
2233 : 63 : errors = PyUnicode_AsUTF8AndSize(args[1], &errors_length);
2234 [ - + ]: 63 : if (errors == NULL) {
2235 : 0 : goto exit;
2236 : : }
2237 [ - + ]: 63 : if (strlen(errors) != (size_t)errors_length) {
2238 : 0 : PyErr_SetString(PyExc_ValueError, "embedded null character");
2239 : 0 : goto exit;
2240 : : }
2241 : : }
2242 : : else {
2243 : 0 : _PyArg_BadArgument("unicode_escape_encode", "argument 2", "str or None", args[1]);
2244 : 0 : goto exit;
2245 : : }
2246 : 3762 : skip_optional:
2247 : 3762 : return_value = _codecs_unicode_escape_encode_impl(module, str, errors);
2248 : :
2249 : 3763 : exit:
2250 : 3763 : return return_value;
2251 : : }
2252 : :
2253 : : PyDoc_STRVAR(_codecs_raw_unicode_escape_encode__doc__,
2254 : : "raw_unicode_escape_encode($module, str, errors=None, /)\n"
2255 : : "--\n"
2256 : : "\n");
2257 : :
2258 : : #define _CODECS_RAW_UNICODE_ESCAPE_ENCODE_METHODDEF \
2259 : : {"raw_unicode_escape_encode", _PyCFunction_CAST(_codecs_raw_unicode_escape_encode), METH_FASTCALL, _codecs_raw_unicode_escape_encode__doc__},
2260 : :
2261 : : static PyObject *
2262 : : _codecs_raw_unicode_escape_encode_impl(PyObject *module, PyObject *str,
2263 : : const char *errors);
2264 : :
2265 : : static PyObject *
2266 : 11253 : _codecs_raw_unicode_escape_encode(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
2267 : : {
2268 : 11253 : PyObject *return_value = NULL;
2269 : : PyObject *str;
2270 : 11253 : const char *errors = NULL;
2271 : :
2272 [ + + - + : 11253 : if (!_PyArg_CheckPositional("raw_unicode_escape_encode", nargs, 1, 2)) {
+ - ]
2273 : 1 : goto exit;
2274 : : }
2275 [ - + ]: 11252 : if (!PyUnicode_Check(args[0])) {
2276 : 0 : _PyArg_BadArgument("raw_unicode_escape_encode", "argument 1", "str", args[0]);
2277 : 0 : goto exit;
2278 : : }
2279 [ - + ]: 11252 : if (PyUnicode_READY(args[0]) == -1) {
2280 : 0 : goto exit;
2281 : : }
2282 : 11252 : str = args[0];
2283 [ + + ]: 11252 : if (nargs < 2) {
2284 : 11189 : goto skip_optional;
2285 : : }
2286 [ - + ]: 63 : if (args[1] == Py_None) {
2287 : 0 : errors = NULL;
2288 : : }
2289 [ + - ]: 63 : else if (PyUnicode_Check(args[1])) {
2290 : : Py_ssize_t errors_length;
2291 : 63 : errors = PyUnicode_AsUTF8AndSize(args[1], &errors_length);
2292 [ - + ]: 63 : if (errors == NULL) {
2293 : 0 : goto exit;
2294 : : }
2295 [ - + ]: 63 : if (strlen(errors) != (size_t)errors_length) {
2296 : 0 : PyErr_SetString(PyExc_ValueError, "embedded null character");
2297 : 0 : goto exit;
2298 : : }
2299 : : }
2300 : : else {
2301 : 0 : _PyArg_BadArgument("raw_unicode_escape_encode", "argument 2", "str or None", args[1]);
2302 : 0 : goto exit;
2303 : : }
2304 : 11252 : skip_optional:
2305 : 11252 : return_value = _codecs_raw_unicode_escape_encode_impl(module, str, errors);
2306 : :
2307 : 11253 : exit:
2308 : 11253 : return return_value;
2309 : : }
2310 : :
2311 : : PyDoc_STRVAR(_codecs_latin_1_encode__doc__,
2312 : : "latin_1_encode($module, str, errors=None, /)\n"
2313 : : "--\n"
2314 : : "\n");
2315 : :
2316 : : #define _CODECS_LATIN_1_ENCODE_METHODDEF \
2317 : : {"latin_1_encode", _PyCFunction_CAST(_codecs_latin_1_encode), METH_FASTCALL, _codecs_latin_1_encode__doc__},
2318 : :
2319 : : static PyObject *
2320 : : _codecs_latin_1_encode_impl(PyObject *module, PyObject *str,
2321 : : const char *errors);
2322 : :
2323 : : static PyObject *
2324 : 11020 : _codecs_latin_1_encode(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
2325 : : {
2326 : 11020 : PyObject *return_value = NULL;
2327 : : PyObject *str;
2328 : 11020 : const char *errors = NULL;
2329 : :
2330 [ + + - + : 11020 : if (!_PyArg_CheckPositional("latin_1_encode", nargs, 1, 2)) {
+ - ]
2331 : 2 : goto exit;
2332 : : }
2333 [ - + ]: 11018 : if (!PyUnicode_Check(args[0])) {
2334 : 0 : _PyArg_BadArgument("latin_1_encode", "argument 1", "str", args[0]);
2335 : 0 : goto exit;
2336 : : }
2337 [ - + ]: 11018 : if (PyUnicode_READY(args[0]) == -1) {
2338 : 0 : goto exit;
2339 : : }
2340 : 11018 : str = args[0];
2341 [ + + ]: 11018 : if (nargs < 2) {
2342 : 10866 : goto skip_optional;
2343 : : }
2344 [ - + ]: 152 : if (args[1] == Py_None) {
2345 : 0 : errors = NULL;
2346 : : }
2347 [ + - ]: 152 : else if (PyUnicode_Check(args[1])) {
2348 : : Py_ssize_t errors_length;
2349 : 152 : errors = PyUnicode_AsUTF8AndSize(args[1], &errors_length);
2350 [ - + ]: 152 : if (errors == NULL) {
2351 : 0 : goto exit;
2352 : : }
2353 [ - + ]: 152 : if (strlen(errors) != (size_t)errors_length) {
2354 : 0 : PyErr_SetString(PyExc_ValueError, "embedded null character");
2355 : 0 : goto exit;
2356 : : }
2357 : : }
2358 : : else {
2359 : 0 : _PyArg_BadArgument("latin_1_encode", "argument 2", "str or None", args[1]);
2360 : 0 : goto exit;
2361 : : }
2362 : 11018 : skip_optional:
2363 : 11018 : return_value = _codecs_latin_1_encode_impl(module, str, errors);
2364 : :
2365 : 11020 : exit:
2366 : 11020 : return return_value;
2367 : : }
2368 : :
2369 : : PyDoc_STRVAR(_codecs_ascii_encode__doc__,
2370 : : "ascii_encode($module, str, errors=None, /)\n"
2371 : : "--\n"
2372 : : "\n");
2373 : :
2374 : : #define _CODECS_ASCII_ENCODE_METHODDEF \
2375 : : {"ascii_encode", _PyCFunction_CAST(_codecs_ascii_encode), METH_FASTCALL, _codecs_ascii_encode__doc__},
2376 : :
2377 : : static PyObject *
2378 : : _codecs_ascii_encode_impl(PyObject *module, PyObject *str,
2379 : : const char *errors);
2380 : :
2381 : : static PyObject *
2382 : 645 : _codecs_ascii_encode(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
2383 : : {
2384 : 645 : PyObject *return_value = NULL;
2385 : : PyObject *str;
2386 : 645 : const char *errors = NULL;
2387 : :
2388 [ + + - + : 645 : if (!_PyArg_CheckPositional("ascii_encode", nargs, 1, 2)) {
+ - ]
2389 : 1 : goto exit;
2390 : : }
2391 [ - + ]: 644 : if (!PyUnicode_Check(args[0])) {
2392 : 0 : _PyArg_BadArgument("ascii_encode", "argument 1", "str", args[0]);
2393 : 0 : goto exit;
2394 : : }
2395 [ - + ]: 644 : if (PyUnicode_READY(args[0]) == -1) {
2396 : 0 : goto exit;
2397 : : }
2398 : 644 : str = args[0];
2399 [ + + ]: 644 : if (nargs < 2) {
2400 : 2 : goto skip_optional;
2401 : : }
2402 [ - + ]: 642 : if (args[1] == Py_None) {
2403 : 0 : errors = NULL;
2404 : : }
2405 [ + - ]: 642 : else if (PyUnicode_Check(args[1])) {
2406 : : Py_ssize_t errors_length;
2407 : 642 : errors = PyUnicode_AsUTF8AndSize(args[1], &errors_length);
2408 [ - + ]: 642 : if (errors == NULL) {
2409 : 0 : goto exit;
2410 : : }
2411 [ - + ]: 642 : if (strlen(errors) != (size_t)errors_length) {
2412 : 0 : PyErr_SetString(PyExc_ValueError, "embedded null character");
2413 : 0 : goto exit;
2414 : : }
2415 : : }
2416 : : else {
2417 : 0 : _PyArg_BadArgument("ascii_encode", "argument 2", "str or None", args[1]);
2418 : 0 : goto exit;
2419 : : }
2420 : 644 : skip_optional:
2421 : 644 : return_value = _codecs_ascii_encode_impl(module, str, errors);
2422 : :
2423 : 645 : exit:
2424 : 645 : return return_value;
2425 : : }
2426 : :
2427 : : PyDoc_STRVAR(_codecs_charmap_encode__doc__,
2428 : : "charmap_encode($module, str, errors=None, mapping=None, /)\n"
2429 : : "--\n"
2430 : : "\n");
2431 : :
2432 : : #define _CODECS_CHARMAP_ENCODE_METHODDEF \
2433 : : {"charmap_encode", _PyCFunction_CAST(_codecs_charmap_encode), METH_FASTCALL, _codecs_charmap_encode__doc__},
2434 : :
2435 : : static PyObject *
2436 : : _codecs_charmap_encode_impl(PyObject *module, PyObject *str,
2437 : : const char *errors, PyObject *mapping);
2438 : :
2439 : : static PyObject *
2440 : 4690 : _codecs_charmap_encode(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
2441 : : {
2442 : 4690 : PyObject *return_value = NULL;
2443 : : PyObject *str;
2444 : 4690 : const char *errors = NULL;
2445 : 4690 : PyObject *mapping = Py_None;
2446 : :
2447 [ + + - + : 4690 : if (!_PyArg_CheckPositional("charmap_encode", nargs, 1, 3)) {
+ - ]
2448 : 1 : goto exit;
2449 : : }
2450 [ - + ]: 4689 : if (!PyUnicode_Check(args[0])) {
2451 : 0 : _PyArg_BadArgument("charmap_encode", "argument 1", "str", args[0]);
2452 : 0 : goto exit;
2453 : : }
2454 [ - + ]: 4689 : if (PyUnicode_READY(args[0]) == -1) {
2455 : 0 : goto exit;
2456 : : }
2457 : 4689 : str = args[0];
2458 [ + + ]: 4689 : if (nargs < 2) {
2459 : 4 : goto skip_optional;
2460 : : }
2461 [ - + ]: 4685 : if (args[1] == Py_None) {
2462 : 0 : errors = NULL;
2463 : : }
2464 [ + - ]: 4685 : else if (PyUnicode_Check(args[1])) {
2465 : : Py_ssize_t errors_length;
2466 : 4685 : errors = PyUnicode_AsUTF8AndSize(args[1], &errors_length);
2467 [ - + ]: 4685 : if (errors == NULL) {
2468 : 0 : goto exit;
2469 : : }
2470 [ - + ]: 4685 : if (strlen(errors) != (size_t)errors_length) {
2471 : 0 : PyErr_SetString(PyExc_ValueError, "embedded null character");
2472 : 0 : goto exit;
2473 : : }
2474 : : }
2475 : : else {
2476 : 0 : _PyArg_BadArgument("charmap_encode", "argument 2", "str or None", args[1]);
2477 : 0 : goto exit;
2478 : : }
2479 [ - + ]: 4685 : if (nargs < 3) {
2480 : 0 : goto skip_optional;
2481 : : }
2482 : 4685 : mapping = args[2];
2483 : 4689 : skip_optional:
2484 : 4689 : return_value = _codecs_charmap_encode_impl(module, str, errors, mapping);
2485 : :
2486 : 4690 : exit:
2487 : 4690 : return return_value;
2488 : : }
2489 : :
2490 : : PyDoc_STRVAR(_codecs_charmap_build__doc__,
2491 : : "charmap_build($module, map, /)\n"
2492 : : "--\n"
2493 : : "\n");
2494 : :
2495 : : #define _CODECS_CHARMAP_BUILD_METHODDEF \
2496 : : {"charmap_build", (PyCFunction)_codecs_charmap_build, METH_O, _codecs_charmap_build__doc__},
2497 : :
2498 : : static PyObject *
2499 : : _codecs_charmap_build_impl(PyObject *module, PyObject *map);
2500 : :
2501 : : static PyObject *
2502 : 217 : _codecs_charmap_build(PyObject *module, PyObject *arg)
2503 : : {
2504 : 217 : PyObject *return_value = NULL;
2505 : : PyObject *map;
2506 : :
2507 [ - + ]: 217 : if (!PyUnicode_Check(arg)) {
2508 : 0 : _PyArg_BadArgument("charmap_build", "argument", "str", arg);
2509 : 0 : goto exit;
2510 : : }
2511 [ - + ]: 217 : if (PyUnicode_READY(arg) == -1) {
2512 : 0 : goto exit;
2513 : : }
2514 : 217 : map = arg;
2515 : 217 : return_value = _codecs_charmap_build_impl(module, map);
2516 : :
2517 : 217 : exit:
2518 : 217 : return return_value;
2519 : : }
2520 : :
2521 : : #if defined(MS_WINDOWS)
2522 : :
2523 : : PyDoc_STRVAR(_codecs_mbcs_encode__doc__,
2524 : : "mbcs_encode($module, str, errors=None, /)\n"
2525 : : "--\n"
2526 : : "\n");
2527 : :
2528 : : #define _CODECS_MBCS_ENCODE_METHODDEF \
2529 : : {"mbcs_encode", _PyCFunction_CAST(_codecs_mbcs_encode), METH_FASTCALL, _codecs_mbcs_encode__doc__},
2530 : :
2531 : : static PyObject *
2532 : : _codecs_mbcs_encode_impl(PyObject *module, PyObject *str, const char *errors);
2533 : :
2534 : : static PyObject *
2535 : : _codecs_mbcs_encode(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
2536 : : {
2537 : : PyObject *return_value = NULL;
2538 : : PyObject *str;
2539 : : const char *errors = NULL;
2540 : :
2541 : : if (!_PyArg_CheckPositional("mbcs_encode", nargs, 1, 2)) {
2542 : : goto exit;
2543 : : }
2544 : : if (!PyUnicode_Check(args[0])) {
2545 : : _PyArg_BadArgument("mbcs_encode", "argument 1", "str", args[0]);
2546 : : goto exit;
2547 : : }
2548 : : if (PyUnicode_READY(args[0]) == -1) {
2549 : : goto exit;
2550 : : }
2551 : : str = args[0];
2552 : : if (nargs < 2) {
2553 : : goto skip_optional;
2554 : : }
2555 : : if (args[1] == Py_None) {
2556 : : errors = NULL;
2557 : : }
2558 : : else if (PyUnicode_Check(args[1])) {
2559 : : Py_ssize_t errors_length;
2560 : : errors = PyUnicode_AsUTF8AndSize(args[1], &errors_length);
2561 : : if (errors == NULL) {
2562 : : goto exit;
2563 : : }
2564 : : if (strlen(errors) != (size_t)errors_length) {
2565 : : PyErr_SetString(PyExc_ValueError, "embedded null character");
2566 : : goto exit;
2567 : : }
2568 : : }
2569 : : else {
2570 : : _PyArg_BadArgument("mbcs_encode", "argument 2", "str or None", args[1]);
2571 : : goto exit;
2572 : : }
2573 : : skip_optional:
2574 : : return_value = _codecs_mbcs_encode_impl(module, str, errors);
2575 : :
2576 : : exit:
2577 : : return return_value;
2578 : : }
2579 : :
2580 : : #endif /* defined(MS_WINDOWS) */
2581 : :
2582 : : #if defined(MS_WINDOWS)
2583 : :
2584 : : PyDoc_STRVAR(_codecs_oem_encode__doc__,
2585 : : "oem_encode($module, str, errors=None, /)\n"
2586 : : "--\n"
2587 : : "\n");
2588 : :
2589 : : #define _CODECS_OEM_ENCODE_METHODDEF \
2590 : : {"oem_encode", _PyCFunction_CAST(_codecs_oem_encode), METH_FASTCALL, _codecs_oem_encode__doc__},
2591 : :
2592 : : static PyObject *
2593 : : _codecs_oem_encode_impl(PyObject *module, PyObject *str, const char *errors);
2594 : :
2595 : : static PyObject *
2596 : : _codecs_oem_encode(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
2597 : : {
2598 : : PyObject *return_value = NULL;
2599 : : PyObject *str;
2600 : : const char *errors = NULL;
2601 : :
2602 : : if (!_PyArg_CheckPositional("oem_encode", nargs, 1, 2)) {
2603 : : goto exit;
2604 : : }
2605 : : if (!PyUnicode_Check(args[0])) {
2606 : : _PyArg_BadArgument("oem_encode", "argument 1", "str", args[0]);
2607 : : goto exit;
2608 : : }
2609 : : if (PyUnicode_READY(args[0]) == -1) {
2610 : : goto exit;
2611 : : }
2612 : : str = args[0];
2613 : : if (nargs < 2) {
2614 : : goto skip_optional;
2615 : : }
2616 : : if (args[1] == Py_None) {
2617 : : errors = NULL;
2618 : : }
2619 : : else if (PyUnicode_Check(args[1])) {
2620 : : Py_ssize_t errors_length;
2621 : : errors = PyUnicode_AsUTF8AndSize(args[1], &errors_length);
2622 : : if (errors == NULL) {
2623 : : goto exit;
2624 : : }
2625 : : if (strlen(errors) != (size_t)errors_length) {
2626 : : PyErr_SetString(PyExc_ValueError, "embedded null character");
2627 : : goto exit;
2628 : : }
2629 : : }
2630 : : else {
2631 : : _PyArg_BadArgument("oem_encode", "argument 2", "str or None", args[1]);
2632 : : goto exit;
2633 : : }
2634 : : skip_optional:
2635 : : return_value = _codecs_oem_encode_impl(module, str, errors);
2636 : :
2637 : : exit:
2638 : : return return_value;
2639 : : }
2640 : :
2641 : : #endif /* defined(MS_WINDOWS) */
2642 : :
2643 : : #if defined(MS_WINDOWS)
2644 : :
2645 : : PyDoc_STRVAR(_codecs_code_page_encode__doc__,
2646 : : "code_page_encode($module, code_page, str, errors=None, /)\n"
2647 : : "--\n"
2648 : : "\n");
2649 : :
2650 : : #define _CODECS_CODE_PAGE_ENCODE_METHODDEF \
2651 : : {"code_page_encode", _PyCFunction_CAST(_codecs_code_page_encode), METH_FASTCALL, _codecs_code_page_encode__doc__},
2652 : :
2653 : : static PyObject *
2654 : : _codecs_code_page_encode_impl(PyObject *module, int code_page, PyObject *str,
2655 : : const char *errors);
2656 : :
2657 : : static PyObject *
2658 : : _codecs_code_page_encode(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
2659 : : {
2660 : : PyObject *return_value = NULL;
2661 : : int code_page;
2662 : : PyObject *str;
2663 : : const char *errors = NULL;
2664 : :
2665 : : if (!_PyArg_CheckPositional("code_page_encode", nargs, 2, 3)) {
2666 : : goto exit;
2667 : : }
2668 : : code_page = _PyLong_AsInt(args[0]);
2669 : : if (code_page == -1 && PyErr_Occurred()) {
2670 : : goto exit;
2671 : : }
2672 : : if (!PyUnicode_Check(args[1])) {
2673 : : _PyArg_BadArgument("code_page_encode", "argument 2", "str", args[1]);
2674 : : goto exit;
2675 : : }
2676 : : if (PyUnicode_READY(args[1]) == -1) {
2677 : : goto exit;
2678 : : }
2679 : : str = args[1];
2680 : : if (nargs < 3) {
2681 : : goto skip_optional;
2682 : : }
2683 : : if (args[2] == Py_None) {
2684 : : errors = NULL;
2685 : : }
2686 : : else if (PyUnicode_Check(args[2])) {
2687 : : Py_ssize_t errors_length;
2688 : : errors = PyUnicode_AsUTF8AndSize(args[2], &errors_length);
2689 : : if (errors == NULL) {
2690 : : goto exit;
2691 : : }
2692 : : if (strlen(errors) != (size_t)errors_length) {
2693 : : PyErr_SetString(PyExc_ValueError, "embedded null character");
2694 : : goto exit;
2695 : : }
2696 : : }
2697 : : else {
2698 : : _PyArg_BadArgument("code_page_encode", "argument 3", "str or None", args[2]);
2699 : : goto exit;
2700 : : }
2701 : : skip_optional:
2702 : : return_value = _codecs_code_page_encode_impl(module, code_page, str, errors);
2703 : :
2704 : : exit:
2705 : : return return_value;
2706 : : }
2707 : :
2708 : : #endif /* defined(MS_WINDOWS) */
2709 : :
2710 : : PyDoc_STRVAR(_codecs_register_error__doc__,
2711 : : "register_error($module, errors, handler, /)\n"
2712 : : "--\n"
2713 : : "\n"
2714 : : "Register the specified error handler under the name errors.\n"
2715 : : "\n"
2716 : : "handler must be a callable object, that will be called with an exception\n"
2717 : : "instance containing information about the location of the encoding/decoding\n"
2718 : : "error and must return a (replacement, new position) tuple.");
2719 : :
2720 : : #define _CODECS_REGISTER_ERROR_METHODDEF \
2721 : : {"register_error", _PyCFunction_CAST(_codecs_register_error), METH_FASTCALL, _codecs_register_error__doc__},
2722 : :
2723 : : static PyObject *
2724 : : _codecs_register_error_impl(PyObject *module, const char *errors,
2725 : : PyObject *handler);
2726 : :
2727 : : static PyObject *
2728 : 236 : _codecs_register_error(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
2729 : : {
2730 : 236 : PyObject *return_value = NULL;
2731 : : const char *errors;
2732 : : PyObject *handler;
2733 : :
2734 [ + + - + : 236 : if (!_PyArg_CheckPositional("register_error", nargs, 2, 2)) {
+ - ]
2735 : 1 : goto exit;
2736 : : }
2737 [ - + ]: 235 : if (!PyUnicode_Check(args[0])) {
2738 : 0 : _PyArg_BadArgument("register_error", "argument 1", "str", args[0]);
2739 : 0 : goto exit;
2740 : : }
2741 : : Py_ssize_t errors_length;
2742 : 235 : errors = PyUnicode_AsUTF8AndSize(args[0], &errors_length);
2743 [ - + ]: 235 : if (errors == NULL) {
2744 : 0 : goto exit;
2745 : : }
2746 [ - + ]: 235 : if (strlen(errors) != (size_t)errors_length) {
2747 : 0 : PyErr_SetString(PyExc_ValueError, "embedded null character");
2748 : 0 : goto exit;
2749 : : }
2750 : 235 : handler = args[1];
2751 : 235 : return_value = _codecs_register_error_impl(module, errors, handler);
2752 : :
2753 : 236 : exit:
2754 : 236 : return return_value;
2755 : : }
2756 : :
2757 : : PyDoc_STRVAR(_codecs_lookup_error__doc__,
2758 : : "lookup_error($module, name, /)\n"
2759 : : "--\n"
2760 : : "\n"
2761 : : "lookup_error(errors) -> handler\n"
2762 : : "\n"
2763 : : "Return the error handler for the specified error handling name or raise a\n"
2764 : : "LookupError, if no handler exists under this name.");
2765 : :
2766 : : #define _CODECS_LOOKUP_ERROR_METHODDEF \
2767 : : {"lookup_error", (PyCFunction)_codecs_lookup_error, METH_O, _codecs_lookup_error__doc__},
2768 : :
2769 : : static PyObject *
2770 : : _codecs_lookup_error_impl(PyObject *module, const char *name);
2771 : :
2772 : : static PyObject *
2773 : 18825 : _codecs_lookup_error(PyObject *module, PyObject *arg)
2774 : : {
2775 : 18825 : PyObject *return_value = NULL;
2776 : : const char *name;
2777 : :
2778 [ - + ]: 18825 : if (!PyUnicode_Check(arg)) {
2779 : 0 : _PyArg_BadArgument("lookup_error", "argument", "str", arg);
2780 : 0 : goto exit;
2781 : : }
2782 : : Py_ssize_t name_length;
2783 : 18825 : name = PyUnicode_AsUTF8AndSize(arg, &name_length);
2784 [ - + ]: 18825 : if (name == NULL) {
2785 : 0 : goto exit;
2786 : : }
2787 [ - + ]: 18825 : if (strlen(name) != (size_t)name_length) {
2788 : 0 : PyErr_SetString(PyExc_ValueError, "embedded null character");
2789 : 0 : goto exit;
2790 : : }
2791 : 18825 : return_value = _codecs_lookup_error_impl(module, name);
2792 : :
2793 : 18825 : exit:
2794 : 18825 : return return_value;
2795 : : }
2796 : :
2797 : : #ifndef _CODECS_MBCS_DECODE_METHODDEF
2798 : : #define _CODECS_MBCS_DECODE_METHODDEF
2799 : : #endif /* !defined(_CODECS_MBCS_DECODE_METHODDEF) */
2800 : :
2801 : : #ifndef _CODECS_OEM_DECODE_METHODDEF
2802 : : #define _CODECS_OEM_DECODE_METHODDEF
2803 : : #endif /* !defined(_CODECS_OEM_DECODE_METHODDEF) */
2804 : :
2805 : : #ifndef _CODECS_CODE_PAGE_DECODE_METHODDEF
2806 : : #define _CODECS_CODE_PAGE_DECODE_METHODDEF
2807 : : #endif /* !defined(_CODECS_CODE_PAGE_DECODE_METHODDEF) */
2808 : :
2809 : : #ifndef _CODECS_MBCS_ENCODE_METHODDEF
2810 : : #define _CODECS_MBCS_ENCODE_METHODDEF
2811 : : #endif /* !defined(_CODECS_MBCS_ENCODE_METHODDEF) */
2812 : :
2813 : : #ifndef _CODECS_OEM_ENCODE_METHODDEF
2814 : : #define _CODECS_OEM_ENCODE_METHODDEF
2815 : : #endif /* !defined(_CODECS_OEM_ENCODE_METHODDEF) */
2816 : :
2817 : : #ifndef _CODECS_CODE_PAGE_ENCODE_METHODDEF
2818 : : #define _CODECS_CODE_PAGE_ENCODE_METHODDEF
2819 : : #endif /* !defined(_CODECS_CODE_PAGE_ENCODE_METHODDEF) */
2820 : : /*[clinic end generated code: output=92250568c3a6f0a0 input=a9049054013a1b77]*/
|
