1 | /*[clinic input] |
2 | preserve |
3 | [clinic start generated code]*/ |
4 | |
5 | PyDoc_STRVAR(unicodedata_UCD_decimal__doc__, |
6 | "decimal($self, chr, default=<unrepresentable>, /)\n" |
7 | "--\n" |
8 | "\n" |
9 | "Converts a Unicode character into its equivalent decimal value.\n" |
10 | "\n" |
11 | "Returns the decimal value assigned to the character chr as integer.\n" |
12 | "If no such value is defined, default is returned, or, if not given,\n" |
13 | "ValueError is raised." ); |
14 | |
15 | #define UNICODEDATA_UCD_DECIMAL_METHODDEF \ |
16 | {"decimal", (PyCFunction)(void(*)(void))unicodedata_UCD_decimal, METH_FASTCALL, unicodedata_UCD_decimal__doc__}, |
17 | |
18 | static PyObject * |
19 | unicodedata_UCD_decimal_impl(PyObject *self, int chr, |
20 | PyObject *default_value); |
21 | |
22 | static PyObject * |
23 | unicodedata_UCD_decimal(PyObject *self, PyObject *const *args, Py_ssize_t nargs) |
24 | { |
25 | PyObject *return_value = NULL; |
26 | int chr; |
27 | PyObject *default_value = NULL; |
28 | |
29 | if (!_PyArg_CheckPositional("decimal" , nargs, 1, 2)) { |
30 | goto exit; |
31 | } |
32 | if (!PyUnicode_Check(args[0])) { |
33 | _PyArg_BadArgument("decimal" , "argument 1" , "a unicode character" , args[0]); |
34 | goto exit; |
35 | } |
36 | if (PyUnicode_READY(args[0])) { |
37 | goto exit; |
38 | } |
39 | if (PyUnicode_GET_LENGTH(args[0]) != 1) { |
40 | _PyArg_BadArgument("decimal" , "argument 1" , "a unicode character" , args[0]); |
41 | goto exit; |
42 | } |
43 | chr = PyUnicode_READ_CHAR(args[0], 0); |
44 | if (nargs < 2) { |
45 | goto skip_optional; |
46 | } |
47 | default_value = args[1]; |
48 | skip_optional: |
49 | return_value = unicodedata_UCD_decimal_impl(self, chr, default_value); |
50 | |
51 | exit: |
52 | return return_value; |
53 | } |
54 | |
55 | PyDoc_STRVAR(unicodedata_UCD_digit__doc__, |
56 | "digit($self, chr, default=<unrepresentable>, /)\n" |
57 | "--\n" |
58 | "\n" |
59 | "Converts a Unicode character into its equivalent digit value.\n" |
60 | "\n" |
61 | "Returns the digit value assigned to the character chr as integer.\n" |
62 | "If no such value is defined, default is returned, or, if not given,\n" |
63 | "ValueError is raised." ); |
64 | |
65 | #define UNICODEDATA_UCD_DIGIT_METHODDEF \ |
66 | {"digit", (PyCFunction)(void(*)(void))unicodedata_UCD_digit, METH_FASTCALL, unicodedata_UCD_digit__doc__}, |
67 | |
68 | static PyObject * |
69 | unicodedata_UCD_digit_impl(PyObject *self, int chr, PyObject *default_value); |
70 | |
71 | static PyObject * |
72 | unicodedata_UCD_digit(PyObject *self, PyObject *const *args, Py_ssize_t nargs) |
73 | { |
74 | PyObject *return_value = NULL; |
75 | int chr; |
76 | PyObject *default_value = NULL; |
77 | |
78 | if (!_PyArg_CheckPositional("digit" , nargs, 1, 2)) { |
79 | goto exit; |
80 | } |
81 | if (!PyUnicode_Check(args[0])) { |
82 | _PyArg_BadArgument("digit" , "argument 1" , "a unicode character" , args[0]); |
83 | goto exit; |
84 | } |
85 | if (PyUnicode_READY(args[0])) { |
86 | goto exit; |
87 | } |
88 | if (PyUnicode_GET_LENGTH(args[0]) != 1) { |
89 | _PyArg_BadArgument("digit" , "argument 1" , "a unicode character" , args[0]); |
90 | goto exit; |
91 | } |
92 | chr = PyUnicode_READ_CHAR(args[0], 0); |
93 | if (nargs < 2) { |
94 | goto skip_optional; |
95 | } |
96 | default_value = args[1]; |
97 | skip_optional: |
98 | return_value = unicodedata_UCD_digit_impl(self, chr, default_value); |
99 | |
100 | exit: |
101 | return return_value; |
102 | } |
103 | |
104 | PyDoc_STRVAR(unicodedata_UCD_numeric__doc__, |
105 | "numeric($self, chr, default=<unrepresentable>, /)\n" |
106 | "--\n" |
107 | "\n" |
108 | "Converts a Unicode character into its equivalent numeric value.\n" |
109 | "\n" |
110 | "Returns the numeric value assigned to the character chr as float.\n" |
111 | "If no such value is defined, default is returned, or, if not given,\n" |
112 | "ValueError is raised." ); |
113 | |
114 | #define UNICODEDATA_UCD_NUMERIC_METHODDEF \ |
115 | {"numeric", (PyCFunction)(void(*)(void))unicodedata_UCD_numeric, METH_FASTCALL, unicodedata_UCD_numeric__doc__}, |
116 | |
117 | static PyObject * |
118 | unicodedata_UCD_numeric_impl(PyObject *self, int chr, |
119 | PyObject *default_value); |
120 | |
121 | static PyObject * |
122 | unicodedata_UCD_numeric(PyObject *self, PyObject *const *args, Py_ssize_t nargs) |
123 | { |
124 | PyObject *return_value = NULL; |
125 | int chr; |
126 | PyObject *default_value = NULL; |
127 | |
128 | if (!_PyArg_CheckPositional("numeric" , nargs, 1, 2)) { |
129 | goto exit; |
130 | } |
131 | if (!PyUnicode_Check(args[0])) { |
132 | _PyArg_BadArgument("numeric" , "argument 1" , "a unicode character" , args[0]); |
133 | goto exit; |
134 | } |
135 | if (PyUnicode_READY(args[0])) { |
136 | goto exit; |
137 | } |
138 | if (PyUnicode_GET_LENGTH(args[0]) != 1) { |
139 | _PyArg_BadArgument("numeric" , "argument 1" , "a unicode character" , args[0]); |
140 | goto exit; |
141 | } |
142 | chr = PyUnicode_READ_CHAR(args[0], 0); |
143 | if (nargs < 2) { |
144 | goto skip_optional; |
145 | } |
146 | default_value = args[1]; |
147 | skip_optional: |
148 | return_value = unicodedata_UCD_numeric_impl(self, chr, default_value); |
149 | |
150 | exit: |
151 | return return_value; |
152 | } |
153 | |
154 | PyDoc_STRVAR(unicodedata_UCD_category__doc__, |
155 | "category($self, chr, /)\n" |
156 | "--\n" |
157 | "\n" |
158 | "Returns the general category assigned to the character chr as string." ); |
159 | |
160 | #define UNICODEDATA_UCD_CATEGORY_METHODDEF \ |
161 | {"category", (PyCFunction)unicodedata_UCD_category, METH_O, unicodedata_UCD_category__doc__}, |
162 | |
163 | static PyObject * |
164 | unicodedata_UCD_category_impl(PyObject *self, int chr); |
165 | |
166 | static PyObject * |
167 | unicodedata_UCD_category(PyObject *self, PyObject *arg) |
168 | { |
169 | PyObject *return_value = NULL; |
170 | int chr; |
171 | |
172 | if (!PyUnicode_Check(arg)) { |
173 | _PyArg_BadArgument("category" , "argument" , "a unicode character" , arg); |
174 | goto exit; |
175 | } |
176 | if (PyUnicode_READY(arg)) { |
177 | goto exit; |
178 | } |
179 | if (PyUnicode_GET_LENGTH(arg) != 1) { |
180 | _PyArg_BadArgument("category" , "argument" , "a unicode character" , arg); |
181 | goto exit; |
182 | } |
183 | chr = PyUnicode_READ_CHAR(arg, 0); |
184 | return_value = unicodedata_UCD_category_impl(self, chr); |
185 | |
186 | exit: |
187 | return return_value; |
188 | } |
189 | |
190 | PyDoc_STRVAR(unicodedata_UCD_bidirectional__doc__, |
191 | "bidirectional($self, chr, /)\n" |
192 | "--\n" |
193 | "\n" |
194 | "Returns the bidirectional class assigned to the character chr as string.\n" |
195 | "\n" |
196 | "If no such value is defined, an empty string is returned." ); |
197 | |
198 | #define UNICODEDATA_UCD_BIDIRECTIONAL_METHODDEF \ |
199 | {"bidirectional", (PyCFunction)unicodedata_UCD_bidirectional, METH_O, unicodedata_UCD_bidirectional__doc__}, |
200 | |
201 | static PyObject * |
202 | unicodedata_UCD_bidirectional_impl(PyObject *self, int chr); |
203 | |
204 | static PyObject * |
205 | unicodedata_UCD_bidirectional(PyObject *self, PyObject *arg) |
206 | { |
207 | PyObject *return_value = NULL; |
208 | int chr; |
209 | |
210 | if (!PyUnicode_Check(arg)) { |
211 | _PyArg_BadArgument("bidirectional" , "argument" , "a unicode character" , arg); |
212 | goto exit; |
213 | } |
214 | if (PyUnicode_READY(arg)) { |
215 | goto exit; |
216 | } |
217 | if (PyUnicode_GET_LENGTH(arg) != 1) { |
218 | _PyArg_BadArgument("bidirectional" , "argument" , "a unicode character" , arg); |
219 | goto exit; |
220 | } |
221 | chr = PyUnicode_READ_CHAR(arg, 0); |
222 | return_value = unicodedata_UCD_bidirectional_impl(self, chr); |
223 | |
224 | exit: |
225 | return return_value; |
226 | } |
227 | |
228 | PyDoc_STRVAR(unicodedata_UCD_combining__doc__, |
229 | "combining($self, chr, /)\n" |
230 | "--\n" |
231 | "\n" |
232 | "Returns the canonical combining class assigned to the character chr as integer.\n" |
233 | "\n" |
234 | "Returns 0 if no combining class is defined." ); |
235 | |
236 | #define UNICODEDATA_UCD_COMBINING_METHODDEF \ |
237 | {"combining", (PyCFunction)unicodedata_UCD_combining, METH_O, unicodedata_UCD_combining__doc__}, |
238 | |
239 | static int |
240 | unicodedata_UCD_combining_impl(PyObject *self, int chr); |
241 | |
242 | static PyObject * |
243 | unicodedata_UCD_combining(PyObject *self, PyObject *arg) |
244 | { |
245 | PyObject *return_value = NULL; |
246 | int chr; |
247 | int _return_value; |
248 | |
249 | if (!PyUnicode_Check(arg)) { |
250 | _PyArg_BadArgument("combining" , "argument" , "a unicode character" , arg); |
251 | goto exit; |
252 | } |
253 | if (PyUnicode_READY(arg)) { |
254 | goto exit; |
255 | } |
256 | if (PyUnicode_GET_LENGTH(arg) != 1) { |
257 | _PyArg_BadArgument("combining" , "argument" , "a unicode character" , arg); |
258 | goto exit; |
259 | } |
260 | chr = PyUnicode_READ_CHAR(arg, 0); |
261 | _return_value = unicodedata_UCD_combining_impl(self, chr); |
262 | if ((_return_value == -1) && PyErr_Occurred()) { |
263 | goto exit; |
264 | } |
265 | return_value = PyLong_FromLong((long)_return_value); |
266 | |
267 | exit: |
268 | return return_value; |
269 | } |
270 | |
271 | PyDoc_STRVAR(unicodedata_UCD_mirrored__doc__, |
272 | "mirrored($self, chr, /)\n" |
273 | "--\n" |
274 | "\n" |
275 | "Returns the mirrored property assigned to the character chr as integer.\n" |
276 | "\n" |
277 | "Returns 1 if the character has been identified as a \"mirrored\"\n" |
278 | "character in bidirectional text, 0 otherwise." ); |
279 | |
280 | #define UNICODEDATA_UCD_MIRRORED_METHODDEF \ |
281 | {"mirrored", (PyCFunction)unicodedata_UCD_mirrored, METH_O, unicodedata_UCD_mirrored__doc__}, |
282 | |
283 | static int |
284 | unicodedata_UCD_mirrored_impl(PyObject *self, int chr); |
285 | |
286 | static PyObject * |
287 | unicodedata_UCD_mirrored(PyObject *self, PyObject *arg) |
288 | { |
289 | PyObject *return_value = NULL; |
290 | int chr; |
291 | int _return_value; |
292 | |
293 | if (!PyUnicode_Check(arg)) { |
294 | _PyArg_BadArgument("mirrored" , "argument" , "a unicode character" , arg); |
295 | goto exit; |
296 | } |
297 | if (PyUnicode_READY(arg)) { |
298 | goto exit; |
299 | } |
300 | if (PyUnicode_GET_LENGTH(arg) != 1) { |
301 | _PyArg_BadArgument("mirrored" , "argument" , "a unicode character" , arg); |
302 | goto exit; |
303 | } |
304 | chr = PyUnicode_READ_CHAR(arg, 0); |
305 | _return_value = unicodedata_UCD_mirrored_impl(self, chr); |
306 | if ((_return_value == -1) && PyErr_Occurred()) { |
307 | goto exit; |
308 | } |
309 | return_value = PyLong_FromLong((long)_return_value); |
310 | |
311 | exit: |
312 | return return_value; |
313 | } |
314 | |
315 | PyDoc_STRVAR(unicodedata_UCD_east_asian_width__doc__, |
316 | "east_asian_width($self, chr, /)\n" |
317 | "--\n" |
318 | "\n" |
319 | "Returns the east asian width assigned to the character chr as string." ); |
320 | |
321 | #define UNICODEDATA_UCD_EAST_ASIAN_WIDTH_METHODDEF \ |
322 | {"east_asian_width", (PyCFunction)unicodedata_UCD_east_asian_width, METH_O, unicodedata_UCD_east_asian_width__doc__}, |
323 | |
324 | static PyObject * |
325 | unicodedata_UCD_east_asian_width_impl(PyObject *self, int chr); |
326 | |
327 | static PyObject * |
328 | unicodedata_UCD_east_asian_width(PyObject *self, PyObject *arg) |
329 | { |
330 | PyObject *return_value = NULL; |
331 | int chr; |
332 | |
333 | if (!PyUnicode_Check(arg)) { |
334 | _PyArg_BadArgument("east_asian_width" , "argument" , "a unicode character" , arg); |
335 | goto exit; |
336 | } |
337 | if (PyUnicode_READY(arg)) { |
338 | goto exit; |
339 | } |
340 | if (PyUnicode_GET_LENGTH(arg) != 1) { |
341 | _PyArg_BadArgument("east_asian_width" , "argument" , "a unicode character" , arg); |
342 | goto exit; |
343 | } |
344 | chr = PyUnicode_READ_CHAR(arg, 0); |
345 | return_value = unicodedata_UCD_east_asian_width_impl(self, chr); |
346 | |
347 | exit: |
348 | return return_value; |
349 | } |
350 | |
351 | PyDoc_STRVAR(unicodedata_UCD_decomposition__doc__, |
352 | "decomposition($self, chr, /)\n" |
353 | "--\n" |
354 | "\n" |
355 | "Returns the character decomposition mapping assigned to the character chr as string.\n" |
356 | "\n" |
357 | "An empty string is returned in case no such mapping is defined." ); |
358 | |
359 | #define UNICODEDATA_UCD_DECOMPOSITION_METHODDEF \ |
360 | {"decomposition", (PyCFunction)unicodedata_UCD_decomposition, METH_O, unicodedata_UCD_decomposition__doc__}, |
361 | |
362 | static PyObject * |
363 | unicodedata_UCD_decomposition_impl(PyObject *self, int chr); |
364 | |
365 | static PyObject * |
366 | unicodedata_UCD_decomposition(PyObject *self, PyObject *arg) |
367 | { |
368 | PyObject *return_value = NULL; |
369 | int chr; |
370 | |
371 | if (!PyUnicode_Check(arg)) { |
372 | _PyArg_BadArgument("decomposition" , "argument" , "a unicode character" , arg); |
373 | goto exit; |
374 | } |
375 | if (PyUnicode_READY(arg)) { |
376 | goto exit; |
377 | } |
378 | if (PyUnicode_GET_LENGTH(arg) != 1) { |
379 | _PyArg_BadArgument("decomposition" , "argument" , "a unicode character" , arg); |
380 | goto exit; |
381 | } |
382 | chr = PyUnicode_READ_CHAR(arg, 0); |
383 | return_value = unicodedata_UCD_decomposition_impl(self, chr); |
384 | |
385 | exit: |
386 | return return_value; |
387 | } |
388 | |
389 | PyDoc_STRVAR(unicodedata_UCD_is_normalized__doc__, |
390 | "is_normalized($self, form, unistr, /)\n" |
391 | "--\n" |
392 | "\n" |
393 | "Return whether the Unicode string unistr is in the normal form \'form\'.\n" |
394 | "\n" |
395 | "Valid values for form are \'NFC\', \'NFKC\', \'NFD\', and \'NFKD\'." ); |
396 | |
397 | #define UNICODEDATA_UCD_IS_NORMALIZED_METHODDEF \ |
398 | {"is_normalized", (PyCFunction)(void(*)(void))unicodedata_UCD_is_normalized, METH_FASTCALL, unicodedata_UCD_is_normalized__doc__}, |
399 | |
400 | static PyObject * |
401 | unicodedata_UCD_is_normalized_impl(PyObject *self, PyObject *form, |
402 | PyObject *input); |
403 | |
404 | static PyObject * |
405 | unicodedata_UCD_is_normalized(PyObject *self, PyObject *const *args, Py_ssize_t nargs) |
406 | { |
407 | PyObject *return_value = NULL; |
408 | PyObject *form; |
409 | PyObject *input; |
410 | |
411 | if (!_PyArg_CheckPositional("is_normalized" , nargs, 2, 2)) { |
412 | goto exit; |
413 | } |
414 | if (!PyUnicode_Check(args[0])) { |
415 | _PyArg_BadArgument("is_normalized" , "argument 1" , "str" , args[0]); |
416 | goto exit; |
417 | } |
418 | if (PyUnicode_READY(args[0]) == -1) { |
419 | goto exit; |
420 | } |
421 | form = args[0]; |
422 | if (!PyUnicode_Check(args[1])) { |
423 | _PyArg_BadArgument("is_normalized" , "argument 2" , "str" , args[1]); |
424 | goto exit; |
425 | } |
426 | if (PyUnicode_READY(args[1]) == -1) { |
427 | goto exit; |
428 | } |
429 | input = args[1]; |
430 | return_value = unicodedata_UCD_is_normalized_impl(self, form, input); |
431 | |
432 | exit: |
433 | return return_value; |
434 | } |
435 | |
436 | PyDoc_STRVAR(unicodedata_UCD_normalize__doc__, |
437 | "normalize($self, form, unistr, /)\n" |
438 | "--\n" |
439 | "\n" |
440 | "Return the normal form \'form\' for the Unicode string unistr.\n" |
441 | "\n" |
442 | "Valid values for form are \'NFC\', \'NFKC\', \'NFD\', and \'NFKD\'." ); |
443 | |
444 | #define UNICODEDATA_UCD_NORMALIZE_METHODDEF \ |
445 | {"normalize", (PyCFunction)(void(*)(void))unicodedata_UCD_normalize, METH_FASTCALL, unicodedata_UCD_normalize__doc__}, |
446 | |
447 | static PyObject * |
448 | unicodedata_UCD_normalize_impl(PyObject *self, PyObject *form, |
449 | PyObject *input); |
450 | |
451 | static PyObject * |
452 | unicodedata_UCD_normalize(PyObject *self, PyObject *const *args, Py_ssize_t nargs) |
453 | { |
454 | PyObject *return_value = NULL; |
455 | PyObject *form; |
456 | PyObject *input; |
457 | |
458 | if (!_PyArg_CheckPositional("normalize" , nargs, 2, 2)) { |
459 | goto exit; |
460 | } |
461 | if (!PyUnicode_Check(args[0])) { |
462 | _PyArg_BadArgument("normalize" , "argument 1" , "str" , args[0]); |
463 | goto exit; |
464 | } |
465 | if (PyUnicode_READY(args[0]) == -1) { |
466 | goto exit; |
467 | } |
468 | form = args[0]; |
469 | if (!PyUnicode_Check(args[1])) { |
470 | _PyArg_BadArgument("normalize" , "argument 2" , "str" , args[1]); |
471 | goto exit; |
472 | } |
473 | if (PyUnicode_READY(args[1]) == -1) { |
474 | goto exit; |
475 | } |
476 | input = args[1]; |
477 | return_value = unicodedata_UCD_normalize_impl(self, form, input); |
478 | |
479 | exit: |
480 | return return_value; |
481 | } |
482 | |
483 | PyDoc_STRVAR(unicodedata_UCD_name__doc__, |
484 | "name($self, chr, default=<unrepresentable>, /)\n" |
485 | "--\n" |
486 | "\n" |
487 | "Returns the name assigned to the character chr as a string.\n" |
488 | "\n" |
489 | "If no name is defined, default is returned, or, if not given,\n" |
490 | "ValueError is raised." ); |
491 | |
492 | #define UNICODEDATA_UCD_NAME_METHODDEF \ |
493 | {"name", (PyCFunction)(void(*)(void))unicodedata_UCD_name, METH_FASTCALL, unicodedata_UCD_name__doc__}, |
494 | |
495 | static PyObject * |
496 | unicodedata_UCD_name_impl(PyObject *self, int chr, PyObject *default_value); |
497 | |
498 | static PyObject * |
499 | unicodedata_UCD_name(PyObject *self, PyObject *const *args, Py_ssize_t nargs) |
500 | { |
501 | PyObject *return_value = NULL; |
502 | int chr; |
503 | PyObject *default_value = NULL; |
504 | |
505 | if (!_PyArg_CheckPositional("name" , nargs, 1, 2)) { |
506 | goto exit; |
507 | } |
508 | if (!PyUnicode_Check(args[0])) { |
509 | _PyArg_BadArgument("name" , "argument 1" , "a unicode character" , args[0]); |
510 | goto exit; |
511 | } |
512 | if (PyUnicode_READY(args[0])) { |
513 | goto exit; |
514 | } |
515 | if (PyUnicode_GET_LENGTH(args[0]) != 1) { |
516 | _PyArg_BadArgument("name" , "argument 1" , "a unicode character" , args[0]); |
517 | goto exit; |
518 | } |
519 | chr = PyUnicode_READ_CHAR(args[0], 0); |
520 | if (nargs < 2) { |
521 | goto skip_optional; |
522 | } |
523 | default_value = args[1]; |
524 | skip_optional: |
525 | return_value = unicodedata_UCD_name_impl(self, chr, default_value); |
526 | |
527 | exit: |
528 | return return_value; |
529 | } |
530 | |
531 | PyDoc_STRVAR(unicodedata_UCD_lookup__doc__, |
532 | "lookup($self, name, /)\n" |
533 | "--\n" |
534 | "\n" |
535 | "Look up character by name.\n" |
536 | "\n" |
537 | "If a character with the given name is found, return the\n" |
538 | "corresponding character. If not found, KeyError is raised." ); |
539 | |
540 | #define UNICODEDATA_UCD_LOOKUP_METHODDEF \ |
541 | {"lookup", (PyCFunction)unicodedata_UCD_lookup, METH_O, unicodedata_UCD_lookup__doc__}, |
542 | |
543 | static PyObject * |
544 | unicodedata_UCD_lookup_impl(PyObject *self, const char *name, |
545 | Py_ssize_clean_t name_length); |
546 | |
547 | static PyObject * |
548 | unicodedata_UCD_lookup(PyObject *self, PyObject *arg) |
549 | { |
550 | PyObject *return_value = NULL; |
551 | const char *name; |
552 | Py_ssize_clean_t name_length; |
553 | |
554 | if (!PyArg_Parse(arg, "s#:lookup" , &name, &name_length)) { |
555 | goto exit; |
556 | } |
557 | return_value = unicodedata_UCD_lookup_impl(self, name, name_length); |
558 | |
559 | exit: |
560 | return return_value; |
561 | } |
562 | /*[clinic end generated code: output=10c23477dbe8a202 input=a9049054013a1b77]*/ |
563 | |