1 /*[clinic input]
2 preserve
3 [clinic start generated code]*/
4
5 PyDoc_STRVAR(_multibytecodec_MultibyteCodec_encode__doc__,
6 "encode($self, /, input, errors=None)\n"
7 "--\n"
8 "\n"
9 "Return an encoded string version of `input\'.\n"
10 "\n"
11 "\'errors\' may be given to set a different error handling scheme. Default is\n"
12 "\'strict\' meaning that encoding errors raise a UnicodeEncodeError. Other possible\n"
13 "values are \'ignore\', \'replace\' and \'xmlcharrefreplace\' as well as any other name\n"
14 "registered with codecs.register_error that can handle UnicodeEncodeErrors.");
15
16 #define _MULTIBYTECODEC_MULTIBYTECODEC_ENCODE_METHODDEF \
17 {"encode", _PyCFunction_CAST(_multibytecodec_MultibyteCodec_encode), METH_FASTCALL|METH_KEYWORDS, _multibytecodec_MultibyteCodec_encode__doc__},
18
19 static PyObject *
20 _multibytecodec_MultibyteCodec_encode_impl(MultibyteCodecObject *self,
21 PyObject *input,
22 const char *errors);
23
24 static PyObject *
25 _multibytecodec_MultibyteCodec_encode(MultibyteCodecObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
26 {
27 PyObject *return_value = NULL;
28 static const char * const _keywords[] = {"input", "errors", NULL};
29 static _PyArg_Parser _parser = {NULL, _keywords, "encode", 0};
30 PyObject *argsbuf[2];
31 Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
32 PyObject *input;
33 const char *errors = NULL;
34
35 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 2, 0, argsbuf);
36 if (!args) {
37 goto exit;
38 }
39 input = args[0];
40 if (!noptargs) {
41 goto skip_optional_pos;
42 }
43 if (args[1] == Py_None) {
44 errors = NULL;
45 }
46 else if (PyUnicode_Check(args[1])) {
47 Py_ssize_t errors_length;
48 errors = PyUnicode_AsUTF8AndSize(args[1], &errors_length);
49 if (errors == NULL) {
50 goto exit;
51 }
52 if (strlen(errors) != (size_t)errors_length) {
53 PyErr_SetString(PyExc_ValueError, "embedded null character");
54 goto exit;
55 }
56 }
57 else {
58 _PyArg_BadArgument("encode", "argument 'errors'", "str or None", args[1]);
59 goto exit;
60 }
61 skip_optional_pos:
62 return_value = _multibytecodec_MultibyteCodec_encode_impl(self, input, errors);
63
64 exit:
65 return return_value;
66 }
67
68 PyDoc_STRVAR(_multibytecodec_MultibyteCodec_decode__doc__,
69 "decode($self, /, input, errors=None)\n"
70 "--\n"
71 "\n"
72 "Decodes \'input\'.\n"
73 "\n"
74 "\'errors\' may be given to set a different error handling scheme. Default is\n"
75 "\'strict\' meaning that encoding errors raise a UnicodeDecodeError. Other possible\n"
76 "values are \'ignore\' and \'replace\' as well as any other name registered with\n"
77 "codecs.register_error that is able to handle UnicodeDecodeErrors.\"");
78
79 #define _MULTIBYTECODEC_MULTIBYTECODEC_DECODE_METHODDEF \
80 {"decode", _PyCFunction_CAST(_multibytecodec_MultibyteCodec_decode), METH_FASTCALL|METH_KEYWORDS, _multibytecodec_MultibyteCodec_decode__doc__},
81
82 static PyObject *
83 _multibytecodec_MultibyteCodec_decode_impl(MultibyteCodecObject *self,
84 Py_buffer *input,
85 const char *errors);
86
87 static PyObject *
88 _multibytecodec_MultibyteCodec_decode(MultibyteCodecObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
89 {
90 PyObject *return_value = NULL;
91 static const char * const _keywords[] = {"input", "errors", NULL};
92 static _PyArg_Parser _parser = {NULL, _keywords, "decode", 0};
93 PyObject *argsbuf[2];
94 Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
95 Py_buffer input = {NULL, NULL};
96 const char *errors = NULL;
97
98 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 2, 0, argsbuf);
99 if (!args) {
100 goto exit;
101 }
102 if (PyObject_GetBuffer(args[0], &input, PyBUF_SIMPLE) != 0) {
103 goto exit;
104 }
105 if (!PyBuffer_IsContiguous(&input, 'C')) {
106 _PyArg_BadArgument("decode", "argument 'input'", "contiguous buffer", args[0]);
107 goto exit;
108 }
109 if (!noptargs) {
110 goto skip_optional_pos;
111 }
112 if (args[1] == Py_None) {
113 errors = NULL;
114 }
115 else if (PyUnicode_Check(args[1])) {
116 Py_ssize_t errors_length;
117 errors = PyUnicode_AsUTF8AndSize(args[1], &errors_length);
118 if (errors == NULL) {
119 goto exit;
120 }
121 if (strlen(errors) != (size_t)errors_length) {
122 PyErr_SetString(PyExc_ValueError, "embedded null character");
123 goto exit;
124 }
125 }
126 else {
127 _PyArg_BadArgument("decode", "argument 'errors'", "str or None", args[1]);
128 goto exit;
129 }
130 skip_optional_pos:
131 return_value = _multibytecodec_MultibyteCodec_decode_impl(self, &input, errors);
132
133 exit:
134 /* Cleanup for input */
135 if (input.obj) {
136 PyBuffer_Release(&input);
137 }
138
139 return return_value;
140 }
141
142 PyDoc_STRVAR(_multibytecodec_MultibyteIncrementalEncoder_encode__doc__,
143 "encode($self, /, input, final=False)\n"
144 "--\n"
145 "\n");
146
147 #define _MULTIBYTECODEC_MULTIBYTEINCREMENTALENCODER_ENCODE_METHODDEF \
148 {"encode", _PyCFunction_CAST(_multibytecodec_MultibyteIncrementalEncoder_encode), METH_FASTCALL|METH_KEYWORDS, _multibytecodec_MultibyteIncrementalEncoder_encode__doc__},
149
150 static PyObject *
151 _multibytecodec_MultibyteIncrementalEncoder_encode_impl(MultibyteIncrementalEncoderObject *self,
152 PyObject *input,
153 int final);
154
155 static PyObject *
156 _multibytecodec_MultibyteIncrementalEncoder_encode(MultibyteIncrementalEncoderObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
157 {
158 PyObject *return_value = NULL;
159 static const char * const _keywords[] = {"input", "final", NULL};
160 static _PyArg_Parser _parser = {NULL, _keywords, "encode", 0};
161 PyObject *argsbuf[2];
162 Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
163 PyObject *input;
164 int final = 0;
165
166 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 2, 0, argsbuf);
167 if (!args) {
168 goto exit;
169 }
170 input = args[0];
171 if (!noptargs) {
172 goto skip_optional_pos;
173 }
174 final = _PyLong_AsInt(args[1]);
175 if (final == -1 && PyErr_Occurred()) {
176 goto exit;
177 }
178 skip_optional_pos:
179 return_value = _multibytecodec_MultibyteIncrementalEncoder_encode_impl(self, input, final);
180
181 exit:
182 return return_value;
183 }
184
185 PyDoc_STRVAR(_multibytecodec_MultibyteIncrementalEncoder_getstate__doc__,
186 "getstate($self, /)\n"
187 "--\n"
188 "\n");
189
190 #define _MULTIBYTECODEC_MULTIBYTEINCREMENTALENCODER_GETSTATE_METHODDEF \
191 {"getstate", (PyCFunction)_multibytecodec_MultibyteIncrementalEncoder_getstate, METH_NOARGS, _multibytecodec_MultibyteIncrementalEncoder_getstate__doc__},
192
193 static PyObject *
194 _multibytecodec_MultibyteIncrementalEncoder_getstate_impl(MultibyteIncrementalEncoderObject *self);
195
196 static PyObject *
197 _multibytecodec_MultibyteIncrementalEncoder_getstate(MultibyteIncrementalEncoderObject *self, PyObject *Py_UNUSED(ignored))
198 {
199 return _multibytecodec_MultibyteIncrementalEncoder_getstate_impl(self);
200 }
201
202 PyDoc_STRVAR(_multibytecodec_MultibyteIncrementalEncoder_setstate__doc__,
203 "setstate($self, state, /)\n"
204 "--\n"
205 "\n");
206
207 #define _MULTIBYTECODEC_MULTIBYTEINCREMENTALENCODER_SETSTATE_METHODDEF \
208 {"setstate", (PyCFunction)_multibytecodec_MultibyteIncrementalEncoder_setstate, METH_O, _multibytecodec_MultibyteIncrementalEncoder_setstate__doc__},
209
210 static PyObject *
211 _multibytecodec_MultibyteIncrementalEncoder_setstate_impl(MultibyteIncrementalEncoderObject *self,
212 PyLongObject *statelong);
213
214 static PyObject *
215 _multibytecodec_MultibyteIncrementalEncoder_setstate(MultibyteIncrementalEncoderObject *self, PyObject *arg)
216 {
217 PyObject *return_value = NULL;
218 PyLongObject *statelong;
219
220 if (!PyLong_Check(arg)) {
221 _PyArg_BadArgument("setstate", "argument", "int", arg);
222 goto exit;
223 }
224 statelong = (PyLongObject *)arg;
225 return_value = _multibytecodec_MultibyteIncrementalEncoder_setstate_impl(self, statelong);
226
227 exit:
228 return return_value;
229 }
230
231 PyDoc_STRVAR(_multibytecodec_MultibyteIncrementalEncoder_reset__doc__,
232 "reset($self, /)\n"
233 "--\n"
234 "\n");
235
236 #define _MULTIBYTECODEC_MULTIBYTEINCREMENTALENCODER_RESET_METHODDEF \
237 {"reset", (PyCFunction)_multibytecodec_MultibyteIncrementalEncoder_reset, METH_NOARGS, _multibytecodec_MultibyteIncrementalEncoder_reset__doc__},
238
239 static PyObject *
240 _multibytecodec_MultibyteIncrementalEncoder_reset_impl(MultibyteIncrementalEncoderObject *self);
241
242 static PyObject *
243 _multibytecodec_MultibyteIncrementalEncoder_reset(MultibyteIncrementalEncoderObject *self, PyObject *Py_UNUSED(ignored))
244 {
245 return _multibytecodec_MultibyteIncrementalEncoder_reset_impl(self);
246 }
247
248 PyDoc_STRVAR(_multibytecodec_MultibyteIncrementalDecoder_decode__doc__,
249 "decode($self, /, input, final=False)\n"
250 "--\n"
251 "\n");
252
253 #define _MULTIBYTECODEC_MULTIBYTEINCREMENTALDECODER_DECODE_METHODDEF \
254 {"decode", _PyCFunction_CAST(_multibytecodec_MultibyteIncrementalDecoder_decode), METH_FASTCALL|METH_KEYWORDS, _multibytecodec_MultibyteIncrementalDecoder_decode__doc__},
255
256 static PyObject *
257 _multibytecodec_MultibyteIncrementalDecoder_decode_impl(MultibyteIncrementalDecoderObject *self,
258 Py_buffer *input,
259 int final);
260
261 static PyObject *
262 _multibytecodec_MultibyteIncrementalDecoder_decode(MultibyteIncrementalDecoderObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
263 {
264 PyObject *return_value = NULL;
265 static const char * const _keywords[] = {"input", "final", NULL};
266 static _PyArg_Parser _parser = {NULL, _keywords, "decode", 0};
267 PyObject *argsbuf[2];
268 Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
269 Py_buffer input = {NULL, NULL};
270 int final = 0;
271
272 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 2, 0, argsbuf);
273 if (!args) {
274 goto exit;
275 }
276 if (PyObject_GetBuffer(args[0], &input, PyBUF_SIMPLE) != 0) {
277 goto exit;
278 }
279 if (!PyBuffer_IsContiguous(&input, 'C')) {
280 _PyArg_BadArgument("decode", "argument 'input'", "contiguous buffer", args[0]);
281 goto exit;
282 }
283 if (!noptargs) {
284 goto skip_optional_pos;
285 }
286 final = _PyLong_AsInt(args[1]);
287 if (final == -1 && PyErr_Occurred()) {
288 goto exit;
289 }
290 skip_optional_pos:
291 return_value = _multibytecodec_MultibyteIncrementalDecoder_decode_impl(self, &input, final);
292
293 exit:
294 /* Cleanup for input */
295 if (input.obj) {
296 PyBuffer_Release(&input);
297 }
298
299 return return_value;
300 }
301
302 PyDoc_STRVAR(_multibytecodec_MultibyteIncrementalDecoder_getstate__doc__,
303 "getstate($self, /)\n"
304 "--\n"
305 "\n");
306
307 #define _MULTIBYTECODEC_MULTIBYTEINCREMENTALDECODER_GETSTATE_METHODDEF \
308 {"getstate", (PyCFunction)_multibytecodec_MultibyteIncrementalDecoder_getstate, METH_NOARGS, _multibytecodec_MultibyteIncrementalDecoder_getstate__doc__},
309
310 static PyObject *
311 _multibytecodec_MultibyteIncrementalDecoder_getstate_impl(MultibyteIncrementalDecoderObject *self);
312
313 static PyObject *
314 _multibytecodec_MultibyteIncrementalDecoder_getstate(MultibyteIncrementalDecoderObject *self, PyObject *Py_UNUSED(ignored))
315 {
316 return _multibytecodec_MultibyteIncrementalDecoder_getstate_impl(self);
317 }
318
319 PyDoc_STRVAR(_multibytecodec_MultibyteIncrementalDecoder_setstate__doc__,
320 "setstate($self, state, /)\n"
321 "--\n"
322 "\n");
323
324 #define _MULTIBYTECODEC_MULTIBYTEINCREMENTALDECODER_SETSTATE_METHODDEF \
325 {"setstate", (PyCFunction)_multibytecodec_MultibyteIncrementalDecoder_setstate, METH_O, _multibytecodec_MultibyteIncrementalDecoder_setstate__doc__},
326
327 static PyObject *
328 _multibytecodec_MultibyteIncrementalDecoder_setstate_impl(MultibyteIncrementalDecoderObject *self,
329 PyObject *state);
330
331 static PyObject *
332 _multibytecodec_MultibyteIncrementalDecoder_setstate(MultibyteIncrementalDecoderObject *self, PyObject *arg)
333 {
334 PyObject *return_value = NULL;
335 PyObject *state;
336
337 if (!PyTuple_Check(arg)) {
338 _PyArg_BadArgument("setstate", "argument", "tuple", arg);
339 goto exit;
340 }
341 state = arg;
342 return_value = _multibytecodec_MultibyteIncrementalDecoder_setstate_impl(self, state);
343
344 exit:
345 return return_value;
346 }
347
348 PyDoc_STRVAR(_multibytecodec_MultibyteIncrementalDecoder_reset__doc__,
349 "reset($self, /)\n"
350 "--\n"
351 "\n");
352
353 #define _MULTIBYTECODEC_MULTIBYTEINCREMENTALDECODER_RESET_METHODDEF \
354 {"reset", (PyCFunction)_multibytecodec_MultibyteIncrementalDecoder_reset, METH_NOARGS, _multibytecodec_MultibyteIncrementalDecoder_reset__doc__},
355
356 static PyObject *
357 _multibytecodec_MultibyteIncrementalDecoder_reset_impl(MultibyteIncrementalDecoderObject *self);
358
359 static PyObject *
360 _multibytecodec_MultibyteIncrementalDecoder_reset(MultibyteIncrementalDecoderObject *self, PyObject *Py_UNUSED(ignored))
361 {
362 return _multibytecodec_MultibyteIncrementalDecoder_reset_impl(self);
363 }
364
365 PyDoc_STRVAR(_multibytecodec_MultibyteStreamReader_read__doc__,
366 "read($self, sizeobj=None, /)\n"
367 "--\n"
368 "\n");
369
370 #define _MULTIBYTECODEC_MULTIBYTESTREAMREADER_READ_METHODDEF \
371 {"read", _PyCFunction_CAST(_multibytecodec_MultibyteStreamReader_read), METH_FASTCALL, _multibytecodec_MultibyteStreamReader_read__doc__},
372
373 static PyObject *
374 _multibytecodec_MultibyteStreamReader_read_impl(MultibyteStreamReaderObject *self,
375 PyObject *sizeobj);
376
377 static PyObject *
378 _multibytecodec_MultibyteStreamReader_read(MultibyteStreamReaderObject *self, PyObject *const *args, Py_ssize_t nargs)
379 {
380 PyObject *return_value = NULL;
381 PyObject *sizeobj = Py_None;
382
383 if (!_PyArg_CheckPositional("read", nargs, 0, 1)) {
384 goto exit;
385 }
386 if (nargs < 1) {
387 goto skip_optional;
388 }
389 sizeobj = args[0];
390 skip_optional:
391 return_value = _multibytecodec_MultibyteStreamReader_read_impl(self, sizeobj);
392
393 exit:
394 return return_value;
395 }
396
397 PyDoc_STRVAR(_multibytecodec_MultibyteStreamReader_readline__doc__,
398 "readline($self, sizeobj=None, /)\n"
399 "--\n"
400 "\n");
401
402 #define _MULTIBYTECODEC_MULTIBYTESTREAMREADER_READLINE_METHODDEF \
403 {"readline", _PyCFunction_CAST(_multibytecodec_MultibyteStreamReader_readline), METH_FASTCALL, _multibytecodec_MultibyteStreamReader_readline__doc__},
404
405 static PyObject *
406 _multibytecodec_MultibyteStreamReader_readline_impl(MultibyteStreamReaderObject *self,
407 PyObject *sizeobj);
408
409 static PyObject *
410 _multibytecodec_MultibyteStreamReader_readline(MultibyteStreamReaderObject *self, PyObject *const *args, Py_ssize_t nargs)
411 {
412 PyObject *return_value = NULL;
413 PyObject *sizeobj = Py_None;
414
415 if (!_PyArg_CheckPositional("readline", nargs, 0, 1)) {
416 goto exit;
417 }
418 if (nargs < 1) {
419 goto skip_optional;
420 }
421 sizeobj = args[0];
422 skip_optional:
423 return_value = _multibytecodec_MultibyteStreamReader_readline_impl(self, sizeobj);
424
425 exit:
426 return return_value;
427 }
428
429 PyDoc_STRVAR(_multibytecodec_MultibyteStreamReader_readlines__doc__,
430 "readlines($self, sizehintobj=None, /)\n"
431 "--\n"
432 "\n");
433
434 #define _MULTIBYTECODEC_MULTIBYTESTREAMREADER_READLINES_METHODDEF \
435 {"readlines", _PyCFunction_CAST(_multibytecodec_MultibyteStreamReader_readlines), METH_FASTCALL, _multibytecodec_MultibyteStreamReader_readlines__doc__},
436
437 static PyObject *
438 _multibytecodec_MultibyteStreamReader_readlines_impl(MultibyteStreamReaderObject *self,
439 PyObject *sizehintobj);
440
441 static PyObject *
442 _multibytecodec_MultibyteStreamReader_readlines(MultibyteStreamReaderObject *self, PyObject *const *args, Py_ssize_t nargs)
443 {
444 PyObject *return_value = NULL;
445 PyObject *sizehintobj = Py_None;
446
447 if (!_PyArg_CheckPositional("readlines", nargs, 0, 1)) {
448 goto exit;
449 }
450 if (nargs < 1) {
451 goto skip_optional;
452 }
453 sizehintobj = args[0];
454 skip_optional:
455 return_value = _multibytecodec_MultibyteStreamReader_readlines_impl(self, sizehintobj);
456
457 exit:
458 return return_value;
459 }
460
461 PyDoc_STRVAR(_multibytecodec_MultibyteStreamReader_reset__doc__,
462 "reset($self, /)\n"
463 "--\n"
464 "\n");
465
466 #define _MULTIBYTECODEC_MULTIBYTESTREAMREADER_RESET_METHODDEF \
467 {"reset", (PyCFunction)_multibytecodec_MultibyteStreamReader_reset, METH_NOARGS, _multibytecodec_MultibyteStreamReader_reset__doc__},
468
469 static PyObject *
470 _multibytecodec_MultibyteStreamReader_reset_impl(MultibyteStreamReaderObject *self);
471
472 static PyObject *
473 _multibytecodec_MultibyteStreamReader_reset(MultibyteStreamReaderObject *self, PyObject *Py_UNUSED(ignored))
474 {
475 return _multibytecodec_MultibyteStreamReader_reset_impl(self);
476 }
477
478 PyDoc_STRVAR(_multibytecodec_MultibyteStreamWriter_write__doc__,
479 "write($self, strobj, /)\n"
480 "--\n"
481 "\n");
482
483 #define _MULTIBYTECODEC_MULTIBYTESTREAMWRITER_WRITE_METHODDEF \
484 {"write", _PyCFunction_CAST(_multibytecodec_MultibyteStreamWriter_write), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _multibytecodec_MultibyteStreamWriter_write__doc__},
485
486 static PyObject *
487 _multibytecodec_MultibyteStreamWriter_write_impl(MultibyteStreamWriterObject *self,
488 PyTypeObject *cls,
489 PyObject *strobj);
490
491 static PyObject *
492 _multibytecodec_MultibyteStreamWriter_write(MultibyteStreamWriterObject *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
493 {
494 PyObject *return_value = NULL;
495 static const char * const _keywords[] = {"", NULL};
496 static _PyArg_Parser _parser = {NULL, _keywords, "write", 0};
497 PyObject *argsbuf[1];
498 PyObject *strobj;
499
500 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, argsbuf);
501 if (!args) {
502 goto exit;
503 }
504 strobj = args[0];
505 return_value = _multibytecodec_MultibyteStreamWriter_write_impl(self, cls, strobj);
506
507 exit:
508 return return_value;
509 }
510
511 PyDoc_STRVAR(_multibytecodec_MultibyteStreamWriter_writelines__doc__,
512 "writelines($self, lines, /)\n"
513 "--\n"
514 "\n");
515
516 #define _MULTIBYTECODEC_MULTIBYTESTREAMWRITER_WRITELINES_METHODDEF \
517 {"writelines", _PyCFunction_CAST(_multibytecodec_MultibyteStreamWriter_writelines), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _multibytecodec_MultibyteStreamWriter_writelines__doc__},
518
519 static PyObject *
520 _multibytecodec_MultibyteStreamWriter_writelines_impl(MultibyteStreamWriterObject *self,
521 PyTypeObject *cls,
522 PyObject *lines);
523
524 static PyObject *
525 _multibytecodec_MultibyteStreamWriter_writelines(MultibyteStreamWriterObject *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
526 {
527 PyObject *return_value = NULL;
528 static const char * const _keywords[] = {"", NULL};
529 static _PyArg_Parser _parser = {NULL, _keywords, "writelines", 0};
530 PyObject *argsbuf[1];
531 PyObject *lines;
532
533 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, argsbuf);
534 if (!args) {
535 goto exit;
536 }
537 lines = args[0];
538 return_value = _multibytecodec_MultibyteStreamWriter_writelines_impl(self, cls, lines);
539
540 exit:
541 return return_value;
542 }
543
544 PyDoc_STRVAR(_multibytecodec_MultibyteStreamWriter_reset__doc__,
545 "reset($self, /)\n"
546 "--\n"
547 "\n");
548
549 #define _MULTIBYTECODEC_MULTIBYTESTREAMWRITER_RESET_METHODDEF \
550 {"reset", _PyCFunction_CAST(_multibytecodec_MultibyteStreamWriter_reset), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _multibytecodec_MultibyteStreamWriter_reset__doc__},
551
552 static PyObject *
553 _multibytecodec_MultibyteStreamWriter_reset_impl(MultibyteStreamWriterObject *self,
554 PyTypeObject *cls);
555
556 static PyObject *
557 _multibytecodec_MultibyteStreamWriter_reset(MultibyteStreamWriterObject *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
558 {
559 if (nargs) {
560 PyErr_SetString(PyExc_TypeError, "reset() takes no arguments");
561 return NULL;
562 }
563 return _multibytecodec_MultibyteStreamWriter_reset_impl(self, cls);
564 }
565
566 PyDoc_STRVAR(_multibytecodec___create_codec__doc__,
567 "__create_codec($module, arg, /)\n"
568 "--\n"
569 "\n");
570
571 #define _MULTIBYTECODEC___CREATE_CODEC_METHODDEF \
572 {"__create_codec", (PyCFunction)_multibytecodec___create_codec, METH_O, _multibytecodec___create_codec__doc__},
573 /*[clinic end generated code: output=9e4e3da5ca3c8288 input=a9049054013a1b77]*/