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_lookup__doc__, 19 "lookup($module, encoding, /)\n" 20 "--\n" 21 "\n" 22 "Looks up a codec tuple in the Python codec registry and returns a CodecInfo object."); 23 24 #define _CODECS_LOOKUP_METHODDEF \ 25 {"lookup", (PyCFunction)_codecs_lookup, METH_O, _codecs_lookup__doc__}, 26 27 static PyObject * 28 _codecs_lookup_impl(PyObject *module, const char *encoding); 29 30 static PyObject * 31 _codecs_lookup(PyObject *module, PyObject *arg) 32 { 33 PyObject *return_value = NULL; 34 const char *encoding; 35 36 if (!PyArg_Parse(arg, "s:lookup", &encoding)) { 37 goto exit; 38 } 39 return_value = _codecs_lookup_impl(module, encoding); 40 41 exit: 42 return return_value; 43 } 44 45 PyDoc_STRVAR(_codecs_encode__doc__, 46 "encode($module, /, obj, encoding=\'utf-8\', errors=\'strict\')\n" 47 "--\n" 48 "\n" 49 "Encodes obj using the codec registered for encoding.\n" 50 "\n" 51 "The default encoding is \'utf-8\'. errors may be given to set a\n" 52 "different error handling scheme. Default is \'strict\' meaning that encoding\n" 53 "errors raise a ValueError. Other possible values are \'ignore\', \'replace\'\n" 54 "and \'backslashreplace\' as well as any other name registered with\n" 55 "codecs.register_error that can handle ValueErrors."); 56 57 #define _CODECS_ENCODE_METHODDEF \ 58 {"encode", (PyCFunction)_codecs_encode, METH_FASTCALL, _codecs_encode__doc__}, 59 60 static PyObject * 61 _codecs_encode_impl(PyObject *module, PyObject *obj, const char *encoding, 62 const char *errors); 63 64 static PyObject * 65 _codecs_encode(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames) 66 { 67 PyObject *return_value = NULL; 68 static const char * const _keywords[] = {"obj", "encoding", "errors", NULL}; 69 static _PyArg_Parser _parser = {"O|ss:encode", _keywords, 0}; 70 PyObject *obj; 71 const char *encoding = NULL; 72 const char *errors = NULL; 73 74 if (!_PyArg_ParseStack(args, nargs, kwnames, &_parser, 75 &obj, &encoding, &errors)) { 76 goto exit; 77 } 78 return_value = _codecs_encode_impl(module, obj, encoding, errors); 79 80 exit: 81 return return_value; 82 } 83 84 PyDoc_STRVAR(_codecs_decode__doc__, 85 "decode($module, /, obj, encoding=\'utf-8\', errors=\'strict\')\n" 86 "--\n" 87 "\n" 88 "Decodes obj using the codec registered for encoding.\n" 89 "\n" 90 "Default encoding is \'utf-8\'. errors may be given to set a\n" 91 "different error handling scheme. Default is \'strict\' meaning that encoding\n" 92 "errors raise a ValueError. Other possible values are \'ignore\', \'replace\'\n" 93 "and \'backslashreplace\' as well as any other name registered with\n" 94 "codecs.register_error that can handle ValueErrors."); 95 96 #define _CODECS_DECODE_METHODDEF \ 97 {"decode", (PyCFunction)_codecs_decode, METH_FASTCALL, _codecs_decode__doc__}, 98 99 static PyObject * 100 _codecs_decode_impl(PyObject *module, PyObject *obj, const char *encoding, 101 const char *errors); 102 103 static PyObject * 104 _codecs_decode(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames) 105 { 106 PyObject *return_value = NULL; 107 static const char * const _keywords[] = {"obj", "encoding", "errors", NULL}; 108 static _PyArg_Parser _parser = {"O|ss:decode", _keywords, 0}; 109 PyObject *obj; 110 const char *encoding = NULL; 111 const char *errors = NULL; 112 113 if (!_PyArg_ParseStack(args, nargs, kwnames, &_parser, 114 &obj, &encoding, &errors)) { 115 goto exit; 116 } 117 return_value = _codecs_decode_impl(module, obj, encoding, errors); 118 119 exit: 120 return return_value; 121 } 122 123 PyDoc_STRVAR(_codecs__forget_codec__doc__, 124 "_forget_codec($module, encoding, /)\n" 125 "--\n" 126 "\n" 127 "Purge the named codec from the internal codec lookup cache"); 128 129 #define _CODECS__FORGET_CODEC_METHODDEF \ 130 {"_forget_codec", (PyCFunction)_codecs__forget_codec, METH_O, _codecs__forget_codec__doc__}, 131 132 static PyObject * 133 _codecs__forget_codec_impl(PyObject *module, const char *encoding); 134 135 static PyObject * 136 _codecs__forget_codec(PyObject *module, PyObject *arg) 137 { 138 PyObject *return_value = NULL; 139 const char *encoding; 140 141 if (!PyArg_Parse(arg, "s:_forget_codec", &encoding)) { 142 goto exit; 143 } 144 return_value = _codecs__forget_codec_impl(module, encoding); 145 146 exit: 147 return return_value; 148 } 149 150 PyDoc_STRVAR(_codecs_escape_decode__doc__, 151 "escape_decode($module, data, errors=None, /)\n" 152 "--\n" 153 "\n"); 154 155 #define _CODECS_ESCAPE_DECODE_METHODDEF \ 156 {"escape_decode", (PyCFunction)_codecs_escape_decode, METH_VARARGS, _codecs_escape_decode__doc__}, 157 158 static PyObject * 159 _codecs_escape_decode_impl(PyObject *module, Py_buffer *data, 160 const char *errors); 161 162 static PyObject * 163 _codecs_escape_decode(PyObject *module, PyObject *args) 164 { 165 PyObject *return_value = NULL; 166 Py_buffer data = {NULL, NULL}; 167 const char *errors = NULL; 168 169 if (!PyArg_ParseTuple(args, "s*|z:escape_decode", 170 &data, &errors)) { 171 goto exit; 172 } 173 return_value = _codecs_escape_decode_impl(module, &data, errors); 174 175 exit: 176 /* Cleanup for data */ 177 if (data.obj) { 178 PyBuffer_Release(&data); 179 } 180 181 return return_value; 182 } 183 184 PyDoc_STRVAR(_codecs_escape_encode__doc__, 185 "escape_encode($module, data, errors=None, /)\n" 186 "--\n" 187 "\n"); 188 189 #define _CODECS_ESCAPE_ENCODE_METHODDEF \ 190 {"escape_encode", (PyCFunction)_codecs_escape_encode, METH_VARARGS, _codecs_escape_encode__doc__}, 191 192 static PyObject * 193 _codecs_escape_encode_impl(PyObject *module, PyObject *data, 194 const char *errors); 195 196 static PyObject * 197 _codecs_escape_encode(PyObject *module, PyObject *args) 198 { 199 PyObject *return_value = NULL; 200 PyObject *data; 201 const char *errors = NULL; 202 203 if (!PyArg_ParseTuple(args, "O!|z:escape_encode", 204 &PyBytes_Type, &data, &errors)) { 205 goto exit; 206 } 207 return_value = _codecs_escape_encode_impl(module, data, errors); 208 209 exit: 210 return return_value; 211 } 212 213 PyDoc_STRVAR(_codecs_unicode_internal_decode__doc__, 214 "unicode_internal_decode($module, obj, errors=None, /)\n" 215 "--\n" 216 "\n"); 217 218 #define _CODECS_UNICODE_INTERNAL_DECODE_METHODDEF \ 219 {"unicode_internal_decode", (PyCFunction)_codecs_unicode_internal_decode, METH_VARARGS, _codecs_unicode_internal_decode__doc__}, 220 221 static PyObject * 222 _codecs_unicode_internal_decode_impl(PyObject *module, PyObject *obj, 223 const char *errors); 224 225 static PyObject * 226 _codecs_unicode_internal_decode(PyObject *module, PyObject *args) 227 { 228 PyObject *return_value = NULL; 229 PyObject *obj; 230 const char *errors = NULL; 231 232 if (!PyArg_ParseTuple(args, "O|z:unicode_internal_decode", 233 &obj, &errors)) { 234 goto exit; 235 } 236 return_value = _codecs_unicode_internal_decode_impl(module, obj, errors); 237 238 exit: 239 return return_value; 240 } 241 242 PyDoc_STRVAR(_codecs_utf_7_decode__doc__, 243 "utf_7_decode($module, data, errors=None, final=False, /)\n" 244 "--\n" 245 "\n"); 246 247 #define _CODECS_UTF_7_DECODE_METHODDEF \ 248 {"utf_7_decode", (PyCFunction)_codecs_utf_7_decode, METH_VARARGS, _codecs_utf_7_decode__doc__}, 249 250 static PyObject * 251 _codecs_utf_7_decode_impl(PyObject *module, Py_buffer *data, 252 const char *errors, int final); 253 254 static PyObject * 255 _codecs_utf_7_decode(PyObject *module, PyObject *args) 256 { 257 PyObject *return_value = NULL; 258 Py_buffer data = {NULL, NULL}; 259 const char *errors = NULL; 260 int final = 0; 261 262 if (!PyArg_ParseTuple(args, "y*|zi:utf_7_decode", 263 &data, &errors, &final)) { 264 goto exit; 265 } 266 return_value = _codecs_utf_7_decode_impl(module, &data, errors, final); 267 268 exit: 269 /* Cleanup for data */ 270 if (data.obj) { 271 PyBuffer_Release(&data); 272 } 273 274 return return_value; 275 } 276 277 PyDoc_STRVAR(_codecs_utf_8_decode__doc__, 278 "utf_8_decode($module, data, errors=None, final=False, /)\n" 279 "--\n" 280 "\n"); 281 282 #define _CODECS_UTF_8_DECODE_METHODDEF \ 283 {"utf_8_decode", (PyCFunction)_codecs_utf_8_decode, METH_VARARGS, _codecs_utf_8_decode__doc__}, 284 285 static PyObject * 286 _codecs_utf_8_decode_impl(PyObject *module, Py_buffer *data, 287 const char *errors, int final); 288 289 static PyObject * 290 _codecs_utf_8_decode(PyObject *module, PyObject *args) 291 { 292 PyObject *return_value = NULL; 293 Py_buffer data = {NULL, NULL}; 294 const char *errors = NULL; 295 int final = 0; 296 297 if (!PyArg_ParseTuple(args, "y*|zi:utf_8_decode", 298 &data, &errors, &final)) { 299 goto exit; 300 } 301 return_value = _codecs_utf_8_decode_impl(module, &data, errors, final); 302 303 exit: 304 /* Cleanup for data */ 305 if (data.obj) { 306 PyBuffer_Release(&data); 307 } 308 309 return return_value; 310 } 311 312 PyDoc_STRVAR(_codecs_utf_16_decode__doc__, 313 "utf_16_decode($module, data, errors=None, final=False, /)\n" 314 "--\n" 315 "\n"); 316 317 #define _CODECS_UTF_16_DECODE_METHODDEF \ 318 {"utf_16_decode", (PyCFunction)_codecs_utf_16_decode, METH_VARARGS, _codecs_utf_16_decode__doc__}, 319 320 static PyObject * 321 _codecs_utf_16_decode_impl(PyObject *module, Py_buffer *data, 322 const char *errors, int final); 323 324 static PyObject * 325 _codecs_utf_16_decode(PyObject *module, PyObject *args) 326 { 327 PyObject *return_value = NULL; 328 Py_buffer data = {NULL, NULL}; 329 const char *errors = NULL; 330 int final = 0; 331 332 if (!PyArg_ParseTuple(args, "y*|zi:utf_16_decode", 333 &data, &errors, &final)) { 334 goto exit; 335 } 336 return_value = _codecs_utf_16_decode_impl(module, &data, errors, final); 337 338 exit: 339 /* Cleanup for data */ 340 if (data.obj) { 341 PyBuffer_Release(&data); 342 } 343 344 return return_value; 345 } 346 347 PyDoc_STRVAR(_codecs_utf_16_le_decode__doc__, 348 "utf_16_le_decode($module, data, errors=None, final=False, /)\n" 349 "--\n" 350 "\n"); 351 352 #define _CODECS_UTF_16_LE_DECODE_METHODDEF \ 353 {"utf_16_le_decode", (PyCFunction)_codecs_utf_16_le_decode, METH_VARARGS, _codecs_utf_16_le_decode__doc__}, 354 355 static PyObject * 356 _codecs_utf_16_le_decode_impl(PyObject *module, Py_buffer *data, 357 const char *errors, int final); 358 359 static PyObject * 360 _codecs_utf_16_le_decode(PyObject *module, PyObject *args) 361 { 362 PyObject *return_value = NULL; 363 Py_buffer data = {NULL, NULL}; 364 const char *errors = NULL; 365 int final = 0; 366 367 if (!PyArg_ParseTuple(args, "y*|zi:utf_16_le_decode", 368 &data, &errors, &final)) { 369 goto exit; 370 } 371 return_value = _codecs_utf_16_le_decode_impl(module, &data, errors, final); 372 373 exit: 374 /* Cleanup for data */ 375 if (data.obj) { 376 PyBuffer_Release(&data); 377 } 378 379 return return_value; 380 } 381 382 PyDoc_STRVAR(_codecs_utf_16_be_decode__doc__, 383 "utf_16_be_decode($module, data, errors=None, final=False, /)\n" 384 "--\n" 385 "\n"); 386 387 #define _CODECS_UTF_16_BE_DECODE_METHODDEF \ 388 {"utf_16_be_decode", (PyCFunction)_codecs_utf_16_be_decode, METH_VARARGS, _codecs_utf_16_be_decode__doc__}, 389 390 static PyObject * 391 _codecs_utf_16_be_decode_impl(PyObject *module, Py_buffer *data, 392 const char *errors, int final); 393 394 static PyObject * 395 _codecs_utf_16_be_decode(PyObject *module, PyObject *args) 396 { 397 PyObject *return_value = NULL; 398 Py_buffer data = {NULL, NULL}; 399 const char *errors = NULL; 400 int final = 0; 401 402 if (!PyArg_ParseTuple(args, "y*|zi:utf_16_be_decode", 403 &data, &errors, &final)) { 404 goto exit; 405 } 406 return_value = _codecs_utf_16_be_decode_impl(module, &data, errors, final); 407 408 exit: 409 /* Cleanup for data */ 410 if (data.obj) { 411 PyBuffer_Release(&data); 412 } 413 414 return return_value; 415 } 416 417 PyDoc_STRVAR(_codecs_utf_16_ex_decode__doc__, 418 "utf_16_ex_decode($module, data, errors=None, byteorder=0, final=False,\n" 419 " /)\n" 420 "--\n" 421 "\n"); 422 423 #define _CODECS_UTF_16_EX_DECODE_METHODDEF \ 424 {"utf_16_ex_decode", (PyCFunction)_codecs_utf_16_ex_decode, METH_VARARGS, _codecs_utf_16_ex_decode__doc__}, 425 426 static PyObject * 427 _codecs_utf_16_ex_decode_impl(PyObject *module, Py_buffer *data, 428 const char *errors, int byteorder, int final); 429 430 static PyObject * 431 _codecs_utf_16_ex_decode(PyObject *module, PyObject *args) 432 { 433 PyObject *return_value = NULL; 434 Py_buffer data = {NULL, NULL}; 435 const char *errors = NULL; 436 int byteorder = 0; 437 int final = 0; 438 439 if (!PyArg_ParseTuple(args, "y*|zii:utf_16_ex_decode", 440 &data, &errors, &byteorder, &final)) { 441 goto exit; 442 } 443 return_value = _codecs_utf_16_ex_decode_impl(module, &data, errors, byteorder, final); 444 445 exit: 446 /* Cleanup for data */ 447 if (data.obj) { 448 PyBuffer_Release(&data); 449 } 450 451 return return_value; 452 } 453 454 PyDoc_STRVAR(_codecs_utf_32_decode__doc__, 455 "utf_32_decode($module, data, errors=None, final=False, /)\n" 456 "--\n" 457 "\n"); 458 459 #define _CODECS_UTF_32_DECODE_METHODDEF \ 460 {"utf_32_decode", (PyCFunction)_codecs_utf_32_decode, METH_VARARGS, _codecs_utf_32_decode__doc__}, 461 462 static PyObject * 463 _codecs_utf_32_decode_impl(PyObject *module, Py_buffer *data, 464 const char *errors, int final); 465 466 static PyObject * 467 _codecs_utf_32_decode(PyObject *module, PyObject *args) 468 { 469 PyObject *return_value = NULL; 470 Py_buffer data = {NULL, NULL}; 471 const char *errors = NULL; 472 int final = 0; 473 474 if (!PyArg_ParseTuple(args, "y*|zi:utf_32_decode", 475 &data, &errors, &final)) { 476 goto exit; 477 } 478 return_value = _codecs_utf_32_decode_impl(module, &data, errors, final); 479 480 exit: 481 /* Cleanup for data */ 482 if (data.obj) { 483 PyBuffer_Release(&data); 484 } 485 486 return return_value; 487 } 488 489 PyDoc_STRVAR(_codecs_utf_32_le_decode__doc__, 490 "utf_32_le_decode($module, data, errors=None, final=False, /)\n" 491 "--\n" 492 "\n"); 493 494 #define _CODECS_UTF_32_LE_DECODE_METHODDEF \ 495 {"utf_32_le_decode", (PyCFunction)_codecs_utf_32_le_decode, METH_VARARGS, _codecs_utf_32_le_decode__doc__}, 496 497 static PyObject * 498 _codecs_utf_32_le_decode_impl(PyObject *module, Py_buffer *data, 499 const char *errors, int final); 500 501 static PyObject * 502 _codecs_utf_32_le_decode(PyObject *module, PyObject *args) 503 { 504 PyObject *return_value = NULL; 505 Py_buffer data = {NULL, NULL}; 506 const char *errors = NULL; 507 int final = 0; 508 509 if (!PyArg_ParseTuple(args, "y*|zi:utf_32_le_decode", 510 &data, &errors, &final)) { 511 goto exit; 512 } 513 return_value = _codecs_utf_32_le_decode_impl(module, &data, errors, final); 514 515 exit: 516 /* Cleanup for data */ 517 if (data.obj) { 518 PyBuffer_Release(&data); 519 } 520 521 return return_value; 522 } 523 524 PyDoc_STRVAR(_codecs_utf_32_be_decode__doc__, 525 "utf_32_be_decode($module, data, errors=None, final=False, /)\n" 526 "--\n" 527 "\n"); 528 529 #define _CODECS_UTF_32_BE_DECODE_METHODDEF \ 530 {"utf_32_be_decode", (PyCFunction)_codecs_utf_32_be_decode, METH_VARARGS, _codecs_utf_32_be_decode__doc__}, 531 532 static PyObject * 533 _codecs_utf_32_be_decode_impl(PyObject *module, Py_buffer *data, 534 const char *errors, int final); 535 536 static PyObject * 537 _codecs_utf_32_be_decode(PyObject *module, PyObject *args) 538 { 539 PyObject *return_value = NULL; 540 Py_buffer data = {NULL, NULL}; 541 const char *errors = NULL; 542 int final = 0; 543 544 if (!PyArg_ParseTuple(args, "y*|zi:utf_32_be_decode", 545 &data, &errors, &final)) { 546 goto exit; 547 } 548 return_value = _codecs_utf_32_be_decode_impl(module, &data, errors, final); 549 550 exit: 551 /* Cleanup for data */ 552 if (data.obj) { 553 PyBuffer_Release(&data); 554 } 555 556 return return_value; 557 } 558 559 PyDoc_STRVAR(_codecs_utf_32_ex_decode__doc__, 560 "utf_32_ex_decode($module, data, errors=None, byteorder=0, final=False,\n" 561 " /)\n" 562 "--\n" 563 "\n"); 564 565 #define _CODECS_UTF_32_EX_DECODE_METHODDEF \ 566 {"utf_32_ex_decode", (PyCFunction)_codecs_utf_32_ex_decode, METH_VARARGS, _codecs_utf_32_ex_decode__doc__}, 567 568 static PyObject * 569 _codecs_utf_32_ex_decode_impl(PyObject *module, Py_buffer *data, 570 const char *errors, int byteorder, int final); 571 572 static PyObject * 573 _codecs_utf_32_ex_decode(PyObject *module, PyObject *args) 574 { 575 PyObject *return_value = NULL; 576 Py_buffer data = {NULL, NULL}; 577 const char *errors = NULL; 578 int byteorder = 0; 579 int final = 0; 580 581 if (!PyArg_ParseTuple(args, "y*|zii:utf_32_ex_decode", 582 &data, &errors, &byteorder, &final)) { 583 goto exit; 584 } 585 return_value = _codecs_utf_32_ex_decode_impl(module, &data, errors, byteorder, final); 586 587 exit: 588 /* Cleanup for data */ 589 if (data.obj) { 590 PyBuffer_Release(&data); 591 } 592 593 return return_value; 594 } 595 596 PyDoc_STRVAR(_codecs_unicode_escape_decode__doc__, 597 "unicode_escape_decode($module, data, errors=None, /)\n" 598 "--\n" 599 "\n"); 600 601 #define _CODECS_UNICODE_ESCAPE_DECODE_METHODDEF \ 602 {"unicode_escape_decode", (PyCFunction)_codecs_unicode_escape_decode, METH_VARARGS, _codecs_unicode_escape_decode__doc__}, 603 604 static PyObject * 605 _codecs_unicode_escape_decode_impl(PyObject *module, Py_buffer *data, 606 const char *errors); 607 608 static PyObject * 609 _codecs_unicode_escape_decode(PyObject *module, PyObject *args) 610 { 611 PyObject *return_value = NULL; 612 Py_buffer data = {NULL, NULL}; 613 const char *errors = NULL; 614 615 if (!PyArg_ParseTuple(args, "s*|z:unicode_escape_decode", 616 &data, &errors)) { 617 goto exit; 618 } 619 return_value = _codecs_unicode_escape_decode_impl(module, &data, errors); 620 621 exit: 622 /* Cleanup for data */ 623 if (data.obj) { 624 PyBuffer_Release(&data); 625 } 626 627 return return_value; 628 } 629 630 PyDoc_STRVAR(_codecs_raw_unicode_escape_decode__doc__, 631 "raw_unicode_escape_decode($module, data, errors=None, /)\n" 632 "--\n" 633 "\n"); 634 635 #define _CODECS_RAW_UNICODE_ESCAPE_DECODE_METHODDEF \ 636 {"raw_unicode_escape_decode", (PyCFunction)_codecs_raw_unicode_escape_decode, METH_VARARGS, _codecs_raw_unicode_escape_decode__doc__}, 637 638 static PyObject * 639 _codecs_raw_unicode_escape_decode_impl(PyObject *module, Py_buffer *data, 640 const char *errors); 641 642 static PyObject * 643 _codecs_raw_unicode_escape_decode(PyObject *module, PyObject *args) 644 { 645 PyObject *return_value = NULL; 646 Py_buffer data = {NULL, NULL}; 647 const char *errors = NULL; 648 649 if (!PyArg_ParseTuple(args, "s*|z:raw_unicode_escape_decode", 650 &data, &errors)) { 651 goto exit; 652 } 653 return_value = _codecs_raw_unicode_escape_decode_impl(module, &data, errors); 654 655 exit: 656 /* Cleanup for data */ 657 if (data.obj) { 658 PyBuffer_Release(&data); 659 } 660 661 return return_value; 662 } 663 664 PyDoc_STRVAR(_codecs_latin_1_decode__doc__, 665 "latin_1_decode($module, data, errors=None, /)\n" 666 "--\n" 667 "\n"); 668 669 #define _CODECS_LATIN_1_DECODE_METHODDEF \ 670 {"latin_1_decode", (PyCFunction)_codecs_latin_1_decode, METH_VARARGS, _codecs_latin_1_decode__doc__}, 671 672 static PyObject * 673 _codecs_latin_1_decode_impl(PyObject *module, Py_buffer *data, 674 const char *errors); 675 676 static PyObject * 677 _codecs_latin_1_decode(PyObject *module, PyObject *args) 678 { 679 PyObject *return_value = NULL; 680 Py_buffer data = {NULL, NULL}; 681 const char *errors = NULL; 682 683 if (!PyArg_ParseTuple(args, "y*|z:latin_1_decode", 684 &data, &errors)) { 685 goto exit; 686 } 687 return_value = _codecs_latin_1_decode_impl(module, &data, errors); 688 689 exit: 690 /* Cleanup for data */ 691 if (data.obj) { 692 PyBuffer_Release(&data); 693 } 694 695 return return_value; 696 } 697 698 PyDoc_STRVAR(_codecs_ascii_decode__doc__, 699 "ascii_decode($module, data, errors=None, /)\n" 700 "--\n" 701 "\n"); 702 703 #define _CODECS_ASCII_DECODE_METHODDEF \ 704 {"ascii_decode", (PyCFunction)_codecs_ascii_decode, METH_VARARGS, _codecs_ascii_decode__doc__}, 705 706 static PyObject * 707 _codecs_ascii_decode_impl(PyObject *module, Py_buffer *data, 708 const char *errors); 709 710 static PyObject * 711 _codecs_ascii_decode(PyObject *module, PyObject *args) 712 { 713 PyObject *return_value = NULL; 714 Py_buffer data = {NULL, NULL}; 715 const char *errors = NULL; 716 717 if (!PyArg_ParseTuple(args, "y*|z:ascii_decode", 718 &data, &errors)) { 719 goto exit; 720 } 721 return_value = _codecs_ascii_decode_impl(module, &data, errors); 722 723 exit: 724 /* Cleanup for data */ 725 if (data.obj) { 726 PyBuffer_Release(&data); 727 } 728 729 return return_value; 730 } 731 732 PyDoc_STRVAR(_codecs_charmap_decode__doc__, 733 "charmap_decode($module, data, errors=None, mapping=None, /)\n" 734 "--\n" 735 "\n"); 736 737 #define _CODECS_CHARMAP_DECODE_METHODDEF \ 738 {"charmap_decode", (PyCFunction)_codecs_charmap_decode, METH_VARARGS, _codecs_charmap_decode__doc__}, 739 740 static PyObject * 741 _codecs_charmap_decode_impl(PyObject *module, Py_buffer *data, 742 const char *errors, PyObject *mapping); 743 744 static PyObject * 745 _codecs_charmap_decode(PyObject *module, PyObject *args) 746 { 747 PyObject *return_value = NULL; 748 Py_buffer data = {NULL, NULL}; 749 const char *errors = NULL; 750 PyObject *mapping = NULL; 751 752 if (!PyArg_ParseTuple(args, "y*|zO:charmap_decode", 753 &data, &errors, &mapping)) { 754 goto exit; 755 } 756 return_value = _codecs_charmap_decode_impl(module, &data, errors, mapping); 757 758 exit: 759 /* Cleanup for data */ 760 if (data.obj) { 761 PyBuffer_Release(&data); 762 } 763 764 return return_value; 765 } 766 767 #if defined(MS_WINDOWS) 768 769 PyDoc_STRVAR(_codecs_mbcs_decode__doc__, 770 "mbcs_decode($module, data, errors=None, final=False, /)\n" 771 "--\n" 772 "\n"); 773 774 #define _CODECS_MBCS_DECODE_METHODDEF \ 775 {"mbcs_decode", (PyCFunction)_codecs_mbcs_decode, METH_VARARGS, _codecs_mbcs_decode__doc__}, 776 777 static PyObject * 778 _codecs_mbcs_decode_impl(PyObject *module, Py_buffer *data, 779 const char *errors, int final); 780 781 static PyObject * 782 _codecs_mbcs_decode(PyObject *module, PyObject *args) 783 { 784 PyObject *return_value = NULL; 785 Py_buffer data = {NULL, NULL}; 786 const char *errors = NULL; 787 int final = 0; 788 789 if (!PyArg_ParseTuple(args, "y*|zi:mbcs_decode", 790 &data, &errors, &final)) { 791 goto exit; 792 } 793 return_value = _codecs_mbcs_decode_impl(module, &data, errors, final); 794 795 exit: 796 /* Cleanup for data */ 797 if (data.obj) { 798 PyBuffer_Release(&data); 799 } 800 801 return return_value; 802 } 803 804 #endif /* defined(MS_WINDOWS) */ 805 806 #if defined(MS_WINDOWS) 807 808 PyDoc_STRVAR(_codecs_oem_decode__doc__, 809 "oem_decode($module, data, errors=None, final=False, /)\n" 810 "--\n" 811 "\n"); 812 813 #define _CODECS_OEM_DECODE_METHODDEF \ 814 {"oem_decode", (PyCFunction)_codecs_oem_decode, METH_VARARGS, _codecs_oem_decode__doc__}, 815 816 static PyObject * 817 _codecs_oem_decode_impl(PyObject *module, Py_buffer *data, 818 const char *errors, int final); 819 820 static PyObject * 821 _codecs_oem_decode(PyObject *module, PyObject *args) 822 { 823 PyObject *return_value = NULL; 824 Py_buffer data = {NULL, NULL}; 825 const char *errors = NULL; 826 int final = 0; 827 828 if (!PyArg_ParseTuple(args, "y*|zi:oem_decode", 829 &data, &errors, &final)) { 830 goto exit; 831 } 832 return_value = _codecs_oem_decode_impl(module, &data, errors, final); 833 834 exit: 835 /* Cleanup for data */ 836 if (data.obj) { 837 PyBuffer_Release(&data); 838 } 839 840 return return_value; 841 } 842 843 #endif /* defined(MS_WINDOWS) */ 844 845 #if defined(MS_WINDOWS) 846 847 PyDoc_STRVAR(_codecs_code_page_decode__doc__, 848 "code_page_decode($module, codepage, data, errors=None, final=False, /)\n" 849 "--\n" 850 "\n"); 851 852 #define _CODECS_CODE_PAGE_DECODE_METHODDEF \ 853 {"code_page_decode", (PyCFunction)_codecs_code_page_decode, METH_VARARGS, _codecs_code_page_decode__doc__}, 854 855 static PyObject * 856 _codecs_code_page_decode_impl(PyObject *module, int codepage, 857 Py_buffer *data, const char *errors, int final); 858 859 static PyObject * 860 _codecs_code_page_decode(PyObject *module, PyObject *args) 861 { 862 PyObject *return_value = NULL; 863 int codepage; 864 Py_buffer data = {NULL, NULL}; 865 const char *errors = NULL; 866 int final = 0; 867 868 if (!PyArg_ParseTuple(args, "iy*|zi:code_page_decode", 869 &codepage, &data, &errors, &final)) { 870 goto exit; 871 } 872 return_value = _codecs_code_page_decode_impl(module, codepage, &data, errors, final); 873 874 exit: 875 /* Cleanup for data */ 876 if (data.obj) { 877 PyBuffer_Release(&data); 878 } 879 880 return return_value; 881 } 882 883 #endif /* defined(MS_WINDOWS) */ 884 885 PyDoc_STRVAR(_codecs_readbuffer_encode__doc__, 886 "readbuffer_encode($module, data, errors=None, /)\n" 887 "--\n" 888 "\n"); 889 890 #define _CODECS_READBUFFER_ENCODE_METHODDEF \ 891 {"readbuffer_encode", (PyCFunction)_codecs_readbuffer_encode, METH_VARARGS, _codecs_readbuffer_encode__doc__}, 892 893 static PyObject * 894 _codecs_readbuffer_encode_impl(PyObject *module, Py_buffer *data, 895 const char *errors); 896 897 static PyObject * 898 _codecs_readbuffer_encode(PyObject *module, PyObject *args) 899 { 900 PyObject *return_value = NULL; 901 Py_buffer data = {NULL, NULL}; 902 const char *errors = NULL; 903 904 if (!PyArg_ParseTuple(args, "s*|z:readbuffer_encode", 905 &data, &errors)) { 906 goto exit; 907 } 908 return_value = _codecs_readbuffer_encode_impl(module, &data, errors); 909 910 exit: 911 /* Cleanup for data */ 912 if (data.obj) { 913 PyBuffer_Release(&data); 914 } 915 916 return return_value; 917 } 918 919 PyDoc_STRVAR(_codecs_unicode_internal_encode__doc__, 920 "unicode_internal_encode($module, obj, errors=None, /)\n" 921 "--\n" 922 "\n"); 923 924 #define _CODECS_UNICODE_INTERNAL_ENCODE_METHODDEF \ 925 {"unicode_internal_encode", (PyCFunction)_codecs_unicode_internal_encode, METH_VARARGS, _codecs_unicode_internal_encode__doc__}, 926 927 static PyObject * 928 _codecs_unicode_internal_encode_impl(PyObject *module, PyObject *obj, 929 const char *errors); 930 931 static PyObject * 932 _codecs_unicode_internal_encode(PyObject *module, PyObject *args) 933 { 934 PyObject *return_value = NULL; 935 PyObject *obj; 936 const char *errors = NULL; 937 938 if (!PyArg_ParseTuple(args, "O|z:unicode_internal_encode", 939 &obj, &errors)) { 940 goto exit; 941 } 942 return_value = _codecs_unicode_internal_encode_impl(module, obj, errors); 943 944 exit: 945 return return_value; 946 } 947 948 PyDoc_STRVAR(_codecs_utf_7_encode__doc__, 949 "utf_7_encode($module, str, errors=None, /)\n" 950 "--\n" 951 "\n"); 952 953 #define _CODECS_UTF_7_ENCODE_METHODDEF \ 954 {"utf_7_encode", (PyCFunction)_codecs_utf_7_encode, METH_VARARGS, _codecs_utf_7_encode__doc__}, 955 956 static PyObject * 957 _codecs_utf_7_encode_impl(PyObject *module, PyObject *str, 958 const char *errors); 959 960 static PyObject * 961 _codecs_utf_7_encode(PyObject *module, PyObject *args) 962 { 963 PyObject *return_value = NULL; 964 PyObject *str; 965 const char *errors = NULL; 966 967 if (!PyArg_ParseTuple(args, "U|z:utf_7_encode", 968 &str, &errors)) { 969 goto exit; 970 } 971 return_value = _codecs_utf_7_encode_impl(module, str, errors); 972 973 exit: 974 return return_value; 975 } 976 977 PyDoc_STRVAR(_codecs_utf_8_encode__doc__, 978 "utf_8_encode($module, str, errors=None, /)\n" 979 "--\n" 980 "\n"); 981 982 #define _CODECS_UTF_8_ENCODE_METHODDEF \ 983 {"utf_8_encode", (PyCFunction)_codecs_utf_8_encode, METH_VARARGS, _codecs_utf_8_encode__doc__}, 984 985 static PyObject * 986 _codecs_utf_8_encode_impl(PyObject *module, PyObject *str, 987 const char *errors); 988 989 static PyObject * 990 _codecs_utf_8_encode(PyObject *module, PyObject *args) 991 { 992 PyObject *return_value = NULL; 993 PyObject *str; 994 const char *errors = NULL; 995 996 if (!PyArg_ParseTuple(args, "U|z:utf_8_encode", 997 &str, &errors)) { 998 goto exit; 999 } 1000 return_value = _codecs_utf_8_encode_impl(module, str, errors); 1001 1002 exit: 1003 return return_value; 1004 } 1005 1006 PyDoc_STRVAR(_codecs_utf_16_encode__doc__, 1007 "utf_16_encode($module, str, errors=None, byteorder=0, /)\n" 1008 "--\n" 1009 "\n"); 1010 1011 #define _CODECS_UTF_16_ENCODE_METHODDEF \ 1012 {"utf_16_encode", (PyCFunction)_codecs_utf_16_encode, METH_VARARGS, _codecs_utf_16_encode__doc__}, 1013 1014 static PyObject * 1015 _codecs_utf_16_encode_impl(PyObject *module, PyObject *str, 1016 const char *errors, int byteorder); 1017 1018 static PyObject * 1019 _codecs_utf_16_encode(PyObject *module, PyObject *args) 1020 { 1021 PyObject *return_value = NULL; 1022 PyObject *str; 1023 const char *errors = NULL; 1024 int byteorder = 0; 1025 1026 if (!PyArg_ParseTuple(args, "U|zi:utf_16_encode", 1027 &str, &errors, &byteorder)) { 1028 goto exit; 1029 } 1030 return_value = _codecs_utf_16_encode_impl(module, str, errors, byteorder); 1031 1032 exit: 1033 return return_value; 1034 } 1035 1036 PyDoc_STRVAR(_codecs_utf_16_le_encode__doc__, 1037 "utf_16_le_encode($module, str, errors=None, /)\n" 1038 "--\n" 1039 "\n"); 1040 1041 #define _CODECS_UTF_16_LE_ENCODE_METHODDEF \ 1042 {"utf_16_le_encode", (PyCFunction)_codecs_utf_16_le_encode, METH_VARARGS, _codecs_utf_16_le_encode__doc__}, 1043 1044 static PyObject * 1045 _codecs_utf_16_le_encode_impl(PyObject *module, PyObject *str, 1046 const char *errors); 1047 1048 static PyObject * 1049 _codecs_utf_16_le_encode(PyObject *module, PyObject *args) 1050 { 1051 PyObject *return_value = NULL; 1052 PyObject *str; 1053 const char *errors = NULL; 1054 1055 if (!PyArg_ParseTuple(args, "U|z:utf_16_le_encode", 1056 &str, &errors)) { 1057 goto exit; 1058 } 1059 return_value = _codecs_utf_16_le_encode_impl(module, str, errors); 1060 1061 exit: 1062 return return_value; 1063 } 1064 1065 PyDoc_STRVAR(_codecs_utf_16_be_encode__doc__, 1066 "utf_16_be_encode($module, str, errors=None, /)\n" 1067 "--\n" 1068 "\n"); 1069 1070 #define _CODECS_UTF_16_BE_ENCODE_METHODDEF \ 1071 {"utf_16_be_encode", (PyCFunction)_codecs_utf_16_be_encode, METH_VARARGS, _codecs_utf_16_be_encode__doc__}, 1072 1073 static PyObject * 1074 _codecs_utf_16_be_encode_impl(PyObject *module, PyObject *str, 1075 const char *errors); 1076 1077 static PyObject * 1078 _codecs_utf_16_be_encode(PyObject *module, PyObject *args) 1079 { 1080 PyObject *return_value = NULL; 1081 PyObject *str; 1082 const char *errors = NULL; 1083 1084 if (!PyArg_ParseTuple(args, "U|z:utf_16_be_encode", 1085 &str, &errors)) { 1086 goto exit; 1087 } 1088 return_value = _codecs_utf_16_be_encode_impl(module, str, errors); 1089 1090 exit: 1091 return return_value; 1092 } 1093 1094 PyDoc_STRVAR(_codecs_utf_32_encode__doc__, 1095 "utf_32_encode($module, str, errors=None, byteorder=0, /)\n" 1096 "--\n" 1097 "\n"); 1098 1099 #define _CODECS_UTF_32_ENCODE_METHODDEF \ 1100 {"utf_32_encode", (PyCFunction)_codecs_utf_32_encode, METH_VARARGS, _codecs_utf_32_encode__doc__}, 1101 1102 static PyObject * 1103 _codecs_utf_32_encode_impl(PyObject *module, PyObject *str, 1104 const char *errors, int byteorder); 1105 1106 static PyObject * 1107 _codecs_utf_32_encode(PyObject *module, PyObject *args) 1108 { 1109 PyObject *return_value = NULL; 1110 PyObject *str; 1111 const char *errors = NULL; 1112 int byteorder = 0; 1113 1114 if (!PyArg_ParseTuple(args, "U|zi:utf_32_encode", 1115 &str, &errors, &byteorder)) { 1116 goto exit; 1117 } 1118 return_value = _codecs_utf_32_encode_impl(module, str, errors, byteorder); 1119 1120 exit: 1121 return return_value; 1122 } 1123 1124 PyDoc_STRVAR(_codecs_utf_32_le_encode__doc__, 1125 "utf_32_le_encode($module, str, errors=None, /)\n" 1126 "--\n" 1127 "\n"); 1128 1129 #define _CODECS_UTF_32_LE_ENCODE_METHODDEF \ 1130 {"utf_32_le_encode", (PyCFunction)_codecs_utf_32_le_encode, METH_VARARGS, _codecs_utf_32_le_encode__doc__}, 1131 1132 static PyObject * 1133 _codecs_utf_32_le_encode_impl(PyObject *module, PyObject *str, 1134 const char *errors); 1135 1136 static PyObject * 1137 _codecs_utf_32_le_encode(PyObject *module, PyObject *args) 1138 { 1139 PyObject *return_value = NULL; 1140 PyObject *str; 1141 const char *errors = NULL; 1142 1143 if (!PyArg_ParseTuple(args, "U|z:utf_32_le_encode", 1144 &str, &errors)) { 1145 goto exit; 1146 } 1147 return_value = _codecs_utf_32_le_encode_impl(module, str, errors); 1148 1149 exit: 1150 return return_value; 1151 } 1152 1153 PyDoc_STRVAR(_codecs_utf_32_be_encode__doc__, 1154 "utf_32_be_encode($module, str, errors=None, /)\n" 1155 "--\n" 1156 "\n"); 1157 1158 #define _CODECS_UTF_32_BE_ENCODE_METHODDEF \ 1159 {"utf_32_be_encode", (PyCFunction)_codecs_utf_32_be_encode, METH_VARARGS, _codecs_utf_32_be_encode__doc__}, 1160 1161 static PyObject * 1162 _codecs_utf_32_be_encode_impl(PyObject *module, PyObject *str, 1163 const char *errors); 1164 1165 static PyObject * 1166 _codecs_utf_32_be_encode(PyObject *module, PyObject *args) 1167 { 1168 PyObject *return_value = NULL; 1169 PyObject *str; 1170 const char *errors = NULL; 1171 1172 if (!PyArg_ParseTuple(args, "U|z:utf_32_be_encode", 1173 &str, &errors)) { 1174 goto exit; 1175 } 1176 return_value = _codecs_utf_32_be_encode_impl(module, str, errors); 1177 1178 exit: 1179 return return_value; 1180 } 1181 1182 PyDoc_STRVAR(_codecs_unicode_escape_encode__doc__, 1183 "unicode_escape_encode($module, str, errors=None, /)\n" 1184 "--\n" 1185 "\n"); 1186 1187 #define _CODECS_UNICODE_ESCAPE_ENCODE_METHODDEF \ 1188 {"unicode_escape_encode", (PyCFunction)_codecs_unicode_escape_encode, METH_VARARGS, _codecs_unicode_escape_encode__doc__}, 1189 1190 static PyObject * 1191 _codecs_unicode_escape_encode_impl(PyObject *module, PyObject *str, 1192 const char *errors); 1193 1194 static PyObject * 1195 _codecs_unicode_escape_encode(PyObject *module, PyObject *args) 1196 { 1197 PyObject *return_value = NULL; 1198 PyObject *str; 1199 const char *errors = NULL; 1200 1201 if (!PyArg_ParseTuple(args, "U|z:unicode_escape_encode", 1202 &str, &errors)) { 1203 goto exit; 1204 } 1205 return_value = _codecs_unicode_escape_encode_impl(module, str, errors); 1206 1207 exit: 1208 return return_value; 1209 } 1210 1211 PyDoc_STRVAR(_codecs_raw_unicode_escape_encode__doc__, 1212 "raw_unicode_escape_encode($module, str, errors=None, /)\n" 1213 "--\n" 1214 "\n"); 1215 1216 #define _CODECS_RAW_UNICODE_ESCAPE_ENCODE_METHODDEF \ 1217 {"raw_unicode_escape_encode", (PyCFunction)_codecs_raw_unicode_escape_encode, METH_VARARGS, _codecs_raw_unicode_escape_encode__doc__}, 1218 1219 static PyObject * 1220 _codecs_raw_unicode_escape_encode_impl(PyObject *module, PyObject *str, 1221 const char *errors); 1222 1223 static PyObject * 1224 _codecs_raw_unicode_escape_encode(PyObject *module, PyObject *args) 1225 { 1226 PyObject *return_value = NULL; 1227 PyObject *str; 1228 const char *errors = NULL; 1229 1230 if (!PyArg_ParseTuple(args, "U|z:raw_unicode_escape_encode", 1231 &str, &errors)) { 1232 goto exit; 1233 } 1234 return_value = _codecs_raw_unicode_escape_encode_impl(module, str, errors); 1235 1236 exit: 1237 return return_value; 1238 } 1239 1240 PyDoc_STRVAR(_codecs_latin_1_encode__doc__, 1241 "latin_1_encode($module, str, errors=None, /)\n" 1242 "--\n" 1243 "\n"); 1244 1245 #define _CODECS_LATIN_1_ENCODE_METHODDEF \ 1246 {"latin_1_encode", (PyCFunction)_codecs_latin_1_encode, METH_VARARGS, _codecs_latin_1_encode__doc__}, 1247 1248 static PyObject * 1249 _codecs_latin_1_encode_impl(PyObject *module, PyObject *str, 1250 const char *errors); 1251 1252 static PyObject * 1253 _codecs_latin_1_encode(PyObject *module, PyObject *args) 1254 { 1255 PyObject *return_value = NULL; 1256 PyObject *str; 1257 const char *errors = NULL; 1258 1259 if (!PyArg_ParseTuple(args, "U|z:latin_1_encode", 1260 &str, &errors)) { 1261 goto exit; 1262 } 1263 return_value = _codecs_latin_1_encode_impl(module, str, errors); 1264 1265 exit: 1266 return return_value; 1267 } 1268 1269 PyDoc_STRVAR(_codecs_ascii_encode__doc__, 1270 "ascii_encode($module, str, errors=None, /)\n" 1271 "--\n" 1272 "\n"); 1273 1274 #define _CODECS_ASCII_ENCODE_METHODDEF \ 1275 {"ascii_encode", (PyCFunction)_codecs_ascii_encode, METH_VARARGS, _codecs_ascii_encode__doc__}, 1276 1277 static PyObject * 1278 _codecs_ascii_encode_impl(PyObject *module, PyObject *str, 1279 const char *errors); 1280 1281 static PyObject * 1282 _codecs_ascii_encode(PyObject *module, PyObject *args) 1283 { 1284 PyObject *return_value = NULL; 1285 PyObject *str; 1286 const char *errors = NULL; 1287 1288 if (!PyArg_ParseTuple(args, "U|z:ascii_encode", 1289 &str, &errors)) { 1290 goto exit; 1291 } 1292 return_value = _codecs_ascii_encode_impl(module, str, errors); 1293 1294 exit: 1295 return return_value; 1296 } 1297 1298 PyDoc_STRVAR(_codecs_charmap_encode__doc__, 1299 "charmap_encode($module, str, errors=None, mapping=None, /)\n" 1300 "--\n" 1301 "\n"); 1302 1303 #define _CODECS_CHARMAP_ENCODE_METHODDEF \ 1304 {"charmap_encode", (PyCFunction)_codecs_charmap_encode, METH_VARARGS, _codecs_charmap_encode__doc__}, 1305 1306 static PyObject * 1307 _codecs_charmap_encode_impl(PyObject *module, PyObject *str, 1308 const char *errors, PyObject *mapping); 1309 1310 static PyObject * 1311 _codecs_charmap_encode(PyObject *module, PyObject *args) 1312 { 1313 PyObject *return_value = NULL; 1314 PyObject *str; 1315 const char *errors = NULL; 1316 PyObject *mapping = NULL; 1317 1318 if (!PyArg_ParseTuple(args, "U|zO:charmap_encode", 1319 &str, &errors, &mapping)) { 1320 goto exit; 1321 } 1322 return_value = _codecs_charmap_encode_impl(module, str, errors, mapping); 1323 1324 exit: 1325 return return_value; 1326 } 1327 1328 PyDoc_STRVAR(_codecs_charmap_build__doc__, 1329 "charmap_build($module, map, /)\n" 1330 "--\n" 1331 "\n"); 1332 1333 #define _CODECS_CHARMAP_BUILD_METHODDEF \ 1334 {"charmap_build", (PyCFunction)_codecs_charmap_build, METH_O, _codecs_charmap_build__doc__}, 1335 1336 static PyObject * 1337 _codecs_charmap_build_impl(PyObject *module, PyObject *map); 1338 1339 static PyObject * 1340 _codecs_charmap_build(PyObject *module, PyObject *arg) 1341 { 1342 PyObject *return_value = NULL; 1343 PyObject *map; 1344 1345 if (!PyArg_Parse(arg, "U:charmap_build", &map)) { 1346 goto exit; 1347 } 1348 return_value = _codecs_charmap_build_impl(module, map); 1349 1350 exit: 1351 return return_value; 1352 } 1353 1354 #if defined(MS_WINDOWS) 1355 1356 PyDoc_STRVAR(_codecs_mbcs_encode__doc__, 1357 "mbcs_encode($module, str, errors=None, /)\n" 1358 "--\n" 1359 "\n"); 1360 1361 #define _CODECS_MBCS_ENCODE_METHODDEF \ 1362 {"mbcs_encode", (PyCFunction)_codecs_mbcs_encode, METH_VARARGS, _codecs_mbcs_encode__doc__}, 1363 1364 static PyObject * 1365 _codecs_mbcs_encode_impl(PyObject *module, PyObject *str, const char *errors); 1366 1367 static PyObject * 1368 _codecs_mbcs_encode(PyObject *module, PyObject *args) 1369 { 1370 PyObject *return_value = NULL; 1371 PyObject *str; 1372 const char *errors = NULL; 1373 1374 if (!PyArg_ParseTuple(args, "U|z:mbcs_encode", 1375 &str, &errors)) { 1376 goto exit; 1377 } 1378 return_value = _codecs_mbcs_encode_impl(module, str, errors); 1379 1380 exit: 1381 return return_value; 1382 } 1383 1384 #endif /* defined(MS_WINDOWS) */ 1385 1386 #if defined(MS_WINDOWS) 1387 1388 PyDoc_STRVAR(_codecs_oem_encode__doc__, 1389 "oem_encode($module, str, errors=None, /)\n" 1390 "--\n" 1391 "\n"); 1392 1393 #define _CODECS_OEM_ENCODE_METHODDEF \ 1394 {"oem_encode", (PyCFunction)_codecs_oem_encode, METH_VARARGS, _codecs_oem_encode__doc__}, 1395 1396 static PyObject * 1397 _codecs_oem_encode_impl(PyObject *module, PyObject *str, const char *errors); 1398 1399 static PyObject * 1400 _codecs_oem_encode(PyObject *module, PyObject *args) 1401 { 1402 PyObject *return_value = NULL; 1403 PyObject *str; 1404 const char *errors = NULL; 1405 1406 if (!PyArg_ParseTuple(args, "U|z:oem_encode", 1407 &str, &errors)) { 1408 goto exit; 1409 } 1410 return_value = _codecs_oem_encode_impl(module, str, errors); 1411 1412 exit: 1413 return return_value; 1414 } 1415 1416 #endif /* defined(MS_WINDOWS) */ 1417 1418 #if defined(MS_WINDOWS) 1419 1420 PyDoc_STRVAR(_codecs_code_page_encode__doc__, 1421 "code_page_encode($module, code_page, str, errors=None, /)\n" 1422 "--\n" 1423 "\n"); 1424 1425 #define _CODECS_CODE_PAGE_ENCODE_METHODDEF \ 1426 {"code_page_encode", (PyCFunction)_codecs_code_page_encode, METH_VARARGS, _codecs_code_page_encode__doc__}, 1427 1428 static PyObject * 1429 _codecs_code_page_encode_impl(PyObject *module, int code_page, PyObject *str, 1430 const char *errors); 1431 1432 static PyObject * 1433 _codecs_code_page_encode(PyObject *module, PyObject *args) 1434 { 1435 PyObject *return_value = NULL; 1436 int code_page; 1437 PyObject *str; 1438 const char *errors = NULL; 1439 1440 if (!PyArg_ParseTuple(args, "iU|z:code_page_encode", 1441 &code_page, &str, &errors)) { 1442 goto exit; 1443 } 1444 return_value = _codecs_code_page_encode_impl(module, code_page, str, errors); 1445 1446 exit: 1447 return return_value; 1448 } 1449 1450 #endif /* defined(MS_WINDOWS) */ 1451 1452 PyDoc_STRVAR(_codecs_register_error__doc__, 1453 "register_error($module, errors, handler, /)\n" 1454 "--\n" 1455 "\n" 1456 "Register the specified error handler under the name errors.\n" 1457 "\n" 1458 "handler must be a callable object, that will be called with an exception\n" 1459 "instance containing information about the location of the encoding/decoding\n" 1460 "error and must return a (replacement, new position) tuple."); 1461 1462 #define _CODECS_REGISTER_ERROR_METHODDEF \ 1463 {"register_error", (PyCFunction)_codecs_register_error, METH_VARARGS, _codecs_register_error__doc__}, 1464 1465 static PyObject * 1466 _codecs_register_error_impl(PyObject *module, const char *errors, 1467 PyObject *handler); 1468 1469 static PyObject * 1470 _codecs_register_error(PyObject *module, PyObject *args) 1471 { 1472 PyObject *return_value = NULL; 1473 const char *errors; 1474 PyObject *handler; 1475 1476 if (!PyArg_ParseTuple(args, "sO:register_error", 1477 &errors, &handler)) { 1478 goto exit; 1479 } 1480 return_value = _codecs_register_error_impl(module, errors, handler); 1481 1482 exit: 1483 return return_value; 1484 } 1485 1486 PyDoc_STRVAR(_codecs_lookup_error__doc__, 1487 "lookup_error($module, name, /)\n" 1488 "--\n" 1489 "\n" 1490 "lookup_error(errors) -> handler\n" 1491 "\n" 1492 "Return the error handler for the specified error handling name or raise a\n" 1493 "LookupError, if no handler exists under this name."); 1494 1495 #define _CODECS_LOOKUP_ERROR_METHODDEF \ 1496 {"lookup_error", (PyCFunction)_codecs_lookup_error, METH_O, _codecs_lookup_error__doc__}, 1497 1498 static PyObject * 1499 _codecs_lookup_error_impl(PyObject *module, const char *name); 1500 1501 static PyObject * 1502 _codecs_lookup_error(PyObject *module, PyObject *arg) 1503 { 1504 PyObject *return_value = NULL; 1505 const char *name; 1506 1507 if (!PyArg_Parse(arg, "s:lookup_error", &name)) { 1508 goto exit; 1509 } 1510 return_value = _codecs_lookup_error_impl(module, name); 1511 1512 exit: 1513 return return_value; 1514 } 1515 1516 #ifndef _CODECS_MBCS_DECODE_METHODDEF 1517 #define _CODECS_MBCS_DECODE_METHODDEF 1518 #endif /* !defined(_CODECS_MBCS_DECODE_METHODDEF) */ 1519 1520 #ifndef _CODECS_OEM_DECODE_METHODDEF 1521 #define _CODECS_OEM_DECODE_METHODDEF 1522 #endif /* !defined(_CODECS_OEM_DECODE_METHODDEF) */ 1523 1524 #ifndef _CODECS_CODE_PAGE_DECODE_METHODDEF 1525 #define _CODECS_CODE_PAGE_DECODE_METHODDEF 1526 #endif /* !defined(_CODECS_CODE_PAGE_DECODE_METHODDEF) */ 1527 1528 #ifndef _CODECS_MBCS_ENCODE_METHODDEF 1529 #define _CODECS_MBCS_ENCODE_METHODDEF 1530 #endif /* !defined(_CODECS_MBCS_ENCODE_METHODDEF) */ 1531 1532 #ifndef _CODECS_OEM_ENCODE_METHODDEF 1533 #define _CODECS_OEM_ENCODE_METHODDEF 1534 #endif /* !defined(_CODECS_OEM_ENCODE_METHODDEF) */ 1535 1536 #ifndef _CODECS_CODE_PAGE_ENCODE_METHODDEF 1537 #define _CODECS_CODE_PAGE_ENCODE_METHODDEF 1538 #endif /* !defined(_CODECS_CODE_PAGE_ENCODE_METHODDEF) */ 1539 /*[clinic end generated code: output=6d6afcabde10ed79 input=a9049054013a1b77]*/ 1540
