1 /* ------------------------------------------------------------------------
3 _codecs -- Provides access to the codec registry and the builtin
6 This module should never be imported directly. The standard library
7 module "codecs" wraps this builtin module for use within Python.
9 The codec registry is accessible via:
11 register(search_function) -> None
13 lookup(encoding) -> CodecInfo object
15 The builtin Unicode codecs use the following interface:
17 <encoding>_encode(Unicode_object[,errors='strict']) ->
18 (string object, bytes consumed)
20 <encoding>_decode(char_buffer_obj[,errors='strict']) ->
21 (Unicode object, bytes consumed)
23 <encoding>_encode() interfaces also accept non-Unicode object as
24 input. The objects are then converted to Unicode using
25 PyUnicode_FromObject() prior to applying the conversion.
27 These <encoding>s are available: utf_8, unicode_escape,
28 raw_unicode_escape, unicode_internal, latin_1, ascii (7-bit),
32 Written by Marc-Andre Lemburg (mal@lemburg.com).
34 Copyright (c) Corporation for National Research Initiatives.
36 ------------------------------------------------------------------------ */
38 #define PY_SSIZE_T_CLEAN
41 /* --- Registry ----------------------------------------------------------- */
43 PyDoc_STRVAR(register__doc__
,
44 "register(search_function)\n\
46 Register a codec search function. Search functions are expected to take\n\
47 one argument, the encoding name in all lower case letters, and return\n\
48 a tuple of functions (encoder, decoder, stream_reader, stream_writer)\n\
49 (or a CodecInfo object).");
52 PyObject
*codec_register(PyObject
*self
, PyObject
*search_function
)
54 if (PyCodec_Register(search_function
))
60 PyDoc_STRVAR(lookup__doc__
,
61 "lookup(encoding) -> CodecInfo\n\
63 Looks up a codec tuple in the Python codec registry and returns\n\
64 a tuple of function (or a CodecInfo object).");
67 PyObject
*codec_lookup(PyObject
*self
, PyObject
*args
)
71 if (!PyArg_ParseTuple(args
, "s:lookup", &encoding
))
74 return _PyCodec_Lookup(encoding
);
77 PyDoc_STRVAR(encode__doc__
,
78 "encode(obj, [encoding[,errors]]) -> object\n\
80 Encodes obj using the codec registered for encoding. encoding defaults\n\
81 to the default encoding. errors may be given to set a different error\n\
82 handling scheme. Default is 'strict' meaning that encoding errors raise\n\
83 a ValueError. Other possible values are 'ignore', 'replace' and\n\
84 'xmlcharrefreplace' as well as any other name registered with\n\
85 codecs.register_error that can handle ValueErrors.");
88 codec_encode(PyObject
*self
, PyObject
*args
)
90 const char *encoding
= NULL
;
91 const char *errors
= NULL
;
94 if (!PyArg_ParseTuple(args
, "O|ss:encode", &v
, &encoding
, &errors
))
97 #ifdef Py_USING_UNICODE
99 encoding
= PyUnicode_GetDefaultEncoding();
101 if (encoding
== NULL
) {
102 PyErr_SetString(PyExc_ValueError
, "no encoding specified");
107 /* Encode via the codec registry */
108 return PyCodec_Encode(v
, encoding
, errors
);
111 PyDoc_STRVAR(decode__doc__
,
112 "decode(obj, [encoding[,errors]]) -> object\n\
114 Decodes obj using the codec registered for encoding. encoding defaults\n\
115 to the default encoding. errors may be given to set a different error\n\
116 handling scheme. Default is 'strict' meaning that encoding errors raise\n\
117 a ValueError. Other possible values are 'ignore' and 'replace'\n\
118 as well as any other name registerd with codecs.register_error that is\n\
119 able to handle ValueErrors.");
122 codec_decode(PyObject
*self
, PyObject
*args
)
124 const char *encoding
= NULL
;
125 const char *errors
= NULL
;
128 if (!PyArg_ParseTuple(args
, "O|ss:decode", &v
, &encoding
, &errors
))
131 #ifdef Py_USING_UNICODE
132 if (encoding
== NULL
)
133 encoding
= PyUnicode_GetDefaultEncoding();
135 if (encoding
== NULL
) {
136 PyErr_SetString(PyExc_ValueError
, "no encoding specified");
141 /* Decode via the codec registry */
142 return PyCodec_Decode(v
, encoding
, errors
);
145 /* --- Helpers ------------------------------------------------------------ */
148 PyObject
*codec_tuple(PyObject
*unicode
,
154 v
= Py_BuildValue("On", unicode
, len
);
159 /* --- String codecs ------------------------------------------------------ */
161 escape_decode(PyObject
*self
,
164 const char *errors
= NULL
;
168 if (!PyArg_ParseTuple(args
, "s#|z:escape_decode",
169 &data
, &size
, &errors
))
171 return codec_tuple(PyString_DecodeEscape(data
, size
, errors
, 0, NULL
),
176 escape_encode(PyObject
*self
,
180 const char *errors
= NULL
;
184 if (!PyArg_ParseTuple(args
, "O!|z:escape_encode",
185 &PyString_Type
, &str
, &errors
))
188 str
= PyString_Repr(str
, 0);
192 /* The string will be quoted. Unquote, similar to unicode-escape. */
193 buf
= PyString_AS_STRING (str
);
194 len
= PyString_GET_SIZE (str
);
195 memmove(buf
, buf
+1, len
-2);
196 if (_PyString_Resize(&str
, len
-2) < 0)
199 return codec_tuple(str
, PyString_Size(str
));
202 #ifdef Py_USING_UNICODE
203 /* --- Decoder ------------------------------------------------------------ */
206 unicode_internal_decode(PyObject
*self
,
210 const char *errors
= NULL
;
214 if (!PyArg_ParseTuple(args
, "O|z:unicode_internal_decode",
218 if (PyUnicode_Check(obj
)) {
220 return codec_tuple(obj
, PyUnicode_GET_SIZE(obj
));
223 if (PyObject_AsReadBuffer(obj
, (const void **)&data
, &size
))
226 return codec_tuple(_PyUnicode_DecodeUnicodeInternal(data
, size
, errors
),
232 utf_7_decode(PyObject
*self
,
237 const char *errors
= NULL
;
240 PyObject
*decoded
= NULL
;
242 if (!PyArg_ParseTuple(args
, "t#|zi:utf_7_decode",
243 &data
, &size
, &errors
, &final
))
247 decoded
= PyUnicode_DecodeUTF7Stateful(data
, size
, errors
,
248 final
? NULL
: &consumed
);
251 return codec_tuple(decoded
, consumed
);
255 utf_8_decode(PyObject
*self
,
260 const char *errors
= NULL
;
263 PyObject
*decoded
= NULL
;
265 if (!PyArg_ParseTuple(args
, "t#|zi:utf_8_decode",
266 &data
, &size
, &errors
, &final
))
269 PyErr_SetString(PyExc_ValueError
, "negative argument");
274 decoded
= PyUnicode_DecodeUTF8Stateful(data
, size
, errors
,
275 final
? NULL
: &consumed
);
278 return codec_tuple(decoded
, consumed
);
282 utf_16_decode(PyObject
*self
,
287 const char *errors
= NULL
;
293 if (!PyArg_ParseTuple(args
, "t#|zi:utf_16_decode",
294 &data
, &size
, &errors
, &final
))
297 PyErr_SetString(PyExc_ValueError
, "negative argument");
300 consumed
= size
; /* This is overwritten unless final is true. */
301 decoded
= PyUnicode_DecodeUTF16Stateful(data
, size
, errors
, &byteorder
,
302 final
? NULL
: &consumed
);
305 return codec_tuple(decoded
, consumed
);
309 utf_16_le_decode(PyObject
*self
,
314 const char *errors
= NULL
;
318 PyObject
*decoded
= NULL
;
320 if (!PyArg_ParseTuple(args
, "t#|zi:utf_16_le_decode",
321 &data
, &size
, &errors
, &final
))
325 PyErr_SetString(PyExc_ValueError
, "negative argument");
328 consumed
= size
; /* This is overwritten unless final is true. */
329 decoded
= PyUnicode_DecodeUTF16Stateful(data
, size
, errors
,
330 &byteorder
, final
? NULL
: &consumed
);
333 return codec_tuple(decoded
, consumed
);
338 utf_16_be_decode(PyObject
*self
,
343 const char *errors
= NULL
;
347 PyObject
*decoded
= NULL
;
349 if (!PyArg_ParseTuple(args
, "t#|zi:utf_16_be_decode",
350 &data
, &size
, &errors
, &final
))
353 PyErr_SetString(PyExc_ValueError
, "negative argument");
356 consumed
= size
; /* This is overwritten unless final is true. */
357 decoded
= PyUnicode_DecodeUTF16Stateful(data
, size
, errors
,
358 &byteorder
, final
? NULL
: &consumed
);
361 return codec_tuple(decoded
, consumed
);
364 /* This non-standard version also provides access to the byteorder
365 parameter of the builtin UTF-16 codec.
367 It returns a tuple (unicode, bytesread, byteorder) with byteorder
368 being the value in effect at the end of data.
373 utf_16_ex_decode(PyObject
*self
,
378 const char *errors
= NULL
;
380 PyObject
*unicode
, *tuple
;
384 if (!PyArg_ParseTuple(args
, "t#|zii:utf_16_ex_decode",
385 &data
, &size
, &errors
, &byteorder
, &final
))
388 PyErr_SetString(PyExc_ValueError
, "negative argument");
391 consumed
= size
; /* This is overwritten unless final is true. */
392 unicode
= PyUnicode_DecodeUTF16Stateful(data
, size
, errors
, &byteorder
,
393 final
? NULL
: &consumed
);
396 tuple
= Py_BuildValue("Oni", unicode
, consumed
, byteorder
);
402 utf_32_decode(PyObject
*self
,
407 const char *errors
= NULL
;
413 if (!PyArg_ParseTuple(args
, "t#|zi:utf_32_decode",
414 &data
, &size
, &errors
, &final
))
417 PyErr_SetString(PyExc_ValueError
, "negative argument");
420 consumed
= size
; /* This is overwritten unless final is true. */
421 decoded
= PyUnicode_DecodeUTF32Stateful(data
, size
, errors
, &byteorder
,
422 final
? NULL
: &consumed
);
425 return codec_tuple(decoded
, consumed
);
429 utf_32_le_decode(PyObject
*self
,
434 const char *errors
= NULL
;
438 PyObject
*decoded
= NULL
;
440 if (!PyArg_ParseTuple(args
, "t#|zi:utf_32_le_decode",
441 &data
, &size
, &errors
, &final
))
445 PyErr_SetString(PyExc_ValueError
, "negative argument");
448 consumed
= size
; /* This is overwritten unless final is true. */
449 decoded
= PyUnicode_DecodeUTF32Stateful(data
, size
, errors
,
450 &byteorder
, final
? NULL
: &consumed
);
453 return codec_tuple(decoded
, consumed
);
458 utf_32_be_decode(PyObject
*self
,
463 const char *errors
= NULL
;
467 PyObject
*decoded
= NULL
;
469 if (!PyArg_ParseTuple(args
, "t#|zi:utf_32_be_decode",
470 &data
, &size
, &errors
, &final
))
473 PyErr_SetString(PyExc_ValueError
, "negative argument");
476 consumed
= size
; /* This is overwritten unless final is true. */
477 decoded
= PyUnicode_DecodeUTF32Stateful(data
, size
, errors
,
478 &byteorder
, final
? NULL
: &consumed
);
481 return codec_tuple(decoded
, consumed
);
484 /* This non-standard version also provides access to the byteorder
485 parameter of the builtin UTF-32 codec.
487 It returns a tuple (unicode, bytesread, byteorder) with byteorder
488 being the value in effect at the end of data.
493 utf_32_ex_decode(PyObject
*self
,
498 const char *errors
= NULL
;
500 PyObject
*unicode
, *tuple
;
504 if (!PyArg_ParseTuple(args
, "t#|zii:utf_32_ex_decode",
505 &data
, &size
, &errors
, &byteorder
, &final
))
508 PyErr_SetString(PyExc_ValueError
, "negative argument");
511 consumed
= size
; /* This is overwritten unless final is true. */
512 unicode
= PyUnicode_DecodeUTF32Stateful(data
, size
, errors
, &byteorder
,
513 final
? NULL
: &consumed
);
516 tuple
= Py_BuildValue("Oni", unicode
, consumed
, byteorder
);
522 unicode_escape_decode(PyObject
*self
,
527 const char *errors
= NULL
;
529 if (!PyArg_ParseTuple(args
, "t#|z:unicode_escape_decode",
530 &data
, &size
, &errors
))
533 return codec_tuple(PyUnicode_DecodeUnicodeEscape(data
, size
, errors
),
538 raw_unicode_escape_decode(PyObject
*self
,
543 const char *errors
= NULL
;
545 if (!PyArg_ParseTuple(args
, "t#|z:raw_unicode_escape_decode",
546 &data
, &size
, &errors
))
549 return codec_tuple(PyUnicode_DecodeRawUnicodeEscape(data
, size
, errors
),
554 latin_1_decode(PyObject
*self
,
559 const char *errors
= NULL
;
561 if (!PyArg_ParseTuple(args
, "t#|z:latin_1_decode",
562 &data
, &size
, &errors
))
565 return codec_tuple(PyUnicode_DecodeLatin1(data
, size
, errors
),
570 ascii_decode(PyObject
*self
,
575 const char *errors
= NULL
;
577 if (!PyArg_ParseTuple(args
, "t#|z:ascii_decode",
578 &data
, &size
, &errors
))
581 return codec_tuple(PyUnicode_DecodeASCII(data
, size
, errors
),
586 charmap_decode(PyObject
*self
,
591 const char *errors
= NULL
;
592 PyObject
*mapping
= NULL
;
594 if (!PyArg_ParseTuple(args
, "t#|zO:charmap_decode",
595 &data
, &size
, &errors
, &mapping
))
597 if (mapping
== Py_None
)
600 return codec_tuple(PyUnicode_DecodeCharmap(data
, size
, mapping
, errors
),
604 #if defined(MS_WINDOWS) && defined(HAVE_USABLE_WCHAR_T)
607 mbcs_decode(PyObject
*self
,
611 Py_ssize_t size
, consumed
;
612 const char *errors
= NULL
;
616 if (!PyArg_ParseTuple(args
, "t#|zi:mbcs_decode",
617 &data
, &size
, &errors
, &final
))
620 decoded
= PyUnicode_DecodeMBCSStateful(
621 data
, size
, errors
, final
? NULL
: &consumed
);
624 return codec_tuple(decoded
, final
? size
: consumed
);
627 #endif /* MS_WINDOWS */
629 /* --- Encoder ------------------------------------------------------------ */
632 readbuffer_encode(PyObject
*self
,
637 const char *errors
= NULL
;
639 if (!PyArg_ParseTuple(args
, "s#|z:readbuffer_encode",
640 &data
, &size
, &errors
))
643 return codec_tuple(PyString_FromStringAndSize(data
, size
),
648 charbuffer_encode(PyObject
*self
,
653 const char *errors
= NULL
;
655 if (!PyArg_ParseTuple(args
, "t#|z:charbuffer_encode",
656 &data
, &size
, &errors
))
659 return codec_tuple(PyString_FromStringAndSize(data
, size
),
664 unicode_internal_encode(PyObject
*self
,
668 const char *errors
= NULL
;
672 if (!PyArg_ParseTuple(args
, "O|z:unicode_internal_encode",
676 if (PyUnicode_Check(obj
)) {
677 data
= PyUnicode_AS_DATA(obj
);
678 size
= PyUnicode_GET_DATA_SIZE(obj
);
679 return codec_tuple(PyString_FromStringAndSize(data
, size
),
683 if (PyObject_AsReadBuffer(obj
, (const void **)&data
, &size
))
685 return codec_tuple(PyString_FromStringAndSize(data
, size
),
691 utf_7_encode(PyObject
*self
,
695 const char *errors
= NULL
;
697 if (!PyArg_ParseTuple(args
, "O|z:utf_7_encode",
701 str
= PyUnicode_FromObject(str
);
704 v
= codec_tuple(PyUnicode_EncodeUTF7(PyUnicode_AS_UNICODE(str
),
705 PyUnicode_GET_SIZE(str
),
709 PyUnicode_GET_SIZE(str
));
715 utf_8_encode(PyObject
*self
,
719 const char *errors
= NULL
;
721 if (!PyArg_ParseTuple(args
, "O|z:utf_8_encode",
725 str
= PyUnicode_FromObject(str
);
728 v
= codec_tuple(PyUnicode_EncodeUTF8(PyUnicode_AS_UNICODE(str
),
729 PyUnicode_GET_SIZE(str
),
731 PyUnicode_GET_SIZE(str
));
736 /* This version provides access to the byteorder parameter of the
737 builtin UTF-16 codecs as optional third argument. It defaults to 0
738 which means: use the native byte order and prepend the data with a
744 utf_16_encode(PyObject
*self
,
748 const char *errors
= NULL
;
751 if (!PyArg_ParseTuple(args
, "O|zi:utf_16_encode",
752 &str
, &errors
, &byteorder
))
755 str
= PyUnicode_FromObject(str
);
758 v
= codec_tuple(PyUnicode_EncodeUTF16(PyUnicode_AS_UNICODE(str
),
759 PyUnicode_GET_SIZE(str
),
762 PyUnicode_GET_SIZE(str
));
768 utf_16_le_encode(PyObject
*self
,
772 const char *errors
= NULL
;
774 if (!PyArg_ParseTuple(args
, "O|z:utf_16_le_encode",
778 str
= PyUnicode_FromObject(str
);
781 v
= codec_tuple(PyUnicode_EncodeUTF16(PyUnicode_AS_UNICODE(str
),
782 PyUnicode_GET_SIZE(str
),
785 PyUnicode_GET_SIZE(str
));
791 utf_16_be_encode(PyObject
*self
,
795 const char *errors
= NULL
;
797 if (!PyArg_ParseTuple(args
, "O|z:utf_16_be_encode",
801 str
= PyUnicode_FromObject(str
);
804 v
= codec_tuple(PyUnicode_EncodeUTF16(PyUnicode_AS_UNICODE(str
),
805 PyUnicode_GET_SIZE(str
),
808 PyUnicode_GET_SIZE(str
));
813 /* This version provides access to the byteorder parameter of the
814 builtin UTF-32 codecs as optional third argument. It defaults to 0
815 which means: use the native byte order and prepend the data with a
821 utf_32_encode(PyObject
*self
,
825 const char *errors
= NULL
;
828 if (!PyArg_ParseTuple(args
, "O|zi:utf_32_encode",
829 &str
, &errors
, &byteorder
))
832 str
= PyUnicode_FromObject(str
);
835 v
= codec_tuple(PyUnicode_EncodeUTF32(PyUnicode_AS_UNICODE(str
),
836 PyUnicode_GET_SIZE(str
),
839 PyUnicode_GET_SIZE(str
));
845 utf_32_le_encode(PyObject
*self
,
849 const char *errors
= NULL
;
851 if (!PyArg_ParseTuple(args
, "O|z:utf_32_le_encode",
855 str
= PyUnicode_FromObject(str
);
858 v
= codec_tuple(PyUnicode_EncodeUTF32(PyUnicode_AS_UNICODE(str
),
859 PyUnicode_GET_SIZE(str
),
862 PyUnicode_GET_SIZE(str
));
868 utf_32_be_encode(PyObject
*self
,
872 const char *errors
= NULL
;
874 if (!PyArg_ParseTuple(args
, "O|z:utf_32_be_encode",
878 str
= PyUnicode_FromObject(str
);
881 v
= codec_tuple(PyUnicode_EncodeUTF32(PyUnicode_AS_UNICODE(str
),
882 PyUnicode_GET_SIZE(str
),
885 PyUnicode_GET_SIZE(str
));
891 unicode_escape_encode(PyObject
*self
,
895 const char *errors
= NULL
;
897 if (!PyArg_ParseTuple(args
, "O|z:unicode_escape_encode",
901 str
= PyUnicode_FromObject(str
);
904 v
= codec_tuple(PyUnicode_EncodeUnicodeEscape(PyUnicode_AS_UNICODE(str
),
905 PyUnicode_GET_SIZE(str
)),
906 PyUnicode_GET_SIZE(str
));
912 raw_unicode_escape_encode(PyObject
*self
,
916 const char *errors
= NULL
;
918 if (!PyArg_ParseTuple(args
, "O|z:raw_unicode_escape_encode",
922 str
= PyUnicode_FromObject(str
);
925 v
= codec_tuple(PyUnicode_EncodeRawUnicodeEscape(
926 PyUnicode_AS_UNICODE(str
),
927 PyUnicode_GET_SIZE(str
)),
928 PyUnicode_GET_SIZE(str
));
934 latin_1_encode(PyObject
*self
,
938 const char *errors
= NULL
;
940 if (!PyArg_ParseTuple(args
, "O|z:latin_1_encode",
944 str
= PyUnicode_FromObject(str
);
947 v
= codec_tuple(PyUnicode_EncodeLatin1(
948 PyUnicode_AS_UNICODE(str
),
949 PyUnicode_GET_SIZE(str
),
951 PyUnicode_GET_SIZE(str
));
957 ascii_encode(PyObject
*self
,
961 const char *errors
= NULL
;
963 if (!PyArg_ParseTuple(args
, "O|z:ascii_encode",
967 str
= PyUnicode_FromObject(str
);
970 v
= codec_tuple(PyUnicode_EncodeASCII(
971 PyUnicode_AS_UNICODE(str
),
972 PyUnicode_GET_SIZE(str
),
974 PyUnicode_GET_SIZE(str
));
980 charmap_encode(PyObject
*self
,
984 const char *errors
= NULL
;
985 PyObject
*mapping
= NULL
;
987 if (!PyArg_ParseTuple(args
, "O|zO:charmap_encode",
988 &str
, &errors
, &mapping
))
990 if (mapping
== Py_None
)
993 str
= PyUnicode_FromObject(str
);
996 v
= codec_tuple(PyUnicode_EncodeCharmap(
997 PyUnicode_AS_UNICODE(str
),
998 PyUnicode_GET_SIZE(str
),
1001 PyUnicode_GET_SIZE(str
));
1007 charmap_build(PyObject
*self
, PyObject
*args
)
1010 if (!PyArg_ParseTuple(args
, "U:charmap_build", &map
))
1012 return PyUnicode_BuildEncodingMap(map
);
1015 #if defined(MS_WINDOWS) && defined(HAVE_USABLE_WCHAR_T)
1018 mbcs_encode(PyObject
*self
,
1022 const char *errors
= NULL
;
1024 if (!PyArg_ParseTuple(args
, "O|z:mbcs_encode",
1028 str
= PyUnicode_FromObject(str
);
1031 v
= codec_tuple(PyUnicode_EncodeMBCS(
1032 PyUnicode_AS_UNICODE(str
),
1033 PyUnicode_GET_SIZE(str
),
1035 PyUnicode_GET_SIZE(str
));
1040 #endif /* MS_WINDOWS */
1041 #endif /* Py_USING_UNICODE */
1043 /* --- Error handler registry --------------------------------------------- */
1045 PyDoc_STRVAR(register_error__doc__
,
1046 "register_error(errors, handler)\n\
1048 Register the specified error handler under the name\n\
1049 errors. handler must be a callable object, that\n\
1050 will be called with an exception instance containing\n\
1051 information about the location of the encoding/decoding\n\
1052 error and must return a (replacement, new position) tuple.");
1054 static PyObject
*register_error(PyObject
*self
, PyObject
*args
)
1059 if (!PyArg_ParseTuple(args
, "sO:register_error",
1062 if (PyCodec_RegisterError(name
, handler
))
1067 PyDoc_STRVAR(lookup_error__doc__
,
1068 "lookup_error(errors) -> handler\n\
1070 Return the error handler for the specified error handling name\n\
1071 or raise a LookupError, if no handler exists under this name.");
1073 static PyObject
*lookup_error(PyObject
*self
, PyObject
*args
)
1077 if (!PyArg_ParseTuple(args
, "s:lookup_error",
1080 return PyCodec_LookupError(name
);
1083 /* --- Module API --------------------------------------------------------- */
1085 static PyMethodDef _codecs_functions
[] = {
1086 {"register", codec_register
, METH_O
,
1088 {"lookup", codec_lookup
, METH_VARARGS
,
1090 {"encode", codec_encode
, METH_VARARGS
,
1092 {"decode", codec_decode
, METH_VARARGS
,
1094 {"escape_encode", escape_encode
, METH_VARARGS
},
1095 {"escape_decode", escape_decode
, METH_VARARGS
},
1096 #ifdef Py_USING_UNICODE
1097 {"utf_8_encode", utf_8_encode
, METH_VARARGS
},
1098 {"utf_8_decode", utf_8_decode
, METH_VARARGS
},
1099 {"utf_7_encode", utf_7_encode
, METH_VARARGS
},
1100 {"utf_7_decode", utf_7_decode
, METH_VARARGS
},
1101 {"utf_16_encode", utf_16_encode
, METH_VARARGS
},
1102 {"utf_16_le_encode", utf_16_le_encode
, METH_VARARGS
},
1103 {"utf_16_be_encode", utf_16_be_encode
, METH_VARARGS
},
1104 {"utf_16_decode", utf_16_decode
, METH_VARARGS
},
1105 {"utf_16_le_decode", utf_16_le_decode
, METH_VARARGS
},
1106 {"utf_16_be_decode", utf_16_be_decode
, METH_VARARGS
},
1107 {"utf_16_ex_decode", utf_16_ex_decode
, METH_VARARGS
},
1108 {"utf_32_encode", utf_32_encode
, METH_VARARGS
},
1109 {"utf_32_le_encode", utf_32_le_encode
, METH_VARARGS
},
1110 {"utf_32_be_encode", utf_32_be_encode
, METH_VARARGS
},
1111 {"utf_32_decode", utf_32_decode
, METH_VARARGS
},
1112 {"utf_32_le_decode", utf_32_le_decode
, METH_VARARGS
},
1113 {"utf_32_be_decode", utf_32_be_decode
, METH_VARARGS
},
1114 {"utf_32_ex_decode", utf_32_ex_decode
, METH_VARARGS
},
1115 {"unicode_escape_encode", unicode_escape_encode
, METH_VARARGS
},
1116 {"unicode_escape_decode", unicode_escape_decode
, METH_VARARGS
},
1117 {"unicode_internal_encode", unicode_internal_encode
, METH_VARARGS
},
1118 {"unicode_internal_decode", unicode_internal_decode
, METH_VARARGS
},
1119 {"raw_unicode_escape_encode", raw_unicode_escape_encode
, METH_VARARGS
},
1120 {"raw_unicode_escape_decode", raw_unicode_escape_decode
, METH_VARARGS
},
1121 {"latin_1_encode", latin_1_encode
, METH_VARARGS
},
1122 {"latin_1_decode", latin_1_decode
, METH_VARARGS
},
1123 {"ascii_encode", ascii_encode
, METH_VARARGS
},
1124 {"ascii_decode", ascii_decode
, METH_VARARGS
},
1125 {"charmap_encode", charmap_encode
, METH_VARARGS
},
1126 {"charmap_decode", charmap_decode
, METH_VARARGS
},
1127 {"charmap_build", charmap_build
, METH_VARARGS
},
1128 {"readbuffer_encode", readbuffer_encode
, METH_VARARGS
},
1129 {"charbuffer_encode", charbuffer_encode
, METH_VARARGS
},
1130 #if defined(MS_WINDOWS) && defined(HAVE_USABLE_WCHAR_T)
1131 {"mbcs_encode", mbcs_encode
, METH_VARARGS
},
1132 {"mbcs_decode", mbcs_decode
, METH_VARARGS
},
1134 #endif /* Py_USING_UNICODE */
1135 {"register_error", register_error
, METH_VARARGS
,
1136 register_error__doc__
},
1137 {"lookup_error", lookup_error
, METH_VARARGS
,
1138 lookup_error__doc__
},
1139 {NULL
, NULL
} /* sentinel */
1145 Py_InitModule("_codecs", _codecs_functions
);