Branch data Line data Source code
1 : : /* ------------------------------------------------------------------------
2 : :
3 : : _codecs -- Provides access to the codec registry and the builtin
4 : : codecs.
5 : :
6 : : This module should never be imported directly. The standard library
7 : : module "codecs" wraps this builtin module for use within Python.
8 : :
9 : : The codec registry is accessible via:
10 : :
11 : : register(search_function) -> None
12 : :
13 : : lookup(encoding) -> CodecInfo object
14 : :
15 : : The builtin Unicode codecs use the following interface:
16 : :
17 : : <encoding>_encode(Unicode_object[,errors='strict']) ->
18 : : (string object, bytes consumed)
19 : :
20 : : <encoding>_decode(char_buffer_obj[,errors='strict']) ->
21 : : (Unicode object, bytes consumed)
22 : :
23 : : These <encoding>s are available: utf_8, unicode_escape,
24 : : raw_unicode_escape, latin_1, ascii (7-bit), mbcs (on win32).
25 : :
26 : :
27 : : Written by Marc-Andre Lemburg (mal@lemburg.com).
28 : :
29 : : Copyright (c) Corporation for National Research Initiatives.
30 : :
31 : : ------------------------------------------------------------------------ */
32 : :
33 : : #define PY_SSIZE_T_CLEAN
34 : : #include "Python.h"
35 : :
36 : : #ifdef MS_WINDOWS
37 : : #include <windows.h>
38 : : #endif
39 : :
40 : : /*[clinic input]
41 : : module _codecs
42 : : [clinic start generated code]*/
43 : : /*[clinic end generated code: output=da39a3ee5e6b4b0d input=e1390e3da3cb9deb]*/
44 : :
45 : : #include "pycore_runtime.h"
46 : : #include "clinic/_codecsmodule.c.h"
47 : :
48 : : /* --- Registry ----------------------------------------------------------- */
49 : :
50 : : /*[clinic input]
51 : : _codecs.register
52 : : search_function: object
53 : : /
54 : :
55 : : Register a codec search function.
56 : :
57 : : Search functions are expected to take one argument, the encoding name in
58 : : all lower case letters, and either return None, or a tuple of functions
59 : : (encoder, decoder, stream_reader, stream_writer) (or a CodecInfo object).
60 : : [clinic start generated code]*/
61 : :
62 : : static PyObject *
63 : 25 : _codecs_register(PyObject *module, PyObject *search_function)
64 : : /*[clinic end generated code: output=d1bf21e99db7d6d3 input=369578467955cae4]*/
65 : : {
66 [ - + ]: 25 : if (PyCodec_Register(search_function))
67 : 0 : return NULL;
68 : :
69 : 25 : Py_RETURN_NONE;
70 : : }
71 : :
72 : : /*[clinic input]
73 : : _codecs.unregister
74 : : search_function: object
75 : : /
76 : :
77 : : Unregister a codec search function and clear the registry's cache.
78 : :
79 : : If the search function is not registered, do nothing.
80 : : [clinic start generated code]*/
81 : :
82 : : static PyObject *
83 : 0 : _codecs_unregister(PyObject *module, PyObject *search_function)
84 : : /*[clinic end generated code: output=1f0edee9cf246399 input=dd7c004c652d345e]*/
85 : : {
86 [ # # ]: 0 : if (PyCodec_Unregister(search_function) < 0) {
87 : 0 : return NULL;
88 : : }
89 : :
90 : 0 : Py_RETURN_NONE;
91 : : }
92 : :
93 : : /*[clinic input]
94 : : _codecs.lookup
95 : : encoding: str
96 : : /
97 : :
98 : : Looks up a codec tuple in the Python codec registry and returns a CodecInfo object.
99 : : [clinic start generated code]*/
100 : :
101 : : static PyObject *
102 : 0 : _codecs_lookup_impl(PyObject *module, const char *encoding)
103 : : /*[clinic end generated code: output=9f0afa572080c36d input=3c572c0db3febe9c]*/
104 : : {
105 : 0 : return _PyCodec_Lookup(encoding);
106 : : }
107 : :
108 : : /*[clinic input]
109 : : _codecs.encode
110 : : obj: object
111 : : encoding: str(c_default="NULL") = "utf-8"
112 : : errors: str(c_default="NULL") = "strict"
113 : :
114 : : Encodes obj using the codec registered for encoding.
115 : :
116 : : The default encoding is 'utf-8'. errors may be given to set a
117 : : different error handling scheme. Default is 'strict' meaning that encoding
118 : : errors raise a ValueError. Other possible values are 'ignore', 'replace'
119 : : and 'backslashreplace' as well as any other name registered with
120 : : codecs.register_error that can handle ValueErrors.
121 : : [clinic start generated code]*/
122 : :
123 : : static PyObject *
124 : 0 : _codecs_encode_impl(PyObject *module, PyObject *obj, const char *encoding,
125 : : const char *errors)
126 : : /*[clinic end generated code: output=385148eb9a067c86 input=cd5b685040ff61f0]*/
127 : : {
128 [ # # ]: 0 : if (encoding == NULL)
129 : 0 : encoding = PyUnicode_GetDefaultEncoding();
130 : :
131 : : /* Encode via the codec registry */
132 : 0 : return PyCodec_Encode(obj, encoding, errors);
133 : : }
134 : :
135 : : /*[clinic input]
136 : : _codecs.decode
137 : : obj: object
138 : : encoding: str(c_default="NULL") = "utf-8"
139 : : errors: str(c_default="NULL") = "strict"
140 : :
141 : : Decodes obj using the codec registered for encoding.
142 : :
143 : : Default encoding is 'utf-8'. errors may be given to set a
144 : : different error handling scheme. Default is 'strict' meaning that encoding
145 : : errors raise a ValueError. Other possible values are 'ignore', 'replace'
146 : : and 'backslashreplace' as well as any other name registered with
147 : : codecs.register_error that can handle ValueErrors.
148 : : [clinic start generated code]*/
149 : :
150 : : static PyObject *
151 : 0 : _codecs_decode_impl(PyObject *module, PyObject *obj, const char *encoding,
152 : : const char *errors)
153 : : /*[clinic end generated code: output=679882417dc3a0bd input=7702c0cc2fa1add6]*/
154 : : {
155 [ # # ]: 0 : if (encoding == NULL)
156 : 0 : encoding = PyUnicode_GetDefaultEncoding();
157 : :
158 : : /* Decode via the codec registry */
159 : 0 : return PyCodec_Decode(obj, encoding, errors);
160 : : }
161 : :
162 : : /* --- Helpers ------------------------------------------------------------ */
163 : :
164 : : static
165 : 4094 : PyObject *codec_tuple(PyObject *decoded,
166 : : Py_ssize_t len)
167 : : {
168 [ - + ]: 4094 : if (decoded == NULL)
169 : 0 : return NULL;
170 : 4094 : return Py_BuildValue("Nn", decoded, len);
171 : : }
172 : :
173 : : /* --- String codecs ------------------------------------------------------ */
174 : : /*[clinic input]
175 : : _codecs.escape_decode
176 : : data: Py_buffer(accept={str, buffer})
177 : : errors: str(accept={str, NoneType}) = None
178 : : /
179 : : [clinic start generated code]*/
180 : :
181 : : static PyObject *
182 : 0 : _codecs_escape_decode_impl(PyObject *module, Py_buffer *data,
183 : : const char *errors)
184 : : /*[clinic end generated code: output=505200ba8056979a input=77298a561c90bd82]*/
185 : : {
186 : 0 : PyObject *decoded = PyBytes_DecodeEscape(data->buf, data->len,
187 : : errors, 0, NULL);
188 : 0 : return codec_tuple(decoded, data->len);
189 : : }
190 : :
191 : : /*[clinic input]
192 : : _codecs.escape_encode
193 : : data: object(subclass_of='&PyBytes_Type')
194 : : errors: str(accept={str, NoneType}) = None
195 : : /
196 : : [clinic start generated code]*/
197 : :
198 : : static PyObject *
199 : 0 : _codecs_escape_encode_impl(PyObject *module, PyObject *data,
200 : : const char *errors)
201 : : /*[clinic end generated code: output=4af1d477834bab34 input=8f4b144799a94245]*/
202 : : {
203 : : Py_ssize_t size;
204 : : Py_ssize_t newsize;
205 : : PyObject *v;
206 : :
207 : 0 : size = PyBytes_GET_SIZE(data);
208 [ # # ]: 0 : if (size > PY_SSIZE_T_MAX / 4) {
209 : 0 : PyErr_SetString(PyExc_OverflowError,
210 : : "string is too large to encode");
211 : 0 : return NULL;
212 : : }
213 : 0 : newsize = 4*size;
214 : 0 : v = PyBytes_FromStringAndSize(NULL, newsize);
215 : :
216 [ # # ]: 0 : if (v == NULL) {
217 : 0 : return NULL;
218 : : }
219 : : else {
220 : : Py_ssize_t i;
221 : : char c;
222 : 0 : char *p = PyBytes_AS_STRING(v);
223 : :
224 [ # # ]: 0 : for (i = 0; i < size; i++) {
225 : : /* There's at least enough room for a hex escape */
226 : : assert(newsize - (p - PyBytes_AS_STRING(v)) >= 4);
227 : 0 : c = PyBytes_AS_STRING(data)[i];
228 [ # # # # ]: 0 : if (c == '\'' || c == '\\')
229 : 0 : *p++ = '\\', *p++ = c;
230 [ # # ]: 0 : else if (c == '\t')
231 : 0 : *p++ = '\\', *p++ = 't';
232 [ # # ]: 0 : else if (c == '\n')
233 : 0 : *p++ = '\\', *p++ = 'n';
234 [ # # ]: 0 : else if (c == '\r')
235 : 0 : *p++ = '\\', *p++ = 'r';
236 [ # # # # ]: 0 : else if (c < ' ' || c >= 0x7f) {
237 : 0 : *p++ = '\\';
238 : 0 : *p++ = 'x';
239 : 0 : *p++ = Py_hexdigits[(c & 0xf0) >> 4];
240 : 0 : *p++ = Py_hexdigits[c & 0xf];
241 : : }
242 : : else
243 : 0 : *p++ = c;
244 : : }
245 : 0 : *p = '\0';
246 [ # # ]: 0 : if (_PyBytes_Resize(&v, (p - PyBytes_AS_STRING(v)))) {
247 : 0 : return NULL;
248 : : }
249 : : }
250 : :
251 : 0 : return codec_tuple(v, size);
252 : : }
253 : :
254 : : /* --- Decoder ------------------------------------------------------------ */
255 : : /*[clinic input]
256 : : _codecs.utf_7_decode
257 : : data: Py_buffer
258 : : errors: str(accept={str, NoneType}) = None
259 : : final: bool = False
260 : : /
261 : : [clinic start generated code]*/
262 : :
263 : : static PyObject *
264 : 0 : _codecs_utf_7_decode_impl(PyObject *module, Py_buffer *data,
265 : : const char *errors, int final)
266 : : /*[clinic end generated code: output=0cd3a944a32a4089 input=dbf8c8998102dc7d]*/
267 : : {
268 : 0 : Py_ssize_t consumed = data->len;
269 [ # # ]: 0 : PyObject *decoded = PyUnicode_DecodeUTF7Stateful(data->buf, data->len,
270 : : errors,
271 : : final ? NULL : &consumed);
272 : 0 : return codec_tuple(decoded, consumed);
273 : : }
274 : :
275 : : /*[clinic input]
276 : : _codecs.utf_8_decode
277 : : data: Py_buffer
278 : : errors: str(accept={str, NoneType}) = None
279 : : final: bool = False
280 : : /
281 : : [clinic start generated code]*/
282 : :
283 : : static PyObject *
284 : 4094 : _codecs_utf_8_decode_impl(PyObject *module, Py_buffer *data,
285 : : const char *errors, int final)
286 : : /*[clinic end generated code: output=10f74dec8d9bb8bf input=ca06bc8a9c970e25]*/
287 : : {
288 : 4094 : Py_ssize_t consumed = data->len;
289 [ + + ]: 4094 : PyObject *decoded = PyUnicode_DecodeUTF8Stateful(data->buf, data->len,
290 : : errors,
291 : : final ? NULL : &consumed);
292 : 4094 : return codec_tuple(decoded, consumed);
293 : : }
294 : :
295 : : /*[clinic input]
296 : : _codecs.utf_16_decode
297 : : data: Py_buffer
298 : : errors: str(accept={str, NoneType}) = None
299 : : final: bool = False
300 : : /
301 : : [clinic start generated code]*/
302 : :
303 : : static PyObject *
304 : 0 : _codecs_utf_16_decode_impl(PyObject *module, Py_buffer *data,
305 : : const char *errors, int final)
306 : : /*[clinic end generated code: output=783b442abcbcc2d0 input=5b0f52071ba6cadc]*/
307 : : {
308 : 0 : int byteorder = 0;
309 : : /* This is overwritten unless final is true. */
310 : 0 : Py_ssize_t consumed = data->len;
311 [ # # ]: 0 : PyObject *decoded = PyUnicode_DecodeUTF16Stateful(data->buf, data->len,
312 : : errors, &byteorder,
313 : : final ? NULL : &consumed);
314 : 0 : return codec_tuple(decoded, consumed);
315 : : }
316 : :
317 : : /*[clinic input]
318 : : _codecs.utf_16_le_decode
319 : : data: Py_buffer
320 : : errors: str(accept={str, NoneType}) = None
321 : : final: bool = False
322 : : /
323 : : [clinic start generated code]*/
324 : :
325 : : static PyObject *
326 : 0 : _codecs_utf_16_le_decode_impl(PyObject *module, Py_buffer *data,
327 : : const char *errors, int final)
328 : : /*[clinic end generated code: output=899b9e6364379dcd input=115bd8c7b783d0bf]*/
329 : : {
330 : 0 : int byteorder = -1;
331 : : /* This is overwritten unless final is true. */
332 : 0 : Py_ssize_t consumed = data->len;
333 [ # # ]: 0 : PyObject *decoded = PyUnicode_DecodeUTF16Stateful(data->buf, data->len,
334 : : errors, &byteorder,
335 : : final ? NULL : &consumed);
336 : 0 : return codec_tuple(decoded, consumed);
337 : : }
338 : :
339 : : /*[clinic input]
340 : : _codecs.utf_16_be_decode
341 : : data: Py_buffer
342 : : errors: str(accept={str, NoneType}) = None
343 : : final: bool = False
344 : : /
345 : : [clinic start generated code]*/
346 : :
347 : : static PyObject *
348 : 0 : _codecs_utf_16_be_decode_impl(PyObject *module, Py_buffer *data,
349 : : const char *errors, int final)
350 : : /*[clinic end generated code: output=49f6465ea07669c8 input=63131422b01f9cb4]*/
351 : : {
352 : 0 : int byteorder = 1;
353 : : /* This is overwritten unless final is true. */
354 : 0 : Py_ssize_t consumed = data->len;
355 [ # # ]: 0 : PyObject *decoded = PyUnicode_DecodeUTF16Stateful(data->buf, data->len,
356 : : errors, &byteorder,
357 : : final ? NULL : &consumed);
358 : 0 : return codec_tuple(decoded, consumed);
359 : : }
360 : :
361 : : /* This non-standard version also provides access to the byteorder
362 : : parameter of the builtin UTF-16 codec.
363 : :
364 : : It returns a tuple (unicode, bytesread, byteorder) with byteorder
365 : : being the value in effect at the end of data.
366 : :
367 : : */
368 : : /*[clinic input]
369 : : _codecs.utf_16_ex_decode
370 : : data: Py_buffer
371 : : errors: str(accept={str, NoneType}) = None
372 : : byteorder: int = 0
373 : : final: bool = False
374 : : /
375 : : [clinic start generated code]*/
376 : :
377 : : static PyObject *
378 : 0 : _codecs_utf_16_ex_decode_impl(PyObject *module, Py_buffer *data,
379 : : const char *errors, int byteorder, int final)
380 : : /*[clinic end generated code: output=0f385f251ecc1988 input=f368a51cf384bf4c]*/
381 : : {
382 : : /* This is overwritten unless final is true. */
383 : 0 : Py_ssize_t consumed = data->len;
384 : :
385 [ # # ]: 0 : PyObject *decoded = PyUnicode_DecodeUTF16Stateful(data->buf, data->len,
386 : : errors, &byteorder,
387 : : final ? NULL : &consumed);
388 [ # # ]: 0 : if (decoded == NULL)
389 : 0 : return NULL;
390 : 0 : return Py_BuildValue("Nni", decoded, consumed, byteorder);
391 : : }
392 : :
393 : : /*[clinic input]
394 : : _codecs.utf_32_decode
395 : : data: Py_buffer
396 : : errors: str(accept={str, NoneType}) = None
397 : : final: bool = False
398 : : /
399 : : [clinic start generated code]*/
400 : :
401 : : static PyObject *
402 : 0 : _codecs_utf_32_decode_impl(PyObject *module, Py_buffer *data,
403 : : const char *errors, int final)
404 : : /*[clinic end generated code: output=2fc961807f7b145f input=fcdf3658c5e9b5f3]*/
405 : : {
406 : 0 : int byteorder = 0;
407 : : /* This is overwritten unless final is true. */
408 : 0 : Py_ssize_t consumed = data->len;
409 [ # # ]: 0 : PyObject *decoded = PyUnicode_DecodeUTF32Stateful(data->buf, data->len,
410 : : errors, &byteorder,
411 : : final ? NULL : &consumed);
412 : 0 : return codec_tuple(decoded, consumed);
413 : : }
414 : :
415 : : /*[clinic input]
416 : : _codecs.utf_32_le_decode
417 : : data: Py_buffer
418 : : errors: str(accept={str, NoneType}) = None
419 : : final: bool = False
420 : : /
421 : : [clinic start generated code]*/
422 : :
423 : : static PyObject *
424 : 0 : _codecs_utf_32_le_decode_impl(PyObject *module, Py_buffer *data,
425 : : const char *errors, int final)
426 : : /*[clinic end generated code: output=ec8f46b67a94f3e6 input=12220556e885f817]*/
427 : : {
428 : 0 : int byteorder = -1;
429 : : /* This is overwritten unless final is true. */
430 : 0 : Py_ssize_t consumed = data->len;
431 [ # # ]: 0 : PyObject *decoded = PyUnicode_DecodeUTF32Stateful(data->buf, data->len,
432 : : errors, &byteorder,
433 : : final ? NULL : &consumed);
434 : 0 : return codec_tuple(decoded, consumed);
435 : : }
436 : :
437 : : /*[clinic input]
438 : : _codecs.utf_32_be_decode
439 : : data: Py_buffer
440 : : errors: str(accept={str, NoneType}) = None
441 : : final: bool = False
442 : : /
443 : : [clinic start generated code]*/
444 : :
445 : : static PyObject *
446 : 0 : _codecs_utf_32_be_decode_impl(PyObject *module, Py_buffer *data,
447 : : const char *errors, int final)
448 : : /*[clinic end generated code: output=ff82bae862c92c4e input=2bc669b4781598db]*/
449 : : {
450 : 0 : int byteorder = 1;
451 : : /* This is overwritten unless final is true. */
452 : 0 : Py_ssize_t consumed = data->len;
453 [ # # ]: 0 : PyObject *decoded = PyUnicode_DecodeUTF32Stateful(data->buf, data->len,
454 : : errors, &byteorder,
455 : : final ? NULL : &consumed);
456 : 0 : return codec_tuple(decoded, consumed);
457 : : }
458 : :
459 : : /* This non-standard version also provides access to the byteorder
460 : : parameter of the builtin UTF-32 codec.
461 : :
462 : : It returns a tuple (unicode, bytesread, byteorder) with byteorder
463 : : being the value in effect at the end of data.
464 : :
465 : : */
466 : : /*[clinic input]
467 : : _codecs.utf_32_ex_decode
468 : : data: Py_buffer
469 : : errors: str(accept={str, NoneType}) = None
470 : : byteorder: int = 0
471 : : final: bool = False
472 : : /
473 : : [clinic start generated code]*/
474 : :
475 : : static PyObject *
476 : 0 : _codecs_utf_32_ex_decode_impl(PyObject *module, Py_buffer *data,
477 : : const char *errors, int byteorder, int final)
478 : : /*[clinic end generated code: output=6bfb177dceaf4848 input=4a2323d0013620df]*/
479 : : {
480 : 0 : Py_ssize_t consumed = data->len;
481 [ # # ]: 0 : PyObject *decoded = PyUnicode_DecodeUTF32Stateful(data->buf, data->len,
482 : : errors, &byteorder,
483 : : final ? NULL : &consumed);
484 [ # # ]: 0 : if (decoded == NULL)
485 : 0 : return NULL;
486 : 0 : return Py_BuildValue("Nni", decoded, consumed, byteorder);
487 : : }
488 : :
489 : : /*[clinic input]
490 : : _codecs.unicode_escape_decode
491 : : data: Py_buffer(accept={str, buffer})
492 : : errors: str(accept={str, NoneType}) = None
493 : : final: bool = True
494 : : /
495 : : [clinic start generated code]*/
496 : :
497 : : static PyObject *
498 : 0 : _codecs_unicode_escape_decode_impl(PyObject *module, Py_buffer *data,
499 : : const char *errors, int final)
500 : : /*[clinic end generated code: output=b284f97b12c635ee input=15019f081ffe272b]*/
501 : : {
502 : 0 : Py_ssize_t consumed = data->len;
503 [ # # ]: 0 : PyObject *decoded = _PyUnicode_DecodeUnicodeEscapeStateful(data->buf, data->len,
504 : : errors,
505 : : final ? NULL : &consumed);
506 : 0 : return codec_tuple(decoded, consumed);
507 : : }
508 : :
509 : : /*[clinic input]
510 : : _codecs.raw_unicode_escape_decode
511 : : data: Py_buffer(accept={str, buffer})
512 : : errors: str(accept={str, NoneType}) = None
513 : : final: bool = True
514 : : /
515 : : [clinic start generated code]*/
516 : :
517 : : static PyObject *
518 : 0 : _codecs_raw_unicode_escape_decode_impl(PyObject *module, Py_buffer *data,
519 : : const char *errors, int final)
520 : : /*[clinic end generated code: output=11dbd96301e2879e input=b93f823aa8c343ad]*/
521 : : {
522 : 0 : Py_ssize_t consumed = data->len;
523 [ # # ]: 0 : PyObject *decoded = _PyUnicode_DecodeRawUnicodeEscapeStateful(data->buf, data->len,
524 : : errors,
525 : : final ? NULL : &consumed);
526 : 0 : return codec_tuple(decoded, consumed);
527 : : }
528 : :
529 : : /*[clinic input]
530 : : _codecs.latin_1_decode
531 : : data: Py_buffer
532 : : errors: str(accept={str, NoneType}) = None
533 : : /
534 : : [clinic start generated code]*/
535 : :
536 : : static PyObject *
537 : 0 : _codecs_latin_1_decode_impl(PyObject *module, Py_buffer *data,
538 : : const char *errors)
539 : : /*[clinic end generated code: output=07f3dfa3f72c7d8f input=76ca58fd6dcd08c7]*/
540 : : {
541 : 0 : PyObject *decoded = PyUnicode_DecodeLatin1(data->buf, data->len, errors);
542 : 0 : return codec_tuple(decoded, data->len);
543 : : }
544 : :
545 : : /*[clinic input]
546 : : _codecs.ascii_decode
547 : : data: Py_buffer
548 : : errors: str(accept={str, NoneType}) = None
549 : : /
550 : : [clinic start generated code]*/
551 : :
552 : : static PyObject *
553 : 0 : _codecs_ascii_decode_impl(PyObject *module, Py_buffer *data,
554 : : const char *errors)
555 : : /*[clinic end generated code: output=2627d72058d42429 input=e428a267a04b4481]*/
556 : : {
557 : 0 : PyObject *decoded = PyUnicode_DecodeASCII(data->buf, data->len, errors);
558 : 0 : return codec_tuple(decoded, data->len);
559 : : }
560 : :
561 : : /*[clinic input]
562 : : _codecs.charmap_decode
563 : : data: Py_buffer
564 : : errors: str(accept={str, NoneType}) = None
565 : : mapping: object = None
566 : : /
567 : : [clinic start generated code]*/
568 : :
569 : : static PyObject *
570 : 0 : _codecs_charmap_decode_impl(PyObject *module, Py_buffer *data,
571 : : const char *errors, PyObject *mapping)
572 : : /*[clinic end generated code: output=2c335b09778cf895 input=15b69df43458eb40]*/
573 : : {
574 : : PyObject *decoded;
575 : :
576 [ # # ]: 0 : if (mapping == Py_None)
577 : 0 : mapping = NULL;
578 : :
579 : 0 : decoded = PyUnicode_DecodeCharmap(data->buf, data->len, mapping, errors);
580 : 0 : return codec_tuple(decoded, data->len);
581 : : }
582 : :
583 : : #ifdef MS_WINDOWS
584 : :
585 : : /*[clinic input]
586 : : _codecs.mbcs_decode
587 : : data: Py_buffer
588 : : errors: str(accept={str, NoneType}) = None
589 : : final: bool = False
590 : : /
591 : : [clinic start generated code]*/
592 : :
593 : : static PyObject *
594 : : _codecs_mbcs_decode_impl(PyObject *module, Py_buffer *data,
595 : : const char *errors, int final)
596 : : /*[clinic end generated code: output=39b65b8598938c4b input=f144ad1ed6d8f5a6]*/
597 : : {
598 : : Py_ssize_t consumed = data->len;
599 : : PyObject *decoded = PyUnicode_DecodeMBCSStateful(data->buf, data->len,
600 : : errors, final ? NULL : &consumed);
601 : : return codec_tuple(decoded, consumed);
602 : : }
603 : :
604 : : /*[clinic input]
605 : : _codecs.oem_decode
606 : : data: Py_buffer
607 : : errors: str(accept={str, NoneType}) = None
608 : : final: bool = False
609 : : /
610 : : [clinic start generated code]*/
611 : :
612 : : static PyObject *
613 : : _codecs_oem_decode_impl(PyObject *module, Py_buffer *data,
614 : : const char *errors, int final)
615 : : /*[clinic end generated code: output=da1617612f3fcad8 input=629bf87376d211b4]*/
616 : : {
617 : : Py_ssize_t consumed = data->len;
618 : : PyObject *decoded = PyUnicode_DecodeCodePageStateful(CP_OEMCP,
619 : : data->buf, data->len, errors, final ? NULL : &consumed);
620 : : return codec_tuple(decoded, consumed);
621 : : }
622 : :
623 : : /*[clinic input]
624 : : _codecs.code_page_decode
625 : : codepage: int
626 : : data: Py_buffer
627 : : errors: str(accept={str, NoneType}) = None
628 : : final: bool = False
629 : : /
630 : : [clinic start generated code]*/
631 : :
632 : : static PyObject *
633 : : _codecs_code_page_decode_impl(PyObject *module, int codepage,
634 : : Py_buffer *data, const char *errors, int final)
635 : : /*[clinic end generated code: output=53008ea967da3fff input=6a32589b0658c277]*/
636 : : {
637 : : Py_ssize_t consumed = data->len;
638 : : PyObject *decoded = PyUnicode_DecodeCodePageStateful(codepage,
639 : : data->buf, data->len,
640 : : errors,
641 : : final ? NULL : &consumed);
642 : : return codec_tuple(decoded, consumed);
643 : : }
644 : :
645 : : #endif /* MS_WINDOWS */
646 : :
647 : : /* --- Encoder ------------------------------------------------------------ */
648 : :
649 : : /*[clinic input]
650 : : _codecs.readbuffer_encode
651 : : data: Py_buffer(accept={str, buffer})
652 : : errors: str(accept={str, NoneType}) = None
653 : : /
654 : : [clinic start generated code]*/
655 : :
656 : : static PyObject *
657 : 0 : _codecs_readbuffer_encode_impl(PyObject *module, Py_buffer *data,
658 : : const char *errors)
659 : : /*[clinic end generated code: output=c645ea7cdb3d6e86 input=aa10cfdf252455c5]*/
660 : : {
661 : 0 : PyObject *result = PyBytes_FromStringAndSize(data->buf, data->len);
662 : 0 : return codec_tuple(result, data->len);
663 : : }
664 : :
665 : : /*[clinic input]
666 : : _codecs.utf_7_encode
667 : : str: unicode
668 : : errors: str(accept={str, NoneType}) = None
669 : : /
670 : : [clinic start generated code]*/
671 : :
672 : : static PyObject *
673 : 0 : _codecs_utf_7_encode_impl(PyObject *module, PyObject *str,
674 : : const char *errors)
675 : : /*[clinic end generated code: output=0feda21ffc921bc8 input=2546dbbb3fa53114]*/
676 : : {
677 : 0 : return codec_tuple(_PyUnicode_EncodeUTF7(str, 0, 0, errors),
678 : : PyUnicode_GET_LENGTH(str));
679 : : }
680 : :
681 : : /*[clinic input]
682 : : _codecs.utf_8_encode
683 : : str: unicode
684 : : errors: str(accept={str, NoneType}) = None
685 : : /
686 : : [clinic start generated code]*/
687 : :
688 : : static PyObject *
689 : 0 : _codecs_utf_8_encode_impl(PyObject *module, PyObject *str,
690 : : const char *errors)
691 : : /*[clinic end generated code: output=02bf47332b9c796c input=a3e71ae01c3f93f3]*/
692 : : {
693 : 0 : return codec_tuple(_PyUnicode_AsUTF8String(str, errors),
694 : : PyUnicode_GET_LENGTH(str));
695 : : }
696 : :
697 : : /* This version provides access to the byteorder parameter of the
698 : : builtin UTF-16 codecs as optional third argument. It defaults to 0
699 : : which means: use the native byte order and prepend the data with a
700 : : BOM mark.
701 : :
702 : : */
703 : :
704 : : /*[clinic input]
705 : : _codecs.utf_16_encode
706 : : str: unicode
707 : : errors: str(accept={str, NoneType}) = None
708 : : byteorder: int = 0
709 : : /
710 : : [clinic start generated code]*/
711 : :
712 : : static PyObject *
713 : 0 : _codecs_utf_16_encode_impl(PyObject *module, PyObject *str,
714 : : const char *errors, int byteorder)
715 : : /*[clinic end generated code: output=c654e13efa2e64e4 input=68cdc2eb8338555d]*/
716 : : {
717 : 0 : return codec_tuple(_PyUnicode_EncodeUTF16(str, errors, byteorder),
718 : : PyUnicode_GET_LENGTH(str));
719 : : }
720 : :
721 : : /*[clinic input]
722 : : _codecs.utf_16_le_encode
723 : : str: unicode
724 : : errors: str(accept={str, NoneType}) = None
725 : : /
726 : : [clinic start generated code]*/
727 : :
728 : : static PyObject *
729 : 0 : _codecs_utf_16_le_encode_impl(PyObject *module, PyObject *str,
730 : : const char *errors)
731 : : /*[clinic end generated code: output=431b01e55f2d4995 input=83d042706eed6798]*/
732 : : {
733 : 0 : return codec_tuple(_PyUnicode_EncodeUTF16(str, errors, -1),
734 : : PyUnicode_GET_LENGTH(str));
735 : : }
736 : :
737 : : /*[clinic input]
738 : : _codecs.utf_16_be_encode
739 : : str: unicode
740 : : errors: str(accept={str, NoneType}) = None
741 : : /
742 : : [clinic start generated code]*/
743 : :
744 : : static PyObject *
745 : 0 : _codecs_utf_16_be_encode_impl(PyObject *module, PyObject *str,
746 : : const char *errors)
747 : : /*[clinic end generated code: output=96886a6fd54dcae3 input=6f1e9e623b03071b]*/
748 : : {
749 : 0 : return codec_tuple(_PyUnicode_EncodeUTF16(str, errors, +1),
750 : : PyUnicode_GET_LENGTH(str));
751 : : }
752 : :
753 : : /* This version provides access to the byteorder parameter of the
754 : : builtin UTF-32 codecs as optional third argument. It defaults to 0
755 : : which means: use the native byte order and prepend the data with a
756 : : BOM mark.
757 : :
758 : : */
759 : :
760 : : /*[clinic input]
761 : : _codecs.utf_32_encode
762 : : str: unicode
763 : : errors: str(accept={str, NoneType}) = None
764 : : byteorder: int = 0
765 : : /
766 : : [clinic start generated code]*/
767 : :
768 : : static PyObject *
769 : 0 : _codecs_utf_32_encode_impl(PyObject *module, PyObject *str,
770 : : const char *errors, int byteorder)
771 : : /*[clinic end generated code: output=5c760da0c09a8b83 input=8ec4c64d983bc52b]*/
772 : : {
773 : 0 : return codec_tuple(_PyUnicode_EncodeUTF32(str, errors, byteorder),
774 : : PyUnicode_GET_LENGTH(str));
775 : : }
776 : :
777 : : /*[clinic input]
778 : : _codecs.utf_32_le_encode
779 : : str: unicode
780 : : errors: str(accept={str, NoneType}) = None
781 : : /
782 : : [clinic start generated code]*/
783 : :
784 : : static PyObject *
785 : 0 : _codecs_utf_32_le_encode_impl(PyObject *module, PyObject *str,
786 : : const char *errors)
787 : : /*[clinic end generated code: output=b65cd176de8e36d6 input=f0918d41de3eb1b1]*/
788 : : {
789 : 0 : return codec_tuple(_PyUnicode_EncodeUTF32(str, errors, -1),
790 : : PyUnicode_GET_LENGTH(str));
791 : : }
792 : :
793 : : /*[clinic input]
794 : : _codecs.utf_32_be_encode
795 : : str: unicode
796 : : errors: str(accept={str, NoneType}) = None
797 : : /
798 : : [clinic start generated code]*/
799 : :
800 : : static PyObject *
801 : 0 : _codecs_utf_32_be_encode_impl(PyObject *module, PyObject *str,
802 : : const char *errors)
803 : : /*[clinic end generated code: output=1d9e71a9358709e9 input=967a99a95748b557]*/
804 : : {
805 : 0 : return codec_tuple(_PyUnicode_EncodeUTF32(str, errors, +1),
806 : : PyUnicode_GET_LENGTH(str));
807 : : }
808 : :
809 : : /*[clinic input]
810 : : _codecs.unicode_escape_encode
811 : : str: unicode
812 : : errors: str(accept={str, NoneType}) = None
813 : : /
814 : : [clinic start generated code]*/
815 : :
816 : : static PyObject *
817 : 0 : _codecs_unicode_escape_encode_impl(PyObject *module, PyObject *str,
818 : : const char *errors)
819 : : /*[clinic end generated code: output=66271b30bc4f7a3c input=8c4de07597054e33]*/
820 : : {
821 : 0 : return codec_tuple(PyUnicode_AsUnicodeEscapeString(str),
822 : : PyUnicode_GET_LENGTH(str));
823 : : }
824 : :
825 : : /*[clinic input]
826 : : _codecs.raw_unicode_escape_encode
827 : : str: unicode
828 : : errors: str(accept={str, NoneType}) = None
829 : : /
830 : : [clinic start generated code]*/
831 : :
832 : : static PyObject *
833 : 0 : _codecs_raw_unicode_escape_encode_impl(PyObject *module, PyObject *str,
834 : : const char *errors)
835 : : /*[clinic end generated code: output=a66a806ed01c830a input=4aa6f280d78e4574]*/
836 : : {
837 : 0 : return codec_tuple(PyUnicode_AsRawUnicodeEscapeString(str),
838 : : PyUnicode_GET_LENGTH(str));
839 : : }
840 : :
841 : : /*[clinic input]
842 : : _codecs.latin_1_encode
843 : : str: unicode
844 : : errors: str(accept={str, NoneType}) = None
845 : : /
846 : : [clinic start generated code]*/
847 : :
848 : : static PyObject *
849 : 0 : _codecs_latin_1_encode_impl(PyObject *module, PyObject *str,
850 : : const char *errors)
851 : : /*[clinic end generated code: output=2c28c83a27884e08 input=ec3ef74bf85c5c5d]*/
852 : : {
853 : 0 : return codec_tuple(_PyUnicode_AsLatin1String(str, errors),
854 : : PyUnicode_GET_LENGTH(str));
855 : : }
856 : :
857 : : /*[clinic input]
858 : : _codecs.ascii_encode
859 : : str: unicode
860 : : errors: str(accept={str, NoneType}) = None
861 : : /
862 : : [clinic start generated code]*/
863 : :
864 : : static PyObject *
865 : 0 : _codecs_ascii_encode_impl(PyObject *module, PyObject *str,
866 : : const char *errors)
867 : : /*[clinic end generated code: output=b5e035182d33befc input=93e6e602838bd3de]*/
868 : : {
869 : 0 : return codec_tuple(_PyUnicode_AsASCIIString(str, errors),
870 : : PyUnicode_GET_LENGTH(str));
871 : : }
872 : :
873 : : /*[clinic input]
874 : : _codecs.charmap_encode
875 : : str: unicode
876 : : errors: str(accept={str, NoneType}) = None
877 : : mapping: object = None
878 : : /
879 : : [clinic start generated code]*/
880 : :
881 : : static PyObject *
882 : 0 : _codecs_charmap_encode_impl(PyObject *module, PyObject *str,
883 : : const char *errors, PyObject *mapping)
884 : : /*[clinic end generated code: output=047476f48495a9e9 input=2a98feae73dadce8]*/
885 : : {
886 [ # # ]: 0 : if (mapping == Py_None)
887 : 0 : mapping = NULL;
888 : :
889 : 0 : return codec_tuple(_PyUnicode_EncodeCharmap(str, mapping, errors),
890 : : PyUnicode_GET_LENGTH(str));
891 : : }
892 : :
893 : : /*[clinic input]
894 : : _codecs.charmap_build
895 : : map: unicode
896 : : /
897 : : [clinic start generated code]*/
898 : :
899 : : static PyObject *
900 : 0 : _codecs_charmap_build_impl(PyObject *module, PyObject *map)
901 : : /*[clinic end generated code: output=bb073c27031db9ac input=d91a91d1717dbc6d]*/
902 : : {
903 : 0 : return PyUnicode_BuildEncodingMap(map);
904 : : }
905 : :
906 : : #ifdef MS_WINDOWS
907 : :
908 : : /*[clinic input]
909 : : _codecs.mbcs_encode
910 : : str: unicode
911 : : errors: str(accept={str, NoneType}) = None
912 : : /
913 : : [clinic start generated code]*/
914 : :
915 : : static PyObject *
916 : : _codecs_mbcs_encode_impl(PyObject *module, PyObject *str, const char *errors)
917 : : /*[clinic end generated code: output=76e2e170c966c080 input=2e932fc289ea5a5b]*/
918 : : {
919 : : return codec_tuple(PyUnicode_EncodeCodePage(CP_ACP, str, errors),
920 : : PyUnicode_GET_LENGTH(str));
921 : : }
922 : :
923 : : /*[clinic input]
924 : : _codecs.oem_encode
925 : : str: unicode
926 : : errors: str(accept={str, NoneType}) = None
927 : : /
928 : : [clinic start generated code]*/
929 : :
930 : : static PyObject *
931 : : _codecs_oem_encode_impl(PyObject *module, PyObject *str, const char *errors)
932 : : /*[clinic end generated code: output=65d5982c737de649 input=9eac86dc21eb14f2]*/
933 : : {
934 : : return codec_tuple(PyUnicode_EncodeCodePage(CP_OEMCP, str, errors),
935 : : PyUnicode_GET_LENGTH(str));
936 : : }
937 : :
938 : : /*[clinic input]
939 : : _codecs.code_page_encode
940 : : code_page: int
941 : : str: unicode
942 : : errors: str(accept={str, NoneType}) = None
943 : : /
944 : : [clinic start generated code]*/
945 : :
946 : : static PyObject *
947 : : _codecs_code_page_encode_impl(PyObject *module, int code_page, PyObject *str,
948 : : const char *errors)
949 : : /*[clinic end generated code: output=45673f6085657a9e input=7d18a33bc8cd0f94]*/
950 : : {
951 : : return codec_tuple(PyUnicode_EncodeCodePage(code_page, str, errors),
952 : : PyUnicode_GET_LENGTH(str));
953 : : }
954 : :
955 : : #endif /* MS_WINDOWS */
956 : :
957 : : /* --- Error handler registry --------------------------------------------- */
958 : :
959 : : /*[clinic input]
960 : : _codecs.register_error
961 : : errors: str
962 : : handler: object
963 : : /
964 : :
965 : : Register the specified error handler under the name errors.
966 : :
967 : : handler must be a callable object, that will be called with an exception
968 : : instance containing information about the location of the encoding/decoding
969 : : error and must return a (replacement, new position) tuple.
970 : : [clinic start generated code]*/
971 : :
972 : : static PyObject *
973 : 0 : _codecs_register_error_impl(PyObject *module, const char *errors,
974 : : PyObject *handler)
975 : : /*[clinic end generated code: output=fa2f7d1879b3067d input=5e6709203c2e33fe]*/
976 : : {
977 [ # # ]: 0 : if (PyCodec_RegisterError(errors, handler))
978 : 0 : return NULL;
979 : 0 : Py_RETURN_NONE;
980 : : }
981 : :
982 : : /*[clinic input]
983 : : _codecs.lookup_error
984 : : name: str
985 : : /
986 : :
987 : : lookup_error(errors) -> handler
988 : :
989 : : Return the error handler for the specified error handling name or raise a
990 : : LookupError, if no handler exists under this name.
991 : : [clinic start generated code]*/
992 : :
993 : : static PyObject *
994 : 150 : _codecs_lookup_error_impl(PyObject *module, const char *name)
995 : : /*[clinic end generated code: output=087f05dc0c9a98cc input=4775dd65e6235aba]*/
996 : : {
997 : 150 : return PyCodec_LookupError(name);
998 : : }
999 : :
1000 : : /* --- Module API --------------------------------------------------------- */
1001 : :
1002 : : static PyMethodDef _codecs_functions[] = {
1003 : : _CODECS_REGISTER_METHODDEF
1004 : : _CODECS_UNREGISTER_METHODDEF
1005 : : _CODECS_LOOKUP_METHODDEF
1006 : : _CODECS_ENCODE_METHODDEF
1007 : : _CODECS_DECODE_METHODDEF
1008 : : _CODECS_ESCAPE_ENCODE_METHODDEF
1009 : : _CODECS_ESCAPE_DECODE_METHODDEF
1010 : : _CODECS_UTF_8_ENCODE_METHODDEF
1011 : : _CODECS_UTF_8_DECODE_METHODDEF
1012 : : _CODECS_UTF_7_ENCODE_METHODDEF
1013 : : _CODECS_UTF_7_DECODE_METHODDEF
1014 : : _CODECS_UTF_16_ENCODE_METHODDEF
1015 : : _CODECS_UTF_16_LE_ENCODE_METHODDEF
1016 : : _CODECS_UTF_16_BE_ENCODE_METHODDEF
1017 : : _CODECS_UTF_16_DECODE_METHODDEF
1018 : : _CODECS_UTF_16_LE_DECODE_METHODDEF
1019 : : _CODECS_UTF_16_BE_DECODE_METHODDEF
1020 : : _CODECS_UTF_16_EX_DECODE_METHODDEF
1021 : : _CODECS_UTF_32_ENCODE_METHODDEF
1022 : : _CODECS_UTF_32_LE_ENCODE_METHODDEF
1023 : : _CODECS_UTF_32_BE_ENCODE_METHODDEF
1024 : : _CODECS_UTF_32_DECODE_METHODDEF
1025 : : _CODECS_UTF_32_LE_DECODE_METHODDEF
1026 : : _CODECS_UTF_32_BE_DECODE_METHODDEF
1027 : : _CODECS_UTF_32_EX_DECODE_METHODDEF
1028 : : _CODECS_UNICODE_ESCAPE_ENCODE_METHODDEF
1029 : : _CODECS_UNICODE_ESCAPE_DECODE_METHODDEF
1030 : : _CODECS_RAW_UNICODE_ESCAPE_ENCODE_METHODDEF
1031 : : _CODECS_RAW_UNICODE_ESCAPE_DECODE_METHODDEF
1032 : : _CODECS_LATIN_1_ENCODE_METHODDEF
1033 : : _CODECS_LATIN_1_DECODE_METHODDEF
1034 : : _CODECS_ASCII_ENCODE_METHODDEF
1035 : : _CODECS_ASCII_DECODE_METHODDEF
1036 : : _CODECS_CHARMAP_ENCODE_METHODDEF
1037 : : _CODECS_CHARMAP_DECODE_METHODDEF
1038 : : _CODECS_CHARMAP_BUILD_METHODDEF
1039 : : _CODECS_READBUFFER_ENCODE_METHODDEF
1040 : : _CODECS_MBCS_ENCODE_METHODDEF
1041 : : _CODECS_MBCS_DECODE_METHODDEF
1042 : : _CODECS_OEM_ENCODE_METHODDEF
1043 : : _CODECS_OEM_DECODE_METHODDEF
1044 : : _CODECS_CODE_PAGE_ENCODE_METHODDEF
1045 : : _CODECS_CODE_PAGE_DECODE_METHODDEF
1046 : : _CODECS_REGISTER_ERROR_METHODDEF
1047 : : _CODECS_LOOKUP_ERROR_METHODDEF
1048 : : {NULL, NULL} /* sentinel */
1049 : : };
1050 : :
1051 : : static PyModuleDef_Slot _codecs_slots[] = {
1052 : : {0, NULL}
1053 : : };
1054 : :
1055 : : static struct PyModuleDef codecsmodule = {
1056 : : PyModuleDef_HEAD_INIT,
1057 : : "_codecs",
1058 : : NULL,
1059 : : 0,
1060 : : _codecs_functions,
1061 : : _codecs_slots,
1062 : : NULL,
1063 : : NULL,
1064 : : NULL
1065 : : };
1066 : :
1067 : : PyMODINIT_FUNC
1068 : 26 : PyInit__codecs(void)
1069 : : {
1070 : 26 : return PyModuleDef_Init(&codecsmodule);
1071 : : }
|