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)(void(*)(void))_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 *
_multibytecodec_MultibyteCodec_encode(MultibyteCodecObject * self,PyObject * const * args,Py_ssize_t nargs,PyObject * kwnames)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)(void(*)(void))_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 *
_multibytecodec_MultibyteCodec_decode(MultibyteCodecObject * self,PyObject * const * args,Py_ssize_t nargs,PyObject * kwnames)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)(void(*)(void))_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 *
_multibytecodec_MultibyteIncrementalEncoder_encode(MultibyteIncrementalEncoderObject * self,PyObject * const * args,Py_ssize_t nargs,PyObject * kwnames)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 if (PyFloat_Check(args[1])) {
175 PyErr_SetString(PyExc_TypeError,
176 "integer argument expected, got float" );
177 goto exit;
178 }
179 final = _PyLong_AsInt(args[1]);
180 if (final == -1 && PyErr_Occurred()) {
181 goto exit;
182 }
183 skip_optional_pos:
184 return_value = _multibytecodec_MultibyteIncrementalEncoder_encode_impl(self, input, final);
185
186 exit:
187 return return_value;
188 }
189
190 PyDoc_STRVAR(_multibytecodec_MultibyteIncrementalEncoder_getstate__doc__,
191 "getstate($self, /)\n"
192 "--\n"
193 "\n");
194
195 #define _MULTIBYTECODEC_MULTIBYTEINCREMENTALENCODER_GETSTATE_METHODDEF \
196 {"getstate", (PyCFunction)_multibytecodec_MultibyteIncrementalEncoder_getstate, METH_NOARGS, _multibytecodec_MultibyteIncrementalEncoder_getstate__doc__},
197
198 static PyObject *
199 _multibytecodec_MultibyteIncrementalEncoder_getstate_impl(MultibyteIncrementalEncoderObject *self);
200
201 static PyObject *
_multibytecodec_MultibyteIncrementalEncoder_getstate(MultibyteIncrementalEncoderObject * self,PyObject * Py_UNUSED (ignored))202 _multibytecodec_MultibyteIncrementalEncoder_getstate(MultibyteIncrementalEncoderObject *self, PyObject *Py_UNUSED(ignored))
203 {
204 return _multibytecodec_MultibyteIncrementalEncoder_getstate_impl(self);
205 }
206
207 PyDoc_STRVAR(_multibytecodec_MultibyteIncrementalEncoder_setstate__doc__,
208 "setstate($self, state, /)\n"
209 "--\n"
210 "\n");
211
212 #define _MULTIBYTECODEC_MULTIBYTEINCREMENTALENCODER_SETSTATE_METHODDEF \
213 {"setstate", (PyCFunction)_multibytecodec_MultibyteIncrementalEncoder_setstate, METH_O, _multibytecodec_MultibyteIncrementalEncoder_setstate__doc__},
214
215 static PyObject *
216 _multibytecodec_MultibyteIncrementalEncoder_setstate_impl(MultibyteIncrementalEncoderObject *self,
217 PyLongObject *statelong);
218
219 static PyObject *
_multibytecodec_MultibyteIncrementalEncoder_setstate(MultibyteIncrementalEncoderObject * self,PyObject * arg)220 _multibytecodec_MultibyteIncrementalEncoder_setstate(MultibyteIncrementalEncoderObject *self, PyObject *arg)
221 {
222 PyObject *return_value = NULL;
223 PyLongObject *statelong;
224
225 if (!PyLong_Check(arg)) {
226 _PyArg_BadArgument("setstate", "argument", "int", arg);
227 goto exit;
228 }
229 statelong = (PyLongObject *)arg;
230 return_value = _multibytecodec_MultibyteIncrementalEncoder_setstate_impl(self, statelong);
231
232 exit:
233 return return_value;
234 }
235
236 PyDoc_STRVAR(_multibytecodec_MultibyteIncrementalEncoder_reset__doc__,
237 "reset($self, /)\n"
238 "--\n"
239 "\n");
240
241 #define _MULTIBYTECODEC_MULTIBYTEINCREMENTALENCODER_RESET_METHODDEF \
242 {"reset", (PyCFunction)_multibytecodec_MultibyteIncrementalEncoder_reset, METH_NOARGS, _multibytecodec_MultibyteIncrementalEncoder_reset__doc__},
243
244 static PyObject *
245 _multibytecodec_MultibyteIncrementalEncoder_reset_impl(MultibyteIncrementalEncoderObject *self);
246
247 static PyObject *
_multibytecodec_MultibyteIncrementalEncoder_reset(MultibyteIncrementalEncoderObject * self,PyObject * Py_UNUSED (ignored))248 _multibytecodec_MultibyteIncrementalEncoder_reset(MultibyteIncrementalEncoderObject *self, PyObject *Py_UNUSED(ignored))
249 {
250 return _multibytecodec_MultibyteIncrementalEncoder_reset_impl(self);
251 }
252
253 PyDoc_STRVAR(_multibytecodec_MultibyteIncrementalDecoder_decode__doc__,
254 "decode($self, /, input, final=False)\n"
255 "--\n"
256 "\n");
257
258 #define _MULTIBYTECODEC_MULTIBYTEINCREMENTALDECODER_DECODE_METHODDEF \
259 {"decode", (PyCFunction)(void(*)(void))_multibytecodec_MultibyteIncrementalDecoder_decode, METH_FASTCALL|METH_KEYWORDS, _multibytecodec_MultibyteIncrementalDecoder_decode__doc__},
260
261 static PyObject *
262 _multibytecodec_MultibyteIncrementalDecoder_decode_impl(MultibyteIncrementalDecoderObject *self,
263 Py_buffer *input,
264 int final);
265
266 static PyObject *
_multibytecodec_MultibyteIncrementalDecoder_decode(MultibyteIncrementalDecoderObject * self,PyObject * const * args,Py_ssize_t nargs,PyObject * kwnames)267 _multibytecodec_MultibyteIncrementalDecoder_decode(MultibyteIncrementalDecoderObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
268 {
269 PyObject *return_value = NULL;
270 static const char * const _keywords[] = {"input", "final", NULL};
271 static _PyArg_Parser _parser = {NULL, _keywords, "decode", 0};
272 PyObject *argsbuf[2];
273 Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
274 Py_buffer input = {NULL, NULL};
275 int final = 0;
276
277 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 2, 0, argsbuf);
278 if (!args) {
279 goto exit;
280 }
281 if (PyObject_GetBuffer(args[0], &input, PyBUF_SIMPLE) != 0) {
282 goto exit;
283 }
284 if (!PyBuffer_IsContiguous(&input, 'C')) {
285 _PyArg_BadArgument("decode", "argument 'input'", "contiguous buffer", args[0]);
286 goto exit;
287 }
288 if (!noptargs) {
289 goto skip_optional_pos;
290 }
291 if (PyFloat_Check(args[1])) {
292 PyErr_SetString(PyExc_TypeError,
293 "integer argument expected, got float" );
294 goto exit;
295 }
296 final = _PyLong_AsInt(args[1]);
297 if (final == -1 && PyErr_Occurred()) {
298 goto exit;
299 }
300 skip_optional_pos:
301 return_value = _multibytecodec_MultibyteIncrementalDecoder_decode_impl(self, &input, final);
302
303 exit:
304 /* Cleanup for input */
305 if (input.obj) {
306 PyBuffer_Release(&input);
307 }
308
309 return return_value;
310 }
311
312 PyDoc_STRVAR(_multibytecodec_MultibyteIncrementalDecoder_getstate__doc__,
313 "getstate($self, /)\n"
314 "--\n"
315 "\n");
316
317 #define _MULTIBYTECODEC_MULTIBYTEINCREMENTALDECODER_GETSTATE_METHODDEF \
318 {"getstate", (PyCFunction)_multibytecodec_MultibyteIncrementalDecoder_getstate, METH_NOARGS, _multibytecodec_MultibyteIncrementalDecoder_getstate__doc__},
319
320 static PyObject *
321 _multibytecodec_MultibyteIncrementalDecoder_getstate_impl(MultibyteIncrementalDecoderObject *self);
322
323 static PyObject *
_multibytecodec_MultibyteIncrementalDecoder_getstate(MultibyteIncrementalDecoderObject * self,PyObject * Py_UNUSED (ignored))324 _multibytecodec_MultibyteIncrementalDecoder_getstate(MultibyteIncrementalDecoderObject *self, PyObject *Py_UNUSED(ignored))
325 {
326 return _multibytecodec_MultibyteIncrementalDecoder_getstate_impl(self);
327 }
328
329 PyDoc_STRVAR(_multibytecodec_MultibyteIncrementalDecoder_setstate__doc__,
330 "setstate($self, state, /)\n"
331 "--\n"
332 "\n");
333
334 #define _MULTIBYTECODEC_MULTIBYTEINCREMENTALDECODER_SETSTATE_METHODDEF \
335 {"setstate", (PyCFunction)_multibytecodec_MultibyteIncrementalDecoder_setstate, METH_O, _multibytecodec_MultibyteIncrementalDecoder_setstate__doc__},
336
337 static PyObject *
338 _multibytecodec_MultibyteIncrementalDecoder_setstate_impl(MultibyteIncrementalDecoderObject *self,
339 PyObject *state);
340
341 static PyObject *
_multibytecodec_MultibyteIncrementalDecoder_setstate(MultibyteIncrementalDecoderObject * self,PyObject * arg)342 _multibytecodec_MultibyteIncrementalDecoder_setstate(MultibyteIncrementalDecoderObject *self, PyObject *arg)
343 {
344 PyObject *return_value = NULL;
345 PyObject *state;
346
347 if (!PyTuple_Check(arg)) {
348 _PyArg_BadArgument("setstate", "argument", "tuple", arg);
349 goto exit;
350 }
351 state = arg;
352 return_value = _multibytecodec_MultibyteIncrementalDecoder_setstate_impl(self, state);
353
354 exit:
355 return return_value;
356 }
357
358 PyDoc_STRVAR(_multibytecodec_MultibyteIncrementalDecoder_reset__doc__,
359 "reset($self, /)\n"
360 "--\n"
361 "\n");
362
363 #define _MULTIBYTECODEC_MULTIBYTEINCREMENTALDECODER_RESET_METHODDEF \
364 {"reset", (PyCFunction)_multibytecodec_MultibyteIncrementalDecoder_reset, METH_NOARGS, _multibytecodec_MultibyteIncrementalDecoder_reset__doc__},
365
366 static PyObject *
367 _multibytecodec_MultibyteIncrementalDecoder_reset_impl(MultibyteIncrementalDecoderObject *self);
368
369 static PyObject *
_multibytecodec_MultibyteIncrementalDecoder_reset(MultibyteIncrementalDecoderObject * self,PyObject * Py_UNUSED (ignored))370 _multibytecodec_MultibyteIncrementalDecoder_reset(MultibyteIncrementalDecoderObject *self, PyObject *Py_UNUSED(ignored))
371 {
372 return _multibytecodec_MultibyteIncrementalDecoder_reset_impl(self);
373 }
374
375 PyDoc_STRVAR(_multibytecodec_MultibyteStreamReader_read__doc__,
376 "read($self, sizeobj=None, /)\n"
377 "--\n"
378 "\n");
379
380 #define _MULTIBYTECODEC_MULTIBYTESTREAMREADER_READ_METHODDEF \
381 {"read", (PyCFunction)(void(*)(void))_multibytecodec_MultibyteStreamReader_read, METH_FASTCALL, _multibytecodec_MultibyteStreamReader_read__doc__},
382
383 static PyObject *
384 _multibytecodec_MultibyteStreamReader_read_impl(MultibyteStreamReaderObject *self,
385 PyObject *sizeobj);
386
387 static PyObject *
_multibytecodec_MultibyteStreamReader_read(MultibyteStreamReaderObject * self,PyObject * const * args,Py_ssize_t nargs)388 _multibytecodec_MultibyteStreamReader_read(MultibyteStreamReaderObject *self, PyObject *const *args, Py_ssize_t nargs)
389 {
390 PyObject *return_value = NULL;
391 PyObject *sizeobj = Py_None;
392
393 if (!_PyArg_CheckPositional("read", nargs, 0, 1)) {
394 goto exit;
395 }
396 if (nargs < 1) {
397 goto skip_optional;
398 }
399 sizeobj = args[0];
400 skip_optional:
401 return_value = _multibytecodec_MultibyteStreamReader_read_impl(self, sizeobj);
402
403 exit:
404 return return_value;
405 }
406
407 PyDoc_STRVAR(_multibytecodec_MultibyteStreamReader_readline__doc__,
408 "readline($self, sizeobj=None, /)\n"
409 "--\n"
410 "\n");
411
412 #define _MULTIBYTECODEC_MULTIBYTESTREAMREADER_READLINE_METHODDEF \
413 {"readline", (PyCFunction)(void(*)(void))_multibytecodec_MultibyteStreamReader_readline, METH_FASTCALL, _multibytecodec_MultibyteStreamReader_readline__doc__},
414
415 static PyObject *
416 _multibytecodec_MultibyteStreamReader_readline_impl(MultibyteStreamReaderObject *self,
417 PyObject *sizeobj);
418
419 static PyObject *
_multibytecodec_MultibyteStreamReader_readline(MultibyteStreamReaderObject * self,PyObject * const * args,Py_ssize_t nargs)420 _multibytecodec_MultibyteStreamReader_readline(MultibyteStreamReaderObject *self, PyObject *const *args, Py_ssize_t nargs)
421 {
422 PyObject *return_value = NULL;
423 PyObject *sizeobj = Py_None;
424
425 if (!_PyArg_CheckPositional("readline", nargs, 0, 1)) {
426 goto exit;
427 }
428 if (nargs < 1) {
429 goto skip_optional;
430 }
431 sizeobj = args[0];
432 skip_optional:
433 return_value = _multibytecodec_MultibyteStreamReader_readline_impl(self, sizeobj);
434
435 exit:
436 return return_value;
437 }
438
439 PyDoc_STRVAR(_multibytecodec_MultibyteStreamReader_readlines__doc__,
440 "readlines($self, sizehintobj=None, /)\n"
441 "--\n"
442 "\n");
443
444 #define _MULTIBYTECODEC_MULTIBYTESTREAMREADER_READLINES_METHODDEF \
445 {"readlines", (PyCFunction)(void(*)(void))_multibytecodec_MultibyteStreamReader_readlines, METH_FASTCALL, _multibytecodec_MultibyteStreamReader_readlines__doc__},
446
447 static PyObject *
448 _multibytecodec_MultibyteStreamReader_readlines_impl(MultibyteStreamReaderObject *self,
449 PyObject *sizehintobj);
450
451 static PyObject *
_multibytecodec_MultibyteStreamReader_readlines(MultibyteStreamReaderObject * self,PyObject * const * args,Py_ssize_t nargs)452 _multibytecodec_MultibyteStreamReader_readlines(MultibyteStreamReaderObject *self, PyObject *const *args, Py_ssize_t nargs)
453 {
454 PyObject *return_value = NULL;
455 PyObject *sizehintobj = Py_None;
456
457 if (!_PyArg_CheckPositional("readlines", nargs, 0, 1)) {
458 goto exit;
459 }
460 if (nargs < 1) {
461 goto skip_optional;
462 }
463 sizehintobj = args[0];
464 skip_optional:
465 return_value = _multibytecodec_MultibyteStreamReader_readlines_impl(self, sizehintobj);
466
467 exit:
468 return return_value;
469 }
470
471 PyDoc_STRVAR(_multibytecodec_MultibyteStreamReader_reset__doc__,
472 "reset($self, /)\n"
473 "--\n"
474 "\n");
475
476 #define _MULTIBYTECODEC_MULTIBYTESTREAMREADER_RESET_METHODDEF \
477 {"reset", (PyCFunction)_multibytecodec_MultibyteStreamReader_reset, METH_NOARGS, _multibytecodec_MultibyteStreamReader_reset__doc__},
478
479 static PyObject *
480 _multibytecodec_MultibyteStreamReader_reset_impl(MultibyteStreamReaderObject *self);
481
482 static PyObject *
_multibytecodec_MultibyteStreamReader_reset(MultibyteStreamReaderObject * self,PyObject * Py_UNUSED (ignored))483 _multibytecodec_MultibyteStreamReader_reset(MultibyteStreamReaderObject *self, PyObject *Py_UNUSED(ignored))
484 {
485 return _multibytecodec_MultibyteStreamReader_reset_impl(self);
486 }
487
488 PyDoc_STRVAR(_multibytecodec_MultibyteStreamWriter_write__doc__,
489 "write($self, strobj, /)\n"
490 "--\n"
491 "\n");
492
493 #define _MULTIBYTECODEC_MULTIBYTESTREAMWRITER_WRITE_METHODDEF \
494 {"write", (PyCFunction)_multibytecodec_MultibyteStreamWriter_write, METH_O, _multibytecodec_MultibyteStreamWriter_write__doc__},
495
496 PyDoc_STRVAR(_multibytecodec_MultibyteStreamWriter_writelines__doc__,
497 "writelines($self, lines, /)\n"
498 "--\n"
499 "\n");
500
501 #define _MULTIBYTECODEC_MULTIBYTESTREAMWRITER_WRITELINES_METHODDEF \
502 {"writelines", (PyCFunction)_multibytecodec_MultibyteStreamWriter_writelines, METH_O, _multibytecodec_MultibyteStreamWriter_writelines__doc__},
503
504 PyDoc_STRVAR(_multibytecodec_MultibyteStreamWriter_reset__doc__,
505 "reset($self, /)\n"
506 "--\n"
507 "\n");
508
509 #define _MULTIBYTECODEC_MULTIBYTESTREAMWRITER_RESET_METHODDEF \
510 {"reset", (PyCFunction)_multibytecodec_MultibyteStreamWriter_reset, METH_NOARGS, _multibytecodec_MultibyteStreamWriter_reset__doc__},
511
512 static PyObject *
513 _multibytecodec_MultibyteStreamWriter_reset_impl(MultibyteStreamWriterObject *self);
514
515 static PyObject *
_multibytecodec_MultibyteStreamWriter_reset(MultibyteStreamWriterObject * self,PyObject * Py_UNUSED (ignored))516 _multibytecodec_MultibyteStreamWriter_reset(MultibyteStreamWriterObject *self, PyObject *Py_UNUSED(ignored))
517 {
518 return _multibytecodec_MultibyteStreamWriter_reset_impl(self);
519 }
520
521 PyDoc_STRVAR(_multibytecodec___create_codec__doc__,
522 "__create_codec($module, arg, /)\n"
523 "--\n"
524 "\n");
525
526 #define _MULTIBYTECODEC___CREATE_CODEC_METHODDEF \
527 {"__create_codec", (PyCFunction)_multibytecodec___create_codec, METH_O, _multibytecodec___create_codec__doc__},
528 /*[clinic end generated code: output=5ce6fd4ca1f95620 input=a9049054013a1b77]*/
529