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_CAST(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_CAST(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_CAST(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_CAST(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_CAST(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_CAST(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_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_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=78d7a7ae57014502 input=a9049054013a1b77]*/