Debian Codegraph @

Modules/cjkcodecs/clinic/multibytecodec.c.h

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