Branch data Line data Source code
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 : 1234956 : _multibytecodec_MultibyteCodec_encode(MultibyteCodecObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
26 : : {
27 : 1234956 : 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 [ - + ]: 1234956 : Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
32 : : PyObject *input;
33 : 1234956 : const char *errors = NULL;
34 : :
35 [ + - + + : 1234956 : args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 2, 0, argsbuf);
+ - - + ]
36 [ + + ]: 1234956 : if (!args) {
37 : 24 : goto exit;
38 : : }
39 : 1234932 : input = args[0];
40 [ + + ]: 1234932 : if (!noptargs) {
41 : 186077 : goto skip_optional_pos;
42 : : }
43 [ - + ]: 1048855 : if (args[1] == Py_None) {
44 : 0 : errors = NULL;
45 : : }
46 [ + - ]: 1048855 : else if (PyUnicode_Check(args[1])) {
47 : : Py_ssize_t errors_length;
48 : 1048855 : errors = PyUnicode_AsUTF8AndSize(args[1], &errors_length);
49 [ - + ]: 1048855 : if (errors == NULL) {
50 : 0 : goto exit;
51 : : }
52 [ - + ]: 1048855 : if (strlen(errors) != (size_t)errors_length) {
53 : 0 : PyErr_SetString(PyExc_ValueError, "embedded null character");
54 : 0 : goto exit;
55 : : }
56 : : }
57 : : else {
58 : 0 : _PyArg_BadArgument("encode", "argument 'errors'", "str or None", args[1]);
59 : 0 : goto exit;
60 : : }
61 : 1234932 : skip_optional_pos:
62 : 1234932 : return_value = _multibytecodec_MultibyteCodec_encode_impl(self, input, errors);
63 : :
64 : 1234956 : exit:
65 : 1234956 : 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 : 186096 : _multibytecodec_MultibyteCodec_decode(MultibyteCodecObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
89 : : {
90 : 186096 : 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 [ - + ]: 186096 : Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
95 : 186096 : Py_buffer input = {NULL, NULL};
96 : 186096 : const char *errors = NULL;
97 : :
98 [ + - + + : 186096 : args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 2, 0, argsbuf);
+ - - + ]
99 [ + + ]: 186096 : if (!args) {
100 : 24 : goto exit;
101 : : }
102 [ + + ]: 186072 : if (PyObject_GetBuffer(args[0], &input, PyBUF_SIMPLE) != 0) {
103 : 48 : goto exit;
104 : : }
105 [ - + ]: 186024 : if (!PyBuffer_IsContiguous(&input, 'C')) {
106 : 0 : _PyArg_BadArgument("decode", "argument 'input'", "contiguous buffer", args[0]);
107 : 0 : goto exit;
108 : : }
109 [ + + ]: 186024 : if (!noptargs) {
110 : 185810 : goto skip_optional_pos;
111 : : }
112 [ - + ]: 214 : if (args[1] == Py_None) {
113 : 0 : errors = NULL;
114 : : }
115 [ + - ]: 214 : else if (PyUnicode_Check(args[1])) {
116 : : Py_ssize_t errors_length;
117 : 214 : errors = PyUnicode_AsUTF8AndSize(args[1], &errors_length);
118 [ - + ]: 214 : if (errors == NULL) {
119 : 0 : goto exit;
120 : : }
121 [ - + ]: 214 : if (strlen(errors) != (size_t)errors_length) {
122 : 0 : PyErr_SetString(PyExc_ValueError, "embedded null character");
123 : 0 : goto exit;
124 : : }
125 : : }
126 : : else {
127 : 0 : _PyArg_BadArgument("decode", "argument 'errors'", "str or None", args[1]);
128 : 0 : goto exit;
129 : : }
130 : 186024 : skip_optional_pos:
131 : 186024 : return_value = _multibytecodec_MultibyteCodec_decode_impl(self, &input, errors);
132 : :
133 : 186096 : exit:
134 : : /* Cleanup for input */
135 [ + + ]: 186096 : if (input.obj) {
136 : 186024 : PyBuffer_Release(&input);
137 : : }
138 : :
139 : 186096 : 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 : 27427 : _multibytecodec_MultibyteIncrementalEncoder_encode(MultibyteIncrementalEncoderObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
157 : : {
158 : 27427 : 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 [ + + ]: 27427 : Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
163 : : PyObject *input;
164 : 27427 : int final = 0;
165 : :
166 [ + + + - : 27427 : args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 2, 0, argsbuf);
+ - - + ]
167 [ - + ]: 27427 : if (!args) {
168 : 0 : goto exit;
169 : : }
170 : 27427 : input = args[0];
171 [ + + ]: 27427 : if (!noptargs) {
172 : 27070 : goto skip_optional_pos;
173 : : }
174 : 357 : final = _PyLong_AsInt(args[1]);
175 [ - + - - ]: 357 : if (final == -1 && PyErr_Occurred()) {
176 : 0 : goto exit;
177 : : }
178 : 357 : skip_optional_pos:
179 : 27427 : return_value = _multibytecodec_MultibyteIncrementalEncoder_encode_impl(self, input, final);
180 : :
181 : 27427 : exit:
182 : 27427 : 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 : 177 : _multibytecodec_MultibyteIncrementalEncoder_getstate(MultibyteIncrementalEncoderObject *self, PyObject *Py_UNUSED(ignored))
198 : : {
199 : 177 : 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 : 177 : _multibytecodec_MultibyteIncrementalEncoder_setstate(MultibyteIncrementalEncoderObject *self, PyObject *arg)
216 : : {
217 : 177 : PyObject *return_value = NULL;
218 : : PyLongObject *statelong;
219 : :
220 [ - + ]: 177 : if (!PyLong_Check(arg)) {
221 : 0 : _PyArg_BadArgument("setstate", "argument", "int", arg);
222 : 0 : goto exit;
223 : : }
224 : 177 : statelong = (PyLongObject *)arg;
225 : 177 : return_value = _multibytecodec_MultibyteIncrementalEncoder_setstate_impl(self, statelong);
226 : :
227 : 177 : exit:
228 : 177 : 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 : 24 : _multibytecodec_MultibyteIncrementalEncoder_reset(MultibyteIncrementalEncoderObject *self, PyObject *Py_UNUSED(ignored))
244 : : {
245 : 24 : 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 : 47813 : _multibytecodec_MultibyteIncrementalDecoder_decode(MultibyteIncrementalDecoderObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
263 : : {
264 : 47813 : 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 [ + + ]: 47813 : Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
269 : 47813 : Py_buffer input = {NULL, NULL};
270 : 47813 : int final = 0;
271 : :
272 [ + + + - : 47813 : args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 2, 0, argsbuf);
+ - - + ]
273 [ - + ]: 47813 : if (!args) {
274 : 0 : goto exit;
275 : : }
276 [ + + ]: 47813 : if (PyObject_GetBuffer(args[0], &input, PyBUF_SIMPLE) != 0) {
277 : 24 : goto exit;
278 : : }
279 [ - + ]: 47789 : if (!PyBuffer_IsContiguous(&input, 'C')) {
280 : 0 : _PyArg_BadArgument("decode", "argument 'input'", "contiguous buffer", args[0]);
281 : 0 : goto exit;
282 : : }
283 [ + + ]: 47789 : if (!noptargs) {
284 : 47489 : goto skip_optional_pos;
285 : : }
286 : 300 : final = _PyLong_AsInt(args[1]);
287 [ - + - - ]: 300 : if (final == -1 && PyErr_Occurred()) {
288 : 0 : goto exit;
289 : : }
290 : 300 : skip_optional_pos:
291 : 47789 : return_value = _multibytecodec_MultibyteIncrementalDecoder_decode_impl(self, &input, final);
292 : :
293 : 47813 : exit:
294 : : /* Cleanup for input */
295 [ + + ]: 47813 : if (input.obj) {
296 : 47789 : PyBuffer_Release(&input);
297 : : }
298 : :
299 : 47813 : 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 : 329 : _multibytecodec_MultibyteIncrementalDecoder_getstate(MultibyteIncrementalDecoderObject *self, PyObject *Py_UNUSED(ignored))
315 : : {
316 : 329 : 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 : 306 : _multibytecodec_MultibyteIncrementalDecoder_setstate(MultibyteIncrementalDecoderObject *self, PyObject *arg)
333 : : {
334 : 306 : PyObject *return_value = NULL;
335 : : PyObject *state;
336 : :
337 [ + + ]: 306 : if (!PyTuple_Check(arg)) {
338 : 1 : _PyArg_BadArgument("setstate", "argument", "tuple", arg);
339 : 1 : goto exit;
340 : : }
341 : 305 : state = arg;
342 : 305 : return_value = _multibytecodec_MultibyteIncrementalDecoder_setstate_impl(self, state);
343 : :
344 : 306 : exit:
345 : 306 : 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 : 4 : _multibytecodec_MultibyteIncrementalDecoder_reset(MultibyteIncrementalDecoderObject *self, PyObject *Py_UNUSED(ignored))
361 : : {
362 : 4 : 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 : 42296 : _multibytecodec_MultibyteStreamReader_read(MultibyteStreamReaderObject *self, PyObject *const *args, Py_ssize_t nargs)
379 : : {
380 : 42296 : PyObject *return_value = NULL;
381 : 42296 : PyObject *sizeobj = Py_None;
382 : :
383 [ + - - + : 42296 : if (!_PyArg_CheckPositional("read", nargs, 0, 1)) {
- - ]
384 : 0 : goto exit;
385 : : }
386 [ + + ]: 42296 : if (nargs < 1) {
387 : 264 : goto skip_optional;
388 : : }
389 : 42032 : sizeobj = args[0];
390 : 42296 : skip_optional:
391 : 42296 : return_value = _multibytecodec_MultibyteStreamReader_read_impl(self, sizeobj);
392 : :
393 : 42296 : exit:
394 : 42296 : 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 : 44831 : _multibytecodec_MultibyteStreamReader_readline(MultibyteStreamReaderObject *self, PyObject *const *args, Py_ssize_t nargs)
411 : : {
412 : 44831 : PyObject *return_value = NULL;
413 : 44831 : PyObject *sizeobj = Py_None;
414 : :
415 [ + - - + : 44831 : if (!_PyArg_CheckPositional("readline", nargs, 0, 1)) {
- - ]
416 : 0 : goto exit;
417 : : }
418 [ - + ]: 44831 : if (nargs < 1) {
419 : 0 : goto skip_optional;
420 : : }
421 : 44831 : sizeobj = args[0];
422 : 44831 : skip_optional:
423 : 44831 : return_value = _multibytecodec_MultibyteStreamReader_readline_impl(self, sizeobj);
424 : :
425 : 44831 : exit:
426 : 44831 : 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 : 42031 : _multibytecodec_MultibyteStreamReader_readlines(MultibyteStreamReaderObject *self, PyObject *const *args, Py_ssize_t nargs)
443 : : {
444 : 42031 : PyObject *return_value = NULL;
445 : 42031 : PyObject *sizehintobj = Py_None;
446 : :
447 [ + - - + : 42031 : if (!_PyArg_CheckPositional("readlines", nargs, 0, 1)) {
- - ]
448 : 0 : goto exit;
449 : : }
450 [ - + ]: 42031 : if (nargs < 1) {
451 : 0 : goto skip_optional;
452 : : }
453 : 42031 : sizehintobj = args[0];
454 : 42031 : skip_optional:
455 : 42031 : return_value = _multibytecodec_MultibyteStreamReader_readlines_impl(self, sizehintobj);
456 : :
457 : 42031 : exit:
458 : 42031 : 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 : 120 : _multibytecodec_MultibyteStreamReader_reset(MultibyteStreamReaderObject *self, PyObject *Py_UNUSED(ignored))
474 : : {
475 : 120 : 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 : 55150 : _multibytecodec_MultibyteStreamWriter_write(MultibyteStreamWriterObject *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
493 : : {
494 : 55150 : 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 [ + - + - : 55150 : args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, argsbuf);
+ - - + ]
501 [ - + ]: 55150 : if (!args) {
502 : 0 : goto exit;
503 : : }
504 : 55150 : strobj = args[0];
505 : 55150 : return_value = _multibytecodec_MultibyteStreamWriter_write_impl(self, cls, strobj);
506 : :
507 : 55150 : exit:
508 : 55150 : 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 : 722 : _multibytecodec_MultibyteStreamWriter_writelines(MultibyteStreamWriterObject *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
526 : : {
527 : 722 : 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 [ + - + - : 722 : args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, argsbuf);
+ - - + ]
534 [ - + ]: 722 : if (!args) {
535 : 0 : goto exit;
536 : : }
537 : 722 : lines = args[0];
538 : 722 : return_value = _multibytecodec_MultibyteStreamWriter_writelines_impl(self, cls, lines);
539 : :
540 : 722 : exit:
541 : 722 : 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 : 19 : _multibytecodec_MultibyteStreamWriter_reset(MultibyteStreamWriterObject *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
558 : : {
559 [ - + ]: 19 : if (nargs) {
560 : 0 : PyErr_SetString(PyExc_TypeError, "reset() takes no arguments");
561 : 0 : return NULL;
562 : : }
563 : 19 : 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]*/
|
