PyICU-1.9.5/0000755000076500000000000000000013011413477012663 5ustar vajdawheel00000000000000PyICU-1.9.5/_icu.cpp0000644000076500000000000002315413007152510014304 0ustar vajdawheel00000000000000/* ==================================================================== * Copyright (c) 2004-2015 Open Source Applications Foundation. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. * ==================================================================== */ #include #include "structmember.h" #include "common.h" #include "errors.h" #include "bases.h" #include "locale.h" #include "transliterator.h" #include "iterators.h" #include "format.h" #include "dateformat.h" #include "numberformat.h" #include "calendar.h" #include "collator.h" #include "charset.h" #include "tzinfo.h" #include "unicodeset.h" #include "regex.h" #include "normalizer.h" #include "search.h" #if U_ICU_VERSION_HEX < VERSION_HEX(58, 0, 0) #include "layoutengine.h" #endif #include "script.h" #include "spoof.h" #include "idna.h" #include "char.h" #include "shape.h" /* const variable descriptor */ class t_descriptor { public: PyObject_HEAD int flags; union { PyObject *value; PyObject *(*get)(PyObject *); } access; }; #define DESCRIPTOR_STATIC 0x1 static void t_descriptor_dealloc(t_descriptor *self); static PyObject *t_descriptor___get__(t_descriptor *self, PyObject *obj, PyObject *type); static PyMemberDef t_descriptor_members[] = { { NULL, 0, 0, 0, NULL } }; static PyMethodDef t_descriptor_methods[] = { { NULL, NULL, 0, NULL } }; PyTypeObject ConstVariableDescriptorType = { PyVarObject_HEAD_INIT(NULL, 0) "icu.ConstVariableDescriptor", /* tp_name */ sizeof(t_descriptor), /* tp_basicsize */ 0, /* tp_itemsize */ (destructor)t_descriptor_dealloc, /* tp_dealloc */ 0, /* tp_print */ 0, /* tp_getattr */ 0, /* tp_setattr */ 0, /* tp_compare */ 0, /* tp_repr */ 0, /* tp_as_number */ 0, /* tp_as_sequence */ 0, /* tp_as_mapping */ 0, /* tp_hash */ 0, /* tp_call */ 0, /* tp_str */ 0, /* tp_getattro */ 0, /* tp_setattro */ 0, /* tp_as_buffer */ Py_TPFLAGS_DEFAULT, /* tp_flags */ "const variable descriptor", /* tp_doc */ 0, /* tp_traverse */ 0, /* tp_clear */ 0, /* tp_richcompare */ 0, /* tp_weaklistoffset */ 0, /* tp_iter */ 0, /* tp_iternext */ t_descriptor_methods, /* tp_methods */ t_descriptor_members, /* tp_members */ 0, /* tp_getset */ 0, /* tp_base */ 0, /* tp_dict */ (descrgetfunc)t_descriptor___get__, /* tp_descr_get */ 0, /* tp_descr_set */ 0, /* tp_dictoffset */ 0, /* tp_init */ 0, /* tp_alloc */ 0, /* tp_new */ }; static void t_descriptor_dealloc(t_descriptor *self) { if (self->flags & DESCRIPTOR_STATIC) { Py_DECREF(self->access.value); } Py_TYPE(self)->tp_free((PyObject *) self); } PyObject *make_descriptor(PyObject *value) { t_descriptor *self = (t_descriptor *) ConstVariableDescriptorType.tp_alloc(&ConstVariableDescriptorType, 0); if (self) { self->access.value = value; self->flags = DESCRIPTOR_STATIC; } else Py_DECREF(value); return (PyObject *) self; } PyObject *make_descriptor(PyTypeObject *value) { t_descriptor *self = (t_descriptor *) ConstVariableDescriptorType.tp_alloc(&ConstVariableDescriptorType, 0); if (self) { Py_INCREF(value); self->access.value = (PyObject *) value; self->flags = DESCRIPTOR_STATIC; } return (PyObject *) self; } PyObject *make_descriptor(PyObject *(*get)(PyObject *)) { t_descriptor *self = (t_descriptor *) ConstVariableDescriptorType.tp_alloc(&ConstVariableDescriptorType, 0); if (self) { self->access.get = get; self->flags = 0; } return (PyObject *) self; } static PyObject *t_descriptor___get__(t_descriptor *self, PyObject *obj, PyObject *type) { if (self->flags & DESCRIPTOR_STATIC) { Py_INCREF(self->access.value); return self->access.value; } else if (obj == NULL || obj == Py_None) { Py_INCREF(self); return (PyObject *) self; } return self->access.get(obj); } static PyTypeObject *_method_type; static PyObject *_install__doc__(PyObject *self, PyObject *args) { #ifndef PYPY_VERSION PyObject *object; char *doc; if (!PyArg_ParseTuple(args, "Os", &object, &doc)) return NULL; /* constructors */ if (PyObject_TypeCheck(object, &PyWrapperDescr_Type)) { ((PyWrapperDescrObject *) object)->d_base->doc = strdup(doc); Py_RETURN_NONE; } /* methods */ if (PyObject_TypeCheck(object, _method_type)) { ((PyMethodDescrObject *) object)->d_method->ml_doc = strdup(doc); Py_RETURN_NONE; } /* class methods */ if (PyObject_TypeCheck(object, &PyCFunction_Type)) { ((PyCFunctionObject *) object)->m_ml->ml_doc = strdup(doc); Py_RETURN_NONE; } /* classes */ if (PyType_Check(object)) { object->ob_type->tp_doc = strdup(doc); Py_RETURN_NONE; } PyErr_SetObject(PyExc_TypeError, object); return NULL; #else Py_RETURN_NONE; #endif } static PyMethodDef _icu_funcs[] = { { "_install__doc__", (PyCFunction) _install__doc__, METH_VARARGS, "install immutable doc strings from python" }, { NULL, NULL, 0, NULL } }; static PyObject *PyInit_icu(PyObject *m) { PyObject *ver; PyType_Ready(&ConstVariableDescriptorType); Py_INCREF(&ConstVariableDescriptorType); ver = PyString_FromString(PYICU_VER); PyObject_SetAttrString(m, "VERSION", ver); Py_DECREF(ver); ver = PyString_FromString(U_ICU_VERSION); PyObject_SetAttrString(m, "ICU_VERSION", ver); Py_DECREF(ver); ver = PyString_FromString(U_UNICODE_VERSION); PyObject_SetAttrString(m, "UNICODE_VERSION", ver); Py_DECREF(ver); PyObject *module = PyImport_ImportModule("icu"); if (!module) { if (!PyErr_Occurred()) PyErr_SetString(PyExc_ImportError, "icu"); return NULL; } PyExc_ICUError = PyObject_GetAttrString(module, "ICUError"); PyExc_InvalidArgsError = PyObject_GetAttrString(module, "InvalidArgsError"); Py_DECREF(module); _init_common(m); _init_errors(m); _init_bases(m); _init_locale(m); _init_transliterator(m); _init_iterators(m); _init_format(m); _init_dateformat(m); _init_numberformat(m); _init_calendar(m); _init_collator(m); _init_charset(m); _init_tzinfo(m); _init_unicodeset(m); _init_regex(m); _init_normalizer(m); _init_search(m); #if U_ICU_VERSION_HEX < VERSION_HEX(58, 0, 0) _init_layoutengine(m); #endif _init_script(m); _init_spoof(m); _init_idna(m); _init_char(m); _init_shape(m); PyObject *method = PyObject_GetAttrString((PyObject *) &UObjectType_, "getDynamicClassID"); _method_type = method->ob_type; Py_DECREF(method); if (PyErr_Occurred()) return NULL; return m; } #if PY_MAJOR_VERSION >= 3 /* TODO: Properly implement http://www.python.org/dev/peps/pep-3121/ */ static struct PyModuleDef moduledef = { PyModuleDef_HEAD_INIT, /* m_name */ "_icu", /* m_doc */ "PyICU extension module", /* m_size */ -1, /* m_methods */ _icu_funcs, /* m_reload */ NULL, /* m_clear */ NULL, /* m_free */ NULL, }; extern "C" { PyMODINIT_FUNC PyInit__icu(void) { PyObject *m = PyModule_Create(&moduledef); return PyInit_icu(m); } } #else extern "C" { void init_icu(void) { PyObject *m = Py_InitModule3("_icu", _icu_funcs, "_icu"); PyInit_icu(m); } } #endif PyICU-1.9.5/bases.cpp0000644000076500000000000022272712724422237014504 0ustar vajdawheel00000000000000/* ==================================================================== * Copyright (c) 2004-2015 Open Source Applications Foundation. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. * ==================================================================== */ #include "common.h" #include "structmember.h" #include "bases.h" #include "locale.h" #include "iterators.h" #include "macros.h" /* UObject */ static PyObject *t_uobject_new(PyTypeObject *type, PyObject *args, PyObject *kwds); static PyObject *t_uobject_richcmp(t_uobject *, PyObject *o2, int op); static PyObject *t_uobject_str(t_uobject *self); static PyObject *t_uobject_repr(t_uobject *self); static PyObject *t_uobject_getDynamicClassID(t_uobject *self); static PyObject *t_uobject__getOwned(t_uobject *self, void *data); static PyMemberDef t_uobject_members[] = { { NULL, 0, 0, 0, NULL } }; static PyMethodDef t_uobject_methods[] = { DECLARE_METHOD(t_uobject, getDynamicClassID, METH_NOARGS), { NULL, NULL, 0, NULL } }; static PyGetSetDef t_uobject_properties[] = { { (char *) "owned", (getter) t_uobject__getOwned, NULL, (char *) "", NULL }, { NULL, NULL, NULL, NULL, NULL } }; PyTypeObject UObjectType_ = { PyVarObject_HEAD_INIT(NULL, 0) "icu.UObject", /* tp_name */ sizeof(t_uobject), /* tp_basicsize */ 0, /* tp_itemsize */ (destructor)t_uobject_dealloc, /* tp_dealloc */ 0, /* tp_print */ 0, /* tp_getattr */ 0, /* tp_setattr */ 0, /* tp_compare */ (reprfunc)t_uobject_repr, /* tp_repr */ 0, /* tp_as_number */ 0, /* tp_as_sequence */ 0, /* tp_as_mapping */ 0, /* tp_hash */ 0, /* tp_call */ (reprfunc)t_uobject_str, /* tp_str */ 0, /* tp_getattro */ 0, /* tp_setattro */ 0, /* tp_as_buffer */ (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE), /* tp_flags */ "t_uobject objects", /* tp_doc */ 0, /* tp_traverse */ 0, /* tp_clear */ (richcmpfunc)t_uobject_richcmp, /* tp_richcompare */ 0, /* tp_weaklistoffset */ 0, /* tp_iter */ 0, /* tp_iternext */ t_uobject_methods, /* tp_methods */ t_uobject_members, /* tp_members */ t_uobject_properties, /* tp_getset */ 0, /* tp_base */ 0, /* tp_dict */ 0, /* tp_descr_get */ 0, /* tp_descr_set */ 0, /* tp_dictoffset */ (initproc)abstract_init, /* tp_init */ 0, /* tp_alloc */ (newfunc)t_uobject_new, /* tp_new */ }; PyObject *wrap_UObject(UObject *object, int flags) { if (object) { if (ISINSTANCE(object, UnicodeString)) return PyUnicode_FromUnicodeString((UnicodeString *) object); t_uobject *self = (t_uobject *) UObjectType_.tp_alloc(&UObjectType_, 0); if (self) { self->object = object; self->flags = flags; } return (PyObject *) self; } Py_RETURN_NONE; } static PyObject *t_uobject__getOwned(t_uobject *self, void *data) { int b = self->flags & T_OWNED; Py_RETURN_BOOL(b); } /* Replaceable */ class t_replaceable : public _wrapper { public: Replaceable *object; }; static PyObject *t_replaceable_length(t_replaceable *self); static PyObject *t_replaceable_charAt(t_replaceable *self, PyObject *arg); static PyObject *t_replaceable_char32At(t_replaceable *self, PyObject *arg); static PyObject *t_replaceable_hasMetaData(t_replaceable *self); static PyMethodDef t_replaceable_methods[] = { DECLARE_METHOD(t_replaceable, length, METH_NOARGS), DECLARE_METHOD(t_replaceable, charAt, METH_O), DECLARE_METHOD(t_replaceable, char32At, METH_O), DECLARE_METHOD(t_replaceable, hasMetaData, METH_NOARGS), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(Replaceable, t_replaceable, UObject, Replaceable, abstract_init, NULL); /* UnicodeString */ class t_unicodestring : public _wrapper { public: UnicodeString *object; }; static int t_unicodestring_init(t_unicodestring *self, PyObject *args, PyObject *kwds); static PyObject *t_unicodestring_getAvailableStandards(PyTypeObject *type); static PyObject *t_unicodestring_getAvailableEncodings(PyTypeObject *type, PyObject *args); static PyObject *t_unicodestring_getStandardEncoding(PyTypeObject *type, PyObject *args); static PyObject *t_unicodestring_append(t_unicodestring *self, PyObject *args); static PyObject *t_unicodestring_compare(t_unicodestring *self, PyObject *args); static PyObject *t_unicodestring_compareBetween(t_unicodestring *self, PyObject *args); static PyObject *t_unicodestring_compareCodePointOrder(t_unicodestring *self, PyObject *args); static PyObject *t_unicodestring_compareCodePointOrderBetween(t_unicodestring *self, PyObject *args); static PyObject *t_unicodestring_caseCompare(t_unicodestring *self, PyObject *args); static PyObject *t_unicodestring_caseCompareBetween(t_unicodestring *self, PyObject *args); static PyObject *t_unicodestring_startsWith(t_unicodestring *self, PyObject *args); static PyObject *t_unicodestring_endsWith(t_unicodestring *self, PyObject *args); #define t_unicodestring_startswith t_unicodestring_startsWith #define t_unicodestring_endswith t_unicodestring_endsWith static PyObject *t_unicodestring_indexOf(t_unicodestring *self, PyObject *args); static PyObject *t_unicodestring_lastIndexOf(t_unicodestring *self, PyObject *args); static PyObject *t_unicodestring_trim(t_unicodestring *self); static PyObject *t_unicodestring_reverse(t_unicodestring *self); static PyObject *t_unicodestring_toUpper(t_unicodestring *self, PyObject *args); static PyObject *t_unicodestring_toLower(t_unicodestring *self, PyObject *args); static PyObject *t_unicodestring_toTitle(t_unicodestring *self, PyObject *args); static PyObject *t_unicodestring_foldCase(t_unicodestring *self, PyObject *args); static PyObject *t_unicodestring_isBogus(t_unicodestring *self); static PyObject *t_unicodestring_encode(t_unicodestring *self, PyObject *arg); static PyObject *t_unicodestring_countChar32(t_unicodestring *self, PyObject *args); #if U_ICU_VERSION_HEX < VERSION_HEX(55, 1, 0) static PyObject *t_unicodestring_idna_toASCII(t_unicodestring *self, PyObject *args); static PyObject *t_unicodestring_idna_toUnicode(t_unicodestring *self, PyObject *args); static PyObject *t_unicodestring_idna_IDNtoASCII(t_unicodestring *self, PyObject *args); static PyObject *t_unicodestring_idna_IDNtoUnicode(t_unicodestring *self, PyObject *args); static PyObject *t_unicodestring_idna_compare(t_unicodestring *self, PyObject *args); #endif static PyMethodDef t_unicodestring_methods[] = { DECLARE_METHOD(t_unicodestring, getAvailableStandards, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_unicodestring, getAvailableEncodings, METH_VARARGS | METH_CLASS), DECLARE_METHOD(t_unicodestring, getStandardEncoding, METH_VARARGS | METH_CLASS), DECLARE_METHOD(t_unicodestring, append, METH_VARARGS), DECLARE_METHOD(t_unicodestring, compare, METH_VARARGS), DECLARE_METHOD(t_unicodestring, compareBetween, METH_VARARGS), DECLARE_METHOD(t_unicodestring, compareCodePointOrder, METH_VARARGS), DECLARE_METHOD(t_unicodestring, compareCodePointOrderBetween, METH_VARARGS), DECLARE_METHOD(t_unicodestring, caseCompare, METH_VARARGS), DECLARE_METHOD(t_unicodestring, caseCompareBetween, METH_VARARGS), DECLARE_METHOD(t_unicodestring, startsWith, METH_VARARGS), DECLARE_METHOD(t_unicodestring, endsWith, METH_VARARGS), DECLARE_METHOD(t_unicodestring, startswith, METH_VARARGS), DECLARE_METHOD(t_unicodestring, endswith, METH_VARARGS), DECLARE_METHOD(t_unicodestring, indexOf, METH_VARARGS), DECLARE_METHOD(t_unicodestring, lastIndexOf, METH_VARARGS), DECLARE_METHOD(t_unicodestring, trim, METH_NOARGS), DECLARE_METHOD(t_unicodestring, reverse, METH_NOARGS), DECLARE_METHOD(t_unicodestring, toUpper, METH_VARARGS), DECLARE_METHOD(t_unicodestring, toLower, METH_VARARGS), DECLARE_METHOD(t_unicodestring, toTitle, METH_VARARGS), DECLARE_METHOD(t_unicodestring, foldCase, METH_VARARGS), DECLARE_METHOD(t_unicodestring, isBogus, METH_NOARGS), DECLARE_METHOD(t_unicodestring, encode, METH_O), DECLARE_METHOD(t_unicodestring, countChar32, METH_VARARGS), #if U_ICU_VERSION_HEX < VERSION_HEX(55, 1, 0) DECLARE_METHOD(t_unicodestring, idna_toASCII, METH_VARARGS), DECLARE_METHOD(t_unicodestring, idna_toUnicode, METH_VARARGS), DECLARE_METHOD(t_unicodestring, idna_IDNtoASCII, METH_VARARGS), DECLARE_METHOD(t_unicodestring, idna_IDNtoUnicode, METH_VARARGS), DECLARE_METHOD(t_unicodestring, idna_compare, METH_VARARGS), #endif { NULL, NULL, 0, NULL } }; DECLARE_TYPE(UnicodeString, t_unicodestring, Replaceable, UnicodeString, t_unicodestring_init, NULL); /* Formattable */ class t_formattable : public _wrapper { public: Formattable *object; }; static int t_formattable_init(t_formattable *self, PyObject *args, PyObject *kwds); static PyObject *t_formattable_isNumeric(t_formattable *self); static PyObject *t_formattable_getType(t_formattable *self); static PyObject *t_formattable_getDouble(t_formattable *self); static PyObject *t_formattable_getLong(t_formattable *self); static PyObject *t_formattable_getInt64(t_formattable *self); static PyObject *t_formattable_getDate(t_formattable *self); static PyObject *t_formattable_getString(t_formattable *self, PyObject *args); static PyObject *t_formattable_setDouble(t_formattable *self, PyObject *arg); static PyObject *t_formattable_setLong(t_formattable *self, PyObject *arg); static PyObject *t_formattable_setInt64(t_formattable *self, PyObject *arg); static PyObject *t_formattable_setDate(t_formattable *self, PyObject *arg); static PyObject *t_formattable_setString(t_formattable *self, PyObject *arg); static PyMethodDef t_formattable_methods[] = { DECLARE_METHOD(t_formattable, isNumeric, METH_NOARGS), DECLARE_METHOD(t_formattable, getType, METH_NOARGS), DECLARE_METHOD(t_formattable, getDouble, METH_NOARGS), DECLARE_METHOD(t_formattable, getLong, METH_NOARGS), DECLARE_METHOD(t_formattable, getInt64, METH_NOARGS), DECLARE_METHOD(t_formattable, getDate, METH_NOARGS), DECLARE_METHOD(t_formattable, getString, METH_VARARGS), DECLARE_METHOD(t_formattable, setDouble, METH_O), DECLARE_METHOD(t_formattable, setLong, METH_O), DECLARE_METHOD(t_formattable, setInt64, METH_O), DECLARE_METHOD(t_formattable, setDate, METH_O), DECLARE_METHOD(t_formattable, setString, METH_O), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(Formattable, t_formattable, UObject, Formattable, t_formattable_init, NULL); PyObject *wrap_Formattable(Formattable &formattable) { return wrap_Formattable(new Formattable(formattable), T_OWNED); } /* MeasureUnit */ class t_measureunit : public _wrapper { public: MeasureUnit *object; }; static PyMethodDef t_measureunit_methods[] = { { NULL, NULL, 0, NULL } }; DECLARE_TYPE(MeasureUnit, t_measureunit, UObject, MeasureUnit, abstract_init, NULL); /* Measure */ class t_measure : public _wrapper { public: Measure *object; }; static PyObject *t_measure_getNumber(t_measure *self); static PyObject *t_measure_getUnit(t_measure *self); static PyMethodDef t_measure_methods[] = { DECLARE_METHOD(t_measure, getNumber, METH_NOARGS), DECLARE_METHOD(t_measure, getUnit, METH_NOARGS), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(Measure, t_measure, UObject, Measure, abstract_init, NULL); /* CurrencyUnit */ class t_currencyunit : public _wrapper { public: CurrencyUnit *object; }; static int t_currencyunit_init(t_currencyunit *self, PyObject *args, PyObject *kwds); static PyObject *t_currencyunit_getISOCurrency(t_currencyunit *self); static PyMethodDef t_currencyunit_methods[] = { DECLARE_METHOD(t_currencyunit, getISOCurrency, METH_NOARGS), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(CurrencyUnit, t_currencyunit, MeasureUnit, CurrencyUnit, t_currencyunit_init, NULL); /* CurrencyAmount */ class t_currencyamount : public _wrapper { public: CurrencyAmount *object; }; static int t_currencyamount_init(t_currencyamount *self, PyObject *args, PyObject *kwds); static PyObject *t_currencyamount_getCurrency(t_currencyamount *self); static PyObject *t_currencyamount_getISOCurrency(t_currencyamount *self); static PyMethodDef t_currencyamount_methods[] = { DECLARE_METHOD(t_currencyamount, getCurrency, METH_NOARGS), DECLARE_METHOD(t_currencyamount, getISOCurrency, METH_NOARGS), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(CurrencyAmount, t_currencyamount, Measure, CurrencyAmount, t_currencyamount_init, NULL); /* StringEnumeration */ class t_stringenumeration : public _wrapper { public: StringEnumeration *object; }; static PyObject *t_stringenumeration_count(t_stringenumeration *self); static PyObject *t_stringenumeration_reset(t_stringenumeration *self); static PyObject *t_stringenumeration_next(t_stringenumeration *self); static PyObject *t_stringenumeration_unext(t_stringenumeration *self); static PyObject *t_stringenumeration_snext(t_stringenumeration *self); static PyMethodDef t_stringenumeration_methods[] = { DECLARE_METHOD(t_stringenumeration, count, METH_NOARGS), DECLARE_METHOD(t_stringenumeration, reset, METH_NOARGS), DECLARE_METHOD(t_stringenumeration, next, METH_NOARGS), DECLARE_METHOD(t_stringenumeration, unext, METH_NOARGS), DECLARE_METHOD(t_stringenumeration, snext, METH_NOARGS), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(StringEnumeration, t_stringenumeration, UObject, StringEnumeration, abstract_init, NULL); /* UObject */ void t_uobject_dealloc(t_uobject *self) { if (self->flags & T_OWNED) delete self->object; self->object = NULL; Py_TYPE(self)->tp_free((PyObject *) self); } static PyObject *t_uobject_new(PyTypeObject *type, PyObject *args, PyObject *kwds) { t_uobject *self = (t_uobject *) type->tp_alloc(type, 0); if (self) { self->object = NULL; self->flags = 0; } return (PyObject *) self; } static PyObject *t_uobject_richcmp(t_uobject *self, PyObject *arg, int op) { int b = 0; switch (op) { case Py_EQ: case Py_NE: if (PyObject_TypeCheck(arg, &UObjectType_)) b = self->object == ((t_uobject *) arg)->object; if (op == Py_EQ) Py_RETURN_BOOL(b); Py_RETURN_BOOL(!b); case Py_LT: PyErr_SetString(PyExc_NotImplementedError, "<"); return NULL; case Py_LE: PyErr_SetString(PyExc_NotImplementedError, "<="); return NULL; case Py_GT: PyErr_SetString(PyExc_NotImplementedError, ">"); return NULL; case Py_GE: PyErr_SetString(PyExc_NotImplementedError, ">="); return NULL; } return NULL; } static PyObject *t_uobject_str(t_uobject *self) { if (self->object) { char buf[32]; #if U_ICU_VERSION_HEX < 0x04060000 sprintf(buf, "0x%lx", (unsigned long) self->object->getDynamicClassID()); #else sprintf(buf, "0x%llx", (unsigned long long) (intptr_t) self->object); #endif return PyString_FromString(buf); } return PyString_FromString(""); } static PyObject *t_uobject_repr(t_uobject *self) { PyObject *name = PyObject_GetAttrString((PyObject *) Py_TYPE(self), "__name__"); PyObject *str = Py_TYPE(self)->tp_str((PyObject *) self); #if PY_VERSION_HEX < 0x02040000 PyObject *args = Py_BuildValue("(OO)", name, str); #else PyObject *args = PyTuple_Pack(2, name, str); #endif PyObject *format = PyString_FromString("<%s: %s>"); PyObject *repr = PyString_Format(format, args); Py_DECREF(name); Py_DECREF(str); Py_DECREF(args); Py_DECREF(format); return repr; } static PyObject *t_uobject_getDynamicClassID(t_uobject *self) { return PyInt_FromLong((long) self->object->getDynamicClassID()); } /* Replaceable */ static PyObject *t_replaceable_length(t_replaceable *self) { return PyInt_FromLong(self->object->length()); } static PyObject *t_replaceable_charAt(t_replaceable *self, PyObject *arg) { int32_t i; if (!parseArg(arg, "i", &i)) { if (i >= 0 && self->object->length()) return PyInt_FromLong(self->object->charAt(i)); else { PyErr_SetObject(PyExc_IndexError, arg); return NULL; } } return PyErr_SetArgsError((PyObject *) self, "charAt", arg); } static PyObject *t_replaceable_char32At(t_replaceable *self, PyObject *arg) { int32_t i; if (!parseArg(arg, "i", &i)) { if (i >= 0 && self->object->length()) return PyInt_FromLong(self->object->char32At(i)); else { PyErr_SetObject(PyExc_IndexError, arg); return NULL; } } return PyErr_SetArgsError((PyObject *) self, "char32At", arg); } static PyObject *t_replaceable_hasMetaData(t_replaceable *self) { int b = self->object->hasMetaData(); Py_RETURN_BOOL(b); } /* UnicodeString */ static int t_unicodestring_init(t_unicodestring *self, PyObject *args, PyObject *kwds) { UnicodeString *u, _u; PyObject *obj; charsArg encoding, mode; int32_t start, length; int i; switch (PyTuple_Size(args)) { case 0: self->object = new UnicodeString(); self->flags = T_OWNED; break; case 1: if (!parseArgs(args, "u", &u)) { self->object = u; self->flags = T_OWNED; break; } if (!parseArgs(args, "U", &u)) { self->object = new UnicodeString(*u); self->flags = T_OWNED; break; } if (!parseArgs(args, "i", &i)) { self->object = new UnicodeString((UChar32) i); self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; case 2: if (!parseArgs(args, "Cn", &obj, &encoding)) { UnicodeString u; try { PyObject_AsUnicodeString(obj, encoding, "strict", u); self->object = new UnicodeString(u); self->flags = T_OWNED; } catch (ICUException e) { e.reportError(); return -1; } break; } if (!parseArgs(args, "Si", &u, &_u, &start)) { self->object = new UnicodeString(*u, start); self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; case 3: if (!parseArgs(args, "Cnn", &obj, &encoding, &mode)) { try { PyObject_AsUnicodeString(obj, encoding, mode, _u); self->object = new UnicodeString(_u); self->flags = T_OWNED; } catch (ICUException e) { e.reportError(); return -1; } break; } if (!parseArgs(args, "Sii", &u, &_u, &start, &length)) { self->object = new UnicodeString(*u, start, length); self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; default: PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; } if (self->object) return 0; return -1; } static PyObject *t_unicodestring_getAvailableStandards(PyTypeObject *type) { UErrorCode status = U_ZERO_ERROR; int count = ucnv_countStandards(); PyObject *list = PyList_New(count); for (int i = 0; i < count; i++) { const char *name = ucnv_getStandard(i, &status); PyList_SetItem(list, i, PyString_FromString(name)); } return list; } static PyObject *t_unicodestring_getAvailableEncodings(PyTypeObject *type, PyObject *args) { charsArg standard; switch (PyTuple_Size(args)) { case 0: break; case 1: if (!parseArgs(args, "n", &standard)) break; default: return PyErr_SetArgsError(type, "getAvailableEncodings", args); } int count = ucnv_countAvailable(); PyObject *list = PyList_New(0); for (int i = 0; i < count; i++) { const char *name = ucnv_getAvailableName(i); if (standard) { UErrorCode status = U_ZERO_ERROR; name = ucnv_getStandardName(name, standard, &status); } if (name) PyList_Append(list, PyString_FromString(name)); } return list; } static PyObject *t_unicodestring_getStandardEncoding(PyTypeObject *type, PyObject *args) { charsArg name, standard; if (!parseArgs(args, "nn", &name, &standard)) { UErrorCode status = U_ZERO_ERROR; const char *standardName = ucnv_getStandardName(name, standard, &status); if (standardName) return PyString_FromString(standardName); Py_RETURN_NONE; } return PyErr_SetArgsError(type, "getStandardEncodings", args); } static int verifyStart(int &start, int size) { if (start < 0) { start += size; if (start < 0) return -1; } return 0; } static int verifyStartLen(int &start, int &len, int size) { if (start < 0) { start += size; if (start < 0) return -1; } if (len < 0) len = 0; else if (len > size - start) len = size - start; return 0; } static int verifyStartEnd(int &start, int &end, int len) { if (start < 0) { start += len; if (start < 0) return -1; } else if (start > len) start = len; if (end < 0) { end += len; if (end < 0) return -1; } else if (end > len) end = len; return 0; } static PyObject *t_unicodestring_append(t_unicodestring *self, PyObject *args) { UnicodeString *u; UnicodeString _u; int i, start, len; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "S", &u, &_u)) { self->object->append(*u); Py_INCREF(self); return (PyObject *) self; } if (!parseArgs(args, "i", &i)) { if (sizeof(Py_UNICODE) == sizeof(UChar)) self->object->append((UChar) i); else self->object->append((UChar32) i); Py_INCREF(self); return (PyObject *) self; } break; case 3: if (!parseArgs(args, "Sii", &u, &_u, &start, &len)) { if (!verifyStartLen(start, len, u->length())) { self->object->append(*u, start, len); Py_INCREF(self); return (PyObject *) self; } PyErr_SetObject(PyExc_IndexError, args); return NULL; } break; } return PyErr_SetArgsError((PyObject *) self, "append", args); } static PyObject *t_unicodestring_compare(t_unicodestring *self, PyObject *args) { UnicodeString *u; UnicodeString _u; int start, len; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "S", &u, &_u)) { int c = self->object->compare(*u); return PyInt_FromLong(c); } break; case 3: if (!parseArgs(args, "iiS", &start, &len, &u, &_u)) { if (!verifyStartLen(start, len, u->length())) { int c = self->object->compare(start, len, *u); return PyInt_FromLong(c); } PyErr_SetObject(PyExc_IndexError, args); return NULL; } break; } return PyErr_SetArgsError((PyObject *) self, "compare", args); } static PyObject *t_unicodestring_compareBetween(t_unicodestring *self, PyObject *args) { UnicodeString *u; UnicodeString _u; int start, end, srcStart, srcEnd; if (!parseArgs(args, "iiSii", &start, &end, &u, &_u, &srcStart, &srcEnd)) { if (!verifyStartEnd(start, end, self->object->length()) && !verifyStartEnd(srcStart, srcEnd, u->length())) { int c = self->object->compareBetween(start, end, *u, srcStart, srcEnd); return PyInt_FromLong(c); } PyErr_SetObject(PyExc_IndexError, args); return NULL; } return PyErr_SetArgsError((PyObject *) self, "compareBetween", args); } static PyObject *t_unicodestring_compareCodePointOrder(t_unicodestring *self, PyObject *args) { UnicodeString *u; UnicodeString _u; int start, len; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "S", &u, &_u)) { int c = self->object->compareCodePointOrder(*u); return PyInt_FromLong(c); } break; case 3: if (!parseArgs(args, "iiS", &start, &len, &u, &_u)) { if (!verifyStartLen(start, len, self->object->length())) { int c = self->object->compareCodePointOrder(start, len, *u); return PyInt_FromLong(c); } PyErr_SetObject(PyExc_IndexError, args); return NULL; } break; } return PyErr_SetArgsError((PyObject *) self, "compareCodePointOrder", args); } static PyObject *t_unicodestring_compareCodePointOrderBetween(t_unicodestring *self, PyObject *args) { UnicodeString *u; UnicodeString _u; int start, end, srcStart, srcEnd; if (!parseArgs(args, "iiSii", &start, &end, &u, &_u, &srcStart, &srcEnd)) { if (!verifyStartEnd(start, end, self->object->length()) && !verifyStartEnd(srcStart, srcEnd, u->length())) { int c = self->object->compareCodePointOrderBetween(start, end, *u, srcStart, srcEnd); return PyInt_FromLong(c); } PyErr_SetObject(PyExc_IndexError, args); return NULL; } return PyErr_SetArgsError((PyObject *) self, "compareCodePointOrderBetween", args); } static PyObject *t_unicodestring_caseCompare(t_unicodestring *self, PyObject *args) { UnicodeString *u; UnicodeString _u; int start, len, options; switch (PyTuple_Size(args)) { case 2: if (!parseArgs(args, "Si", &u, &_u, &options)) { int c = self->object->caseCompare(*u, options); return PyInt_FromLong(c); } break; case 4: if (!parseArgs(args, "iiSi", &start, &len, &u, &_u, &options)) { if (!verifyStartLen(start, len, self->object->length())) { int c = self->object->caseCompare(start, len, *u, options); return PyInt_FromLong(c); } PyErr_SetObject(PyExc_IndexError, args); return NULL; } break; } return PyErr_SetArgsError((PyObject *) self, "caseCompare", args); } static PyObject *t_unicodestring_caseCompareBetween(t_unicodestring *self, PyObject *args) { UnicodeString *u; UnicodeString _u; int start, end, srcStart, srcEnd, options; if (!parseArgs(args, "iiSiii", &start, &end, &u, &_u, &srcStart, &srcEnd, &options)) { if (!verifyStartEnd(start, end, self->object->length()) && !verifyStartEnd(srcStart, srcEnd, u->length())) { int c = self->object->caseCompareBetween(start, end, *u, srcStart, srcEnd, options); return PyInt_FromLong(c); } PyErr_SetObject(PyExc_IndexError, args); return NULL; } return PyErr_SetArgsError((PyObject *) self, "caseCompareBetween", args); } static PyObject *t_unicodestring_startsWith(t_unicodestring *self, PyObject *args) { UnicodeString *u; UnicodeString _u; int start, len; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "S", &u, &_u)) { int b = self->object->startsWith(*u); Py_RETURN_BOOL(b); } break; case 3: if (!parseArgs(args, "Sii", &u, &_u, &start, &len)) { if (!verifyStartLen(start, len, u->length())) { int b = self->object->startsWith(*u, start, len); Py_RETURN_BOOL(b); } PyErr_SetObject(PyExc_IndexError, args); return NULL; } break; } return PyErr_SetArgsError((PyObject *) self, "startsWith", args); } static PyObject *t_unicodestring_endsWith(t_unicodestring *self, PyObject *args) { UnicodeString *u; UnicodeString _u; int start, len; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "S", &u, &_u)) { int b = self->object->endsWith(*u); Py_RETURN_BOOL(b); } break; case 3: if (!parseArgs(args, "Sii", &u, &_u, &start, &len)) { if (!verifyStartLen(start, len, u->length())) { int b = self->object->endsWith(*u, start, len); Py_RETURN_BOOL(b); } PyErr_SetObject(PyExc_IndexError, args); return NULL; } break; } return PyErr_SetArgsError((PyObject *) self, "endsWith", args); } static PyObject *t_unicodestring_indexOf(t_unicodestring *self, PyObject *args) { UnicodeString *u; UnicodeString _u; int c, start, len, srcStart, srcLen; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "S", &u, &_u)) { int i = self->object->indexOf(*u); return PyInt_FromLong(i); } if (!parseArgs(args, "i", &c)) { int i; if (sizeof(Py_UNICODE) == sizeof(UChar)) i = self->object->indexOf((UChar) c); else i = self->object->indexOf((UChar32) c); return PyInt_FromLong(i); } break; case 2: if (!parseArgs(args, "Si", &u, &_u, &start)) { if (!verifyStart(start, u->length())) { int i = self->object->indexOf(*u, start); return PyInt_FromLong(i); } PyErr_SetObject(PyExc_IndexError, args); return NULL; } if (!parseArgs(args, "ii", &c, &start)) { if (!verifyStart(start, self->object->length())) { int i; if (sizeof(Py_UNICODE) == sizeof(UChar)) i = self->object->indexOf((UChar) c, start); else i = self->object->indexOf((UChar32) c, start); return PyInt_FromLong(i); } PyErr_SetObject(PyExc_IndexError, args); return NULL; } break; case 3: if (!parseArgs(args, "Sii", &u, &_u, &start, &len)) { if (!verifyStartLen(start, len, u->length())) { int i = self->object->indexOf(*u, start, len); return PyInt_FromLong(i); } PyErr_SetObject(PyExc_IndexError, args); return NULL; } if (!parseArgs(args, "iii", &c, &start, &len)) { if (!verifyStartLen(start, len, self->object->length())) { int i; if (sizeof(Py_UNICODE) == sizeof(UChar)) i = self->object->indexOf((UChar) c, start, len); else i = self->object->indexOf((UChar32) c, start, len); return PyInt_FromLong(i); } PyErr_SetObject(PyExc_IndexError, args); return NULL; } break; case 5: if (!parseArgs(args, "Siiii", &u, &_u, &srcStart, &srcLen, &start, &len)) { if (!verifyStartLen(srcStart, srcLen, u->length()) && !verifyStartLen(start, len, self->object->length())) { int i = self->object->indexOf(*u, srcStart, srcLen, start, len); return PyInt_FromLong(i); } PyErr_SetObject(PyExc_IndexError, args); return NULL; } } return PyErr_SetArgsError((PyObject *) self, "indexOf", args); } static PyObject *t_unicodestring_lastIndexOf(t_unicodestring *self, PyObject *args) { UnicodeString *u; UnicodeString _u; int c, start, len, srcStart, srcLen; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "S", &u, &_u)) { int i = self->object->lastIndexOf(*u); return PyInt_FromLong(i); } if (!parseArgs(args, "i", &c)) { int i; if (sizeof(Py_UNICODE) == sizeof(UChar)) i = self->object->lastIndexOf((UChar) c); else i = self->object->lastIndexOf((UChar32) c); return PyInt_FromLong(i); } break; case 2: if (!parseArgs(args, "Si", &u, &_u, &start)) { if (!verifyStart(start, u->length())) { int i = self->object->lastIndexOf(*u, start); return PyInt_FromLong(i); } PyErr_SetObject(PyExc_IndexError, args); return NULL; } if (!parseArgs(args, "ii", &c, &start)) { if (!verifyStart(start, self->object->length())) { int i; if (sizeof(Py_UNICODE) == sizeof(UChar)) i = self->object->lastIndexOf((UChar) c, start); else i = self->object->lastIndexOf((UChar32) c, start); return PyInt_FromLong(i); } PyErr_SetObject(PyExc_IndexError, args); return NULL; } break; case 3: if (!parseArgs(args, "Sii", &u, &_u, &start, &len)) { if (!verifyStartLen(start, len, u->length())) { int i = self->object->lastIndexOf(*u, start, len); return PyInt_FromLong(i); } PyErr_SetObject(PyExc_IndexError, args); return NULL; } if (!parseArgs(args, "iii", &c, &start, &len)) { if (!verifyStartLen(start, len, self->object->length())) { int i; if (sizeof(Py_UNICODE) == sizeof(UChar)) i = self->object->lastIndexOf((UChar) c, start, len); else i = self->object->lastIndexOf((UChar32) c, start, len); return PyInt_FromLong(i); } PyErr_SetObject(PyExc_IndexError, args); return NULL; } break; case 5: if (!parseArgs(args, "Siiii", &u, &_u, &srcStart, &srcLen, &start, &len)) { if (!verifyStartLen(srcStart, srcLen, u->length()) && !verifyStartLen(start, len, self->object->length())) { int i = self->object->lastIndexOf(*u, srcStart, srcLen, start, len); return PyInt_FromLong(i); } PyErr_SetObject(PyExc_IndexError, args); return NULL; } } return PyErr_SetArgsError((PyObject *) self, "lastIndexOf", args); } static PyObject *t_unicodestring_trim(t_unicodestring *self) { self->object->trim(); Py_RETURN_SELF(); } static PyObject *t_unicodestring_reverse(t_unicodestring *self) { self->object->reverse(); Py_RETURN_SELF(); } static PyObject *t_unicodestring_toUpper(t_unicodestring *self, PyObject *args) { Locale *locale; switch (PyTuple_Size(args)) { case 0: self->object->toUpper(); Py_RETURN_SELF(); case 1: if (!parseArgs(args, "P", TYPE_CLASSID(Locale), &locale)) { self->object->toUpper(*locale); Py_RETURN_SELF(); } break; } return PyErr_SetArgsError((PyObject *) self, "toUpper", args); } static PyObject *t_unicodestring_toLower(t_unicodestring *self, PyObject *args) { Locale *locale; switch (PyTuple_Size(args)) { case 0: self->object->toLower(); Py_RETURN_SELF(); case 1: if (!parseArgs(args, "P", TYPE_CLASSID(Locale), &locale)) { self->object->toLower(*locale); Py_RETURN_SELF(); } break; } return PyErr_SetArgsError((PyObject *) self, "toLower", args); } static PyObject *t_unicodestring_toTitle(t_unicodestring *self, PyObject *args) { BreakIterator *iterator; Locale *locale; switch (PyTuple_Size(args)) { case 0: self->object->toTitle(NULL); Py_RETURN_SELF(); case 1: if (!parseArgs(args, "P", TYPE_CLASSID(Locale), &locale)) { self->object->toTitle(NULL, *locale); Py_RETURN_SELF(); } if (!parseArg(args, "P", TYPE_ID(BreakIterator), &iterator)) { self->object->toTitle(iterator); Py_RETURN_SELF(); } break; case 2: if (!parseArgs(args, "PP", TYPE_ID(BreakIterator), TYPE_CLASSID(Locale), &iterator, &locale)) { self->object->toTitle(iterator, *locale); Py_RETURN_SELF(); } break; } return PyErr_SetArgsError((PyObject *) self, "toTitle", args); } static PyObject *t_unicodestring_foldCase(t_unicodestring *self, PyObject *args) { int i; switch (PyTuple_Size(args)) { case 0: self->object->foldCase(0); Py_RETURN_SELF(); case 1: if (!parseArgs(args, "i", &i)) { self->object->foldCase(i); Py_RETURN_SELF(); } break; } return PyErr_SetArgsError((PyObject *) self, "foldCase", args); } static PyObject *t_unicodestring_isBogus(t_unicodestring *self) { int b = self->object->isBogus(); Py_RETURN_BOOL(b); } static PyObject *t_unicodestring_str(t_unicodestring *self) { return PyUnicode_FromUnicodeString(self->object); } static PyObject *t_unicodestring_repr(t_unicodestring *self) { PyObject *name = PyObject_GetAttrString((PyObject *) Py_TYPE(self), "__name__"); PyObject *str = PyUnicode_FromUnicodeString(self->object); if (str) { PyObject *repr = str->ob_type->tp_repr(str); Py_DECREF(str); str = repr; } if (!str) return NULL; #if PY_VERSION_HEX < 0x02040000 PyObject *args = Py_BuildValue("(OO)", name, str); #else PyObject *args = PyTuple_Pack(2, name, str); #endif PyObject *format = PyString_FromString("<%s: %s>"); PyObject *repr = PyString_Format(format, args); Py_DECREF(name); Py_DECREF(str); Py_DECREF(args); Py_DECREF(format); return repr; } static long t_unicodestring_hash(t_unicodestring *self) { return (long) self->object->hashCode(); } static PyObject *t_unicodestring_encode(t_unicodestring *self, PyObject *arg) { charsArg encoding; if (!parseArg(arg, "n", &encoding)) { int srcLen = self->object->length(); int dstLen = srcLen * 4, _dstLen; UErrorCode status = U_ZERO_ERROR; UConverter *conv = ucnv_open(encoding, &status); PyObject *string; if (U_FAILURE(status)) return ICUException(status).reportError(); string = PyBytes_FromStringAndSize(NULL, dstLen); retry: if (!string) { ucnv_close(conv); return NULL; } _dstLen = ucnv_fromUChars(conv, PyBytes_AS_STRING(string), dstLen, self->object->getBuffer(), srcLen, &status); if (status == U_BUFFER_OVERFLOW_ERROR && _dstLen > dstLen) { _PyBytes_Resize(&string, _dstLen); dstLen = _dstLen; status = U_ZERO_ERROR; goto retry; } ucnv_close(conv); if (U_FAILURE(status)) { Py_DECREF(string); return ICUException(status).reportError(); } if (_dstLen != dstLen) _PyBytes_Resize(&string, _dstLen); return string; } return PyErr_SetArgsError((PyObject *) self, "encode", arg); } static PyObject *t_unicodestring_countChar32(t_unicodestring *self, PyObject *args) { int32_t start = 0, length = INT32_MAX; int32_t len; switch (PyTuple_Size(args)) { case 0: len = self->object->countChar32(); return PyInt_FromLong(len); case 1: if (!parseArgs(args, "i", &start)) { len = self->object->countChar32(start); return PyInt_FromLong(len); } break; case 2: if (!parseArgs(args, "ii", &start, &length)) { len = self->object->countChar32(start, length); return PyInt_FromLong(len); } break; } return PyErr_SetArgsError((PyObject *) self, "countChar32", args); } #if U_ICU_VERSION_HEX < VERSION_HEX(55, 1, 0) static PyObject *t_unicodestring_idna_toASCII(t_unicodestring *self, PyObject *args) { UErrorCode status = U_ZERO_ERROR; UParseError parseError; int options = UIDNA_DEFAULT; int len = self->object->length(); UnicodeString *u; UChar *dest; if (!PyArg_ParseTuple(args, "|i", &options)) return NULL; dest = new UChar[len * 4 + 32]; if (!dest) { PyErr_SetNone(PyExc_MemoryError); return NULL; } len = uidna_toASCII(self->object->getBuffer(), len, dest, len * 4 + 32, options, &parseError, &status); if (U_FAILURE(status)) { delete dest; return ICUException(parseError, status).reportError(); } u = new UnicodeString(dest, len); delete dest; return wrap_UnicodeString(u, T_OWNED); } static PyObject *t_unicodestring_idna_toUnicode(t_unicodestring *self, PyObject *args) { UErrorCode status = U_ZERO_ERROR; UParseError parseError; int options = UIDNA_DEFAULT; int len = self->object->length(); UnicodeString *u; UChar *dest; if (!PyArg_ParseTuple(args, "|i", &options)) return NULL; dest = new UChar[len]; if (!dest) { PyErr_SetNone(PyExc_MemoryError); return NULL; } len = uidna_toUnicode(self->object->getBuffer(), len, dest, len, options, &parseError, &status); if (U_FAILURE(status)) { delete dest; return ICUException(parseError, status).reportError(); } u = new UnicodeString(dest, len); delete dest; return wrap_UnicodeString(u, T_OWNED); } static PyObject *t_unicodestring_idna_IDNtoASCII(t_unicodestring *self, PyObject *args) { UErrorCode status = U_ZERO_ERROR; UParseError parseError; int options = UIDNA_DEFAULT; int len = self->object->length(); UnicodeString *u; UChar *dest; if (!PyArg_ParseTuple(args, "|i", &options)) return NULL; dest = new UChar[len * 4 + 32]; if (!dest) { PyErr_SetNone(PyExc_MemoryError); return NULL; } len = uidna_IDNToASCII(self->object->getBuffer(), len, dest, len * 4 + 32, options, &parseError, &status); if (U_FAILURE(status)) { delete dest; return ICUException(parseError, status).reportError(); } u = new UnicodeString(dest, len); delete dest; return wrap_UnicodeString(u, T_OWNED); } static PyObject *t_unicodestring_idna_IDNtoUnicode(t_unicodestring *self, PyObject *args) { UErrorCode status = U_ZERO_ERROR; UParseError parseError; int options = UIDNA_DEFAULT; int len = self->object->length(); UnicodeString *u; UChar *dest; if (!PyArg_ParseTuple(args, "|i", &options)) return NULL; dest = new UChar[len]; if (!dest) { PyErr_SetNone(PyExc_MemoryError); return NULL; } len = uidna_IDNToUnicode(self->object->getBuffer(), len, dest, len, options, &parseError, &status); if (U_FAILURE(status)) { delete dest; return ICUException(parseError, status).reportError(); } u = new UnicodeString(dest, len); delete dest; return wrap_UnicodeString(u, T_OWNED); } static PyObject *t_unicodestring_idna_compare(t_unicodestring *self, PyObject *args) { int options = UIDNA_DEFAULT; UnicodeString *u; UnicodeString _u; int n; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "S", &u, &_u)) { STATUS_CALL(n = uidna_compare(self->object->getBuffer(), self->object->length(), u->getBuffer(), u->length(), options, &status)); return PyInt_FromLong(n); } break; case 2: if (!parseArgs(args, "Si", &u, &_u, &options)) { STATUS_CALL(n = uidna_compare(self->object->getBuffer(), self->object->length(), u->getBuffer(), u->length(), options, &status)); return PyInt_FromLong(n); } break; } return PyErr_SetArgsError((PyObject *) self, "idna_compare", args); } #endif static PyObject *t_unicodestring_richcmp(t_unicodestring *self, PyObject *arg, int op) { UnicodeString *u; UnicodeString _u; int b = 0; if (isUnicodeString(arg)) u = (UnicodeString *) ((t_uobject *) arg)->object; else try { PyObject_AsUnicodeString(arg, _u); u = &_u; } catch (ICUException e) { return e.reportError(); } switch (op) { case Py_EQ: b = *self->object == *u; break; case Py_NE: b = *self->object != *u; break; case Py_LT: b = *self->object < *u; break; case Py_LE: b = *self->object <= *u; break; case Py_GT: b = *self->object > *u; break; case Py_GE: b = *self->object >= *u; break; default: PyErr_SetNone(PyExc_NotImplementedError); return NULL; } Py_RETURN_BOOL(b); } static Py_ssize_t t_unicodestring_length(t_unicodestring *self) { return self->object->length(); } static PyObject *t_unicodestring_concat(t_unicodestring *self, PyObject *arg) { UnicodeString *u; UnicodeString _u; int i; if (!parseArg(arg, "S", &u, &_u)) { UnicodeString *v = new UnicodeString(*self->object); *v += *u; return wrap_UnicodeString(v, T_OWNED); } if (!parseArg(arg, "i", &i)) { UnicodeString *v = new UnicodeString(*self->object); if (sizeof(Py_UNICODE) == sizeof(UChar)) v->append((UChar) i); else v->append((UChar32) i); return wrap_UnicodeString(v, T_OWNED); } return PyErr_SetArgsError((PyObject *) self, "+", arg); } static PyObject *t_unicodestring_repeat(t_unicodestring *self, Py_ssize_t n) { if (n <= 0) return wrap_UnicodeString(new UnicodeString(), T_OWNED); else { UnicodeString *u = self->object; UnicodeString *v = new UnicodeString(u->length() * n, 0, 0); while (n-- > 0) *v += *u; return wrap_UnicodeString(v, T_OWNED); } } static PyObject *t_unicodestring_item(t_unicodestring *self, int n) { UnicodeString *u = self->object; int len = u->length(); if (n < 0) n += len; if (n >= 0 && n < len) { if (sizeof(Py_UNICODE) == sizeof(UChar)) { Py_UNICODE c = (Py_UNICODE) u->charAt(n); return PyUnicode_FromUnicode(&c, 1); } else { Py_UNICODE c = (Py_UNICODE) u->char32At(n); return PyUnicode_FromUnicode(&c, 1); } } PyErr_SetNone(PyExc_IndexError); return NULL; } static PyObject *t_unicodestring_slice(t_unicodestring *self, Py_ssize_t l, Py_ssize_t h) { UnicodeString *u = self->object; int len = u->length(); if (l < 0) l += len; else if (l > len) l = len; if (h < 0) h += len; else if (h > len) h = len; UnicodeString *v = new UnicodeString(); if (l >= 0 && h >= 0) { if (h > l) u->extract(l, h - l, *v); return wrap_UnicodeString(v, T_OWNED); } PyErr_SetNone(PyExc_IndexError); return NULL; } static int t_unicodestring_ass_item(t_unicodestring *self, Py_ssize_t n, PyObject *arg) { UnicodeString *u = self->object; int len = u->length(); if (n < 0) n += len; if (n >= 0 && n < len) { int32_t i; if (!parseArg(arg, "i", &i)) { if (sizeof(Py_UNICODE) == sizeof(UChar)) u->replace(n, 1, (UChar) i); else u->replace(n, 1, (UChar32) i); return 0; } UnicodeString *v; UnicodeString _v; if (!parseArg(arg, "S", &v, &_v)) { if (v->length() == 1) { u->setCharAt(n, v->charAt(0)); return 0; } else { PyErr_SetObject(PyExc_ValueError, arg); return -1; } } PyErr_SetObject(PyExc_TypeError, arg); return -1; } PyErr_SetNone(PyExc_IndexError); return -1; } static int t_unicodestring_ass_slice(t_unicodestring *self, Py_ssize_t l, Py_ssize_t h, PyObject *arg) { UnicodeString *v; UnicodeString _v; if (!parseArg(arg, "S", &v, &_v)) { UnicodeString *u = self->object; int len = u->length(); if (l < 0) l += len; else if (l > len) l = len; if (h < 0) h += len; else if (h > len) h = len; if (h < l) h = l; if (h >= 0 && l >= 0) { u->replaceBetween(l, h, *v); return 0; } PyErr_SetNone(PyExc_IndexError); return -1; } PyErr_SetObject(PyExc_TypeError, arg); return -1; } static int t_unicodestring_contains(t_unicodestring *self, PyObject *arg) { UnicodeString *u; UnicodeString _u; if (!parseArg(arg, "S", &u, &_u)) return self->object->indexOf(*u) == 0; PyErr_SetObject(PyExc_TypeError, arg); return -1; } static PyObject *t_unicodestring_inplace_concat(t_unicodestring *self, PyObject *arg) { UnicodeString *u; UnicodeString _u; int i; if (!parseArg(arg, "S", &u, &_u)) { *self->object += *u; Py_INCREF(self); return (PyObject *) self; } if (!parseArg(arg, "i", &i)) { if (sizeof(Py_UNICODE) == sizeof(UChar)) self->object->append((UChar) i); else self->object->append((UChar32) i); Py_INCREF(self); return (PyObject *) self; } return PyErr_SetArgsError((PyObject *) self, "+=", arg); } static PyObject *t_unicodestring_inplace_repeat(t_unicodestring *self, Py_ssize_t n) { if (n <= 0) self->object->remove(); else if (n > 1) { UnicodeString v = *self->object; while (n-- > 1) *self->object += v; } Py_INCREF(self); return (PyObject *) self; } static PySequenceMethods t_unicodestring_as_sequence = { (lenfunc) t_unicodestring_length, /* sq_length */ (binaryfunc) t_unicodestring_concat, /* sq_concat */ (ssizeargfunc) t_unicodestring_repeat, /* sq_repeat */ (ssizeargfunc) t_unicodestring_item, /* sq_item */ #if PY_MAJOR_VERSION >= 3 NULL, (ssizeobjargproc) t_unicodestring_ass_item, /* sq_ass_item */ NULL, #else (ssizessizeargfunc) t_unicodestring_slice, /* sq_slice */ (ssizeobjargproc) t_unicodestring_ass_item, /* sq_ass_item */ (ssizessizeobjargproc) t_unicodestring_ass_slice, /* sq_ass_slice */ #endif (objobjproc) t_unicodestring_contains, /* sq_contains */ (binaryfunc) t_unicodestring_inplace_concat, /* sq_inplace_concat */ (ssizeargfunc) t_unicodestring_inplace_repeat, /* sq_inplace_repeat */ }; #if PY_MAJOR_VERSION >= 3 // Inspired by // http://renesd.blogspot.com/2009/07/python3-c-api-simple-slicing-sqslice.html static PyObject *t_unicodestring_subscript(t_unicodestring *self, PyObject *key) { if (PyIndex_Check(key)) { Py_ssize_t i = PyNumber_AsSsize_t(key, PyExc_IndexError); if (i == -1 && PyErr_Occurred()) return NULL; return t_unicodestring_item(self, i); } if (PySlice_Check(key)) { Py_ssize_t length, start, stop, step, slicelength; length = t_unicodestring_length(self); if (PySlice_GetIndicesEx(key, length, &start, &stop, &step, &slicelength)) return NULL; if (step != 1) { PyErr_SetString(PyExc_TypeError, "slice steps not supported"); return NULL; } return t_unicodestring_slice(self, start, stop); } PyErr_SetObject(PyExc_TypeError, key); return NULL; } static int t_unicodestring_ass_subscript(t_unicodestring *self, PyObject *key, PyObject *arg) { if (PyIndex_Check(key)) { Py_ssize_t i = PyNumber_AsSsize_t(key, PyExc_IndexError); if (i == -1 && PyErr_Occurred()) return -1; return t_unicodestring_ass_item(self, i, arg); } if (PySlice_Check(key)) { Py_ssize_t length, start, stop, step, slicelength; length = t_unicodestring_length(self); if (PySlice_GetIndicesEx(key, length, &start, &stop, &step, &slicelength)) return -1; if (step != 1) { PyErr_SetString(PyExc_TypeError, "slice steps not supported"); return -1; } return t_unicodestring_ass_slice(self, start, stop, arg); } PyErr_SetObject(PyExc_TypeError, key); return -1; } static PyMappingMethods t_unicodestring_as_mapping = { (lenfunc) t_unicodestring_length, /* mp_length */ (binaryfunc) t_unicodestring_subscript, /* mp_subscript */ (objobjargproc) t_unicodestring_ass_subscript, /* mp_ass_subscript */ }; #endif /* Formattable */ static int t_formattable_init(t_formattable *self, PyObject *args, PyObject *kwds) { UDate date; Formattable::ISDATE flag; switch (PyTuple_Size(args)) { case 0: self->object = new Formattable(); self->flags = T_OWNED; break; case 1: self->object = toFormattable(PyTuple_GET_ITEM(args, 0)); if (self->object) { self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; case 2: if (!parseArgs(args, "Di", &date, &flag)) { self->object = new Formattable(date, flag); self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; default: PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; } if (self->object) return 0; return -1; } static PyObject *t_formattable_getType(t_formattable *self) { return PyInt_FromLong(self->object->getType()); } static PyObject *t_formattable_isNumeric(t_formattable *self) { int b = self->object->isNumeric(); Py_RETURN_BOOL(b); } static PyObject *t_formattable_getDouble(t_formattable *self) { UErrorCode status = U_ZERO_ERROR; double d = self->object->getDouble(status); if (U_FAILURE(status)) return ICUException(status).reportError(); return PyFloat_FromDouble(d); } static PyObject *t_formattable_getLong(t_formattable *self) { UErrorCode status = U_ZERO_ERROR; int n = self->object->getLong(status); if (U_FAILURE(status)) return ICUException(status).reportError(); return PyInt_FromLong(n); } static PyObject *t_formattable_getInt64(t_formattable *self) { UErrorCode status = U_ZERO_ERROR; PY_LONG_LONG l = self->object->getInt64(status); if (U_FAILURE(status)) return ICUException(status).reportError(); return PyLong_FromLongLong(l); } static PyObject *t_formattable_getDate(t_formattable *self) { UErrorCode status = U_ZERO_ERROR; double date = self->object->getDate(status); if (U_FAILURE(status)) return ICUException(status).reportError(); return PyFloat_FromDouble(date / 1000.0); } static PyObject *t_formattable_getString(t_formattable *self, PyObject *args) { UErrorCode status = U_ZERO_ERROR; switch (PyTuple_Size(args)) { case 0: { UnicodeString u; self->object->getString(u, status); if (U_FAILURE(status)) return ICUException(status).reportError(); return PyUnicode_FromUnicodeString(&u); } case 1: { PyObject *arg = PyTuple_GET_ITEM(args, 0); UnicodeString *u; if (!parseArg(arg, "U", &u)) { self->object->getString(*u, status); if (U_FAILURE(status)) return ICUException(status).reportError(); Py_INCREF(arg); return arg; } break; } } return PyErr_SetArgsError((PyObject *) self, "getString", args); } static PyObject *t_formattable_setDouble(t_formattable *self, PyObject *arg) { double d; if (!parseArg(arg, "d", &d)) { self->object->setDouble(d); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setDouble", arg); } static PyObject *t_formattable_setLong(t_formattable *self, PyObject *arg) { int n; if (!parseArg(arg, "i", &n)) { self->object->setLong(n); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setLong", arg); } static PyObject *t_formattable_setInt64(t_formattable *self, PyObject *arg) { PY_LONG_LONG l; if (!parseArg(arg, "L", &l)) { self->object->setInt64(l); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setInt64", arg); } static PyObject *t_formattable_setDate(t_formattable *self, PyObject *arg) { double date; if (!parseArg(arg, "D", &date)) { self->object->setDate(date); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setDate", arg); } static PyObject *t_formattable_setString(t_formattable *self, PyObject *arg) { UnicodeString *u, _u; if (!parseArg(arg, "S", &u, &_u)) { self->object->setString(*u); /* copied */ Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setString", arg); } static PyObject *t_formattable_richcmp(t_formattable *self, PyObject *arg, int op) { Formattable *f; if (!parseArg(arg, "P", TYPE_CLASSID(Formattable), &f)) { int b = 0; switch (op) { case Py_EQ: b = *self->object == *f; break; case Py_NE: b = *self->object != *f; break; default: PyErr_SetNone(PyExc_NotImplementedError); return NULL; } Py_RETURN_BOOL(b); } return PyErr_SetArgsError((PyObject *) self, "__richcmp__", arg); } static PyObject *t_formattable_str(t_formattable *self) { UErrorCode status = U_ZERO_ERROR; UnicodeString u; switch (self->object->getType()) { case Formattable::kDate: { SimpleDateFormat f = SimpleDateFormat(status); if (U_FAILURE(status)) return ICUException(status).reportError(); f.format(*self->object, u, status); if (U_FAILURE(status)) return ICUException(status).reportError(); break; } case Formattable::kDouble: case Formattable::kLong: case Formattable::kInt64: { DecimalFormat f = DecimalFormat(status); if (U_FAILURE(status)) return ICUException(status).reportError(); f.format(*self->object, u, status); if (U_FAILURE(status)) return ICUException(status).reportError(); break; } case Formattable::kString: { self->object->getString(u, status); if (U_FAILURE(status)) return ICUException(status).reportError(); break; } default: return t_uobject_str((t_uobject *) self); } return PyUnicode_FromUnicodeString(&u); } static PyObject *t_formattable_repr(t_formattable *self) { PyObject *name = PyObject_GetAttrString((PyObject *) Py_TYPE(self), "__name__"); PyObject *str = Py_TYPE(self)->tp_str((PyObject *) self); if (str) { PyObject *repr = str->ob_type->tp_repr(str); Py_DECREF(str); str = repr; } if (!str) return NULL; #if PY_VERSION_HEX < 0x02040000 PyObject *args = Py_BuildValue("(OO)", name, str); #else PyObject *args = PyTuple_Pack(2, name, str); #endif PyObject *format = PyString_FromString("<%s: %s>"); PyObject *repr = PyString_Format(format, args); Py_DECREF(name); Py_DECREF(str); Py_DECREF(args); Py_DECREF(format); return repr; } /* MeasureUnit */ static PyObject *t_measureunit_richcmp(t_measureunit *self, PyObject *arg, int op) { int b = 0; switch (op) { case Py_EQ: case Py_NE: if (PyObject_TypeCheck(arg, &UObjectType_)) b = *self->object == *((t_uobject *) arg)->object; if (op == Py_EQ) Py_RETURN_BOOL(b); Py_RETURN_BOOL(!b); case Py_LT: case Py_LE: case Py_GT: case Py_GE: PyErr_SetNone(PyExc_NotImplementedError); return NULL; } return NULL; } /* Measure */ static PyObject *t_measure_getNumber(t_measure *self) { Formattable *f = new Formattable(self->object->getNumber()); return wrap_Formattable(f, T_OWNED); } static PyObject *t_measure_getUnit(t_measure *self) { MeasureUnit *u = (MeasureUnit *) self->object->getUnit().clone(); return wrap_MeasureUnit(u, T_OWNED); } static PyObject *t_measure_richcmp(t_measure *self, PyObject *arg, int op) { int b = 0; switch (op) { case Py_EQ: case Py_NE: if (PyObject_TypeCheck(arg, &UObjectType_)) b = *self->object == *((t_uobject *) arg)->object; if (op == Py_EQ) Py_RETURN_BOOL(b); Py_RETURN_BOOL(!b); case Py_LT: case Py_LE: case Py_GT: case Py_GE: PyErr_SetNone(PyExc_NotImplementedError); return NULL; } return NULL; } /* CurrencyUnit */ static int t_currencyunit_init(t_currencyunit *self, PyObject *args, PyObject *kwds) { UErrorCode status = U_ZERO_ERROR; UnicodeString *u; UnicodeString _u; if (!parseArgs(args, "S", &u, &_u)) { CurrencyUnit *cu = new CurrencyUnit(u->getTerminatedBuffer(), status); if (U_FAILURE(status)) { ICUException(status).reportError(); return -1; } self->object = cu; self->flags = T_OWNED; return 0; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; } static PyObject *t_currencyunit_getISOCurrency(t_currencyunit *self) { UnicodeString u(self->object->getISOCurrency()); return PyUnicode_FromUnicodeString(&u); } static PyObject *t_currencyunit_str(t_currencyunit *self) { UnicodeString u(self->object->getISOCurrency()); return PyUnicode_FromUnicodeString(&u); } /* CurrencyAmount */ static int t_currencyamount_init(t_currencyamount *self, PyObject *args, PyObject *kwds) { UErrorCode status = U_ZERO_ERROR; Formattable *f; double d; UnicodeString *u; UnicodeString _u; if (!parseArgs(args, "PS", TYPE_CLASSID(Formattable), &f, &u, &_u)) { CurrencyAmount *ca = new CurrencyAmount(*f, u->getTerminatedBuffer(), status); if (U_FAILURE(status)) { ICUException(status).reportError(); return -1; } self->object = ca; self->flags = T_OWNED; return 0; } if (!parseArgs(args, "dS", &d, &u, &_u)) { CurrencyAmount *ca = new CurrencyAmount(d, u->getTerminatedBuffer(), status); if (U_FAILURE(status)) { ICUException(status).reportError(); return -1; } self->object = ca; self->flags = T_OWNED; return 0; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; } static PyObject *t_currencyamount_getCurrency(t_currencyamount *self) { CurrencyUnit *cu = new CurrencyUnit(self->object->getCurrency()); return wrap_CurrencyUnit(cu, T_OWNED); } static PyObject *t_currencyamount_getISOCurrency(t_currencyamount *self) { UnicodeString u(self->object->getISOCurrency()); return PyUnicode_FromUnicodeString(&u); } static PyObject *t_currencyamount_str(t_currencyamount *self) { UnicodeString u(self->object->getISOCurrency()); UErrorCode status = U_ZERO_ERROR; double d = self->object->getNumber().getDouble(status); PyObject *currency = PyUnicode_FromUnicodeString(&u); PyObject *amount = PyFloat_FromDouble(d); PyObject *format = PyString_FromString("%s %0.2f"); PyObject *tuple = PyTuple_New(2); PyObject *str; PyTuple_SET_ITEM(tuple, 0, currency); PyTuple_SET_ITEM(tuple, 1, amount); str = PyString_Format(format, tuple); Py_DECREF(tuple); Py_DECREF(format); return str; } /* StringEnumeration */ static PyObject *t_stringenumeration_count(t_stringenumeration *self) { UErrorCode status = U_ZERO_ERROR; int i = self->object->count(status); if (U_FAILURE(status)) return ICUException(status).reportError(); return PyInt_FromLong(i); } static PyObject *t_stringenumeration_reset(t_stringenumeration *self) { UErrorCode status = U_ZERO_ERROR; self->object->reset(status); if (U_FAILURE(status)) return ICUException(status).reportError(); Py_RETURN_NONE; } static PyObject *t_stringenumeration_next(t_stringenumeration *self) { int32_t len; UErrorCode status = U_ZERO_ERROR; const char *str = self->object->next(&len, status); if (U_FAILURE(status)) return ICUException(status).reportError(); if (str == NULL) { PyErr_SetNone(PyExc_StopIteration); return NULL; } return PyString_FromStringAndSize(str, len); } static PyObject *t_stringenumeration_unext(t_stringenumeration *self) { int32_t len; UErrorCode status = U_ZERO_ERROR; const UChar *str = self->object->unext(&len, status); if (U_FAILURE(status)) return ICUException(status).reportError(); if (str == NULL) { PyErr_SetNone(PyExc_StopIteration); return NULL; } UnicodeString u(str); return PyUnicode_FromUnicodeString(&u); } static PyObject *t_stringenumeration_snext(t_stringenumeration *self) { UErrorCode status = U_ZERO_ERROR; const UnicodeString *str = self->object->snext(status); if (U_FAILURE(status)) return ICUException(status).reportError(); if (str == NULL) { PyErr_SetNone(PyExc_StopIteration); return NULL; } return wrap_UnicodeString(new UnicodeString(*str), T_OWNED); } static PyObject *t_stringenumeration_iter(t_stringenumeration *self) { Py_INCREF(self); return (PyObject *) self; } void _init_bases(PyObject *m) { UnicodeStringType_.tp_str = (reprfunc) t_unicodestring_str; UnicodeStringType_.tp_repr = (reprfunc) t_unicodestring_repr; UnicodeStringType_.tp_richcompare = (richcmpfunc) t_unicodestring_richcmp; UnicodeStringType_.tp_hash = (hashfunc) t_unicodestring_hash; UnicodeStringType_.tp_as_sequence = &t_unicodestring_as_sequence; #if PY_MAJOR_VERSION >= 3 UnicodeStringType_.tp_as_mapping = &t_unicodestring_as_mapping; #endif FormattableType_.tp_richcompare = (richcmpfunc) t_formattable_richcmp; FormattableType_.tp_str = (reprfunc) t_formattable_str; FormattableType_.tp_repr = (reprfunc) t_formattable_repr; MeasureUnitType_.tp_richcompare = (richcmpfunc) t_measureunit_richcmp; MeasureType_.tp_richcompare = (richcmpfunc) t_measure_richcmp; CurrencyUnitType_.tp_str = (reprfunc) t_currencyunit_str; CurrencyAmountType_.tp_str = (reprfunc) t_currencyamount_str; StringEnumerationType_.tp_iter = (getiterfunc) t_stringenumeration_iter; StringEnumerationType_.tp_iternext = (iternextfunc) t_stringenumeration_next; INSTALL_TYPE(UObject, m); INSTALL_TYPE(Replaceable, m); REGISTER_TYPE(UnicodeString, m); REGISTER_TYPE(Formattable, m); INSTALL_TYPE(MeasureUnit, m); INSTALL_TYPE(Measure, m); REGISTER_TYPE(CurrencyUnit, m); REGISTER_TYPE(CurrencyAmount, m); INSTALL_TYPE(StringEnumeration, m); INSTALL_MODULE_INT(m, U_FOLD_CASE_DEFAULT); INSTALL_MODULE_INT(m, U_COMPARE_CODE_POINT_ORDER); INSTALL_MODULE_INT(m, U_FOLD_CASE_EXCLUDE_SPECIAL_I); #if U_ICU_VERSION_HEX < VERSION_HEX(55, 1, 0) INSTALL_MODULE_INT(m, UIDNA_DEFAULT); INSTALL_MODULE_INT(m, UIDNA_ALLOW_UNASSIGNED); INSTALL_MODULE_INT(m, UIDNA_USE_STD3_RULES); #endif INSTALL_STATIC_INT(Formattable, kIsDate); INSTALL_STATIC_INT(Formattable, kDate); INSTALL_STATIC_INT(Formattable, kDouble); INSTALL_STATIC_INT(Formattable, kLong); INSTALL_STATIC_INT(Formattable, kString); INSTALL_STATIC_INT(Formattable, kArray); INSTALL_STATIC_INT(Formattable, kInt64); INSTALL_STATIC_INT(Formattable, kObject); } PyICU-1.9.5/bases.h0000644000076500000000000000357012520065775014146 0ustar vajdawheel00000000000000/* ==================================================================== * Copyright (c) 2004-2010 Open Source Applications Foundation. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. * ==================================================================== */ #ifndef _bases_h #define _bases_h #define T_OWNED 0x0001 class _wrapper { public: PyObject_HEAD int flags; }; class t_uobject : public _wrapper { public: UObject *object; }; void t_uobject_dealloc(t_uobject *self); extern PyTypeObject UObjectType_; extern PyTypeObject FormattableType_; PyObject *wrap_StringEnumeration(StringEnumeration *, int); PyObject *wrap_Formattable(Formattable *, int); PyObject *wrap_Formattable(Formattable &); PyObject *wrap_UnicodeString(UnicodeString *, int); PyObject *wrap_CurrencyAmount(CurrencyAmount *, int); void _init_bases(PyObject *m); #endif /* _bases_h */ PyICU-1.9.5/calendar.cpp0000644000076500000000000015402212662702070015145 0ustar vajdawheel00000000000000/* ==================================================================== * Copyright (c) 2004-2011 Open Source Applications Foundation. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. * ==================================================================== */ #include "common.h" #include "structmember.h" #include "bases.h" #include "locale.h" #include "calendar.h" #include "macros.h" DECLARE_CONSTANTS_TYPE(UCalendarDateFields); DECLARE_CONSTANTS_TYPE(UCalendarDaysOfWeek); DECLARE_CONSTANTS_TYPE(UCalendarMonths); DECLARE_CONSTANTS_TYPE(UCalendarAMPMs); /* TimeZone */ static PyObject *t_timezone_getOffset(t_timezone *self, PyObject *args); static PyObject *t_timezone_getRawOffset(t_timezone *self); static PyObject *t_timezone_setRawOffset(t_timezone *self, PyObject *arg); static PyObject *t_timezone_getID(t_timezone *self, PyObject *args); static PyObject *t_timezone_setID(t_timezone *self, PyObject *arg); static PyObject *t_timezone_getDisplayName(t_timezone *self, PyObject *args); static PyObject *t_timezone_useDaylightTime(t_timezone *self); static PyObject *t_timezone_inDaylightTime(t_timezone *self, PyObject *arg); static PyObject *t_timezone_hasSameRules(t_timezone *self, PyObject *arg); static PyObject *t_timezone_getDSTSavings(t_timezone *self); static PyObject *t_timezone_getGMT(PyTypeObject *type); static PyObject *t_timezone_createEnumeration(PyTypeObject *type, PyObject *args); static PyObject *t_timezone_countEquivalentIDs(PyTypeObject *type, PyObject *arg); static PyObject *t_timezone_getEquivalentID(PyTypeObject *type, PyObject *args); #if U_ICU_VERSION_HEX >= VERSION_HEX(52, 0, 0) static PyObject *t_timezone_getIDForWindowsID(PyTypeObject *type, PyObject *args); static PyObject *t_timezone_getWindowsID(PyTypeObject *type, PyObject *arg); #endif static PyObject *t_timezone_createDefault(PyTypeObject *type); static PyObject *t_timezone_setDefault(PyTypeObject *type, PyObject *arg); static PyMethodDef t_timezone_methods[] = { DECLARE_METHOD(t_timezone, getOffset, METH_VARARGS), DECLARE_METHOD(t_timezone, getRawOffset, METH_NOARGS), DECLARE_METHOD(t_timezone, setRawOffset, METH_O), DECLARE_METHOD(t_timezone, getID, METH_VARARGS), DECLARE_METHOD(t_timezone, setID, METH_O), DECLARE_METHOD(t_timezone, getDisplayName, METH_VARARGS), DECLARE_METHOD(t_timezone, useDaylightTime, METH_NOARGS), DECLARE_METHOD(t_timezone, inDaylightTime, METH_O), DECLARE_METHOD(t_timezone, hasSameRules, METH_O), DECLARE_METHOD(t_timezone, getDSTSavings, METH_NOARGS), DECLARE_METHOD(t_timezone, getGMT, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_timezone, createTimeZone, METH_O | METH_CLASS), DECLARE_METHOD(t_timezone, createEnumeration, METH_VARARGS | METH_CLASS), DECLARE_METHOD(t_timezone, countEquivalentIDs, METH_O | METH_CLASS), DECLARE_METHOD(t_timezone, getEquivalentID, METH_VARARGS | METH_CLASS), #if U_ICU_VERSION_HEX >= VERSION_HEX(52, 0, 0) DECLARE_METHOD(t_timezone, getIDForWindowsID, METH_VARARGS | METH_CLASS), DECLARE_METHOD(t_timezone, getWindowsID, METH_O | METH_CLASS), #endif DECLARE_METHOD(t_timezone, createDefault, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_timezone, setDefault, METH_O | METH_CLASS), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(TimeZone, t_timezone, UObject, TimeZone, abstract_init, NULL); /* SimpleTimeZone */ class t_simpletimezone : public _wrapper { public: SimpleTimeZone *object; }; static int t_simpletimezone_init(t_simpletimezone *self, PyObject *args, PyObject *kwds); static PyObject *t_simpletimezone_setStartYear(t_simpletimezone *self, PyObject *arg); static PyObject *t_simpletimezone_setStartRule(t_simpletimezone *self, PyObject *args); static PyObject *t_simpletimezone_setEndRule(t_simpletimezone *self, PyObject *args); static PyObject *t_simpletimezone_getOffset(t_simpletimezone *self, PyObject *args); static PyObject *t_simpletimezone_setDSTSavings(t_simpletimezone *self, PyObject *arg); static PyMethodDef t_simpletimezone_methods[] = { DECLARE_METHOD(t_simpletimezone, setStartYear, METH_O), DECLARE_METHOD(t_simpletimezone, setStartRule, METH_VARARGS), DECLARE_METHOD(t_simpletimezone, setEndRule, METH_VARARGS), DECLARE_METHOD(t_simpletimezone, getOffset, METH_VARARGS), DECLARE_METHOD(t_simpletimezone, setDSTSavings, METH_O), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(SimpleTimeZone, t_simpletimezone, TimeZone, SimpleTimeZone, t_simpletimezone_init, NULL); /* Calendar */ class t_calendar : public _wrapper { public: Calendar *object; }; static PyObject *t_calendar_getTime(t_calendar *self); static PyObject *t_calendar_setTime(t_calendar *self, PyObject *arg); static PyObject *t_calendar_isEquivalentTo(t_calendar *self, PyObject *arg); static PyObject *t_calendar_equals(t_calendar *self, PyObject *arg); static PyObject *t_calendar_before(t_calendar *self, PyObject *arg); static PyObject *t_calendar_after(t_calendar *self, PyObject *arg); static PyObject *t_calendar_add(t_calendar *self, PyObject *args); static PyObject *t_calendar_roll(t_calendar *self, PyObject *args); static PyObject *t_calendar_fieldDifference(t_calendar *self, PyObject *args); static PyObject *t_calendar_getTimeZone(t_calendar *self); static PyObject *t_calendar_setTimeZone(t_calendar *self, PyObject *arg); static PyObject *t_calendar_inDaylightTime(t_calendar *self); static PyObject *t_calendar_isLenient(t_calendar *self); static PyObject *t_calendar_setLenient(t_calendar *self, PyObject *arg); static PyObject *t_calendar_getType(t_calendar *self); static PyObject *t_calendar_getFirstDayOfWeek(t_calendar *self); static PyObject *t_calendar_setFirstDayOfWeek(t_calendar *self, PyObject *arg); static PyObject *t_calendar_getMinimalDaysInFirstWeek(t_calendar *self); static PyObject *t_calendar_setMinimalDaysInFirstWeek(t_calendar *self, PyObject *arg); static PyObject *t_calendar_getMinimum(t_calendar *self, PyObject *arg); static PyObject *t_calendar_getMaximum(t_calendar *self, PyObject *arg); static PyObject *t_calendar_getGreatestMinimum(t_calendar *self, PyObject *arg); static PyObject *t_calendar_getActualMinimum(t_calendar *self, PyObject *arg); static PyObject *t_calendar_getLeastMaximum(t_calendar *self, PyObject *arg); static PyObject *t_calendar_getActualMaximum(t_calendar *self, PyObject *arg); static PyObject *t_calendar_get(t_calendar *self, PyObject *arg); static PyObject *t_calendar_isSet(t_calendar *self, PyObject *arg); static PyObject *t_calendar_set(t_calendar *self, PyObject *args); static PyObject *t_calendar_clear(t_calendar *self, PyObject *args); static PyObject *t_calendar_haveDefaultCentury(t_calendar *self); static PyObject *t_calendar_defaultCenturyStart(t_calendar *self); static PyObject *t_calendar_defaultCenturyStartYear(t_calendar *self); static PyObject *t_calendar_getLocale(t_calendar *self, PyObject *args); static PyObject *t_calendar_getLocaleID(t_calendar *self, PyObject *args); static PyObject *t_calendar_createInstance(PyTypeObject *type, PyObject *args); static PyObject *t_calendar_getAvailableLocales(PyTypeObject *type); static PyObject *t_calendar_getNow(PyTypeObject *type); static PyMethodDef t_calendar_methods[] = { DECLARE_METHOD(t_calendar, getTime, METH_NOARGS), DECLARE_METHOD(t_calendar, setTime, METH_O), DECLARE_METHOD(t_calendar, isEquivalentTo, METH_O), DECLARE_METHOD(t_calendar, equals, METH_O), DECLARE_METHOD(t_calendar, before, METH_O), DECLARE_METHOD(t_calendar, after, METH_O), DECLARE_METHOD(t_calendar, add, METH_VARARGS), DECLARE_METHOD(t_calendar, roll, METH_VARARGS), DECLARE_METHOD(t_calendar, fieldDifference, METH_VARARGS), DECLARE_METHOD(t_calendar, getTimeZone, METH_NOARGS), DECLARE_METHOD(t_calendar, setTimeZone, METH_O), DECLARE_METHOD(t_calendar, inDaylightTime, METH_NOARGS), DECLARE_METHOD(t_calendar, isLenient, METH_NOARGS), DECLARE_METHOD(t_calendar, setLenient, METH_O), DECLARE_METHOD(t_calendar, getType, METH_NOARGS), DECLARE_METHOD(t_calendar, getFirstDayOfWeek, METH_NOARGS), DECLARE_METHOD(t_calendar, setFirstDayOfWeek, METH_O), DECLARE_METHOD(t_calendar, getMinimalDaysInFirstWeek, METH_NOARGS), DECLARE_METHOD(t_calendar, setMinimalDaysInFirstWeek, METH_O), DECLARE_METHOD(t_calendar, getMinimum, METH_O), DECLARE_METHOD(t_calendar, getMaximum, METH_O), DECLARE_METHOD(t_calendar, getGreatestMinimum, METH_O), DECLARE_METHOD(t_calendar, getActualMinimum, METH_O), DECLARE_METHOD(t_calendar, getLeastMaximum, METH_O), DECLARE_METHOD(t_calendar, getActualMaximum, METH_O), DECLARE_METHOD(t_calendar, get, METH_O), DECLARE_METHOD(t_calendar, isSet, METH_O), DECLARE_METHOD(t_calendar, set, METH_VARARGS), DECLARE_METHOD(t_calendar, clear, METH_VARARGS), DECLARE_METHOD(t_calendar, haveDefaultCentury, METH_NOARGS), DECLARE_METHOD(t_calendar, defaultCenturyStart, METH_NOARGS), DECLARE_METHOD(t_calendar, defaultCenturyStartYear, METH_NOARGS), DECLARE_METHOD(t_calendar, getLocale, METH_VARARGS), DECLARE_METHOD(t_calendar, getLocaleID, METH_VARARGS), DECLARE_METHOD(t_calendar, createInstance, METH_VARARGS | METH_CLASS), DECLARE_METHOD(t_calendar, getAvailableLocales, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_calendar, getNow, METH_NOARGS | METH_CLASS), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(Calendar, t_calendar, UObject, Calendar, abstract_init, NULL); /* GregorianCalendar */ class t_gregoriancalendar : public _wrapper { public: GregorianCalendar *object; }; static int t_gregoriancalendar_init(t_gregoriancalendar *self, PyObject *args, PyObject *kwds); static PyObject *t_gregoriancalendar_getGregorianChange(t_gregoriancalendar *self); static PyObject *t_gregoriancalendar_setGregorianChange(t_gregoriancalendar *self, PyObject *arg); static PyObject *t_gregoriancalendar_isLeapYear(t_gregoriancalendar *self, PyObject *arg); static PyMethodDef t_gregoriancalendar_methods[] = { DECLARE_METHOD(t_gregoriancalendar, getGregorianChange, METH_NOARGS), DECLARE_METHOD(t_gregoriancalendar, setGregorianChange, METH_O), DECLARE_METHOD(t_gregoriancalendar, isLeapYear, METH_O), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(GregorianCalendar, t_gregoriancalendar, Calendar, GregorianCalendar, t_gregoriancalendar_init, NULL); /* TimeZone */ PyObject *wrap_TimeZone(TimeZone *tz) { RETURN_WRAPPED_IF_ISINSTANCE(tz, SimpleTimeZone); return wrap_TimeZone(tz, T_OWNED); } PyObject *wrap_TimeZone(const TimeZone &tz) { return wrap_TimeZone(tz.clone()); } static PyObject *t_timezone_getOffset(t_timezone *self, PyObject *args) { UDate date; int local, rawOffset, dstOffset, offset; int era, year, month, day, dayOfWeek, millis, monthLength; switch (PyTuple_Size(args)) { case 2: if (!parseArgs(args, "Db", &date, &local)) { STATUS_CALL(self->object->getOffset(date, (UBool) local, rawOffset, dstOffset, status)); return Py_BuildValue("(ii)", rawOffset, dstOffset); } break; case 6: if (!parseArgs(args, "iiiiii", &era, &year, &month, &day, &dayOfWeek, &millis)) { STATUS_CALL(offset = self->object->getOffset((uint8_t) era, year, month, day, dayOfWeek, millis, status)); return PyInt_FromLong(offset); } break; case 7: if (!parseArgs(args, "iiiiiii", &era, &year, &month, &day, &dayOfWeek, &millis, &monthLength)) { STATUS_CALL(offset = self->object->getOffset((uint8_t) era, year, month, day, dayOfWeek, millis, monthLength, status)); return PyInt_FromLong(offset); } break; } return PyErr_SetArgsError((PyObject *) self, "getOffset", args); } static PyObject *t_timezone_getRawOffset(t_timezone *self) { return PyInt_FromLong(self->object->getRawOffset()); } static PyObject *t_timezone_setRawOffset(t_timezone *self, PyObject *arg) { int offset; if (!parseArg(arg, "i", &offset)) { self->object->setRawOffset(offset); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setRawOffset", arg); } static PyObject *t_timezone_getID(t_timezone *self, PyObject *args) { UnicodeString *u; UnicodeString _u; switch (PyTuple_Size(args)) { case 0: self->object->getID(_u); return PyUnicode_FromUnicodeString(&_u); case 1: if (!parseArgs(args, "U", &u)) { self->object->getID(*u); Py_RETURN_ARG(args, 0); } break; } return PyErr_SetArgsError((PyObject *) self, "getID", args); } static PyObject *t_timezone_setID(t_timezone *self, PyObject *arg) { UnicodeString *u, _u; if (!parseArg(arg, "S", &u, &_u)) { self->object->setID(*u); /* copied */ Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setID", arg); } static PyObject *t_timezone_getDisplayName(t_timezone *self, PyObject *args) { UnicodeString *u, _u; int daylight; Locale *locale; TimeZone::EDisplayType type; switch (PyTuple_Size(args)) { case 0: self->object->getDisplayName(_u); return PyUnicode_FromUnicodeString(&_u); case 1: if (!parseArgs(args, "P", TYPE_CLASSID(Locale), &locale)) { self->object->getDisplayName(*locale, _u); return PyUnicode_FromUnicodeString(&_u); } if (!parseArgs(args, "U", &u)) { self->object->getDisplayName(*u); Py_RETURN_ARG(args, 0); } break; case 2: if (!parseArgs(args, "bi", &daylight, &type)) { self->object->getDisplayName((UBool) daylight, type, _u); return PyUnicode_FromUnicodeString(&_u); } if (!parseArgs(args, "PU", TYPE_CLASSID(Locale), &locale, &u)) { self->object->getDisplayName(*locale, *u); Py_RETURN_ARG(args, 1); } break; case 3: if (!parseArgs(args, "biP", TYPE_CLASSID(Locale), &daylight, &type, &locale)) { self->object->getDisplayName((UBool) daylight, type, *locale, _u); return PyUnicode_FromUnicodeString(&_u); } if (!parseArgs(args, "biU", &daylight, &type, &u)) { self->object->getDisplayName((UBool) daylight, type, *u); Py_RETURN_ARG(args, 2); } break; case 4: if (!parseArgs(args, "biPU", TYPE_CLASSID(Locale), &daylight, &type, &locale, &u)) { self->object->getDisplayName((UBool) daylight, type, *locale, *u); Py_RETURN_ARG(args, 3); } break; } return PyErr_SetArgsError((PyObject *) self, "getDisplayName", args); } static PyObject *t_timezone_useDaylightTime(t_timezone *self) { UBool b = self->object->useDaylightTime(); Py_RETURN_BOOL(b); } static PyObject *t_timezone_inDaylightTime(t_timezone *self, PyObject *arg) { UDate date; UBool b; if (!parseArg(arg, "D", &date)) { STATUS_CALL(b = self->object->inDaylightTime(date, status)); Py_RETURN_BOOL(b); } return PyErr_SetArgsError((PyObject *) self, "inDaylightTime", arg); } static PyObject *t_timezone_hasSameRules(t_timezone *self, PyObject *arg) { TimeZone *tz; UBool b; if (!parseArg(arg, "P", TYPE_CLASSID(TimeZone), &tz)) { b = self->object->hasSameRules(*tz); Py_RETURN_BOOL(b); } return PyErr_SetArgsError((PyObject *) self, "hasSameRules", arg); } static PyObject *t_timezone_getDSTSavings(t_timezone *self) { return PyInt_FromLong(self->object->getDSTSavings()); } static PyObject *t_timezone_getGMT(PyTypeObject *type) { return wrap_TimeZone((TimeZone *) TimeZone::getGMT(), 0); } PyObject *t_timezone_createTimeZone(PyTypeObject *type, PyObject *arg) { UnicodeString *u; UnicodeString _u; if (!parseArg(arg, "S", &u, &_u)) { TimeZone *tz = TimeZone::createTimeZone(*u); const TimeZone *gmt = TimeZone::getGMT(); UnicodeString tzid, GMT; /* PyICU bug 8180 and ICU bug 5612: * https://bugzilla.osafoundation.org/show_bug.cgi?id=8180 * http://bugs.icu-project.org/trac/ticket/5612 * Only an Olson ID can be used with createTimeZone(). * If GMT is returned, it means the requested id was incorrect. * Matching it with the default timezone increases the likelihood of * returning a sensible timezone with the intended raw offset as the * non-Olson requested id is likely to have come from the OS's default * timezone id in the first place. */ tz->getID(tzid); gmt->getID(GMT); if (tzid == GMT && *u != GMT) { TimeZone *deflt = TimeZone::createDefault(); deflt->getID(tzid); if (tzid == *u) { delete tz; tz = deflt; } else delete deflt; } return wrap_TimeZone(tz); } return PyErr_SetArgsError(type, "createTimeZone", arg); } static PyObject *t_timezone_createEnumeration(PyTypeObject *type, PyObject *args) { int offset; charsArg country; switch (PyTuple_Size(args)) { case 0: return wrap_StringEnumeration(TimeZone::createEnumeration(), T_OWNED); case 1: if (!parseArgs(args, "i", &offset)) return wrap_StringEnumeration(TimeZone::createEnumeration(offset), T_OWNED); if (!parseArgs(args, "n", &country)) return wrap_StringEnumeration(TimeZone::createEnumeration(country), T_OWNED); break; } return PyErr_SetArgsError(type, "createEnumeration", args); } static PyObject *t_timezone_countEquivalentIDs(PyTypeObject *type, PyObject *arg) { UnicodeString *u; UnicodeString _u; if (!parseArg(arg, "S", &u, &_u)) return PyInt_FromLong(TimeZone::countEquivalentIDs(*u)); return PyErr_SetArgsError(type, "countEquivalentIDs", arg); } static PyObject *t_timezone_getEquivalentID(PyTypeObject *type, PyObject *args) { UnicodeString *u; UnicodeString _u; int index; if (!parseArgs(args, "Si", &u, &_u, &index)) { UnicodeString v = TimeZone::getEquivalentID(*u, index); return PyUnicode_FromUnicodeString(&v); } return PyErr_SetArgsError(type, "getEquivalentID", args); } #if U_ICU_VERSION_HEX >= VERSION_HEX(52, 0, 0) static PyObject *t_timezone_getIDForWindowsID(PyTypeObject *type, PyObject *args) { UnicodeString *winId; UnicodeString _winId; charsArg region; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "S", &winId, &_winId)) { UnicodeString id; STATUS_CALL(TimeZone::getIDForWindowsID(*winId, NULL, id, status)); return PyUnicode_FromUnicodeString(&id); } break; case 2: if (!parseArgs(args, "Sn", &winId, &_winId, ®ion)) { UnicodeString id; STATUS_CALL(TimeZone::getIDForWindowsID(*winId, region, id, status)); return PyUnicode_FromUnicodeString(&id); } break; } return PyErr_SetArgsError(type, "getIDForWindowsID", args); } static PyObject *t_timezone_getWindowsID(PyTypeObject *type, PyObject *arg) { UnicodeString *id; UnicodeString _id; if (!parseArg(arg, "S", &id, &_id)) { UnicodeString winId; STATUS_CALL(TimeZone::getWindowsID(*id, winId, status)); return PyUnicode_FromUnicodeString(&winId); } return PyErr_SetArgsError(type, "getWindowsID", arg); } #endif static PyObject *t_timezone_createDefault(PyTypeObject *type) { return wrap_TimeZone(TimeZone::createDefault()); } static PyObject *t_timezone_setDefault(PyTypeObject *type, PyObject *arg) { TimeZone *tz; if (!parseArg(arg, "P", TYPE_CLASSID(TimeZone), &tz)) { TimeZone::setDefault(*tz); /* copied */ PyObject *m = PyImport_ImportModule("icu"); PyObject *cls = PyObject_GetAttrString(m, "ICUtzinfo"); PyObject *result = PyObject_CallMethod( cls, (char *) "_resetDefault", (char *) "", NULL); Py_DECREF(m); Py_DECREF(cls); return result; } return PyErr_SetArgsError(type, "setDefault", arg); } static PyObject *t_timezone_str(t_timezone *self) { UnicodeString u; self->object->getID(u); return PyUnicode_FromUnicodeString(&u); } static PyObject *t_timezone_richcmp(t_timezone *self, PyObject *arg, int op) { int b = 0; TimeZone *tz; if (!parseArg(arg, "P", TYPE_CLASSID(TimeZone), &tz)) { switch (op) { case Py_EQ: case Py_NE: b = *self->object == *tz; if (op == Py_EQ) Py_RETURN_BOOL(b); Py_RETURN_BOOL(!b); case Py_LT: case Py_LE: case Py_GT: case Py_GE: PyErr_SetNone(PyExc_NotImplementedError); return NULL; } } return PyErr_SetArgsError((PyObject *) self, "__richcmp__", arg); } /* SimpleTimeZone */ static int t_simpletimezone_init(t_simpletimezone *self, PyObject *args, PyObject *kwds) { SimpleTimeZone *tz; UnicodeString *u; UnicodeString _u; int rawOffsetGMT, savingsStartMonth, savingsStartDayOfWeekInMonth; int savingsStartDayOfWeek, savingsStartTime, savingsEndMonth, savingsDST; int savingsEndDayOfWeekInMonth, savingsEndDayOfWeek, savingsEndTime; SimpleTimeZone::TimeMode startMode, endMode; switch (PyTuple_Size(args)) { case 2: if (!parseArgs(args, "iS", &rawOffsetGMT, &u, &_u)) { tz = new SimpleTimeZone(rawOffsetGMT, *u); self->object = tz; self->flags = T_OWNED; break; } case 10: if (!parseArgs(args, "iSiiiiiiii", &rawOffsetGMT, &u, &_u, &savingsStartMonth, &savingsStartDayOfWeekInMonth, &savingsStartDayOfWeek, &savingsStartTime, &savingsEndMonth, &savingsEndDayOfWeekInMonth, &savingsEndDayOfWeek, &savingsEndTime)) { INT_STATUS_CALL(tz = new SimpleTimeZone(rawOffsetGMT, *u, savingsStartMonth, savingsStartDayOfWeekInMonth, savingsStartDayOfWeek, savingsStartTime, savingsEndMonth, savingsEndDayOfWeekInMonth, savingsEndDayOfWeek, savingsEndTime, status)); self->object = tz; self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; case 11: if (!parseArgs(args, "iSiiiiiiiii", &rawOffsetGMT, &u, &_u, &savingsStartMonth, &savingsStartDayOfWeekInMonth, &savingsStartDayOfWeek, &savingsStartTime, &savingsEndMonth, &savingsEndDayOfWeekInMonth, &savingsEndDayOfWeek, &savingsEndTime, &savingsDST)) { INT_STATUS_CALL(tz = new SimpleTimeZone(rawOffsetGMT, *u, savingsStartMonth, savingsStartDayOfWeekInMonth, savingsStartDayOfWeek, savingsStartTime, savingsEndMonth, savingsEndDayOfWeekInMonth, savingsEndDayOfWeek, savingsEndTime, savingsDST, status)); self->object = tz; self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; case 13: if (!parseArgs(args, "iSiiiiiiiiiii", &rawOffsetGMT, &u, &_u, &savingsStartMonth, &savingsStartDayOfWeekInMonth, &savingsStartDayOfWeek, &savingsStartTime, &startMode, &savingsEndMonth, &savingsEndDayOfWeekInMonth, &savingsEndDayOfWeek, &savingsEndTime, &endMode, &savingsDST)) { INT_STATUS_CALL(tz = new SimpleTimeZone(rawOffsetGMT, *u, savingsStartMonth, savingsStartDayOfWeekInMonth, savingsStartDayOfWeek, savingsStartTime, startMode, savingsEndMonth, savingsEndDayOfWeekInMonth, savingsEndDayOfWeek, savingsEndTime, endMode, savingsDST, status)); self->object = tz; self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; default: PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; } if (self->object) return 0; return -1; } static PyObject *t_simpletimezone_setStartYear(t_simpletimezone *self, PyObject *arg) { int year; if (!parseArg(arg, "i", &year)) { self->object->setStartYear(year); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setStartYear", arg); } static PyObject *t_simpletimezone_setStartRule(t_simpletimezone *self, PyObject *args) { SimpleTimeZone::TimeMode mode; int month, dayOfMonth, dayOfWeek, dayOfWeekInMonth, time; int after; switch (PyTuple_Size(args)) { case 3: if (!parseArgs(args, "iii", &month, &dayOfMonth, &time)) { STATUS_CALL(self->object->setStartRule(month, dayOfMonth, time, status)); Py_RETURN_NONE; } break; case 4: if (!parseArgs(args, "iiii", &month, &dayOfWeekInMonth, &dayOfWeek, &time)) { STATUS_CALL(self->object->setStartRule(month, dayOfWeekInMonth, dayOfWeek, time, status)); Py_RETURN_NONE; } break; case 5: if (!parseArgs(args, "iiiiB", &month, &dayOfMonth, &dayOfWeek, &time, &after)) { STATUS_CALL(self->object->setStartRule(month, dayOfMonth, dayOfWeek, time, (UBool) after, status)); Py_RETURN_NONE; } break; if (!parseArgs(args, "iiiii", &month, &dayOfMonth, &dayOfWeek, &time, &mode)) { STATUS_CALL(self->object->setStartRule(month, dayOfMonth, dayOfWeek, time, mode, status)); Py_RETURN_NONE; } break; case 6: if (!parseArgs(args, "iiiiiib", &month, &dayOfMonth, &dayOfWeek, &time, &mode, &after)) { STATUS_CALL(self->object->setStartRule(month, dayOfMonth, dayOfWeek, time, mode, after, status)); Py_RETURN_NONE; } break; } return PyErr_SetArgsError((PyObject *) self, "setStartRule", args); } static PyObject *t_simpletimezone_setEndRule(t_simpletimezone *self, PyObject *args) { SimpleTimeZone::TimeMode mode; int month, dayOfMonth, dayOfWeek, dayOfWeekInMonth, time; int after; switch (PyTuple_Size(args)) { case 3: if (!parseArgs(args, "iii", &month, &dayOfMonth, &time)) { STATUS_CALL(self->object->setEndRule(month, dayOfMonth, time, status)); Py_RETURN_NONE; } break; case 4: if (!parseArgs(args, "iiii", &month, &dayOfWeekInMonth, &dayOfWeek, &time)) { STATUS_CALL(self->object->setEndRule(month, dayOfWeekInMonth, dayOfWeek, time, status)); Py_RETURN_NONE; } break; case 5: if (!parseArgs(args, "iiiiB", &month, &dayOfMonth, &dayOfWeek, &time, &after)) { STATUS_CALL(self->object->setEndRule(month, dayOfMonth, dayOfWeek, time, (UBool) after, status)); Py_RETURN_NONE; } break; if (!parseArgs(args, "iiiii", &month, &dayOfMonth, &dayOfWeek, &time, &mode)) { STATUS_CALL(self->object->setEndRule(month, dayOfMonth, dayOfWeek, time, mode, status)); Py_RETURN_NONE; } break; case 6: if (!parseArgs(args, "iiiiiib", &month, &dayOfMonth, &dayOfWeek, &time, &mode, &after)) { STATUS_CALL(self->object->setEndRule(month, dayOfMonth, dayOfWeek, time, mode, after, status)); Py_RETURN_NONE; } break; } return PyErr_SetArgsError((PyObject *) self, "setEndRule", args); } static PyObject *t_simpletimezone_getOffset(t_simpletimezone *self, PyObject *args) { int era, year, month, day, dayOfWeek, millis; int monthLength, prevMonthLength; int offset; if (!parseArgs(args, "iiiiiiii", &era, &year, &month, &day, &dayOfWeek, &millis, &monthLength, &prevMonthLength)) { STATUS_CALL(offset = self->object->getOffset(era, year, month, day, dayOfWeek, millis, monthLength, prevMonthLength, status)); return PyInt_FromLong(offset); } return t_timezone_getOffset((t_timezone *) self, args); } static PyObject *t_simpletimezone_setDSTSavings(t_simpletimezone *self, PyObject *arg) { int savings; if (!parseArg(arg, "i", &savings)) { STATUS_CALL(self->object->setDSTSavings(savings, status)); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setDSTSavings", arg); } /* Calendar */ PyObject *wrap_Calendar(Calendar *calendar) { RETURN_WRAPPED_IF_ISINSTANCE(calendar, GregorianCalendar); return wrap_Calendar(calendar, T_OWNED); } static PyObject *t_calendar_getTime(t_calendar *self) { UDate date; STATUS_CALL(date = self->object->getTime(status)); return PyFloat_FromDouble(date / 1000.0); } static PyObject *t_calendar_setTime(t_calendar *self, PyObject *arg) { UDate date; if (!parseArg(arg, "D", &date)) { STATUS_CALL(self->object->setTime(date, status)); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setTime", arg); } static PyObject *t_calendar_isEquivalentTo(t_calendar *self, PyObject *arg) { Calendar *calendar; int b; if (!parseArg(arg, "P", TYPE_ID(Calendar), &calendar)) { b = self->object->isEquivalentTo(*calendar); Py_RETURN_BOOL(b); } return PyErr_SetArgsError((PyObject *) self, "isEquivalentTo", arg); } static PyObject *t_calendar_equals(t_calendar *self, PyObject *arg) { Calendar *calendar; int b; if (!parseArg(arg, "P", TYPE_ID(Calendar), &calendar)) { STATUS_CALL(b = self->object->equals(*calendar, status)); Py_RETURN_BOOL(b); } return PyErr_SetArgsError((PyObject *) self, "equals", arg); } static PyObject *t_calendar_before(t_calendar *self, PyObject *arg) { Calendar *calendar; int b; if (!parseArg(arg, "P", TYPE_ID(Calendar), &calendar)) { STATUS_CALL(b = self->object->before(*calendar, status)); Py_RETURN_BOOL(b); } return PyErr_SetArgsError((PyObject *) self, "before", arg); } static PyObject *t_calendar_after(t_calendar *self, PyObject *arg) { Calendar *calendar; int b; if (!parseArg(arg, "P", TYPE_ID(Calendar), &calendar)) { STATUS_CALL(b = self->object->after(*calendar, status)); Py_RETURN_BOOL(b); } return PyErr_SetArgsError((PyObject *) self, "after", arg); } static PyObject *t_calendar_add(t_calendar *self, PyObject *args) { UCalendarDateFields field; int amount; if (!parseArgs(args, "ii", &field, &amount)) { STATUS_CALL(self->object->add(field, amount, status)); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "add", args); } static PyObject *t_calendar_roll(t_calendar *self, PyObject *args) { UCalendarDateFields field; int amount, up; if (!parseArgs(args, "iB", &field, &up)) { STATUS_CALL(self->object->roll(field, (UBool) up, status)); Py_RETURN_NONE; } if (!parseArgs(args, "ii", &field, &amount)) { STATUS_CALL(self->object->roll(field, amount, status)); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "roll", args); } static PyObject *t_calendar_fieldDifference(t_calendar *self, PyObject *args) { UDate date; UCalendarDateFields field; int diff; if (!parseArgs(args, "Di", &date, &field)) { STATUS_CALL(diff = self->object->fieldDifference(date, field, status)); return PyInt_FromLong(diff); } return PyErr_SetArgsError((PyObject *) self, "fieldDifference", args); } static PyObject *t_calendar_getTimeZone(t_calendar *self) { const TimeZone &tz = self->object->getTimeZone(); return wrap_TimeZone(tz); } static PyObject *t_calendar_setTimeZone(t_calendar *self, PyObject *arg) { TimeZone *tz; if (!parseArg(arg, "P", TYPE_CLASSID(TimeZone), &tz)) { self->object->setTimeZone(*tz); /* copied */ Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setTimeZone", arg); } static PyObject *t_calendar_inDaylightTime(t_calendar *self) { int b; STATUS_CALL(b = self->object->inDaylightTime(status)); Py_RETURN_BOOL(b); } static PyObject *t_calendar_isLenient(t_calendar *self) { int b = self->object->isLenient(); Py_RETURN_BOOL(b); } static PyObject *t_calendar_setLenient(t_calendar *self, PyObject *arg) { int b; if (!parseArg(arg, "b", &b)) { self->object->setLenient(b); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setLenient", arg); } static PyObject *t_calendar_getType(t_calendar *self) { return PyString_FromString(self->object->getType()); } static PyObject *t_calendar_getFirstDayOfWeek(t_calendar *self) { return PyInt_FromLong(self->object->getFirstDayOfWeek()); } static PyObject *t_calendar_setFirstDayOfWeek(t_calendar *self, PyObject *arg) { UCalendarDaysOfWeek day; if (!parseArg(arg, "i", &day)) { self->object->setFirstDayOfWeek(day); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setFirstDayOfWeek", arg); } static PyObject *t_calendar_getMinimalDaysInFirstWeek(t_calendar *self) { return PyInt_FromLong(self->object->getMinimalDaysInFirstWeek()); } static PyObject *t_calendar_setMinimalDaysInFirstWeek(t_calendar *self, PyObject *arg) { int days; if (!parseArg(arg, "i", &days)) { self->object->setMinimalDaysInFirstWeek(days); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setMinimalDaysInFirstWeek", arg); } static PyObject *t_calendar_getMinimum(t_calendar *self, PyObject *arg) { UCalendarDateFields field; if (!parseArg(arg, "i", &field)) return PyInt_FromLong(self->object->getMinimum(field)); return PyErr_SetArgsError((PyObject *) self, "getMinimum", arg); } static PyObject *t_calendar_getMaximum(t_calendar *self, PyObject *arg) { UCalendarDateFields field; if (!parseArg(arg, "i", &field)) return PyInt_FromLong(self->object->getMaximum(field)); return PyErr_SetArgsError((PyObject *) self, "getMaximum", arg); } static PyObject *t_calendar_getGreatestMinimum(t_calendar *self, PyObject *arg) { UCalendarDateFields field; if (!parseArg(arg, "i", &field)) return PyInt_FromLong(self->object->getGreatestMinimum(field)); return PyErr_SetArgsError((PyObject *) self, "getGreatestMinimum", arg); } static PyObject *t_calendar_getActualMinimum(t_calendar *self, PyObject *arg) { UCalendarDateFields field; int actual; if (!parseArg(arg, "i", &field)) { STATUS_CALL(actual = self->object->getActualMinimum(field, status)); return PyInt_FromLong(actual); } return PyErr_SetArgsError((PyObject *) self, "getActualMinimum", arg); } static PyObject *t_calendar_getLeastMaximum(t_calendar *self, PyObject *arg) { UCalendarDateFields field; if (!parseArg(arg, "i", &field)) return PyInt_FromLong(self->object->getLeastMaximum(field)); return PyErr_SetArgsError((PyObject *) self, "getLeastMaximum", arg); } static PyObject *t_calendar_getActualMaximum(t_calendar *self, PyObject *arg) { UCalendarDateFields field; int actual; if (!parseArg(arg, "i", &field)) { STATUS_CALL(actual = self->object->getActualMaximum(field, status)); return PyInt_FromLong(actual); } return PyErr_SetArgsError((PyObject *) self, "getActualMaximum", arg); } static PyObject *t_calendar_get(t_calendar *self, PyObject *arg) { UCalendarDateFields field; int value; if (!parseArg(arg, "i", &field)) { STATUS_CALL(value = self->object->get(field, status)); return PyInt_FromLong(value); } return PyErr_SetArgsError((PyObject *) self, "get", arg); } static PyObject *t_calendar_isSet(t_calendar *self, PyObject *arg) { UCalendarDateFields field; int b; if (!parseArg(arg, "i", &field)) { b = self->object->isSet(field); Py_RETURN_BOOL(b); } return PyErr_SetArgsError((PyObject *) self, "isSet", arg); } static PyObject *t_calendar_set(t_calendar *self, PyObject *args) { int year, month, date, hour, minute, second; int field, value; switch (PyTuple_Size(args)) { case 2: if (!parseArgs(args, "ii", &field, &value)) { self->object->set((UCalendarDateFields) field, value); Py_RETURN_NONE; } break; case 3: if (!parseArgs(args, "iii", &year, &month, &date)) { self->object->set(year, month, date); Py_RETURN_NONE; } break; case 5: if (!parseArgs(args, "iiiii", &year, &month, &date, &hour, &minute)) { self->object->set(year, month, date, hour, minute); Py_RETURN_NONE; } break; case 6: if (!parseArgs(args, "iiiiii", &year, &month, &date, &hour, &minute, &second)) { self->object->set(year, month, date, hour, minute, second); Py_RETURN_NONE; } break; } return PyErr_SetArgsError((PyObject *) self, "set", args); } static PyObject *t_calendar_clear(t_calendar *self, PyObject *args) { UCalendarDateFields field; switch (PyTuple_Size(args)) { case 0: self->object->clear(); Py_RETURN_NONE; case 1: if (!parseArgs(args, "i", &field)) { self->object->clear(field); Py_RETURN_NONE; } break; } return PyErr_SetArgsError((PyObject *) self, "clear", args); } static PyObject *t_calendar_haveDefaultCentury(t_calendar *self) { int b = self->object->haveDefaultCentury(); Py_RETURN_BOOL(b); } static PyObject *t_calendar_defaultCenturyStart(t_calendar *self) { UDate date = self->object->defaultCenturyStart(); return PyFloat_FromDouble(date / 1000.0); } static PyObject *t_calendar_defaultCenturyStartYear(t_calendar *self) { int year = self->object->defaultCenturyStartYear(); return PyInt_FromLong(year); } static PyObject *t_calendar_getLocale(t_calendar *self, PyObject *args) { ULocDataLocaleType type; Locale locale; switch (PyTuple_Size(args)) { case 0: STATUS_CALL(locale = self->object->getLocale(ULOC_VALID_LOCALE, status)); return wrap_Locale(locale); case 1: if (!parseArgs(args, "i", &type)) { STATUS_CALL(locale = self->object->getLocale(type, status)); return wrap_Locale(locale); } break; } return PyErr_SetArgsError((PyObject *) self, "getLocale", args); } static PyObject *t_calendar_getLocaleID(t_calendar *self, PyObject *args) { ULocDataLocaleType type; const char *id; switch (PyTuple_Size(args)) { case 0: STATUS_CALL(id = self->object->getLocaleID(ULOC_VALID_LOCALE, status)); return PyString_FromString(id); case 1: if (!parseArgs(args, "i", &type)) { STATUS_CALL(id = self->object->getLocaleID(type, status)); return PyString_FromString(id); } break; } return PyErr_SetArgsError((PyObject *) self, "getLocaleID", args); } static PyObject *t_calendar_createInstance(PyTypeObject *type, PyObject *args) { TimeZone *tz; Locale *locale; Calendar *calendar; switch (PyTuple_Size(args)) { case 0: { STATUS_CALL(calendar = Calendar::createInstance(status)); return wrap_Calendar(calendar); } case 1: if (!parseArgs(args, "P", TYPE_CLASSID(TimeZone), &tz)) { STATUS_CALL(calendar = Calendar::createInstance(*tz, status)); return wrap_Calendar(calendar); } if (!parseArgs(args, "P", TYPE_CLASSID(Locale), &locale)) { STATUS_CALL(calendar = Calendar::createInstance(*locale, status)); return wrap_Calendar(calendar); } break; case 2: if (!parseArgs(args, "PP", TYPE_CLASSID(TimeZone), TYPE_CLASSID(Locale), &tz, &locale)) { STATUS_CALL(calendar = Calendar::createInstance(*tz, *locale, status)); return wrap_Calendar(calendar); } break; } return PyErr_SetArgsError(type, "createInstance", args); } static PyObject *t_calendar_getAvailableLocales(PyTypeObject *type) { int count; const Locale *locales = Calendar::getAvailableLocales(count); PyObject *dict = PyDict_New(); for (int32_t i = 0; i < count; i++) { Locale *locale = (Locale *) locales + i; PyObject *obj = wrap_Locale(locale, 0); PyDict_SetItemString(dict, locale->getName(), obj); Py_DECREF(obj); } return dict; } static PyObject *t_calendar_getNow(PyTypeObject *type) { UDate date = Calendar::getNow(); return PyFloat_FromDouble(date / 1000.0); } static PyObject *t_calendar_str(t_calendar *self) { UDate date; Locale locale; UnicodeString u; STATUS_CALL(date = self->object->getTime(status)); STATUS_CALL(locale = self->object->getLocale(ULOC_VALID_LOCALE, status)); DateFormat *df = DateFormat::createDateTimeInstance(DateFormat::kDefault, DateFormat::kDefault, locale); df->format(date, u); delete df; return PyUnicode_FromUnicodeString(&u); } static PyObject *t_calendar_richcmp(t_calendar *self, PyObject *arg, int op) { int b = 0; Calendar *calendar; if (!parseArg(arg, "P", TYPE_ID(Calendar), &calendar)) { switch (op) { case Py_EQ: case Py_NE: b = *self->object == *calendar; if (op == Py_EQ) Py_RETURN_BOOL(b); Py_RETURN_BOOL(!b); case Py_LT: case Py_LE: case Py_GT: case Py_GE: PyErr_SetNone(PyExc_NotImplementedError); return NULL; } } return PyErr_SetArgsError((PyObject *) self, "__richcmp__", arg); } /* GregorianCalendar */ static int t_gregoriancalendar_init(t_gregoriancalendar *self, PyObject *args, PyObject *kwds) { SimpleTimeZone *tz; Locale *locale; int year, month, date, hour, minute, second; GregorianCalendar *calendar; switch (PyTuple_Size(args)) { case 0: INT_STATUS_CALL(calendar = new GregorianCalendar(status)); self->object = calendar; self->flags = T_OWNED; break; case 1: if (!parseArgs(args, "P", TYPE_CLASSID(TimeZone), &tz)) { INT_STATUS_CALL(calendar = new GregorianCalendar(*tz, status)); self->object = calendar; self->flags = T_OWNED; break; } if (!parseArgs(args, "P", TYPE_CLASSID(Locale), &locale)) { INT_STATUS_CALL(calendar = new GregorianCalendar(*locale, status)); self->object = calendar; self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; case 2: if (!parseArgs(args, "PP", TYPE_CLASSID(TimeZone), TYPE_CLASSID(Locale), &tz, &locale)) { INT_STATUS_CALL(calendar = new GregorianCalendar(*tz, *locale, status)); self->object = calendar; self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; case 3: if (!parseArgs(args, "iii", &year, &month, &date)) { INT_STATUS_CALL(calendar = new GregorianCalendar(year, month, date, status)); self->object = calendar; self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; case 5: if (!parseArgs(args, "iiiii", &year, &month, &date, &hour, &minute)) { INT_STATUS_CALL(calendar = new GregorianCalendar(year, month, date, hour, minute, status)); self->object = calendar; self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; case 6: if (!parseArgs(args, "iiiiii", &year, &month, &date, &hour, &minute, &second)) { INT_STATUS_CALL(calendar = new GregorianCalendar(year, month, date, hour, minute, second, status)); self->object = calendar; self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; default: PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; } if (self->object) return 0; return -1; } static PyObject *t_gregoriancalendar_getGregorianChange(t_gregoriancalendar *self) { UDate date = self->object->getGregorianChange(); return PyFloat_FromDouble(date / 1000.0); } static PyObject *t_gregoriancalendar_setGregorianChange(t_gregoriancalendar *self, PyObject *arg) { UDate date; if (!parseArg(arg, "D", &date)) { STATUS_CALL(self->object->setGregorianChange(date, status)); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setGregorianChange", arg); } static PyObject *t_gregoriancalendar_isLeapYear(t_gregoriancalendar *self, PyObject *arg) { int year, b; if (!parseArg(arg, "i", &year)) { b = self->object->isLeapYear(year); Py_RETURN_BOOL(b); } return PyErr_SetArgsError((PyObject *) self, "isLeapYear", arg); } void _init_calendar(PyObject *m) { TimeZoneType_.tp_str = (reprfunc) t_timezone_str; TimeZoneType_.tp_richcompare = (richcmpfunc) t_timezone_richcmp; CalendarType_.tp_str = (reprfunc) t_calendar_str; CalendarType_.tp_richcompare = (richcmpfunc) t_calendar_richcmp; INSTALL_CONSTANTS_TYPE(UCalendarDateFields, m); INSTALL_CONSTANTS_TYPE(UCalendarDaysOfWeek, m); INSTALL_CONSTANTS_TYPE(UCalendarMonths, m); INSTALL_CONSTANTS_TYPE(UCalendarAMPMs, m); REGISTER_TYPE(TimeZone, m); REGISTER_TYPE(SimpleTimeZone, m); INSTALL_TYPE(Calendar, m); REGISTER_TYPE(GregorianCalendar, m); INSTALL_ENUM(UCalendarDateFields, "ERA", UCAL_ERA); INSTALL_ENUM(UCalendarDateFields, "YEAR", UCAL_YEAR); INSTALL_ENUM(UCalendarDateFields, "MONTH", UCAL_MONTH); INSTALL_ENUM(UCalendarDateFields, "WEEK_OF_YEAR", UCAL_WEEK_OF_YEAR); INSTALL_ENUM(UCalendarDateFields, "WEEK_OF_MONTH", UCAL_WEEK_OF_MONTH); INSTALL_ENUM(UCalendarDateFields, "DATE", UCAL_DATE); INSTALL_ENUM(UCalendarDateFields, "DAY_OF_YEAR", UCAL_DAY_OF_YEAR); INSTALL_ENUM(UCalendarDateFields, "DAY_OF_WEEK", UCAL_DAY_OF_WEEK); INSTALL_ENUM(UCalendarDateFields, "DAY_OF_WEEK_IN_MONTH", UCAL_DAY_OF_WEEK_IN_MONTH); INSTALL_ENUM(UCalendarDateFields, "AM_PM", UCAL_AM_PM); INSTALL_ENUM(UCalendarDateFields, "HOUR", UCAL_HOUR); INSTALL_ENUM(UCalendarDateFields, "HOUR_OF_DAY", UCAL_HOUR_OF_DAY); INSTALL_ENUM(UCalendarDateFields, "MINUTE", UCAL_MINUTE); INSTALL_ENUM(UCalendarDateFields, "SECOND", UCAL_SECOND); INSTALL_ENUM(UCalendarDateFields, "MILLISECOND", UCAL_MILLISECOND); INSTALL_ENUM(UCalendarDateFields, "ZONE_OFFSET", UCAL_ZONE_OFFSET); INSTALL_ENUM(UCalendarDateFields, "DST_OFFSET", UCAL_DST_OFFSET); INSTALL_ENUM(UCalendarDateFields, "YEAR_WOY", UCAL_YEAR_WOY); INSTALL_ENUM(UCalendarDateFields, "DOW_LOCAL", UCAL_DOW_LOCAL); INSTALL_ENUM(UCalendarDateFields, "EXTENDED_YEAR", UCAL_EXTENDED_YEAR); INSTALL_ENUM(UCalendarDateFields, "JULIAN_DAY", UCAL_JULIAN_DAY); INSTALL_ENUM(UCalendarDateFields, "MILLISECONDS_IN_DAY", UCAL_MILLISECONDS_IN_DAY); INSTALL_ENUM(UCalendarDateFields, "DAY_OF_MONTH", UCAL_DAY_OF_MONTH); INSTALL_ENUM(UCalendarDaysOfWeek, "SUNDAY", UCAL_SUNDAY); INSTALL_ENUM(UCalendarDaysOfWeek, "MONDAY", UCAL_MONDAY); INSTALL_ENUM(UCalendarDaysOfWeek, "TUESDAY", UCAL_TUESDAY); INSTALL_ENUM(UCalendarDaysOfWeek, "WEDNESDAY", UCAL_WEDNESDAY); INSTALL_ENUM(UCalendarDaysOfWeek, "THURSDAY", UCAL_THURSDAY); INSTALL_ENUM(UCalendarDaysOfWeek, "FRIDAY", UCAL_FRIDAY); INSTALL_ENUM(UCalendarDaysOfWeek, "SATURDAY", UCAL_SATURDAY); INSTALL_ENUM(UCalendarMonths, "JANUARY", UCAL_JANUARY); INSTALL_ENUM(UCalendarMonths, "FEBRUARY", UCAL_FEBRUARY); INSTALL_ENUM(UCalendarMonths, "MARCH", UCAL_MARCH); INSTALL_ENUM(UCalendarMonths, "APRIL", UCAL_APRIL); INSTALL_ENUM(UCalendarMonths, "MAY", UCAL_MAY); INSTALL_ENUM(UCalendarMonths, "JUNE", UCAL_JUNE); INSTALL_ENUM(UCalendarMonths, "JULY", UCAL_JULY); INSTALL_ENUM(UCalendarMonths, "AUGUST", UCAL_AUGUST); INSTALL_ENUM(UCalendarMonths, "SEPTEMBER", UCAL_SEPTEMBER); INSTALL_ENUM(UCalendarMonths, "OCTOBER", UCAL_OCTOBER); INSTALL_ENUM(UCalendarMonths, "NOVEMBER", UCAL_NOVEMBER); INSTALL_ENUM(UCalendarMonths, "DECEMBER", UCAL_DECEMBER); INSTALL_ENUM(UCalendarMonths, "UNDECIMBER", UCAL_UNDECIMBER); INSTALL_ENUM(UCalendarAMPMs, "AM", UCAL_AM); INSTALL_ENUM(UCalendarAMPMs, "PM", UCAL_PM); INSTALL_STATIC_INT(TimeZone, SHORT); INSTALL_STATIC_INT(TimeZone, LONG); INSTALL_STATIC_INT(SimpleTimeZone, WALL_TIME); INSTALL_STATIC_INT(SimpleTimeZone, STANDARD_TIME); INSTALL_STATIC_INT(SimpleTimeZone, UTC_TIME); INSTALL_STATIC_INT(Calendar, ERA); INSTALL_STATIC_INT(Calendar, YEAR); INSTALL_STATIC_INT(Calendar, MONTH); INSTALL_STATIC_INT(Calendar, WEEK_OF_YEAR); INSTALL_STATIC_INT(Calendar, WEEK_OF_MONTH); INSTALL_STATIC_INT(Calendar, DATE); INSTALL_STATIC_INT(Calendar, DAY_OF_YEAR); INSTALL_STATIC_INT(Calendar, DAY_OF_WEEK); INSTALL_STATIC_INT(Calendar, DAY_OF_WEEK_IN_MONTH); INSTALL_STATIC_INT(Calendar, AM_PM); INSTALL_STATIC_INT(Calendar, HOUR); INSTALL_STATIC_INT(Calendar, HOUR_OF_DAY); INSTALL_STATIC_INT(Calendar, MINUTE); INSTALL_STATIC_INT(Calendar, SECOND); INSTALL_STATIC_INT(Calendar, MILLISECOND); INSTALL_STATIC_INT(Calendar, ZONE_OFFSET); INSTALL_STATIC_INT(Calendar, DST_OFFSET); INSTALL_STATIC_INT(Calendar, YEAR_WOY); INSTALL_STATIC_INT(Calendar, DOW_LOCAL); INSTALL_STATIC_INT(Calendar, SUNDAY); INSTALL_STATIC_INT(Calendar, MONDAY); INSTALL_STATIC_INT(Calendar, TUESDAY); INSTALL_STATIC_INT(Calendar, WEDNESDAY); INSTALL_STATIC_INT(Calendar, THURSDAY); INSTALL_STATIC_INT(Calendar, FRIDAY); INSTALL_STATIC_INT(Calendar, SATURDAY); INSTALL_STATIC_INT(Calendar, JANUARY); INSTALL_STATIC_INT(Calendar, FEBRUARY); INSTALL_STATIC_INT(Calendar, MARCH); INSTALL_STATIC_INT(Calendar, APRIL); INSTALL_STATIC_INT(Calendar, MAY); INSTALL_STATIC_INT(Calendar, JUNE); INSTALL_STATIC_INT(Calendar, JULY); INSTALL_STATIC_INT(Calendar, AUGUST); INSTALL_STATIC_INT(Calendar, SEPTEMBER); INSTALL_STATIC_INT(Calendar, OCTOBER); INSTALL_STATIC_INT(Calendar, NOVEMBER); INSTALL_STATIC_INT(Calendar, DECEMBER); INSTALL_STATIC_INT(Calendar, UNDECIMBER); INSTALL_STATIC_INT(Calendar, AM); INSTALL_STATIC_INT(Calendar, PM); INSTALL_STATIC_INT(GregorianCalendar, BC); INSTALL_STATIC_INT(GregorianCalendar, AD); } PyICU-1.9.5/calendar.h0000644000076500000000000000335412520066263014613 0ustar vajdawheel00000000000000/* ==================================================================== * Copyright (c) 2004-2010 Open Source Applications Foundation. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. * ==================================================================== */ #ifndef _calendar_h #define _calendar_h class t_timezone : public _wrapper { public: TimeZone *object; }; extern PyTypeObject CalendarType_; extern PyTypeObject TimeZoneType_; PyObject *wrap_Calendar(Calendar *, int); PyObject *wrap_TimeZone(TimeZone *, int); PyObject *wrap_TimeZone(TimeZone *); PyObject *wrap_TimeZone(const TimeZone &); PyObject *t_timezone_createTimeZone(PyTypeObject *type, PyObject *arg); void _init_calendar(PyObject *m); #endif /* _calendar_h */ PyICU-1.9.5/CHANGES0000644000076500000000000002635413011412464013663 0ustar vajdawheel00000000000000Version 1.9.4 -> 1.9.5 ---------------------- - added icu-config --version check in setup.py to exclude libicule from libs - fixed bug with Python3.3+ <-> UnicodeString conversion with surrogate pairs - reworked Python3.3+ <-> UnicodeString with no allocations (Markus Scherer) - fixed bugs with 32bit Python2..Python3.2 <-> UnicodeString conversions - added conditionals around uses of features in newer ICUs (Keegan Parker) Version 1.9.3 -> 1.9.4 ---------------------- - added wrappers for uloc_addLikelySubtags(), uloc_minimizeSubtags() on Locale - fixed bug in some script.cpp wrappers not accepting surrogate pairs - added wrapper for UnicodeString.countChar32() and test - fixed crasher due to ICUException not incref'ing members during copy - added support for ICU 58.1 (conditionally removed layout engine wrapper) - fixed bug in StringCharacterIterator's dealloc freeing random memory - reworked Python <-> Unicode conversions for Python 3.3+ to use new APIs Version 1.9.2 -> 1.9.3 ---------------------- - added missing conditionals around uses of features in newer ICU versions - added wrappers for TimeZone::getIDForWindowsID, TimeZone::getWindowsID - added wrappers for DateTimePatternGenerator - added missing Context and BooleanAttribute wrappers on DateFormat - added support for ICU 57.1 - build tested with Python 2.7.5, Python 3.5.1 and PyPy 2.2.1 Version 1.9 -> 1.9.2 -------------------- - added MANIFEST.in to ensure nothing's missing in the 'sdist' package - enabled -Wwrite-strings and fixed warnings - added missing conditionals around uses of features in newer ICU versions Version 1.8 -> 1.9 ------------------ - fixed utf-8 conversion error position reporting (bug 13113) - fixed delete/delete[] bug in common.cpp (Fredrik Roubert) - added support for ICU 54.1 - added wrapper for USpoofChecker and related enums - added support for ICU 55.1 - replaced UnicodeString idna methods with new uidna.h UTS #46 wrapper (55.1) - added wrapper for Char functions and related enums (from uchar.h) - added wrapper for Shape defines and shapeArabic() (from ushape.h) - added wrapper for RelativeDateTimeFormatter (bug 13115) - build tested with Python 2.7.5, Python 3.3.0 and PyPy 2.2.1 Version 1.7 -> 1.8 ------------------ - added wrapper for Locale::getRoot() - added tp_hash implementation for Locale type based on Locale::hashCode() - fixed bug 13112 (Markus Scherer) - added support for building with PyPy (tested on PyPy 2.2.1 / Python 2.7.3) - added Locale(lcid) constructor calling uloc_getLocaleForLCID() - added wrapper for CompactDecimalFormat and its createInstance() method Version 1.6 -> 1.7 ------------------ - added missing #include for - fixed issues building against ICU 4.2 - added wrapper for Script.isRightToLeft() (bug 13081) - added support for ICU 53.1 (bug 13110) - added wrappers for other Script functions introduced in ICU 51 Version 1.5 -> 1.6 ------------------ - removed wrappers for some layoutengine.cpp internal flags (bug 13074) - added wrappers for ULocaleData functions (bug 13080) - added wrappers for uscript functions and UScriptCode enum (bug 13081) - generalized freebsd setup.py support (Laurence Parry) - added support for ICU 52.1 - added wrapper for Locale::setKeywordValue() - added Locale::removeKeywordValue() - added support for ListFormatter - build tested with Python 2.7 and Python 3.3.0 Version 1.4 -> 1.5 ------------------ - added wrapper for MessageFormat::format(argumentNames, arguments, ...) - fixed bug in t_transliterator_filteredTransliterate passing UBool for int - added wrapper for DateFormat::format(Calendar) - added wrapper for Calendar::set(UCalendarDateFields field, value) - added wrappers for UnicodeString::toTitle() w/o iterator (Fredrik Roubert) - added support for ICU 50.1 - improved test_Collator's testGetSortKey() (Markus Scherer) - added pypi classifiers to PyICU project info, including Python 3 tag - build tested with Python 2.7 and Python 3.3.0 Version 1.3 -> 1.4 ------------------ - fixed bug with default tzinfo set on ICUtzinfo type (bug 13038) - fixed bug 13040 (Martin Hosken) - added wrapper for Transliterator::toRules() - added missing wrapper for RuleBasedNumberFormat(URBNFRuleSetTag, Locale) - added support for ICU 49.1.1 - implemented wrapper for new NumberFormat.parseCurrency() - fixed bug in CurrencyAmount.str() not calling correct getDouble() overload - added ScriptCode constants new in 49.0 Version 1.2 -> 1.3 ------------------ - fixed bug 13031 - PyICU ready for Python 3.2 (tests pass 2to3'd) (Martin von Gagern) - added auto-conversion of test sources for Python 3 during setup - added support for LEFontInstance and LayoutEngine (Martin Hosken, bug 13035) - fixed bugs in RegexMatcher and RegexPattern not keeping their inputs - added support for ICU 4.8.1.1 Version 1.1 -> 1.2 ------------------ - fixed bug 13009 (Martin von Gagern) - fixed bug 13011 (Martin von Gagern) - some unit test beautification (Martin von Gagern) - added macros for RTTI checks (Martin von Gagern) - fixed bug 13012 - fixed bug 13013 (Yuriy Pilgun) - added wrappers for Locale::isBogus()/setToBogus() (Jimmy Yuen Ho Wong) - fixed bug 13022 (Martin von Gagern) - added support for ICU 4.8 Version 1.0 -> 1.1 ------------------ - added support for ICU 4.6 - switched to using RTTI if ICU >= 4.6 instead of poor man's ICU RTTI - fixed bug with incorrect icu.VERSION string on Windows build Version 1.0 -> 1.0.1 -------------------- - removed variable length array uses in regex.cpp (Chandler Carruth) - fixed bug 12983 - fixed bug with BreakIterator.setText() not keeping reference to text - fixed incorrect conditional include in locale.cpp (Ralf Haring) - fixed incorrect spellings of PyErr_SetFromWindowsErrWithFilename (ditto) - fixed incorrect declaration of PythonTransliterator (Christian Heimes) Version 0.9 -> 1.0 ------------------ - added support for UnicodeSet, UnicodeFunctor, UnicodeFilter, UnicodeMatcher - added support for RegexPattern and RegexMatcher - added support for Normalizer - added support for UTransPosition (Christoph Burgmer) - added support for UTransPosition and UnicodeFilter methods to Transliterator - fixed bug in UnicodeString single character assignment method - added support for extending Transliterator from Python (Christoph Burgmer) - improved support for in-place operations on UnicodeStrings - added support for Transliterator::registerInstance (Christoph Burgmer) - added support for ICU 4.4 - added support for Normalizer2, FilteredNormalizer2 if ICU version >= 4.4 - added support for SelectFormat if ICU version >= 4.4 - added support for TimeUnitFormat if ICU version >= 4.2 - added support for PluralRules and PluralFormat if ICU version >= 4.0 - added support for DateInterval, DateIntervalFormat if ICU version >= 4.0 - added support for CurrencyPluralInfo if ICU version >= 4.2 - added support for UnicodeSetIterator and UnicodeSet iterates via it - added support for SearchIterator and StringSearch - added some missing Collator and RuleBasedCollator methods - refreshed README and CREDITS - fixed bugs with UnicodeString-converted text arg ownership in iterators - added missing conditionals for features in ICU versions >= 4.0 - README now marked-up with reStructuredText (Christoph Burgmer) - PyICU main module renamed to 'icu' (with deprecation warning for old name) - UnicodeString objects are now hashable - reviewed all wrapped ICU setters for parameter ownership - removed symbol prefixes from wrapped typed enums symbols - added ResourceBundle.setAppData() implementation that memory maps file Version 0.8 -> 0.9 ------------------ - fixed 64-bit random crasher bug in registerType()/isInstance() - fixed bug 11548 - added entries for freebsd7 to setup.py (Jan Gehring) - added support for building on Solaris (Christian Kesselheim) - added missing wrapper for Collator.getSortKey() - added support for built-in Transliterators (bug 12870) - removed support for ICU internal URES_TABLE32 ResourceBundle type - added support for TimeZone::getDSTSavings() (Jimmy Yuen Ho Wong) - added support for ICU 4.2 - refreshed README Version 0.6 -> 0.8 ------------------ - ICUtzinfo and FloatingTZ types now written in C for faster performance - fixed bug 8180 - fixed bug 9229 - reworked FloatingTZ to optionally wrap a specific tzinfo instead of default - incorporated c++ patches by Fredrik Roubert - changed Exact unicode and string check to allow subclasses - replaced Makefile with setup.py for distutils-based build (Bernd Zeimetz) - PyICU supported with ICU 3.6 or 3.8 - PyICU supported on 64-bit processors (bug 11394) Version 0.5 -> 0.6 ------------------ - integrated patch to support Python 2.3 and MSVC 6 - changed naive datetime to UDate conversion to use ICUtzinfo.default - fixed bug not checking return value of PyImport_ImportModule - PyICU now wraps ICU 3.6 - added support for building with Python 2.5 - added support for CharsetDetector and CharsetMatch C ICU APIs - added UnicodeString.encode() to access compression and conversion APIs - added support for IDNA APIs to UnicodeString - added support for MessageFormat(string) %(objs) style formatting - fixed bug in Formattable constructor not accepting a python unicode string - added support for BreakIterator::DONE - added support for BreakIterator::getText() - added support for BreakIterator::nextBoundary() to bypass iterator code Version 0.4 -> 0.5 ------------------ - changed OS X linking to resolve all symbols at link time - Collator.getCollationKey() wasn't working - added Collator.getCollationKey(string) overload - using u_strFromUTF32() now to convert 4 byte unicode to 2 byte unicode - improved support for Python 2.3 - PyICU no longer uses SWIG, wrappers are written by hand - all APIs returning UnicodeString now return 'unicode' - all APIs returning UnicodeString also take a UnicodeString arg to return it Version 0.3 -> 0.4 ------------------ - PyICU now wraps ICU 3.4 - added Calendar.getType(), changed Calendar.__repr__() - added Locale.createKeywords(), Locale.getKeywordValue() - moved Locale to locale.i and added support for ResourceBundle - replaced TimeZone.adoptDefault() with TimeZone.getDefault() Version 0.2 -> 0.3 ------------------ - added support for CanonicalIterator, CollationElementIterator - added static formatMessage() method on MessageFormat - added static encoding helper methods to UnicodeString - reworked PyString_AsUnicodeString() to report decode errors by default - added support for Collator, RuleBasedCollator and CollationKey - added test_Collator unit tests - added test_MessageFormat unit tests - fixed various MessageFormat bugs - fixed bug in ICUtzinfo, now returning copy of ICU TimeZone instance - fixed bug in TimeZone.adoptDefault() not checking type of pointer - added __eq__, __ne__ and __hash__ methods to ICUtzinfo - MessageFormat.getFormats() now returns copies of concrete formats Version 0.1 -> 0.2 ------------------ - added most missing UnicodeString methods - added support for the BreakIterator and CharacterIterator classes Version 0.0 -> 0.1 ------------------ - initial release PyICU-1.9.5/char.cpp0000644000076500000000000016762112523534136014324 0ustar vajdawheel00000000000000/* ==================================================================== * Copyright (c) 2004-2015 Open Source Applications Foundation. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. * ==================================================================== */ #include #include #include "common.h" #include "structmember.h" #include "bases.h" #include "char.h" #include "macros.h" DECLARE_CONSTANTS_TYPE(UProperty); DECLARE_CONSTANTS_TYPE(UCharDirection); DECLARE_CONSTANTS_TYPE(UCharCategory); DECLARE_CONSTANTS_TYPE(UBlockCode); DECLARE_CONSTANTS_TYPE(UCharNameChoice); DECLARE_CONSTANTS_TYPE(UPropertyNameChoice); /* Char */ struct UNone; typedef struct UNone UNone; class t_char : public _wrapper { public: UNone *object; }; typedef UBool (*bool_char_fn)(UChar32 c); typedef UChar32 (*uchar32_char_fn)(UChar32 c); static int t_char_init(t_char *self, PyObject *args, PyObject *kwds); static PyObject *t_char_hasBinaryProperty(PyTypeObject *type, PyObject *args); static PyObject *t_char_getIntPropertyValue(PyTypeObject *type, PyObject *args); static PyObject *t_char_getIntPropertyMinValue(PyTypeObject *type, PyObject *arg); static PyObject *t_char_getIntPropertyMaxValue(PyTypeObject *type, PyObject *arg); static PyObject *t_char_getNumericValue(PyTypeObject *type, PyObject *arg); static PyObject *t_char_isUAlphabetic(PyTypeObject *type, PyObject *arg); static PyObject *t_char_isULowercase(PyTypeObject *type, PyObject *arg); static PyObject *t_char_isUUppercase(PyTypeObject *type, PyObject *arg); static PyObject *t_char_isUWhiteSpace(PyTypeObject *type, PyObject *arg); static PyObject *t_char_islower(PyTypeObject *type, PyObject *arg); static PyObject *t_char_isupper(PyTypeObject *type, PyObject *arg); static PyObject *t_char_istitle(PyTypeObject *type, PyObject *arg); static PyObject *t_char_isdigit(PyTypeObject *type, PyObject *arg); static PyObject *t_char_isalpha(PyTypeObject *type, PyObject *arg); static PyObject *t_char_isalnum(PyTypeObject *type, PyObject *arg); static PyObject *t_char_isxdigit(PyTypeObject *type, PyObject *arg); static PyObject *t_char_ispunct(PyTypeObject *type, PyObject *arg); static PyObject *t_char_isgraph(PyTypeObject *type, PyObject *arg); static PyObject *t_char_isblank(PyTypeObject *type, PyObject *arg); static PyObject *t_char_isdefined(PyTypeObject *type, PyObject *arg); static PyObject *t_char_isspace(PyTypeObject *type, PyObject *arg); static PyObject *t_char_isJavaSpaceChar(PyTypeObject *type, PyObject *arg); static PyObject *t_char_isWhitespace(PyTypeObject *type, PyObject *arg); static PyObject *t_char_iscntrl(PyTypeObject *type, PyObject *arg); static PyObject *t_char_isISOControl(PyTypeObject *type, PyObject *arg); static PyObject *t_char_isprint(PyTypeObject *type, PyObject *arg); static PyObject *t_char_isbase(PyTypeObject *type, PyObject *arg); static PyObject *t_char_charDirection(PyTypeObject *type, PyObject *arg); static PyObject *t_char_isMirrored(PyTypeObject *type, PyObject *arg); static PyObject *t_char_charMirror(PyTypeObject *type, PyObject *arg); #if U_ICU_VERSION_HEX >= VERSION_HEX(52, 0, 0) static PyObject *t_char_getBidiPairedBracket(PyTypeObject *type, PyObject *arg); #endif static PyObject *t_char_charType(PyTypeObject *type, PyObject *arg); static PyObject *t_char_enumCharTypes(PyTypeObject *type, PyObject *arg); static PyObject *t_char_getCombiningClass(PyTypeObject *type, PyObject *arg); static PyObject *t_char_charDigitValue(PyTypeObject *type, PyObject *arg); static PyObject *t_char_ublock_getCode(PyTypeObject *type, PyObject *arg); static PyObject *t_char_charName(PyTypeObject *type, PyObject *args); static PyObject *t_char_charFromName(PyTypeObject *type, PyObject *args); static PyObject *t_char_enumCharNames(PyTypeObject *type, PyObject *args); static PyObject *t_char_getPropertyName(PyTypeObject *type, PyObject *args); static PyObject *t_char_getPropertyEnum(PyTypeObject *type, PyObject *arg); static PyObject *t_char_isIDStart(PyTypeObject *type, PyObject *arg); static PyObject *t_char_isIDIgnorable(PyTypeObject *type, PyObject *arg); static PyObject *t_char_isJavaIDStart(PyTypeObject *type, PyObject *arg); static PyObject *t_char_isJavaIDPart(PyTypeObject *type, PyObject *arg); static PyObject *t_char_tolower(PyTypeObject *type, PyObject *arg); static PyObject *t_char_toupper(PyTypeObject *type, PyObject *arg); static PyObject *t_char_totitle(PyTypeObject *type, PyObject *arg); static PyObject *t_char_foldCase(PyTypeObject *type, PyObject *args); static PyObject *t_char_digit(PyTypeObject *type, PyObject *args); static PyObject *t_char_forDigit(PyTypeObject *type, PyObject *args); static PyObject *t_char_charAge(PyTypeObject *type, PyObject *arg); static PyObject *t_char_getUnicodeVersion(PyTypeObject *type); static PyObject *t_char_getFC_NFKC_Closure(PyTypeObject *type, PyObject *arg); static PyMethodDef t_char_methods[] = { DECLARE_METHOD(t_char, hasBinaryProperty, METH_VARARGS | METH_CLASS), DECLARE_METHOD(t_char, getIntPropertyValue, METH_VARARGS | METH_CLASS), DECLARE_METHOD(t_char, getIntPropertyMinValue, METH_O | METH_CLASS), DECLARE_METHOD(t_char, getIntPropertyMaxValue, METH_O | METH_CLASS), DECLARE_METHOD(t_char, getNumericValue, METH_O | METH_CLASS), DECLARE_METHOD(t_char, isUAlphabetic, METH_O | METH_CLASS), DECLARE_METHOD(t_char, isULowercase, METH_O | METH_CLASS), DECLARE_METHOD(t_char, isUUppercase, METH_O | METH_CLASS), DECLARE_METHOD(t_char, isUWhiteSpace, METH_O | METH_CLASS), DECLARE_METHOD(t_char, islower, METH_O | METH_CLASS), DECLARE_METHOD(t_char, isupper, METH_O | METH_CLASS), DECLARE_METHOD(t_char, istitle, METH_O | METH_CLASS), DECLARE_METHOD(t_char, isdigit, METH_O | METH_CLASS), DECLARE_METHOD(t_char, isalpha, METH_O | METH_CLASS), DECLARE_METHOD(t_char, isalnum, METH_O | METH_CLASS), DECLARE_METHOD(t_char, isxdigit, METH_O | METH_CLASS), DECLARE_METHOD(t_char, ispunct, METH_O | METH_CLASS), DECLARE_METHOD(t_char, isgraph, METH_O | METH_CLASS), DECLARE_METHOD(t_char, isblank, METH_O | METH_CLASS), DECLARE_METHOD(t_char, isdefined, METH_O | METH_CLASS), DECLARE_METHOD(t_char, isspace, METH_O | METH_CLASS), DECLARE_METHOD(t_char, isJavaSpaceChar, METH_O | METH_CLASS), DECLARE_METHOD(t_char, isWhitespace, METH_O | METH_CLASS), DECLARE_METHOD(t_char, iscntrl, METH_O | METH_CLASS), DECLARE_METHOD(t_char, isISOControl, METH_O | METH_CLASS), DECLARE_METHOD(t_char, isprint, METH_O | METH_CLASS), DECLARE_METHOD(t_char, isbase, METH_O | METH_CLASS), DECLARE_METHOD(t_char, charDirection, METH_O | METH_CLASS), DECLARE_METHOD(t_char, isMirrored, METH_O | METH_CLASS), DECLARE_METHOD(t_char, charMirror, METH_O | METH_CLASS), #if U_ICU_VERSION_HEX >= VERSION_HEX(52, 0, 0) DECLARE_METHOD(t_char, getBidiPairedBracket, METH_O | METH_CLASS), #endif DECLARE_METHOD(t_char, charType, METH_O | METH_CLASS), DECLARE_METHOD(t_char, enumCharTypes, METH_O | METH_CLASS), DECLARE_METHOD(t_char, getCombiningClass, METH_O | METH_CLASS), DECLARE_METHOD(t_char, charDigitValue, METH_O | METH_CLASS), DECLARE_METHOD(t_char, ublock_getCode, METH_O | METH_CLASS), DECLARE_METHOD(t_char, charName, METH_VARARGS | METH_CLASS), DECLARE_METHOD(t_char, charFromName, METH_VARARGS | METH_CLASS), DECLARE_METHOD(t_char, enumCharNames, METH_VARARGS | METH_CLASS), DECLARE_METHOD(t_char, getPropertyName, METH_VARARGS | METH_CLASS), DECLARE_METHOD(t_char, getPropertyEnum, METH_O | METH_CLASS), DECLARE_METHOD(t_char, isIDStart, METH_O | METH_CLASS), DECLARE_METHOD(t_char, isIDIgnorable, METH_O | METH_CLASS), DECLARE_METHOD(t_char, isJavaIDStart, METH_O | METH_CLASS), DECLARE_METHOD(t_char, isJavaIDPart, METH_O | METH_CLASS), DECLARE_METHOD(t_char, tolower, METH_O | METH_CLASS), DECLARE_METHOD(t_char, toupper, METH_O | METH_CLASS), DECLARE_METHOD(t_char, totitle, METH_O | METH_CLASS), DECLARE_METHOD(t_char, foldCase, METH_VARARGS | METH_CLASS), DECLARE_METHOD(t_char, digit, METH_VARARGS | METH_CLASS), DECLARE_METHOD(t_char, forDigit, METH_VARARGS | METH_CLASS), DECLARE_METHOD(t_char, charAge, METH_O | METH_CLASS), DECLARE_METHOD(t_char, getUnicodeVersion, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_char, getFC_NFKC_Closure, METH_O | METH_CLASS), { NULL, NULL, 0, NULL } }; static void t_char_dealloc(t_char *self) { Py_TYPE(self)->tp_free((PyObject *) self); } DECLARE_STRUCT(Char, t_char, UNone, t_char_init, t_char_dealloc); /* Char */ static int t_char_init(t_char *self, PyObject *args, PyObject *kwds) { switch (PyTuple_Size(args)) { case 0: self->object = NULL; /* there is no ICU struct for this */ self->flags = T_OWNED; return 0; default: PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; } } static PyObject *t_char_hasBinaryProperty(PyTypeObject *type, PyObject *args) { UnicodeString *u, _u; UProperty prop; UChar32 c; switch (PyTuple_Size(args)) { case 2: if (!parseArgs(args, "ii", &c, &prop)) Py_RETURN_BOOL(u_hasBinaryProperty(c, prop)); if (!parseArgs(args, "Si", &u, &_u, &prop) && u->length() >= 1) Py_RETURN_BOOL(u_hasBinaryProperty(u->char32At(0), prop)); break; } return PyErr_SetArgsError((PyObject *) type, "hasBinaryProperty", args); } static PyObject *t_char_getIntPropertyValue(PyTypeObject *type, PyObject *args) { UnicodeString *u, _u; UProperty prop; UChar32 c; switch (PyTuple_Size(args)) { case 2: if (!parseArgs(args, "ii", &c, &prop)) return PyInt_FromLong(u_getIntPropertyValue(c, prop)); if (!parseArgs(args, "Si", &u, &_u, &prop) && u->length() >= 1) return PyInt_FromLong(u_getIntPropertyValue(u->char32At(0), prop)); break; } return PyErr_SetArgsError((PyObject *) type, "getIntPropertyValue", args); } static PyObject *t_char_getIntPropertyMinValue(PyTypeObject *type, PyObject *arg) { UProperty prop; if (!parseArg(arg, "i", &prop)) return PyInt_FromLong(u_getIntPropertyMinValue(prop)); return PyErr_SetArgsError((PyObject *) type, "getIntPropertyMinValue", arg); } static PyObject *t_char_getIntPropertyMaxValue(PyTypeObject *type, PyObject *arg) { UProperty prop; if (!parseArg(arg, "i", &prop)) return PyInt_FromLong(u_getIntPropertyMaxValue(prop)); return PyErr_SetArgsError((PyObject *) type, "getIntPropertyMaxValue", arg); } static PyObject *t_char_getNumericValue(PyTypeObject *type, PyObject *arg) { UnicodeString *u, _u; UChar32 c; double value = U_NO_NUMERIC_VALUE; if (!parseArg(arg, "i", &c)) value = u_getNumericValue(c); else if (!parseArg(arg, "S", &u, &_u) && u->length() >= 1) value = u_getNumericValue(u->char32At(0)); else return PyErr_SetArgsError((PyObject *) type, "getNumericValue", arg); if (value == U_NO_NUMERIC_VALUE) Py_RETURN_NONE; return PyFloat_FromDouble(value); } static PyObject *t_char_fn(bool_char_fn fn, const char *name, PyTypeObject *type, PyObject *arg) { UnicodeString *u, _u; UChar32 c; if (!parseArg(arg, "i", &c)) Py_RETURN_BOOL((*fn)(c)); if (!parseArg(arg, "S", &u, &_u) && u->length() >= 1) Py_RETURN_BOOL((*fn)(u->char32At(0))); return PyErr_SetArgsError((PyObject *) type, name, arg); } static PyObject *t_char_isUAlphabetic(PyTypeObject *type, PyObject *arg) { return t_char_fn(u_isUAlphabetic, "isUAlphabetic", type, arg); } static PyObject *t_char_isULowercase(PyTypeObject *type, PyObject *arg) { return t_char_fn(u_isULowercase, "isULowercase", type, arg); } static PyObject *t_char_isUUppercase(PyTypeObject *type, PyObject *arg) { return t_char_fn(u_isUUppercase, "isUUpperCase", type, arg); } static PyObject *t_char_isUWhiteSpace(PyTypeObject *type, PyObject *arg) { return t_char_fn(u_isUWhiteSpace, "isUWhiteSpace", type, arg); } static PyObject *t_char_islower(PyTypeObject *type, PyObject *arg) { return t_char_fn(u_islower, "islower", type, arg); } static PyObject *t_char_isupper(PyTypeObject *type, PyObject *arg) { return t_char_fn(u_isupper, "isupper", type, arg); } static PyObject *t_char_istitle(PyTypeObject *type, PyObject *arg) { return t_char_fn(u_istitle, "istitle", type, arg); } static PyObject *t_char_isdigit(PyTypeObject *type, PyObject *arg) { return t_char_fn(u_isdigit, "isdigit", type, arg); } static PyObject *t_char_isalpha(PyTypeObject *type, PyObject *arg) { return t_char_fn(u_isalpha, "isalpha", type, arg); } static PyObject *t_char_isalnum(PyTypeObject *type, PyObject *arg) { return t_char_fn(u_isalnum, "isalnum", type, arg); } static PyObject *t_char_isxdigit(PyTypeObject *type, PyObject *arg) { return t_char_fn(u_isxdigit, "isxdigit", type, arg); } static PyObject *t_char_ispunct(PyTypeObject *type, PyObject *arg) { return t_char_fn(u_ispunct, "ispunct", type, arg); } static PyObject *t_char_isgraph(PyTypeObject *type, PyObject *arg) { return t_char_fn(u_isgraph, "isgraph", type, arg); } static PyObject *t_char_isblank(PyTypeObject *type, PyObject *arg) { return t_char_fn(u_isblank, "isblank", type, arg); } static PyObject *t_char_isdefined(PyTypeObject *type, PyObject *arg) { return t_char_fn(u_isdefined, "isdefined", type, arg); } static PyObject *t_char_isspace(PyTypeObject *type, PyObject *arg) { return t_char_fn(u_isspace, "isspace", type, arg); } static PyObject *t_char_isJavaSpaceChar(PyTypeObject *type, PyObject *arg) { return t_char_fn(u_isJavaSpaceChar, "isJavaSpaceChar", type, arg); } static PyObject *t_char_isWhitespace(PyTypeObject *type, PyObject *arg) { return t_char_fn(u_isWhitespace, "isWhitespace", type, arg); } static PyObject *t_char_iscntrl(PyTypeObject *type, PyObject *arg) { return t_char_fn(u_iscntrl, "iscntrl", type, arg); } static PyObject *t_char_isISOControl(PyTypeObject *type, PyObject *arg) { return t_char_fn(u_isISOControl, "isISOControl", type, arg); } static PyObject *t_char_isprint(PyTypeObject *type, PyObject *arg) { return t_char_fn(u_isprint, "isprint", type, arg); } static PyObject *t_char_isbase(PyTypeObject *type, PyObject *arg) { return t_char_fn(u_isbase, "isbase", type, arg); } static PyObject *t_char_isMirrored(PyTypeObject *type, PyObject *arg) { return t_char_fn(u_isMirrored, "isMirrored", type, arg); } static PyObject *t_char_isIDStart(PyTypeObject *type, PyObject *arg) { return t_char_fn(u_isIDStart, "isIDStart", type, arg); } static PyObject *t_char_isIDIgnorable(PyTypeObject *type, PyObject *arg) { return t_char_fn(u_isIDIgnorable, "isIDIgnorable", type, arg); } static PyObject *t_char_isJavaIDStart(PyTypeObject *type, PyObject *arg) { return t_char_fn(u_isJavaIDStart, "isJavaIDStart", type, arg); } static PyObject *t_char_isJavaIDPart(PyTypeObject *type, PyObject *arg) { return t_char_fn(u_isJavaIDPart, "isJavaIDPart", type, arg); } static PyObject *t_char_charDirection(PyTypeObject *type, PyObject *arg) { UnicodeString *u, _u; UChar32 c; if (!parseArg(arg, "i", &c)) return PyInt_FromLong(u_charDirection(c)); if (!parseArg(arg, "S", &u, &_u) && u->length() >= 1) return PyInt_FromLong(u_charDirection(u->char32At(0))); return PyErr_SetArgsError((PyObject *) type, "charDirection", arg); } static PyObject *t_char_charType(PyTypeObject *type, PyObject *arg) { UnicodeString *u, _u; UChar32 c; if (!parseArg(arg, "i", &c)) return PyInt_FromLong((int) u_charType(c)); if (!parseArg(arg, "S", &u, &_u) && u->length() >= 1) return PyInt_FromLong((int) u_charType(u->char32At(0))); return PyErr_SetArgsError((PyObject *) type, "charType", arg); } static UBool t_char_enum_types_cb( const void *context, UChar32 start, UChar32 limit, UCharCategory type) { PyObject *obj = PyObject_CallFunction( (PyObject *) context, (char *) "iii", start, limit, type); if (obj == NULL) return false; bool result = PyObject_IsTrue(obj); Py_DECREF(obj); return result; } static PyObject *t_char_enumCharTypes(PyTypeObject *type, PyObject *arg) { if (PyCallable_Check(arg)) { u_enumCharTypes(t_char_enum_types_cb, arg); if (PyErr_Occurred()) return NULL; Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) type, "enumCharTypes", arg); } static PyObject *t_char_getCombiningClass(PyTypeObject *type, PyObject *arg) { UnicodeString *u, _u; UChar32 c; if (!parseArg(arg, "i", &c)) return PyInt_FromLong((unsigned int) u_getCombiningClass(c)); if (!parseArg(arg, "S", &u, &_u) && u->length() >= 1) return PyInt_FromLong( (unsigned int) u_getCombiningClass(u->char32At(0))); return PyErr_SetArgsError((PyObject *) type, "getCombiningClass", arg); } static PyObject *t_char_charDigitValue(PyTypeObject *type, PyObject *arg) { UnicodeString *u, _u; UChar32 c; if (!parseArg(arg, "i", &c)) return PyInt_FromLong((int) u_charDigitValue(c)); if (!parseArg(arg, "S", &u, &_u) && u->length() >= 1) return PyInt_FromLong((int) u_charDigitValue(u->char32At(0))); return PyErr_SetArgsError((PyObject *) type, "charDigitValue", arg); } static PyObject *t_char_ublock_getCode(PyTypeObject *type, PyObject *arg) { UnicodeString *u, _u; UChar32 c; if (!parseArg(arg, "i", &c)) return PyInt_FromLong((int) ublock_getCode(c)); if (!parseArg(arg, "S", &u, &_u) && u->length() >= 1) return PyInt_FromLong((int) ublock_getCode(u->char32At(0))); return PyErr_SetArgsError((PyObject *) type, "ublock_getCode", arg); } static PyObject *t_char_charName(PyTypeObject *type, PyObject *args) { UnicodeString *u, _u; UCharNameChoice choice = U_UNICODE_CHAR_NAME; char buffer[128]; int32_t size; UChar32 c; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "i", &c)) { STATUS_CALL(size = u_charName(c, choice, buffer, sizeof(buffer), &status)); return PyString_FromString(buffer); } if (!parseArgs(args, "S", &u, &_u) && u->length() >= 1) { STATUS_CALL(size = u_charName(u->char32At(0), choice, buffer, sizeof(buffer), &status)); return PyString_FromStringAndSize(buffer, size); } break; case 2: if (!parseArgs(args, "ii", &c, &choice)) { STATUS_CALL(size = u_charName(c, choice, buffer, sizeof(buffer), &status)); return PyString_FromStringAndSize(buffer, size); } if (!parseArgs(args, "Si", &u, &_u, &choice) && u->length() >= 1) { STATUS_CALL(size = u_charName(u->char32At(0), choice, buffer, sizeof(buffer), &status)); return PyString_FromStringAndSize(buffer, size); } break; } return PyErr_SetArgsError((PyObject *) type, "charName", args); } static PyObject *t_char_charFromName(PyTypeObject *type, PyObject *args) { char *name; UCharNameChoice choice = U_UNICODE_CHAR_NAME; UChar32 c; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "c", &name)) { STATUS_CALL(c = u_charFromName(choice, name, &status)); return PyInt_FromLong(c); } break; case 2: if (!parseArgs(args, "ci", &name, &choice)) { STATUS_CALL(c = u_charFromName(choice, name, &status)); return PyInt_FromLong(c); } break; } return PyErr_SetArgsError((PyObject *) type, "charFromName", args); } static UBool t_char_enum_names_cb( void *context, UChar32 code, UCharNameChoice choice, const char *name, int32_t length) { PyObject *obj = PyObject_CallFunction( (PyObject *) context, (char *) "is#i", code, name, (int) length, choice); if (obj == NULL) return false; bool result = PyObject_IsTrue(obj); Py_DECREF(obj); return result; } static PyObject *t_char_enumCharNames(PyTypeObject *type, PyObject *args) { PyObject *callable; UCharNameChoice choice = U_UNICODE_CHAR_NAME; UnicodeString *u, _u, *v, _v; UChar32 start, limit; switch (PyTuple_Size(args)) { case 3: if (!parseArgs(args, "iiM", &start, &limit, &callable)) { STATUS_CALL(u_enumCharNames( start, limit, t_char_enum_names_cb, callable, choice, &status)); if (PyErr_Occurred()) return NULL; Py_RETURN_NONE; } if (!parseArgs(args, "SSM", &u, &_u, &v, &_v, &callable) && u->length() >= 1 && v->length() >= 1) { STATUS_CALL(u_enumCharNames( u->char32At(0), v->char32At(0), t_char_enum_names_cb, callable, choice, &status)); if (PyErr_Occurred()) return NULL; Py_RETURN_NONE; } break; case 4: if (!parseArgs(args, "iiMi", &start, &limit, &callable, &choice)) { STATUS_CALL(u_enumCharNames( start, limit, t_char_enum_names_cb, callable, choice, &status)); if (PyErr_Occurred()) return NULL; Py_RETURN_NONE; } if (!parseArgs(args, "SSMi", &u, &_u, &v, &_v, &callable, &choice) && u->length() >= 1 && v->length() >= 1) { STATUS_CALL(u_enumCharNames( u->char32At(0), v->char32At(0), t_char_enum_names_cb, callable, choice, &status)); if (PyErr_Occurred()) return NULL; Py_RETURN_NONE; } break; } return PyErr_SetArgsError((PyObject *) type, "enumCharNames", args); } static PyObject *t_char_getPropertyName(PyTypeObject *type, PyObject *args) { UPropertyNameChoice choice = U_SHORT_PROPERTY_NAME; UProperty prop; const char *result; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "i", &prop)) { result = u_getPropertyName(prop, choice); if (result != NULL) return PyString_FromString(result); Py_RETURN_NONE; } break; case 2: if (!parseArgs(args, "ii", &prop, &choice)) { result = u_getPropertyName(prop, choice); if (result != NULL) return PyString_FromString(result); Py_RETURN_NONE; } break; } return PyErr_SetArgsError((PyObject *) type, "getPropertyName", args); } static PyObject *t_char_getPropertyEnum(PyTypeObject *type, PyObject *arg) { char *alias; if (!parseArg(arg, "c", &alias)) return PyInt_FromLong(u_getPropertyEnum(alias)); return PyErr_SetArgsError((PyObject *) type, "getPropertyEnum", arg); } static PyObject *t_char_fn(uchar32_char_fn fn, const char *name, PyTypeObject *type, PyObject *arg) { UnicodeString *u, _u; UChar32 c; if (!parseArg(arg, "i", &c)) return PyInt_FromLong((*fn)(c)); if (!parseArg(arg, "S", &u, &_u) && u->length() >= 1) { UnicodeString result; result += (*fn)(u->char32At(0)); return PyUnicode_FromUnicodeString(&result); } return PyErr_SetArgsError((PyObject *) type, name, arg); } static PyObject *t_char_charMirror(PyTypeObject *type, PyObject *arg) { return t_char_fn(u_charMirror, "charMirror", type, arg); } #if U_ICU_VERSION_HEX >= VERSION_HEX(52, 0, 0) static PyObject *t_char_getBidiPairedBracket(PyTypeObject *type, PyObject *arg) { return t_char_fn(u_getBidiPairedBracket, "getBidiPairedBracket", type, arg); } #endif static PyObject *t_char_tolower(PyTypeObject *type, PyObject *arg) { return t_char_fn(u_tolower, "tolower", type, arg); } static PyObject *t_char_toupper(PyTypeObject *type, PyObject *arg) { return t_char_fn(u_toupper, "toupper", type, arg); } static PyObject *t_char_totitle(PyTypeObject *type, PyObject *arg) { return t_char_fn(u_totitle, "totitle", type, arg); } static PyObject *t_char_foldCase(PyTypeObject *type, PyObject *args) { UnicodeString *u, _u; UChar32 c; uint32_t options; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "i", &c)) return PyInt_FromLong(u_foldCase(c, U_FOLD_CASE_DEFAULT)); if (!parseArgs(args, "S", &u, &_u) && u->length() >= 1) { UnicodeString result; result += u_foldCase(u->char32At(0), U_FOLD_CASE_DEFAULT); return PyUnicode_FromUnicodeString(&result); } break; case 2: if (!parseArgs(args, "ii", &c, &options)) return PyInt_FromLong(u_foldCase(c, options)); if (!parseArgs(args, "Si", &u, &_u, &options) && u->length() >= 1) { UnicodeString result; result += u_foldCase(u->char32At(0), options); return PyUnicode_FromUnicodeString(&result); } break; } return PyErr_SetArgsError((PyObject *) type, "foldCase", args); } static PyObject *t_char_digit(PyTypeObject *type, PyObject *args) { UnicodeString *u, _u; UChar32 c; int radix; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "i", &c)) return PyInt_FromLong(u_digit(c, (int8_t) 10)); if (!parseArgs(args, "S", &u, &_u) && u->length() >= 1) return PyInt_FromLong(u_digit(u->char32At(0), (int8_t) 10)); break; case 2: if (!parseArgs(args, "ii", &c, &radix)) return PyInt_FromLong(u_digit(c, (int8_t) radix)); if (!parseArgs(args, "Si", &u, &_u, &radix) && u->length() >= 1) return PyInt_FromLong(u_digit(u->char32At(0), (int8_t) radix)); break; } return PyErr_SetArgsError((PyObject *) type, "digit", args); } static PyObject *t_char_forDigit(PyTypeObject *type, PyObject *args) { UChar32 c; int radix; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "i", &c)) return PyInt_FromLong(u_forDigit(c, (int8_t) 10)); break; case 2: if (!parseArgs(args, "ii", &c, &radix)) return PyInt_FromLong(u_forDigit(c, (int8_t) radix)); break; } return PyErr_SetArgsError((PyObject *) type, "forDigit", args); } static PyObject *t_char_charAge(PyTypeObject *type, PyObject *arg) { char buffer[U_MAX_VERSION_STRING_LENGTH + 1]; UVersionInfo versionInfo; UnicodeString *u, _u; UChar32 c; if (!parseArg(arg, "i", &c)) u_charAge(c, versionInfo); else if (!parseArg(arg, "S", &u, &_u) && u->length() >= 1) u_charAge(u->char32At(0), versionInfo); else return PyErr_SetArgsError((PyObject *) type, "charAge", arg); u_versionToString(versionInfo, buffer); return PyString_FromString(buffer); } static PyObject *t_char_getUnicodeVersion(PyTypeObject *type) { UVersionInfo versionInfo; char buffer[U_MAX_VERSION_STRING_LENGTH + 1]; u_getUnicodeVersion(versionInfo); u_versionToString(versionInfo, buffer); return PyString_FromString(buffer); } static PyObject *t_char_getFC_NFKC_Closure(PyTypeObject *type, PyObject *arg) { UChar buffer[128]; UnicodeString *u, _u; UChar32 c; int32_t size; if (!parseArg(arg, "i", &c)) { STATUS_CALL(size = u_getFC_NFKC_Closure(c, buffer, 128, &status)); } else if (!parseArg(arg, "S", &u, &_u) && u->length() >= 1) { STATUS_CALL(size = u_getFC_NFKC_Closure(u->char32At(0), buffer, 128, &status)); } else return PyErr_SetArgsError((PyObject *) type, "getFC_NFKC_Closure", arg); return PyUnicode_FromUnicodeString(buffer, size); } void _init_char(PyObject *m) { INSTALL_CONSTANTS_TYPE(UProperty, m); INSTALL_CONSTANTS_TYPE(UCharDirection, m); INSTALL_CONSTANTS_TYPE(UCharCategory, m); INSTALL_CONSTANTS_TYPE(UBlockCode, m); INSTALL_CONSTANTS_TYPE(UCharNameChoice, m); INSTALL_CONSTANTS_TYPE(UPropertyNameChoice, m); INSTALL_STRUCT(Char, m); INSTALL_ENUM(Char, "FOLD_CASE_DEFAULT", U_FOLD_CASE_DEFAULT); INSTALL_ENUM(Char, "FOLD_CASE_EXCLUDE_SPECIAL_I", U_FOLD_CASE_EXCLUDE_SPECIAL_I); INSTALL_ENUM(UProperty, "ALPHABETIC", UCHAR_ALPHABETIC); INSTALL_ENUM(UProperty, "ASCII_HEX_DIGIT", UCHAR_ASCII_HEX_DIGIT); INSTALL_ENUM(UProperty, "BIDI_CONTROL", UCHAR_BIDI_CONTROL); INSTALL_ENUM(UProperty, "BIDI_MIRRORED", UCHAR_BIDI_MIRRORED); INSTALL_ENUM(UProperty, "DASH", UCHAR_DASH); INSTALL_ENUM(UProperty, "DEFAULT_IGNORABLE_CODE_POINT", UCHAR_DEFAULT_IGNORABLE_CODE_POINT); INSTALL_ENUM(UProperty, "DIACRITIC", UCHAR_DIACRITIC); INSTALL_ENUM(UProperty, "EXTENDER", UCHAR_EXTENDER); INSTALL_ENUM(UProperty, "FULL_COMPOSITION_EXCLUSION", UCHAR_FULL_COMPOSITION_EXCLUSION); INSTALL_ENUM(UProperty, "GRAPHEME_BASE", UCHAR_GRAPHEME_BASE); INSTALL_ENUM(UProperty, "GRAPHEME_EXTEND", UCHAR_GRAPHEME_EXTEND); INSTALL_ENUM(UProperty, "GRAPHEME_LINK", UCHAR_GRAPHEME_LINK); INSTALL_ENUM(UProperty, "HEX_DIGIT", UCHAR_HEX_DIGIT); INSTALL_ENUM(UProperty, "HYPHEN", UCHAR_HYPHEN); INSTALL_ENUM(UProperty, "ID_CONTINUE", UCHAR_ID_CONTINUE); INSTALL_ENUM(UProperty, "ID_START", UCHAR_ID_START); INSTALL_ENUM(UProperty, "IDEOGRAPHIC", UCHAR_IDEOGRAPHIC); INSTALL_ENUM(UProperty, "IDS_BINARY_OPERATOR", UCHAR_IDS_BINARY_OPERATOR); INSTALL_ENUM(UProperty, "IDS_TRINARY_OPERATOR", UCHAR_IDS_TRINARY_OPERATOR); INSTALL_ENUM(UProperty, "JOIN_CONTROL", UCHAR_JOIN_CONTROL); INSTALL_ENUM(UProperty, "LOGICAL_ORDER_EXCEPTION", UCHAR_LOGICAL_ORDER_EXCEPTION); INSTALL_ENUM(UProperty, "LOWERCASE", UCHAR_LOWERCASE); INSTALL_ENUM(UProperty, "MATH", UCHAR_MATH); INSTALL_ENUM(UProperty, "NONCHARACTER_CODE_POINT", UCHAR_NONCHARACTER_CODE_POINT); INSTALL_ENUM(UProperty, "QUOTATION_MARK", UCHAR_QUOTATION_MARK); INSTALL_ENUM(UProperty, "RADICAL", UCHAR_RADICAL); INSTALL_ENUM(UProperty, "SOFT_DOTTED", UCHAR_SOFT_DOTTED); INSTALL_ENUM(UProperty, "TERMINAL_PUNCTUATION", UCHAR_TERMINAL_PUNCTUATION); INSTALL_ENUM(UProperty, "UNIFIED_IDEOGRAPH", UCHAR_UNIFIED_IDEOGRAPH); INSTALL_ENUM(UProperty, "UPPERCASE", UCHAR_UPPERCASE); INSTALL_ENUM(UProperty, "WHITE_SPACE", UCHAR_WHITE_SPACE); INSTALL_ENUM(UProperty, "XID_CONTINUE", UCHAR_XID_CONTINUE); INSTALL_ENUM(UProperty, "XID_START", UCHAR_XID_START); INSTALL_ENUM(UProperty, "CASE_SENSITIVE", UCHAR_CASE_SENSITIVE); INSTALL_ENUM(UProperty, "S_TERM", UCHAR_S_TERM); INSTALL_ENUM(UProperty, "VARIATION_SELECTOR", UCHAR_VARIATION_SELECTOR); INSTALL_ENUM(UProperty, "NFD_INERT", UCHAR_NFD_INERT); INSTALL_ENUM(UProperty, "NFKD_INERT", UCHAR_NFKD_INERT); INSTALL_ENUM(UProperty, "NFC_INERT", UCHAR_NFC_INERT); INSTALL_ENUM(UProperty, "NFKC_INERT", UCHAR_NFKC_INERT); INSTALL_ENUM(UProperty, "SEGMENT_STARTER", UCHAR_SEGMENT_STARTER); INSTALL_ENUM(UProperty, "PATTERN_SYNTAX", UCHAR_PATTERN_SYNTAX); INSTALL_ENUM(UProperty, "PATTERN_WHITE_SPACE", UCHAR_PATTERN_WHITE_SPACE); INSTALL_ENUM(UProperty, "POSIX_ALNUM", UCHAR_POSIX_ALNUM); INSTALL_ENUM(UProperty, "POSIX_BLANK", UCHAR_POSIX_BLANK); INSTALL_ENUM(UProperty, "POSIX_GRAPH", UCHAR_POSIX_GRAPH); INSTALL_ENUM(UProperty, "POSIX_PRINT", UCHAR_POSIX_PRINT); INSTALL_ENUM(UProperty, "POSIX_XDIGIT", UCHAR_POSIX_XDIGIT); #if U_ICU_VERSION_HEX >= 0x04040000 INSTALL_ENUM(UProperty, "CASED", UCHAR_CASED); INSTALL_ENUM(UProperty, "CASE_IGNORABLE", UCHAR_CASE_IGNORABLE); INSTALL_ENUM(UProperty, "CHANGES_WHEN_LOWERCASED", UCHAR_CHANGES_WHEN_LOWERCASED); INSTALL_ENUM(UProperty, "CHANGES_WHEN_UPPERCASED", UCHAR_CHANGES_WHEN_UPPERCASED); INSTALL_ENUM(UProperty, "CHANGES_WHEN_TITLECASED", UCHAR_CHANGES_WHEN_TITLECASED); INSTALL_ENUM(UProperty, "CHANGES_WHEN_CASEFOLDED", UCHAR_CHANGES_WHEN_CASEFOLDED); INSTALL_ENUM(UProperty, "CHANGES_WHEN_CASEMAPPED", UCHAR_CHANGES_WHEN_CASEMAPPED); INSTALL_ENUM(UProperty, "CHANGES_WHEN_NFKC_CASEFOLDED", UCHAR_CHANGES_WHEN_NFKC_CASEFOLDED); #endif INSTALL_ENUM(UProperty, "BINARY_LIMIT", UCHAR_BINARY_LIMIT); INSTALL_ENUM(UProperty, "BIDI_CLASS", UCHAR_BIDI_CLASS); INSTALL_ENUM(UProperty, "INT_START", UCHAR_INT_START); INSTALL_ENUM(UProperty, "BLOCK", UCHAR_BLOCK); INSTALL_ENUM(UProperty, "CANONICAL_COMBINING_CLASS", UCHAR_CANONICAL_COMBINING_CLASS); INSTALL_ENUM(UProperty, "DECOMPOSITION_TYPE", UCHAR_DECOMPOSITION_TYPE); INSTALL_ENUM(UProperty, "EAST_ASIAN_WIDTH", UCHAR_EAST_ASIAN_WIDTH); INSTALL_ENUM(UProperty, "GENERAL_CATEGORY", UCHAR_GENERAL_CATEGORY); INSTALL_ENUM(UProperty, "JOINING_GROUP", UCHAR_JOINING_GROUP); INSTALL_ENUM(UProperty, "JOINING_TYPE", UCHAR_JOINING_TYPE); INSTALL_ENUM(UProperty, "LINE_BREAK", UCHAR_LINE_BREAK); INSTALL_ENUM(UProperty, "NUMERIC_TYPE", UCHAR_NUMERIC_TYPE); INSTALL_ENUM(UProperty, "SCRIPT", UCHAR_SCRIPT); INSTALL_ENUM(UProperty, "HANGUL_SYLLABLE_TYPE", UCHAR_HANGUL_SYLLABLE_TYPE); INSTALL_ENUM(UProperty, "NFD_QUICK_CHECK", UCHAR_NFD_QUICK_CHECK); INSTALL_ENUM(UProperty, "NFKD_QUICK_CHECK", UCHAR_NFKD_QUICK_CHECK); INSTALL_ENUM(UProperty, "NFC_QUICK_CHECK", UCHAR_NFC_QUICK_CHECK); INSTALL_ENUM(UProperty, "NFKC_QUICK_CHECK", UCHAR_NFKC_QUICK_CHECK); INSTALL_ENUM(UProperty, "LEAD_CANONICAL_COMBINING_CLASS", UCHAR_LEAD_CANONICAL_COMBINING_CLASS); INSTALL_ENUM(UProperty, "TRAIL_CANONICAL_COMBINING_CLASS", UCHAR_TRAIL_CANONICAL_COMBINING_CLASS); INSTALL_ENUM(UProperty, "GRAPHEME_CLUSTER_BREAK", UCHAR_GRAPHEME_CLUSTER_BREAK); INSTALL_ENUM(UProperty, "SENTENCE_BREAK", UCHAR_SENTENCE_BREAK); INSTALL_ENUM(UProperty, "WORD_BREAK", UCHAR_WORD_BREAK); #if U_ICU_VERSION_HEX >= VERSION_HEX(52, 0, 0) INSTALL_ENUM(UProperty, "BIDI_PAIRED_BRACKET_TYPE", UCHAR_BIDI_PAIRED_BRACKET_TYPE); #endif INSTALL_ENUM(UProperty, "INT_LIMIT", UCHAR_INT_LIMIT); INSTALL_ENUM(UProperty, "GENERAL_CATEGORY_MASK", UCHAR_GENERAL_CATEGORY_MASK); INSTALL_ENUM(UProperty, "MASK_START", UCHAR_MASK_START); INSTALL_ENUM(UProperty, "MASK_LIMIT", UCHAR_MASK_LIMIT); INSTALL_ENUM(UProperty, "NUMERIC_VALUE", UCHAR_NUMERIC_VALUE); INSTALL_ENUM(UProperty, "DOUBLE_START", UCHAR_DOUBLE_START); INSTALL_ENUM(UProperty, "DOUBLE_LIMIT", UCHAR_DOUBLE_LIMIT); INSTALL_ENUM(UProperty, "AGE", UCHAR_AGE); INSTALL_ENUM(UProperty, "STRING_START", UCHAR_STRING_START); INSTALL_ENUM(UProperty, "BIDI_MIRRORING_GLYPH", UCHAR_BIDI_MIRRORING_GLYPH); INSTALL_ENUM(UProperty, "CASE_FOLDING", UCHAR_CASE_FOLDING); INSTALL_ENUM(UProperty, "LOWERCASE_MAPPING", UCHAR_LOWERCASE_MAPPING); INSTALL_ENUM(UProperty, "NAME", UCHAR_NAME); INSTALL_ENUM(UProperty, "SIMPLE_CASE_FOLDING", UCHAR_SIMPLE_CASE_FOLDING); INSTALL_ENUM(UProperty, "SIMPLE_LOWERCASE_MAPPING", UCHAR_SIMPLE_LOWERCASE_MAPPING); INSTALL_ENUM(UProperty, "SIMPLE_TITLECASE_MAPPING", UCHAR_SIMPLE_TITLECASE_MAPPING); INSTALL_ENUM(UProperty, "SIMPLE_UPPERCASE_MAPPING", UCHAR_SIMPLE_UPPERCASE_MAPPING); INSTALL_ENUM(UProperty, "TITLECASE_MAPPING", UCHAR_TITLECASE_MAPPING); INSTALL_ENUM(UProperty, "UPPERCASE_MAPPING", UCHAR_UPPERCASE_MAPPING); #if U_ICU_VERSION_HEX >= VERSION_HEX(52, 0, 0) INSTALL_ENUM(UProperty, "BIDI_PAIRED_BRACKET", UCHAR_BIDI_PAIRED_BRACKET); #endif INSTALL_ENUM(UProperty, "STRING_LIMIT", UCHAR_STRING_LIMIT); #if U_ICU_VERSION_HEX >= 0x04060000 INSTALL_ENUM(UProperty, "SCRIPT_EXTENSIONS", UCHAR_SCRIPT_EXTENSIONS); INSTALL_ENUM(UProperty, "OTHER_PROPERTY_START", UCHAR_OTHER_PROPERTY_START); INSTALL_ENUM(UProperty, "OTHER_PROPERTY_LIMIT", UCHAR_OTHER_PROPERTY_LIMIT); #endif INSTALL_ENUM(UProperty, "INVALID_CODE ", UCHAR_INVALID_CODE ); INSTALL_ENUM(UCharDirection, "LEFT_TO_RIGHT", U_LEFT_TO_RIGHT); INSTALL_ENUM(UCharDirection, "RIGHT_TO_LEFT", U_RIGHT_TO_LEFT); INSTALL_ENUM(UCharDirection, "EUROPEAN_NUMBER", U_EUROPEAN_NUMBER); INSTALL_ENUM(UCharDirection, "EUROPEAN_NUMBER_SEPARATOR", U_EUROPEAN_NUMBER_SEPARATOR); INSTALL_ENUM(UCharDirection, "EUROPEAN_NUMBER_TERMINATOR", U_EUROPEAN_NUMBER_TERMINATOR); INSTALL_ENUM(UCharDirection, "ARABIC_NUMBER", U_ARABIC_NUMBER); INSTALL_ENUM(UCharDirection, "COMMON_NUMBER_SEPARATOR", U_COMMON_NUMBER_SEPARATOR); INSTALL_ENUM(UCharDirection, "BLOCK_SEPARATOR", U_BLOCK_SEPARATOR); INSTALL_ENUM(UCharDirection, "SEGMENT_SEPARATOR", U_SEGMENT_SEPARATOR); INSTALL_ENUM(UCharDirection, "WHITE_SPACE_NEUTRAL", U_WHITE_SPACE_NEUTRAL); INSTALL_ENUM(UCharDirection, "OTHER_NEUTRAL", U_OTHER_NEUTRAL); INSTALL_ENUM(UCharDirection, "LEFT_TO_RIGHT_EMBEDDING", U_LEFT_TO_RIGHT_EMBEDDING); INSTALL_ENUM(UCharDirection, "LEFT_TO_RIGHT_OVERRIDE", U_LEFT_TO_RIGHT_OVERRIDE); INSTALL_ENUM(UCharDirection, "RIGHT_TO_LEFT_ARABIC", U_RIGHT_TO_LEFT_ARABIC); INSTALL_ENUM(UCharDirection, "RIGHT_TO_LEFT_EMBEDDING", U_RIGHT_TO_LEFT_EMBEDDING); INSTALL_ENUM(UCharDirection, "RIGHT_TO_LEFT_OVERRIDE", U_RIGHT_TO_LEFT_OVERRIDE); INSTALL_ENUM(UCharDirection, "POP_DIRECTIONAL_FORMAT", U_POP_DIRECTIONAL_FORMAT); INSTALL_ENUM(UCharDirection, "DIR_NON_SPACING_MARK", U_DIR_NON_SPACING_MARK); INSTALL_ENUM(UCharDirection, "BOUNDARY_NEUTRAL", U_BOUNDARY_NEUTRAL); #if U_ICU_VERSION_HEX >= VERSION_HEX(52, 0, 0) INSTALL_ENUM(UCharDirection, "FIRST_STRONG_ISOLATE", U_FIRST_STRONG_ISOLATE); INSTALL_ENUM(UCharDirection, "LEFT_TO_RIGHT_ISOLATE", U_LEFT_TO_RIGHT_ISOLATE); INSTALL_ENUM(UCharDirection, "RIGHT_TO_LEFT_ISOLATE", U_RIGHT_TO_LEFT_ISOLATE); INSTALL_ENUM(UCharDirection, "POP_DIRECTIONAL_ISOLATE", U_POP_DIRECTIONAL_ISOLATE); #endif INSTALL_ENUM(UCharCategory, "UNASSIGNED", U_UNASSIGNED); INSTALL_ENUM(UCharCategory, "GENERAL_OTHER_TYPES", U_GENERAL_OTHER_TYPES); INSTALL_ENUM(UCharCategory, "UPPERCASE_LETTER", U_UPPERCASE_LETTER); INSTALL_ENUM(UCharCategory, "LOWERCASE_LETTER", U_LOWERCASE_LETTER); INSTALL_ENUM(UCharCategory, "TITLECASE_LETTER", U_TITLECASE_LETTER); INSTALL_ENUM(UCharCategory, "MODIFIER_LETTER", U_MODIFIER_LETTER); INSTALL_ENUM(UCharCategory, "OTHER_LETTER", U_OTHER_LETTER); INSTALL_ENUM(UCharCategory, "NON_SPACING_MARK", U_NON_SPACING_MARK); INSTALL_ENUM(UCharCategory, "ENCLOSING_MARK", U_ENCLOSING_MARK); INSTALL_ENUM(UCharCategory, "COMBINING_SPACING_MARK", U_COMBINING_SPACING_MARK); INSTALL_ENUM(UCharCategory, "DECIMAL_DIGIT_NUMBER", U_DECIMAL_DIGIT_NUMBER); INSTALL_ENUM(UCharCategory, "LETTER_NUMBER", U_LETTER_NUMBER); INSTALL_ENUM(UCharCategory, "OTHER_NUMBER", U_OTHER_NUMBER); INSTALL_ENUM(UCharCategory, "SPACE_SEPARATOR", U_SPACE_SEPARATOR); INSTALL_ENUM(UCharCategory, "LINE_SEPARATOR", U_LINE_SEPARATOR); INSTALL_ENUM(UCharCategory, "PARAGRAPH_SEPARATOR", U_PARAGRAPH_SEPARATOR); INSTALL_ENUM(UCharCategory, "CONTROL_CHAR", U_CONTROL_CHAR); INSTALL_ENUM(UCharCategory, "FORMAT_CHAR", U_FORMAT_CHAR); INSTALL_ENUM(UCharCategory, "PRIVATE_USE_CHAR", U_PRIVATE_USE_CHAR); INSTALL_ENUM(UCharCategory, "SURROGATE", U_SURROGATE); INSTALL_ENUM(UCharCategory, "DASH_PUNCTUATION", U_DASH_PUNCTUATION); INSTALL_ENUM(UCharCategory, "START_PUNCTUATION", U_START_PUNCTUATION); INSTALL_ENUM(UCharCategory, "END_PUNCTUATION", U_END_PUNCTUATION); INSTALL_ENUM(UCharCategory, "CONNECTOR_PUNCTUATION", U_CONNECTOR_PUNCTUATION); INSTALL_ENUM(UCharCategory, "OTHER_PUNCTUATION", U_OTHER_PUNCTUATION); INSTALL_ENUM(UCharCategory, "MATH_SYMBOL", U_MATH_SYMBOL); INSTALL_ENUM(UCharCategory, "CURRENCY_SYMBOL", U_CURRENCY_SYMBOL); INSTALL_ENUM(UCharCategory, "MODIFIER_SYMBOL", U_MODIFIER_SYMBOL); INSTALL_ENUM(UCharCategory, "OTHER_SYMBOL", U_OTHER_SYMBOL); INSTALL_ENUM(UCharCategory, "INITIAL_PUNCTUATION", U_INITIAL_PUNCTUATION); INSTALL_ENUM(UCharCategory, "FINAL_PUNCTUATION", U_FINAL_PUNCTUATION); INSTALL_ENUM(UBlockCode, "NO_BLOCK", UBLOCK_NO_BLOCK); INSTALL_ENUM(UBlockCode, "BASIC_LATIN", UBLOCK_BASIC_LATIN); INSTALL_ENUM(UBlockCode, "LATIN_1_SUPPLEMENT,", UBLOCK_LATIN_1_SUPPLEMENT); INSTALL_ENUM(UBlockCode, "LATIN_EXTENDED_A", UBLOCK_LATIN_EXTENDED_A); INSTALL_ENUM(UBlockCode, "LATIN_EXTENDED_B", UBLOCK_LATIN_EXTENDED_B); INSTALL_ENUM(UBlockCode, "IPA_EXTENSIONS", UBLOCK_IPA_EXTENSIONS); INSTALL_ENUM(UBlockCode, "SPACING_MODIFIER_LETTERS", UBLOCK_SPACING_MODIFIER_LETTERS); INSTALL_ENUM(UBlockCode, "COMBINING_DIACRITICAL_MARKS", UBLOCK_COMBINING_DIACRITICAL_MARKS); INSTALL_ENUM(UBlockCode, "GREEK", UBLOCK_GREEK); INSTALL_ENUM(UBlockCode, "CYRILLIC", UBLOCK_CYRILLIC); INSTALL_ENUM(UBlockCode, "ARMENIAN", UBLOCK_ARMENIAN); INSTALL_ENUM(UBlockCode, "HEBREW", UBLOCK_HEBREW); INSTALL_ENUM(UBlockCode, "ARABIC", UBLOCK_ARABIC); INSTALL_ENUM(UBlockCode, "SYRIAC", UBLOCK_SYRIAC); INSTALL_ENUM(UBlockCode, "THAANA", UBLOCK_THAANA); INSTALL_ENUM(UBlockCode, "DEVANAGARI", UBLOCK_DEVANAGARI); INSTALL_ENUM(UBlockCode, "BENGALI", UBLOCK_BENGALI); INSTALL_ENUM(UBlockCode, "GURMUKHI", UBLOCK_GURMUKHI); INSTALL_ENUM(UBlockCode, "GUJARATI", UBLOCK_GUJARATI); INSTALL_ENUM(UBlockCode, "ORIYA", UBLOCK_ORIYA); INSTALL_ENUM(UBlockCode, "TAMIL", UBLOCK_TAMIL); INSTALL_ENUM(UBlockCode, "TELUGU", UBLOCK_TELUGU); INSTALL_ENUM(UBlockCode, "KANNADA", UBLOCK_KANNADA); INSTALL_ENUM(UBlockCode, "MALAYALAM", UBLOCK_MALAYALAM); INSTALL_ENUM(UBlockCode, "SINHALA", UBLOCK_SINHALA); INSTALL_ENUM(UBlockCode, "THAI", UBLOCK_THAI); INSTALL_ENUM(UBlockCode, "LAO", UBLOCK_LAO); INSTALL_ENUM(UBlockCode, "TIBETAN", UBLOCK_TIBETAN); INSTALL_ENUM(UBlockCode, "MYANMAR", UBLOCK_MYANMAR); INSTALL_ENUM(UBlockCode, "GEORGIAN", UBLOCK_GEORGIAN); INSTALL_ENUM(UBlockCode, "HANGUL_JAMO", UBLOCK_HANGUL_JAMO); INSTALL_ENUM(UBlockCode, "ETHIOPIC", UBLOCK_ETHIOPIC); INSTALL_ENUM(UBlockCode, "CHEROKEE", UBLOCK_CHEROKEE); INSTALL_ENUM(UBlockCode, "UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS", UBLOCK_UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS); INSTALL_ENUM(UBlockCode, "OGHAM", UBLOCK_OGHAM); INSTALL_ENUM(UBlockCode, "RUNIC", UBLOCK_RUNIC); INSTALL_ENUM(UBlockCode, "KHMER", UBLOCK_KHMER); INSTALL_ENUM(UBlockCode, "MONGOLIAN", UBLOCK_MONGOLIAN); INSTALL_ENUM(UBlockCode, "LATIN_EXTENDED_ADDITIONAL", UBLOCK_LATIN_EXTENDED_ADDITIONAL); INSTALL_ENUM(UBlockCode, "GREEK_EXTENDED", UBLOCK_GREEK_EXTENDED); INSTALL_ENUM(UBlockCode, "GENERAL_PUNCTUATION", UBLOCK_GENERAL_PUNCTUATION); INSTALL_ENUM(UBlockCode, "SUPERSCRIPTS_AND_SUBSCRIPTS", UBLOCK_SUPERSCRIPTS_AND_SUBSCRIPTS); INSTALL_ENUM(UBlockCode, "CURRENCY_SYMBOLS", UBLOCK_CURRENCY_SYMBOLS); INSTALL_ENUM(UBlockCode, "COMBINING_MARKS_FOR_SYMBOLS", UBLOCK_COMBINING_MARKS_FOR_SYMBOLS); INSTALL_ENUM(UBlockCode, "LETTERLIKE_SYMBOLS", UBLOCK_LETTERLIKE_SYMBOLS); INSTALL_ENUM(UBlockCode, "NUMBER_FORMS", UBLOCK_NUMBER_FORMS); INSTALL_ENUM(UBlockCode, "ARROWS", UBLOCK_ARROWS); INSTALL_ENUM(UBlockCode, "MATHEMATICAL_OPERATORS", UBLOCK_MATHEMATICAL_OPERATORS); INSTALL_ENUM(UBlockCode, "MISCELLANEOUS_TECHNICAL", UBLOCK_MISCELLANEOUS_TECHNICAL); INSTALL_ENUM(UBlockCode, "CONTROL_PICTURES", UBLOCK_CONTROL_PICTURES); INSTALL_ENUM(UBlockCode, "OPTICAL_CHARACTER_RECOGNITION", UBLOCK_OPTICAL_CHARACTER_RECOGNITION); INSTALL_ENUM(UBlockCode, "ENCLOSED_ALPHANUMERICS", UBLOCK_ENCLOSED_ALPHANUMERICS); INSTALL_ENUM(UBlockCode, "BOX_DRAWING", UBLOCK_BOX_DRAWING); INSTALL_ENUM(UBlockCode, "BLOCK_ELEMENTS", UBLOCK_BLOCK_ELEMENTS); INSTALL_ENUM(UBlockCode, "GEOMETRIC_SHAPES", UBLOCK_GEOMETRIC_SHAPES); INSTALL_ENUM(UBlockCode, "MISCELLANEOUS_SYMBOLS", UBLOCK_MISCELLANEOUS_SYMBOLS); INSTALL_ENUM(UBlockCode, "DINGBATS", UBLOCK_DINGBATS); INSTALL_ENUM(UBlockCode, "BRAILLE_PATTERNS", UBLOCK_BRAILLE_PATTERNS); INSTALL_ENUM(UBlockCode, "CJK_RADICALS_SUPPLEMENT", UBLOCK_CJK_RADICALS_SUPPLEMENT); INSTALL_ENUM(UBlockCode, "KANGXI_RADICALS", UBLOCK_KANGXI_RADICALS); INSTALL_ENUM(UBlockCode, "IDEOGRAPHIC_DESCRIPTION_CHARACTERS", UBLOCK_IDEOGRAPHIC_DESCRIPTION_CHARACTERS); INSTALL_ENUM(UBlockCode, "CJK_SYMBOLS_AND_PUNCTUATION", UBLOCK_CJK_SYMBOLS_AND_PUNCTUATION); INSTALL_ENUM(UBlockCode, "HIRAGANA", UBLOCK_HIRAGANA); INSTALL_ENUM(UBlockCode, "KATAKANA", UBLOCK_KATAKANA); INSTALL_ENUM(UBlockCode, "BOPOMOFO", UBLOCK_BOPOMOFO); INSTALL_ENUM(UBlockCode, "HANGUL_COMPATIBILITY_JAMO", UBLOCK_HANGUL_COMPATIBILITY_JAMO); INSTALL_ENUM(UBlockCode, "KANBUN", UBLOCK_KANBUN); INSTALL_ENUM(UBlockCode, "BOPOMOFO_EXTENDED", UBLOCK_BOPOMOFO_EXTENDED); INSTALL_ENUM(UBlockCode, "ENCLOSED_CJK_LETTERS_AND_MONTHS", UBLOCK_ENCLOSED_CJK_LETTERS_AND_MONTHS); INSTALL_ENUM(UBlockCode, "CJK_COMPATIBILITY", UBLOCK_CJK_COMPATIBILITY); INSTALL_ENUM(UBlockCode, "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A", UBLOCK_CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A); INSTALL_ENUM(UBlockCode, "CJK_UNIFIED_IDEOGRAPHS", UBLOCK_CJK_UNIFIED_IDEOGRAPHS); INSTALL_ENUM(UBlockCode, "YI_SYLLABLES", UBLOCK_YI_SYLLABLES); INSTALL_ENUM(UBlockCode, "YI_RADICALS", UBLOCK_YI_RADICALS); INSTALL_ENUM(UBlockCode, "HANGUL_SYLLABLES", UBLOCK_HANGUL_SYLLABLES); INSTALL_ENUM(UBlockCode, "HIGH_SURROGATES", UBLOCK_HIGH_SURROGATES); INSTALL_ENUM(UBlockCode, "HIGH_PRIVATE_USE_SURROGATES", UBLOCK_HIGH_PRIVATE_USE_SURROGATES); INSTALL_ENUM(UBlockCode, "LOW_SURROGATES", UBLOCK_LOW_SURROGATES); INSTALL_ENUM(UBlockCode, "PRIVATE_USE_AREA", UBLOCK_PRIVATE_USE_AREA); INSTALL_ENUM(UBlockCode, "PRIVATE_USE", UBLOCK_PRIVATE_USE); INSTALL_ENUM(UBlockCode, "CJK_COMPATIBILITY_IDEOGRAPHS", UBLOCK_CJK_COMPATIBILITY_IDEOGRAPHS); INSTALL_ENUM(UBlockCode, "ALPHABETIC_PRESENTATION_FORMS", UBLOCK_ALPHABETIC_PRESENTATION_FORMS); INSTALL_ENUM(UBlockCode, "ARABIC_PRESENTATION_FORMS_A", UBLOCK_ARABIC_PRESENTATION_FORMS_A); INSTALL_ENUM(UBlockCode, "COMBINING_HALF_MARKS", UBLOCK_COMBINING_HALF_MARKS); INSTALL_ENUM(UBlockCode, "CJK_COMPATIBILITY_FORMS", UBLOCK_CJK_COMPATIBILITY_FORMS); INSTALL_ENUM(UBlockCode, "SMALL_FORM_VARIANTS", UBLOCK_SMALL_FORM_VARIANTS); INSTALL_ENUM(UBlockCode, "ARABIC_PRESENTATION_FORMS_B", UBLOCK_ARABIC_PRESENTATION_FORMS_B); INSTALL_ENUM(UBlockCode, "SPECIALS", UBLOCK_SPECIALS); INSTALL_ENUM(UBlockCode, "HALFWIDTH_AND_FULLWIDTH_FORMS", UBLOCK_HALFWIDTH_AND_FULLWIDTH_FORMS); INSTALL_ENUM(UBlockCode, "OLD_ITALIC", UBLOCK_OLD_ITALIC); INSTALL_ENUM(UBlockCode, "GOTHIC", UBLOCK_GOTHIC); INSTALL_ENUM(UBlockCode, "DESERET", UBLOCK_DESERET); INSTALL_ENUM(UBlockCode, "BYZANTINE_MUSICAL_SYMBOLS", UBLOCK_BYZANTINE_MUSICAL_SYMBOLS); INSTALL_ENUM(UBlockCode, "MUSICAL_SYMBOLS", UBLOCK_MUSICAL_SYMBOLS); INSTALL_ENUM(UBlockCode, "MATHEMATICAL_ALPHANUMERIC_SYMBOLS", UBLOCK_MATHEMATICAL_ALPHANUMERIC_SYMBOLS); INSTALL_ENUM(UBlockCode, "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B", UBLOCK_CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B); INSTALL_ENUM(UBlockCode, "CJK_COMPATIBILITY_IDEOGRAPHS_SUPPLEMENT", UBLOCK_CJK_COMPATIBILITY_IDEOGRAPHS_SUPPLEMENT); INSTALL_ENUM(UBlockCode, "TAGS", UBLOCK_TAGS); INSTALL_ENUM(UBlockCode, "CYRILLIC_SUPPLEMENT", UBLOCK_CYRILLIC_SUPPLEMENT); INSTALL_ENUM(UBlockCode, "CYRILLIC_SUPPLEMENTARY", UBLOCK_CYRILLIC_SUPPLEMENTARY); INSTALL_ENUM(UBlockCode, "TAGALOG", UBLOCK_TAGALOG); INSTALL_ENUM(UBlockCode, "HANUNOO", UBLOCK_HANUNOO); INSTALL_ENUM(UBlockCode, "BUHID", UBLOCK_BUHID); INSTALL_ENUM(UBlockCode, "TAGBANWA", UBLOCK_TAGBANWA); INSTALL_ENUM(UBlockCode, "MISCELLANEOUS_MATHEMATICAL_SYMBOLS_A", UBLOCK_MISCELLANEOUS_MATHEMATICAL_SYMBOLS_A); INSTALL_ENUM(UBlockCode, "SUPPLEMENTAL_ARROWS_A", UBLOCK_SUPPLEMENTAL_ARROWS_A); INSTALL_ENUM(UBlockCode, "SUPPLEMENTAL_ARROWS_B", UBLOCK_SUPPLEMENTAL_ARROWS_B); INSTALL_ENUM(UBlockCode, "MISCELLANEOUS_MATHEMATICAL_SYMBOLS_B", UBLOCK_MISCELLANEOUS_MATHEMATICAL_SYMBOLS_B); INSTALL_ENUM(UBlockCode, "SUPPLEMENTAL_MATHEMATICAL_OPERATORS", UBLOCK_SUPPLEMENTAL_MATHEMATICAL_OPERATORS); INSTALL_ENUM(UBlockCode, "KATAKANA_PHONETIC_EXTENSIONS", UBLOCK_KATAKANA_PHONETIC_EXTENSIONS); INSTALL_ENUM(UBlockCode, "VARIATION_SELECTORS", UBLOCK_VARIATION_SELECTORS); INSTALL_ENUM(UBlockCode, "SUPPLEMENTARY_PRIVATE_USE_AREA_A", UBLOCK_SUPPLEMENTARY_PRIVATE_USE_AREA_A); INSTALL_ENUM(UBlockCode, "SUPPLEMENTARY_PRIVATE_USE_AREA_B", UBLOCK_SUPPLEMENTARY_PRIVATE_USE_AREA_B); INSTALL_ENUM(UBlockCode, "LIMBU", UBLOCK_LIMBU); INSTALL_ENUM(UBlockCode, "TAI_LE", UBLOCK_TAI_LE); INSTALL_ENUM(UBlockCode, "KHMER_SYMBOLS", UBLOCK_KHMER_SYMBOLS); INSTALL_ENUM(UBlockCode, "PHONETIC_EXTENSIONS", UBLOCK_PHONETIC_EXTENSIONS); INSTALL_ENUM(UBlockCode, "MISCELLANEOUS_SYMBOLS_AND_ARROWS", UBLOCK_MISCELLANEOUS_SYMBOLS_AND_ARROWS); INSTALL_ENUM(UBlockCode, "YIJING_HEXAGRAM_SYMBOLS", UBLOCK_YIJING_HEXAGRAM_SYMBOLS); INSTALL_ENUM(UBlockCode, "LINEAR_B_SYLLABARY", UBLOCK_LINEAR_B_SYLLABARY); INSTALL_ENUM(UBlockCode, "LINEAR_B_IDEOGRAMS", UBLOCK_LINEAR_B_IDEOGRAMS); INSTALL_ENUM(UBlockCode, "AEGEAN_NUMBERS", UBLOCK_AEGEAN_NUMBERS); INSTALL_ENUM(UBlockCode, "UGARITIC", UBLOCK_UGARITIC); INSTALL_ENUM(UBlockCode, "SHAVIAN", UBLOCK_SHAVIAN); INSTALL_ENUM(UBlockCode, "OSMANYA", UBLOCK_OSMANYA); INSTALL_ENUM(UBlockCode, "CYPRIOT_SYLLABARY", UBLOCK_CYPRIOT_SYLLABARY); INSTALL_ENUM(UBlockCode, "TAI_XUAN_JING_SYMBOLS", UBLOCK_TAI_XUAN_JING_SYMBOLS); INSTALL_ENUM(UBlockCode, "VARIATION_SELECTORS_SUPPLEMENT", UBLOCK_VARIATION_SELECTORS_SUPPLEMENT); INSTALL_ENUM(UBlockCode, "ANCIENT_GREEK_MUSICAL_NOTATION", UBLOCK_ANCIENT_GREEK_MUSICAL_NOTATION); INSTALL_ENUM(UBlockCode, "ANCIENT_GREEK_NUMBERS", UBLOCK_ANCIENT_GREEK_NUMBERS); INSTALL_ENUM(UBlockCode, "ARABIC_SUPPLEMENT", UBLOCK_ARABIC_SUPPLEMENT); INSTALL_ENUM(UBlockCode, "BUGINESE", UBLOCK_BUGINESE); INSTALL_ENUM(UBlockCode, "CJK_STROKES", UBLOCK_CJK_STROKES); INSTALL_ENUM(UBlockCode, "COMBINING_DIACRITICAL_MARKS_SUPPLEMENT", UBLOCK_COMBINING_DIACRITICAL_MARKS_SUPPLEMENT); INSTALL_ENUM(UBlockCode, "COPTIC", UBLOCK_COPTIC); INSTALL_ENUM(UBlockCode, "ETHIOPIC_EXTENDED", UBLOCK_ETHIOPIC_EXTENDED); INSTALL_ENUM(UBlockCode, "ETHIOPIC_SUPPLEMENT", UBLOCK_ETHIOPIC_SUPPLEMENT); INSTALL_ENUM(UBlockCode, "GEORGIAN_SUPPLEMENT", UBLOCK_GEORGIAN_SUPPLEMENT); INSTALL_ENUM(UBlockCode, "GLAGOLITIC", UBLOCK_GLAGOLITIC); INSTALL_ENUM(UBlockCode, "KHAROSHTHI", UBLOCK_KHAROSHTHI); INSTALL_ENUM(UBlockCode, "MODIFIER_TONE_LETTERS", UBLOCK_MODIFIER_TONE_LETTERS); INSTALL_ENUM(UBlockCode, "NEW_TAI_LUE", UBLOCK_NEW_TAI_LUE); INSTALL_ENUM(UBlockCode, "OLD_PERSIAN", UBLOCK_OLD_PERSIAN); INSTALL_ENUM(UBlockCode, "PHONETIC_EXTENSIONS_SUPPLEMENT", UBLOCK_PHONETIC_EXTENSIONS_SUPPLEMENT); INSTALL_ENUM(UBlockCode, "SUPPLEMENTAL_PUNCTUATION", UBLOCK_SUPPLEMENTAL_PUNCTUATION); INSTALL_ENUM(UBlockCode, "SYLOTI_NAGRI", UBLOCK_SYLOTI_NAGRI); INSTALL_ENUM(UBlockCode, "TIFINAGH", UBLOCK_TIFINAGH); INSTALL_ENUM(UBlockCode, "VERTICAL_FORMS", UBLOCK_VERTICAL_FORMS); INSTALL_ENUM(UBlockCode, "NKO", UBLOCK_NKO); INSTALL_ENUM(UBlockCode, "BALINESE", UBLOCK_BALINESE); INSTALL_ENUM(UBlockCode, "LATIN_EXTENDED_C", UBLOCK_LATIN_EXTENDED_C); INSTALL_ENUM(UBlockCode, "LATIN_EXTENDED_D", UBLOCK_LATIN_EXTENDED_D); INSTALL_ENUM(UBlockCode, "PHAGS_PA", UBLOCK_PHAGS_PA); INSTALL_ENUM(UBlockCode, "PHOENICIAN", UBLOCK_PHOENICIAN); INSTALL_ENUM(UBlockCode, "CUNEIFORM", UBLOCK_CUNEIFORM); INSTALL_ENUM(UBlockCode, "CUNEIFORM_NUMBERS_AND_PUNCTUATION", UBLOCK_CUNEIFORM_NUMBERS_AND_PUNCTUATION); INSTALL_ENUM(UBlockCode, "COUNTING_ROD_NUMERALS", UBLOCK_COUNTING_ROD_NUMERALS); #if U_ICU_VERSION_HEX >= 0x04000000 INSTALL_ENUM(UBlockCode, "SUNDANESE", UBLOCK_SUNDANESE); INSTALL_ENUM(UBlockCode, "LEPCHA", UBLOCK_LEPCHA); INSTALL_ENUM(UBlockCode, "OL_CHIKI", UBLOCK_OL_CHIKI); INSTALL_ENUM(UBlockCode, "CYRILLIC_EXTENDED_A", UBLOCK_CYRILLIC_EXTENDED_A); INSTALL_ENUM(UBlockCode, "VAI", UBLOCK_VAI); INSTALL_ENUM(UBlockCode, "CYRILLIC_EXTENDED_B", UBLOCK_CYRILLIC_EXTENDED_B); INSTALL_ENUM(UBlockCode, "SAURASHTRA", UBLOCK_SAURASHTRA); INSTALL_ENUM(UBlockCode, "KAYAH_LI", UBLOCK_KAYAH_LI); INSTALL_ENUM(UBlockCode, "REJANG", UBLOCK_REJANG); INSTALL_ENUM(UBlockCode, "CHAM", UBLOCK_CHAM); INSTALL_ENUM(UBlockCode, "ANCIENT_SYMBOLS", UBLOCK_ANCIENT_SYMBOLS); INSTALL_ENUM(UBlockCode, "PHAISTOS_DISC", UBLOCK_PHAISTOS_DISC); INSTALL_ENUM(UBlockCode, "LYCIAN", UBLOCK_LYCIAN); INSTALL_ENUM(UBlockCode, "CARIAN", UBLOCK_CARIAN); INSTALL_ENUM(UBlockCode, "LYDIAN", UBLOCK_LYDIAN); INSTALL_ENUM(UBlockCode, "MAHJONG_TILES", UBLOCK_MAHJONG_TILES); INSTALL_ENUM(UBlockCode, "DOMINO_TILES", UBLOCK_DOMINO_TILES); #endif #if U_ICU_VERSION_HEX >= 0x04040000 INSTALL_ENUM(UBlockCode, "SAMARITAN", UBLOCK_SAMARITAN); INSTALL_ENUM(UBlockCode, "UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS_EXTENDED", UBLOCK_UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS_EXTENDED); INSTALL_ENUM(UBlockCode, "TAI_THAM", UBLOCK_TAI_THAM); INSTALL_ENUM(UBlockCode, "VEDIC_EXTENSIONS", UBLOCK_VEDIC_EXTENSIONS); INSTALL_ENUM(UBlockCode, "LISU", UBLOCK_LISU); INSTALL_ENUM(UBlockCode, "BAMUM", UBLOCK_BAMUM); INSTALL_ENUM(UBlockCode, "COMMON_INDIC_NUMBER_FORMS", UBLOCK_COMMON_INDIC_NUMBER_FORMS); INSTALL_ENUM(UBlockCode, "DEVANAGARI_EXTENDED", UBLOCK_DEVANAGARI_EXTENDED); INSTALL_ENUM(UBlockCode, "HANGUL_JAMO_EXTENDED_A", UBLOCK_HANGUL_JAMO_EXTENDED_A); INSTALL_ENUM(UBlockCode, "JAVANESE", UBLOCK_JAVANESE); INSTALL_ENUM(UBlockCode, "MYANMAR_EXTENDED_A", UBLOCK_MYANMAR_EXTENDED_A); INSTALL_ENUM(UBlockCode, "TAI_VIET", UBLOCK_TAI_VIET); INSTALL_ENUM(UBlockCode, "MEETEI_MAYEK", UBLOCK_MEETEI_MAYEK); INSTALL_ENUM(UBlockCode, "HANGUL_JAMO_EXTENDED_B", UBLOCK_HANGUL_JAMO_EXTENDED_B); INSTALL_ENUM(UBlockCode, "IMPERIAL_ARAMAIC", UBLOCK_IMPERIAL_ARAMAIC); INSTALL_ENUM(UBlockCode, "OLD_SOUTH_ARABIAN", UBLOCK_OLD_SOUTH_ARABIAN); INSTALL_ENUM(UBlockCode, "AVESTAN", UBLOCK_AVESTAN); INSTALL_ENUM(UBlockCode, "INSCRIPTIONAL_PARTHIAN", UBLOCK_INSCRIPTIONAL_PARTHIAN); INSTALL_ENUM(UBlockCode, "INSCRIPTIONAL_PAHLAVI", UBLOCK_INSCRIPTIONAL_PAHLAVI); INSTALL_ENUM(UBlockCode, "OLD_TURKIC", UBLOCK_OLD_TURKIC); INSTALL_ENUM(UBlockCode, "RUMI_NUMERAL_SYMBOLS", UBLOCK_RUMI_NUMERAL_SYMBOLS); INSTALL_ENUM(UBlockCode, "KAITHI", UBLOCK_KAITHI); INSTALL_ENUM(UBlockCode, "EGYPTIAN_HIEROGLYPHS", UBLOCK_EGYPTIAN_HIEROGLYPHS); INSTALL_ENUM(UBlockCode, "ENCLOSED_ALPHANUMERIC_SUPPLEMENT", UBLOCK_ENCLOSED_ALPHANUMERIC_SUPPLEMENT); INSTALL_ENUM(UBlockCode, "ENCLOSED_IDEOGRAPHIC_SUPPLEMENT", UBLOCK_ENCLOSED_IDEOGRAPHIC_SUPPLEMENT); INSTALL_ENUM(UBlockCode, "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_C", UBLOCK_CJK_UNIFIED_IDEOGRAPHS_EXTENSION_C); #endif #if U_ICU_VERSION_HEX >= 0x04060000 INSTALL_ENUM(UBlockCode, "MANDAIC", UBLOCK_MANDAIC); INSTALL_ENUM(UBlockCode, "BATAK", UBLOCK_BATAK); INSTALL_ENUM(UBlockCode, "ETHIOPIC_EXTENDED_A", UBLOCK_ETHIOPIC_EXTENDED_A); INSTALL_ENUM(UBlockCode, "BRAHMI", UBLOCK_BRAHMI); INSTALL_ENUM(UBlockCode, "BAMUM_SUPPLEMENT", UBLOCK_BAMUM_SUPPLEMENT); INSTALL_ENUM(UBlockCode, "KANA_SUPPLEMENT", UBLOCK_KANA_SUPPLEMENT); INSTALL_ENUM(UBlockCode, "PLAYING_CARDS", UBLOCK_PLAYING_CARDS); INSTALL_ENUM(UBlockCode, "MISCELLANEOUS_SYMBOLS_AND_PICTOGRAPHS", UBLOCK_MISCELLANEOUS_SYMBOLS_AND_PICTOGRAPHS); INSTALL_ENUM(UBlockCode, "EMOTICONS", UBLOCK_EMOTICONS); INSTALL_ENUM(UBlockCode, "TRANSPORT_AND_MAP_SYMBOLS", UBLOCK_TRANSPORT_AND_MAP_SYMBOLS); INSTALL_ENUM(UBlockCode, "ALCHEMICAL_SYMBOLS", UBLOCK_ALCHEMICAL_SYMBOLS); INSTALL_ENUM(UBlockCode, "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_D", UBLOCK_CJK_UNIFIED_IDEOGRAPHS_EXTENSION_D); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(49, 0, 0) INSTALL_ENUM(UBlockCode, "ARABIC_EXTENDED_A", UBLOCK_ARABIC_EXTENDED_A); INSTALL_ENUM(UBlockCode, "ARABIC_MATHEMATICAL_ALPHABETIC_SYMBOLS", UBLOCK_ARABIC_MATHEMATICAL_ALPHABETIC_SYMBOLS); INSTALL_ENUM(UBlockCode, "CHAKMA", UBLOCK_CHAKMA); INSTALL_ENUM(UBlockCode, "MEETEI_MAYEK_EXTENSIONS", UBLOCK_MEETEI_MAYEK_EXTENSIONS); INSTALL_ENUM(UBlockCode, "MEROITIC_CURSIVE", UBLOCK_MEROITIC_CURSIVE); INSTALL_ENUM(UBlockCode, "MEROITIC_HIEROGLYPHS", UBLOCK_MEROITIC_HIEROGLYPHS); INSTALL_ENUM(UBlockCode, "MIAO", UBLOCK_MIAO); INSTALL_ENUM(UBlockCode, "SHARADA", UBLOCK_SHARADA); INSTALL_ENUM(UBlockCode, "SORA_SOMPENG", UBLOCK_SORA_SOMPENG); INSTALL_ENUM(UBlockCode, "SUNDANESE_SUPPLEMENT", UBLOCK_SUNDANESE_SUPPLEMENT); INSTALL_ENUM(UBlockCode, "TAKRI", UBLOCK_TAKRI); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(54, 0, 0) INSTALL_ENUM(UBlockCode, "BASSA_VAH", UBLOCK_BASSA_VAH); INSTALL_ENUM(UBlockCode, "CAUCASIAN_ALBANIAN", UBLOCK_CAUCASIAN_ALBANIAN); INSTALL_ENUM(UBlockCode, "COPTIC_EPACT_NUMBERS", UBLOCK_COPTIC_EPACT_NUMBERS); INSTALL_ENUM(UBlockCode, "COMBINING_DIACRITICAL_MARKS_EXTENDED", UBLOCK_COMBINING_DIACRITICAL_MARKS_EXTENDED); INSTALL_ENUM(UBlockCode, "DUPLOYAN", UBLOCK_DUPLOYAN); INSTALL_ENUM(UBlockCode, "ELBASAN", UBLOCK_ELBASAN); INSTALL_ENUM(UBlockCode, "GEOMETRIC_SHAPES_EXTENDED", UBLOCK_GEOMETRIC_SHAPES_EXTENDED); INSTALL_ENUM(UBlockCode, "GRANTHA", UBLOCK_GRANTHA); INSTALL_ENUM(UBlockCode, "KHOJKI", UBLOCK_KHOJKI); INSTALL_ENUM(UBlockCode, "KHUDAWADI", UBLOCK_KHUDAWADI); INSTALL_ENUM(UBlockCode, "LATIN_EXTENDED_E", UBLOCK_LATIN_EXTENDED_E); INSTALL_ENUM(UBlockCode, "LINEAR_A", UBLOCK_LINEAR_A); INSTALL_ENUM(UBlockCode, "MAHAJANI", UBLOCK_MAHAJANI); INSTALL_ENUM(UBlockCode, "MANICHAEAN", UBLOCK_MANICHAEAN); INSTALL_ENUM(UBlockCode, "MENDE_KIKAKUI", UBLOCK_MENDE_KIKAKUI); INSTALL_ENUM(UBlockCode, "MODI", UBLOCK_MODI); INSTALL_ENUM(UBlockCode, "MRO", UBLOCK_MRO); INSTALL_ENUM(UBlockCode, "MYANMAR_EXTENDED_B", UBLOCK_MYANMAR_EXTENDED_B); INSTALL_ENUM(UBlockCode, "NABATAEAN", UBLOCK_NABATAEAN); INSTALL_ENUM(UBlockCode, "OLD_NORTH_ARABIAN", UBLOCK_OLD_NORTH_ARABIAN); INSTALL_ENUM(UBlockCode, "OLD_PERMIC", UBLOCK_OLD_PERMIC); INSTALL_ENUM(UBlockCode, "ORNAMENTAL_DINGBATS", UBLOCK_ORNAMENTAL_DINGBATS); INSTALL_ENUM(UBlockCode, "PAHAWH_HMONG", UBLOCK_PAHAWH_HMONG); INSTALL_ENUM(UBlockCode, "PALMYRENE", UBLOCK_PALMYRENE); INSTALL_ENUM(UBlockCode, "PAU_CIN_HAU", UBLOCK_PAU_CIN_HAU); INSTALL_ENUM(UBlockCode, "PSALTER_PAHLAVI", UBLOCK_PSALTER_PAHLAVI); INSTALL_ENUM(UBlockCode, "SHORTHAND_FORMAT_CONTROLS", UBLOCK_SHORTHAND_FORMAT_CONTROLS); INSTALL_ENUM(UBlockCode, "SIDDHAM", UBLOCK_SIDDHAM); INSTALL_ENUM(UBlockCode, "SINHALA_ARCHAIC_NUMBERS", UBLOCK_SINHALA_ARCHAIC_NUMBERS); INSTALL_ENUM(UBlockCode, "SUPPLEMENTAL_ARROWS_C", UBLOCK_SUPPLEMENTAL_ARROWS_C); INSTALL_ENUM(UBlockCode, "TIRHUTA", UBLOCK_TIRHUTA); INSTALL_ENUM(UBlockCode, "WARANG_CITI", UBLOCK_WARANG_CITI); #endif INSTALL_ENUM(UBlockCode, "INVALID_CODE", UBLOCK_INVALID_CODE); INSTALL_ENUM(UCharNameChoice, "UNICODE_CHAR_NAME", U_UNICODE_CHAR_NAME); INSTALL_ENUM(UCharNameChoice, "EXTENDED_CHAR_NAME", U_EXTENDED_CHAR_NAME); #if U_ICU_VERSION_HEX >= 0x04040000 INSTALL_ENUM(UCharNameChoice, "CHAR_NAME_ALIAS", U_CHAR_NAME_ALIAS); #endif INSTALL_ENUM(UPropertyNameChoice, "SHORT_PROPERTY_NAME", U_SHORT_PROPERTY_NAME); INSTALL_ENUM(UPropertyNameChoice, "LONG_PROPERTY_NAME", U_LONG_PROPERTY_NAME); } PyICU-1.9.5/char.h0000644000076500000000000000253712517772774014002 0ustar vajdawheel00000000000000/* ==================================================================== * Copyright (c) 2004-2015 Open Source Applications Foundation. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. * ==================================================================== */ #ifndef _char_h #define _char_h void _init_char(PyObject *m); #endif /* _char_h */ PyICU-1.9.5/charset.cpp0000644000076500000000000002425612526723746015046 0ustar vajdawheel00000000000000/* ==================================================================== * Copyright (c) 2007-2010 Open Source Applications Foundation. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. * ==================================================================== */ #include "common.h" #include "structmember.h" #include "bases.h" #include "charset.h" #include "macros.h" /* CharsetDetector */ class t_charsetdetector : public _wrapper { public: UCharsetDetector *object; PyObject *text; }; static int t_charsetdetector_init(t_charsetdetector *self, PyObject *args, PyObject *kwds); static PyObject *t_charsetdetector_setText(t_charsetdetector *self, PyObject *arg); static PyObject *t_charsetdetector_setDeclaredEncoding(t_charsetdetector *self, PyObject *arg); static PyObject *t_charsetdetector_detect(t_charsetdetector *self); static PyObject *t_charsetdetector_detectAll(t_charsetdetector *self); static PyObject *t_charsetdetector_enableInputFilter(t_charsetdetector *self, PyObject *arg); static PyObject *t_charsetdetector_isInputFilterEnabled(t_charsetdetector *self); static PyObject *t_charsetdetector_getAllDetectableCharsets(t_charsetdetector *self); static PyMethodDef t_charsetdetector_methods[] = { DECLARE_METHOD(t_charsetdetector, setText, METH_O), DECLARE_METHOD(t_charsetdetector, setDeclaredEncoding, METH_O), DECLARE_METHOD(t_charsetdetector, detect, METH_NOARGS), DECLARE_METHOD(t_charsetdetector, detectAll, METH_NOARGS), DECLARE_METHOD(t_charsetdetector, enableInputFilter, METH_O), DECLARE_METHOD(t_charsetdetector, isInputFilterEnabled, METH_NOARGS), DECLARE_METHOD(t_charsetdetector, getAllDetectableCharsets, METH_NOARGS), { NULL, NULL, 0, NULL } }; static void t_charsetdetector_dealloc(t_charsetdetector *self) { if (self->object) { ucsdet_close(self->object); self->object = NULL; } Py_CLEAR(self->text); Py_TYPE(self)->tp_free((PyObject *) self); } DECLARE_STRUCT(CharsetDetector, t_charsetdetector, UCharsetDetector, t_charsetdetector_init, t_charsetdetector_dealloc); /* CharsetMatch */ class t_charsetmatch : public _wrapper { public: UCharsetMatch *object; t_charsetdetector *detector; }; static PyObject *t_charsetmatch_getName(t_charsetmatch *self); static PyObject *t_charsetmatch_getConfidence(t_charsetmatch *self); static PyObject *t_charsetmatch_getLanguage(t_charsetmatch *self); static PyMethodDef t_charsetmatch_methods[] = { DECLARE_METHOD(t_charsetmatch, getName, METH_NOARGS), DECLARE_METHOD(t_charsetmatch, getConfidence, METH_NOARGS), DECLARE_METHOD(t_charsetmatch, getLanguage, METH_NOARGS), { NULL, NULL, 0, NULL } }; static void t_charsetmatch_dealloc(t_charsetmatch *self) { if (self->object) /* not owned */ { self->object = NULL; Py_CLEAR(self->detector); } Py_TYPE(self)->tp_free((PyObject *) self); } DECLARE_STRUCT(CharsetMatch, t_charsetmatch, UCharsetMatch, abstract_init, t_charsetmatch_dealloc); /* CharsetDetector */ static int t_charsetdetector_init(t_charsetdetector *self, PyObject *args, PyObject *kwds) { const char *text; charsArg encoding; int textSize; switch (PyTuple_Size(args)) { case 0: INT_STATUS_CALL(self->object = ucsdet_open(&status)); break; case 1: if (!parseArgs(args, "k", &text, &textSize)) { INT_STATUS_CALL(self->object = ucsdet_open(&status)); INT_STATUS_CALL(ucsdet_setText(self->object, text, textSize, &status)); self->text = PyTuple_GetItem(args, 0); Py_INCREF(self->text); break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; case 2: if (!parseArgs(args, "kn", &text, &textSize, &encoding)) { INT_STATUS_CALL(self->object = ucsdet_open(&status)); INT_STATUS_CALL(ucsdet_setText(self->object, text, textSize, &status)); INT_STATUS_CALL(ucsdet_setDeclaredEncoding(self->object, encoding, -1, &status)); self->text = PyTuple_GetItem(args, 0); Py_INCREF(self->text); break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; default: PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; } if (self->object) return 0; return -1; } static PyObject *t_charsetdetector_setText(t_charsetdetector *self, PyObject *arg) { const char *text; int size; if (!parseArg(arg, "k", &text, &size)) { /* ref'd */ STATUS_CALL(ucsdet_setText(self->object, text, size, &status)); Py_INCREF(arg); Py_XDECREF(self->text); self->text = arg; Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setText", arg); } static PyObject *t_charsetdetector_setDeclaredEncoding(t_charsetdetector *self, PyObject *arg) { const char *encoding; int size; if (!parseArg(arg, "k", &encoding, &size)) { /* copied */ STATUS_CALL(ucsdet_setDeclaredEncoding(self->object, encoding, size, &status)); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setDeclaredEncoding", arg); } static PyObject *t_charsetdetector_detect(t_charsetdetector *self) { const UCharsetMatch *match; PyObject *result; STATUS_CALL(match = ucsdet_detect(self->object, &status)); result = wrap_CharsetMatch((UCharsetMatch *) match, 0); if (result) { ((t_charsetmatch *) result)->detector = self; Py_INCREF(self); } return result; } static PyObject *t_charsetdetector_detectAll(t_charsetdetector *self) { const UCharsetMatch **matches; PyObject *result; int found = 0; STATUS_CALL(matches = ucsdet_detectAll(self->object, &found, &status)); result = PyTuple_New(found); for (int i = 0; i < found; i++) { const UCharsetMatch *match = matches[i]; PyObject *m = wrap_CharsetMatch((UCharsetMatch *) match, 0); if (m) { ((t_charsetmatch *) m)->detector = self; Py_INCREF(self); PyTuple_SET_ITEM(result, i, m); } else { Py_DECREF(result); return NULL; } } return result; } static PyObject *t_charsetdetector_enableInputFilter(t_charsetdetector *self, PyObject *arg) { UBool filter; if (!parseArg(arg, "B", &filter)) { UBool previous = ucsdet_enableInputFilter(self->object, filter); Py_RETURN_BOOL(previous); } return PyErr_SetArgsError((PyObject *) self, "enableInputFilter", arg); } static PyObject *t_charsetdetector_isInputFilterEnabled(t_charsetdetector *self) { UBool filter = ucsdet_isInputFilterEnabled(self->object); Py_RETURN_BOOL(filter); } static PyObject *t_charsetdetector_getAllDetectableCharsets(t_charsetdetector *self) { UEnumeration *_charsets; STATUS_CALL(_charsets = ucsdet_getAllDetectableCharsets(self->object, &status)); return wrap_StringEnumeration(new UStringEnumeration(_charsets), T_OWNED); } /* CharsetMatch */ static PyObject *t_charsetmatch_getName(t_charsetmatch *self) { const char *name; STATUS_CALL(name = ucsdet_getName(self->object, &status)); return PyString_FromString(name); } static PyObject *t_charsetmatch_getConfidence(t_charsetmatch *self) { int confidence; STATUS_CALL(confidence = ucsdet_getConfidence(self->object, &status)); return PyInt_FromLong(confidence); } static PyObject *t_charsetmatch_getLanguage(t_charsetmatch *self) { const char *language; STATUS_CALL(language = ucsdet_getLanguage(self->object, &status)); return PyString_FromString(language); } static PyObject *t_charsetmatch_str(t_charsetmatch *self) { if (self->detector && self->detector->text) { UErrorCode status = U_ZERO_ERROR; int size = PyBytes_GET_SIZE(self->detector->text); UChar *buf = new UChar[size]; PyObject *u; if (!buf) { PyErr_SetNone(PyExc_MemoryError); return NULL; } size = ucsdet_getUChars(self->object, buf, size, &status); if (U_FAILURE(status)) { delete[] buf; return ICUException(status).reportError(); } u = PyUnicode_FromUnicodeString(buf, size); delete[] buf; return u; } return PyUnicode_FromUnicode(NULL, 0); } void _init_charset(PyObject *m) { CharsetMatchType_.tp_str = (reprfunc) t_charsetmatch_str; INSTALL_STRUCT(CharsetDetector, m); INSTALL_STRUCT(CharsetMatch, m); } PyICU-1.9.5/charset.h0000644000076500000000000000255411323445325014474 0ustar vajdawheel00000000000000/* ==================================================================== * Copyright (c) 2004-2010 Open Source Applications Foundation. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. * ==================================================================== */ #ifndef _charset_h #define _charset_h void _init_charset(PyObject *m); #endif /* _charset_h */ PyICU-1.9.5/collator.cpp0000644000076500000000000005520512520066623015216 0ustar vajdawheel00000000000000/* ==================================================================== * Copyright (c) 2004-2011 Open Source Applications Foundation. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. * ==================================================================== */ #include "common.h" #include "structmember.h" #include "bases.h" #include "locale.h" #include "collator.h" #include "iterators.h" #include "unicodeset.h" #include "macros.h" DECLARE_CONSTANTS_TYPE(UCollationResult); DECLARE_CONSTANTS_TYPE(UCollAttribute); DECLARE_CONSTANTS_TYPE(UCollAttributeValue); /* CollationKey */ class t_collationkey : public _wrapper { public: CollationKey *object; }; static int t_collationkey_init(t_collationkey *self, PyObject *args, PyObject *kwds); static PyObject *t_collationkey_isBogus(t_collationkey *self); static PyObject *t_collationkey_compareTo(t_collationkey *self, PyObject *arg); static PyObject *t_collationkey_getByteArray(t_collationkey *self); static PyMethodDef t_collationkey_methods[] = { DECLARE_METHOD(t_collationkey, isBogus, METH_NOARGS), DECLARE_METHOD(t_collationkey, compareTo, METH_O), DECLARE_METHOD(t_collationkey, getByteArray, METH_NOARGS), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(CollationKey, t_collationkey, UObject, CollationKey, t_collationkey_init, NULL); /* Collator */ class t_collator : public _wrapper { public: Collator *object; }; static PyObject *t_collator_compare(t_collator *self, PyObject *args); static PyObject *t_collator_greater(t_collator *self, PyObject *args); static PyObject *t_collator_greaterOrEqual(t_collator *self, PyObject *args); static PyObject *t_collator_equals(t_collator *self, PyObject *args); static PyObject *t_collator_getCollationKey(t_collator *self, PyObject *args); static PyObject *t_collator_getSortKey(t_collator *self, PyObject *args); static PyObject *t_collator_getStrength(t_collator *self); static PyObject *t_collator_setStrength(t_collator *self, PyObject *arg); static PyObject *t_collator_getLocale(t_collator *self, PyObject *args); static PyObject *t_collator_getAttribute(t_collator *self, PyObject *arg); static PyObject *t_collator_setAttribute(t_collator *self, PyObject *args); static PyObject *t_collator_getTailoredSet(t_collator *self); static PyObject *t_collator_getVariableTop(t_collator *self); static PyObject *t_collator_setVariableTop(t_collator *self, PyObject *arg); static PyObject *t_collator_createInstance(PyTypeObject *type, PyObject *args); static PyObject *t_collator_getAvailableLocales(PyTypeObject *type); static PyObject *t_collator_getKeywords(PyTypeObject *type); static PyObject *t_collator_getKeywordValues(PyTypeObject *type, PyObject *arg); static PyObject *t_collator_getFunctionalEquivalent(PyTypeObject *type, PyObject *args); static PyMethodDef t_collator_methods[] = { DECLARE_METHOD(t_collator, compare, METH_VARARGS), DECLARE_METHOD(t_collator, greater, METH_VARARGS), DECLARE_METHOD(t_collator, greaterOrEqual, METH_VARARGS), DECLARE_METHOD(t_collator, equals, METH_VARARGS), DECLARE_METHOD(t_collator, getCollationKey, METH_VARARGS), DECLARE_METHOD(t_collator, getSortKey, METH_VARARGS), DECLARE_METHOD(t_collator, getStrength, METH_NOARGS), DECLARE_METHOD(t_collator, setStrength, METH_O), DECLARE_METHOD(t_collator, getLocale, METH_VARARGS), DECLARE_METHOD(t_collator, getAttribute, METH_O), DECLARE_METHOD(t_collator, setAttribute, METH_VARARGS), DECLARE_METHOD(t_collator, getTailoredSet, METH_O), DECLARE_METHOD(t_collator, getVariableTop, METH_NOARGS), DECLARE_METHOD(t_collator, setVariableTop, METH_O), DECLARE_METHOD(t_collator, createInstance, METH_VARARGS | METH_CLASS), DECLARE_METHOD(t_collator, getAvailableLocales, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_collator, getKeywords, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_collator, getKeywordValues, METH_O | METH_CLASS), DECLARE_METHOD(t_collator, getFunctionalEquivalent, METH_VARARGS | METH_CLASS), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(Collator, t_collator, UObject, Collator, abstract_init, NULL); /* RuleBasedCollator */ class t_rulebasedcollator : public _wrapper { public: RuleBasedCollator *object; PyObject *buf; PyObject *base; }; static int t_rulebasedcollator_init(t_rulebasedcollator *self, PyObject *args, PyObject *kwds); static PyObject *t_rulebasedcollator_getRules(t_rulebasedcollator *self, PyObject *args); static PyObject *t_rulebasedcollator_createCollationElementIterator(t_rulebasedcollator *self, PyObject *arg); static PyObject *t_rulebasedcollator_cloneBinary(t_rulebasedcollator *self); static PyMethodDef t_rulebasedcollator_methods[] = { DECLARE_METHOD(t_rulebasedcollator, getRules, METH_VARARGS), DECLARE_METHOD(t_rulebasedcollator, createCollationElementIterator, METH_O), DECLARE_METHOD(t_rulebasedcollator, cloneBinary, METH_NOARGS), { NULL, NULL, 0, NULL } }; static void t_rulebasedcollator_dealloc(t_rulebasedcollator *self) { if (self->flags & T_OWNED) delete self->object; self->object = NULL; Py_CLEAR(self->buf); Py_CLEAR(self->base); Py_TYPE(self)->tp_free((PyObject *) self); } DECLARE_TYPE(RuleBasedCollator, t_rulebasedcollator, Collator, RuleBasedCollator, t_rulebasedcollator_init, t_rulebasedcollator_dealloc); /* CollationKey */ static int t_collationkey_init(t_collationkey *self, PyObject *args, PyObject *kwds) { switch (PyTuple_Size(args)) { case 0: self->object = new CollationKey(); self->flags = T_OWNED; break; default: PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; } if (self->object) return 0; return -1; } static PyObject *t_collationkey_isBogus(t_collationkey *self) { int b = self->object->isBogus(); Py_RETURN_BOOL(b); } static PyObject *t_collationkey_compareTo(t_collationkey *self, PyObject *arg) { CollationKey *key; if (!parseArg(arg, "P", TYPE_CLASSID(CollationKey), &key)) { UCollationResult result; STATUS_CALL(result = self->object->compareTo(*key, status)); return PyInt_FromLong(result); } return PyErr_SetArgsError((PyObject *) self, "compareTo", arg); } static PyObject *t_collationkey_getByteArray(t_collationkey *self) { int32_t count; const uint8_t *array = self->object->getByteArray(count); return PyBytes_FromStringAndSize((char *) array, count); } DEFINE_RICHCMP(CollationKey, t_collationkey); /* Collator */ static PyObject *t_collator_compare(t_collator *self, PyObject *args) { UCollationResult result; UnicodeString *u, *v; UnicodeString _u, _v; int len; switch (PyTuple_Size(args)) { case 2: if (!parseArgs(args, "SS", &u, &_u, &v, &_v)) { STATUS_CALL(result = self->object->compare(*u, *v, status)); return PyInt_FromLong(result); } break; case 3: if (!parseArgs(args, "SSi", &u, &_u, &v, &_v, &len)) { STATUS_CALL(result = self->object->compare(*u, *v, len, status)); return PyInt_FromLong(result); } break; } return PyErr_SetArgsError((PyObject *) self, "compare", args); } static PyObject *t_collator_greater(t_collator *self, PyObject *args) { int b; UnicodeString *u, *v; UnicodeString _u, _v; if (!parseArgs(args, "SS", &u, &_u, &v, &_v)) { b = self->object->greater(*u, *v); Py_RETURN_BOOL(b); } return PyErr_SetArgsError((PyObject *) self, "greater", args); } static PyObject *t_collator_greaterOrEqual(t_collator *self, PyObject *args) { int b; UnicodeString *u, *v; UnicodeString _u, _v; if (!parseArgs(args, "SS", &u, &_u, &v, &_v)) { b = self->object->greaterOrEqual(*u, *v); Py_RETURN_BOOL(b); } return PyErr_SetArgsError((PyObject *) self, "greaterOrEqual", args); } static PyObject *t_collator_equals(t_collator *self, PyObject *args) { int b; UnicodeString *u, *v; UnicodeString _u, _v; if (!parseArgs(args, "SS", &u, &_u, &v, &_v)) { b = self->object->equals(*u, *v); Py_RETURN_BOOL(b); } return PyErr_SetArgsError((PyObject *) self, "equals", args); } static PyObject *t_collator_getCollationKey(t_collator *self, PyObject *args) { UnicodeString *u; UnicodeString _u; CollationKey *key; CollationKey _key; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "S", &u, &_u)) { STATUS_CALL(self->object->getCollationKey(*u, _key, status)); return wrap_CollationKey(new CollationKey(_key), T_OWNED); } break; case 2: if (!parseArgs(args, "SP", TYPE_CLASSID(CollationKey), &u, &_u, &key)) { STATUS_CALL(self->object->getCollationKey(*u, *key, status)); Py_RETURN_ARG(args, 1); } break; } return PyErr_SetArgsError((PyObject *) self, "getCollationKey", args); } static PyObject *t_collator_getSortKey(t_collator *self, PyObject *args) { UnicodeString *u; UnicodeString _u; uint32_t len, size; uint8_t *buf; PyObject *key; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "S", &u, &_u)) { len = u->length() * 4 + 8; buf = (uint8_t *) malloc(len); retry: if (buf == NULL) return PyErr_NoMemory(); size = self->object->getSortKey(*u, buf, len); if (size <= len) { key = PyBytes_FromStringAndSize((char *) buf, size); free(buf); } else { len = size; buf = (uint8_t *) realloc(buf, len); goto retry; } return key; } break; case 2: if (!parseArgs(args, "Si", &u, &_u, &len)) { buf = (uint8_t *) calloc(len, 1); if (buf == NULL) return PyErr_NoMemory(); len = self->object->getSortKey(*u, buf, len); key = PyBytes_FromStringAndSize((char *) buf, len); free(buf); return key; } break; } return PyErr_SetArgsError((PyObject *) self, "getSortKey", args); } static PyObject *t_collator_getStrength(t_collator *self) { return PyInt_FromLong(self->object->getStrength()); } static PyObject *t_collator_setStrength(t_collator *self, PyObject *arg) { Collator::ECollationStrength strength; if (!parseArg(arg, "i", &strength)) { self->object->setStrength(strength); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setStrength", arg); } static PyObject *t_collator_getLocale(t_collator *self, PyObject *args) { ULocDataLocaleType type; Locale locale; switch (PyTuple_Size(args)) { case 0: STATUS_CALL(locale = self->object->getLocale(ULOC_VALID_LOCALE, status)); return wrap_Locale(locale); case 1: if (!parseArgs(args, "i", &type)) { STATUS_CALL(locale = self->object->getLocale(type, status)); return wrap_Locale(locale); } break; } return PyErr_SetArgsError((PyObject *) self, "getLocale", args); } static inline PyObject *wrap_Collator(Collator *collator) { RETURN_WRAPPED_IF_ISINSTANCE(collator, RuleBasedCollator); return wrap_Collator(collator, T_OWNED); } static PyObject *t_collator_createInstance(PyTypeObject *type, PyObject *args) { Locale *locale; Collator *collator; switch (PyTuple_Size(args)) { case 0: STATUS_CALL(collator = Collator::createInstance(status)); return wrap_Collator(collator); case 1: if (!parseArgs(args, "P", TYPE_CLASSID(Locale), &locale)) { STATUS_CALL(collator = Collator::createInstance(*locale, status)); return wrap_Collator(collator); } break; } return PyErr_SetArgsError(type, "createInstance", args); } static PyObject *t_collator_getKeywords(PyTypeObject *type) { StringEnumeration *e; STATUS_CALL(e = Collator::getKeywords(status)); return wrap_StringEnumeration(e, T_OWNED); } static PyObject *t_collator_getKeywordValues(PyTypeObject *type, PyObject *arg) { StringEnumeration *e; charsArg keyword; if (!parseArg(arg, "n", &keyword)) { STATUS_CALL(e = Collator::getKeywordValues(keyword, status)); return wrap_StringEnumeration(e, T_OWNED); } return PyErr_SetArgsError(type, "getKeywordValues", arg); } static PyObject *t_collator_getAvailableLocales(PyTypeObject *type) { int count; const Locale *locales = Collator::getAvailableLocales(count); PyObject *dict = PyDict_New(); for (int32_t i = 0; i < count; i++) { Locale *locale = (Locale *) locales + i; PyObject *obj = wrap_Locale(locale, 0); PyDict_SetItemString(dict, locale->getName(), obj); Py_DECREF(obj); } return dict; } static PyObject *t_collator_getFunctionalEquivalent(PyTypeObject *type, PyObject *args) { UBool isAvailable; Locale *locale; charsArg keyword; if (!parseArgs(args, "nP", TYPE_CLASSID(Locale), &keyword, &locale)) { Locale result(*locale); STATUS_CALL(Collator::getFunctionalEquivalent(keyword, result, isAvailable, status)); return Py_BuildValue("(OO)", wrap_Locale(result), isAvailable ? Py_True : Py_False); } return PyErr_SetArgsError(type, "getFunctionalEquivalent", args); } static PyObject *t_collator_getAttribute(t_collator *self, PyObject *arg) { UColAttribute attribute; if (!parseArg(arg, "i", &attribute)) { UColAttributeValue value; STATUS_CALL(value = self->object->getAttribute(attribute, status)); return PyInt_FromLong(value); } return PyErr_SetArgsError((PyObject *) self, "getAttribute", arg); } static PyObject *t_collator_setAttribute(t_collator *self, PyObject *args) { UColAttribute attribute; UColAttributeValue value; if (!parseArgs(args, "ii", &attribute, &value)) { STATUS_CALL(self->object->setAttribute(attribute, value, status)); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setAttribute", args); } static PyObject *t_collator_getTailoredSet(t_collator *self) { UnicodeSet *set; STATUS_CALL(set = self->object->getTailoredSet(status)); return wrap_UnicodeSet(set, T_OWNED); } static PyObject *t_collator_getVariableTop(t_collator *self) { uint32_t top; STATUS_CALL(top = self->object->getVariableTop(status)); return PyInt_FromLong(top >> 16); } static PyObject *t_collator_setVariableTop(t_collator *self, PyObject *arg) { UnicodeString *u, _u; uint32_t top; if (!parseArg(arg, "i", &top)) { STATUS_CALL(self->object->setVariableTop(top << 16, status)); Py_RETURN_NONE; } else if (!parseArg(arg, "S", &u, &_u)) { STATUS_CALL(self->object->setVariableTop(*u, status)); /* transient */ Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setVariableTop", arg); } static long t_collator_hash(t_collator *self) { return (long) self->object->hashCode(); } /* RuleBasedCollator */ static int t_rulebasedcollator_init(t_rulebasedcollator *self, PyObject *args, PyObject *kwds) { UnicodeString *u; UnicodeString _u; RuleBasedCollator *collator; Collator::ECollationStrength strength; UColAttributeValue decompositionMode; PyObject *buf, *base; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "S", &u, &_u)) { INT_STATUS_CALL(collator = new RuleBasedCollator(*u, status)); self->object = collator; self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; case 2: if (!parseArgs(args, "CO", &RuleBasedCollatorType_, &buf, &base)) { INT_STATUS_CALL(collator = new RuleBasedCollator((uint8_t *) PyBytes_AS_STRING(buf), PyBytes_GET_SIZE(buf), ((t_rulebasedcollator *) base)->object, status)); self->object = collator; self->flags = T_OWNED; self->buf = buf; Py_INCREF(buf); self->base = base; Py_INCREF(base); break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; case 3: if (!parseArgs(args, "Sii", &u, &_u, &strength, &decompositionMode)) { INT_STATUS_CALL(collator = new RuleBasedCollator(*u, strength, decompositionMode, status)); self->object = collator; self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; default: PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; } if (self->object) return 0; return -1; } static PyObject *t_rulebasedcollator_getRules(t_rulebasedcollator *self, PyObject *args) { UnicodeString u = self->object->getRules(); return PyUnicode_FromUnicodeString(&u); } static PyObject *t_rulebasedcollator_createCollationElementIterator(t_rulebasedcollator *self, PyObject *arg) { UnicodeString *u, _u; CharacterIterator *chars; CollationElementIterator *iterator; if (!parseArg(arg, "S", &u, &_u)) { iterator = self->object->createCollationElementIterator(*u); return wrap_CollationElementIterator(iterator, T_OWNED); } else if (!parseArg(arg, "P", TYPE_ID(CharacterIterator), &chars)) { iterator = self->object->createCollationElementIterator(*chars); return wrap_CollationElementIterator(iterator, T_OWNED); } return PyErr_SetArgsError((PyObject *) self, "createCollationElementIterator", arg); } static PyObject *t_rulebasedcollator_cloneBinary(t_rulebasedcollator *self) { UErrorCode status = U_ZERO_ERROR; PyObject *result; int32_t len; len = self->object->cloneBinary(NULL, 0, status); result = PyBytes_FromStringAndSize(NULL, len); if (!result) return NULL; STATUS_CALL(len = self->object->cloneBinary((uint8_t *) PyBytes_AS_STRING(result), len, status)); return result; } static PyObject *t_rulebasedcollator_str(t_rulebasedcollator *self) { UnicodeString u = self->object->getRules(); return PyUnicode_FromUnicodeString(&u); } DEFINE_RICHCMP(RuleBasedCollator, t_rulebasedcollator); void _init_collator(PyObject *m) { CollationKeyType_.tp_richcompare = (richcmpfunc) t_collationkey_richcmp; CollatorType_.tp_hash = (hashfunc) t_collator_hash; RuleBasedCollatorType_.tp_str = (reprfunc) t_rulebasedcollator_str; RuleBasedCollatorType_.tp_richcompare = (richcmpfunc) t_rulebasedcollator_richcmp; INSTALL_CONSTANTS_TYPE(UCollationResult, m); INSTALL_CONSTANTS_TYPE(UCollAttribute, m); INSTALL_CONSTANTS_TYPE(UCollAttributeValue, m); REGISTER_TYPE(CollationKey, m); INSTALL_TYPE(Collator, m); REGISTER_TYPE(RuleBasedCollator, m); INSTALL_ENUM(UCollationResult, "LESS", UCOL_LESS); INSTALL_ENUM(UCollationResult, "EQUAL", UCOL_EQUAL); INSTALL_ENUM(UCollationResult, "GREATER", UCOL_GREATER); INSTALL_ENUM(UCollAttribute, "FRENCH_COLLATION", UCOL_FRENCH_COLLATION); INSTALL_ENUM(UCollAttribute, "ALTERNATE_HANDLING", UCOL_ALTERNATE_HANDLING); INSTALL_ENUM(UCollAttribute, "CASE_FIRST", UCOL_CASE_FIRST); INSTALL_ENUM(UCollAttribute, "CASE_LEVEL", UCOL_CASE_LEVEL); INSTALL_ENUM(UCollAttribute, "NORMALIZATION_MODE", UCOL_NORMALIZATION_MODE); INSTALL_ENUM(UCollAttribute, "DECOMPOSITION_MODE", UCOL_DECOMPOSITION_MODE); INSTALL_ENUM(UCollAttribute, "STRENGTH", UCOL_STRENGTH); INSTALL_ENUM(UCollAttribute, "HIRAGANA_QUATERNARY_MODE", UCOL_HIRAGANA_QUATERNARY_MODE); INSTALL_ENUM(UCollAttribute, "NUMERIC_COLLATION", UCOL_NUMERIC_COLLATION); INSTALL_ENUM(UCollAttributeValue, "DEFAULT", UCOL_DEFAULT); INSTALL_ENUM(UCollAttributeValue, "PRIMARY", UCOL_PRIMARY); INSTALL_ENUM(UCollAttributeValue, "SECONDARY", UCOL_SECONDARY); INSTALL_ENUM(UCollAttributeValue, "TERTIARY", UCOL_TERTIARY); INSTALL_ENUM(UCollAttributeValue, "DEFAULT_STRENGTH", UCOL_DEFAULT_STRENGTH); INSTALL_ENUM(UCollAttributeValue, "QUATERNARY", UCOL_QUATERNARY); INSTALL_ENUM(UCollAttributeValue, "IDENTICAL", UCOL_IDENTICAL); INSTALL_ENUM(UCollAttributeValue, "OFF", UCOL_OFF); INSTALL_ENUM(UCollAttributeValue, "ON", UCOL_ON); INSTALL_ENUM(UCollAttributeValue, "SHIFTED", UCOL_SHIFTED); INSTALL_ENUM(UCollAttributeValue, "NON_IGNORABLE", UCOL_NON_IGNORABLE); INSTALL_ENUM(UCollAttributeValue, "LOWER_FIRST", UCOL_LOWER_FIRST); INSTALL_ENUM(UCollAttributeValue, "UPPER_FIRST", UCOL_UPPER_FIRST); INSTALL_ENUM(UCollationResult, "LESS", UCOL_LESS); INSTALL_ENUM(UCollationResult, "EQUAL", UCOL_EQUAL); INSTALL_ENUM(UCollationResult, "GREATER", UCOL_GREATER); INSTALL_STATIC_INT(Collator, PRIMARY); INSTALL_STATIC_INT(Collator, SECONDARY); INSTALL_STATIC_INT(Collator, TERTIARY); INSTALL_STATIC_INT(Collator, QUATERNARY); INSTALL_STATIC_INT(Collator, IDENTICAL); INSTALL_STATIC_INT(CollationElementIterator, NULLORDER); } PyICU-1.9.5/collator.h0000644000076500000000000000274712520066577014676 0ustar vajdawheel00000000000000/* ==================================================================== * Copyright (c) 2004-2010 Open Source Applications Foundation. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. * ==================================================================== */ #ifndef _collator_h #define _collator_h extern PyTypeObject RuleBasedCollatorType_; PyObject *wrap_RuleBasedCollator(RuleBasedCollator *collator, int flag); void _init_collator(PyObject *m); #endif /* _collator_h */ PyICU-1.9.5/common.cpp0000644000076500000000000011676413011407155014672 0ustar vajdawheel00000000000000/* ==================================================================== * Copyright (c) 2005-2014 Open Source Applications Foundation. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. * ==================================================================== */ #include "common.h" #include #include #include #include #include "bases.h" #include "macros.h" static PyObject *utcoffset_NAME; static PyObject *toordinal_NAME; static PyObject *getDefault_NAME; typedef struct { UConverterCallbackReason reason; const char *src; int32_t src_length; char chars[8]; int32_t length; int32_t error_position; } _STOPReason; U_STABLE void U_EXPORT2 _stopDecode(const void *context, UConverterToUnicodeArgs *args, const char *chars, int32_t length, UConverterCallbackReason reason, UErrorCode *err) { _STOPReason *stop = (_STOPReason *) context; stop->reason = reason; stop->length = length; if (chars && length) { const int size = stop->src_length - length + 1; const size_t len = (size_t) length < sizeof(stop->chars) - 1 ? (size_t) length : sizeof(stop->chars) - 1; strncpy(stop->chars, chars, len); stop->chars[len] = '\0'; stop->error_position = -1; for (int i = 0; i < size; ++i) { if (!memcmp(stop->src + i, chars, length)) { stop->error_position = i; break; } } } } PyObject *PyExc_ICUError; PyObject *PyExc_InvalidArgsError; EXPORT ICUException::ICUException() { code = NULL; msg = NULL; } EXPORT ICUException::ICUException(const ICUException &e) : code(e.code), msg(e.msg) { Py_XINCREF(code); Py_XINCREF(msg); } EXPORT ICUException::ICUException(UErrorCode status) { PyObject *messages = PyObject_GetAttrString(PyExc_ICUError, "messages"); code = PyInt_FromLong((long) status); msg = PyObject_GetItem(messages, code); Py_DECREF(messages); } EXPORT ICUException::ICUException(UErrorCode status, char *format, ...) { ICUException::code = PyInt_FromLong((long) status); va_list ap; va_start(ap, format); ICUException::msg = PyString_FromFormatV(format, ap); va_end(ap); } EXPORT ICUException::ICUException(UParseError &pe, UErrorCode status) { PyObject *messages = PyObject_GetAttrString(PyExc_ICUError, "messages"); UnicodeString pre((const UChar *) pe.preContext, U_PARSE_CONTEXT_LEN); UnicodeString post((const UChar *) pe.postContext, U_PARSE_CONTEXT_LEN); PyObject *tuple = PyTuple_New(5); ICUException::code = PyInt_FromLong((long) status); PyTuple_SET_ITEM(tuple, 0, PyObject_GetItem(messages, code)); PyTuple_SET_ITEM(tuple, 1, PyInt_FromLong(pe.line)); PyTuple_SET_ITEM(tuple, 2, PyInt_FromLong(pe.offset)); PyTuple_SET_ITEM(tuple, 3, PyUnicode_FromUnicodeString(&pre)); PyTuple_SET_ITEM(tuple, 4, PyUnicode_FromUnicodeString(&post)); ICUException::msg = tuple; Py_DECREF(messages); } EXPORT ICUException::~ICUException() { Py_XDECREF(ICUException::code); Py_XDECREF(ICUException::msg); } EXPORT PyObject *ICUException::reportError() { if (ICUException::code) { PyObject *tuple = Py_BuildValue("(OO)", ICUException::code, ICUException::msg ? ICUException::msg : Py_None); PyErr_SetObject(PyExc_ICUError, tuple); Py_DECREF(tuple); } return NULL; } EXPORT PyObject *PyUnicode_FromUnicodeString(const UnicodeString *string) { if (!string) { Py_INCREF(Py_None); return Py_None; } return PyUnicode_FromUnicodeString(string->getBuffer(), string->length()); } EXPORT PyObject *PyUnicode_FromUnicodeString(const UChar *utf16, int len16) { if (!utf16) { Py_INCREF(Py_None); return Py_None; } #if PY_VERSION_HEX < 0x03030000 else if (sizeof(Py_UNICODE) == sizeof(UChar)) return PyUnicode_FromUnicode((const Py_UNICODE *) utf16, len16); else { int32_t len32 = u_countChar32(utf16, len16); PyObject *u = PyUnicode_FromUnicode(NULL, len32); if (u) { Py_UNICODE *pchars = PyUnicode_AS_UNICODE(u); UErrorCode status = U_ZERO_ERROR; u_strToUTF32((UChar32 *) pchars, len32, NULL, utf16, len16, &status); if (U_FAILURE(status)) { Py_DECREF(u); return ICUException(status).reportError(); } } return u; } #else { int32_t len32 = 0; UChar32 max_char = 0; for (int32_t i = 0; i < len16;) { UChar32 cp; U16_NEXT(utf16, i, len16, cp); max_char |= cp; // we only care about the leftmost bit len32 += 1; } PyObject *result = PyUnicode_New(len32, max_char); if (result == NULL) return NULL; switch (PyUnicode_KIND(result)) { case PyUnicode_1BYTE_KIND: // note: len16 == len32 for (int32_t i = 0; i < len32; ++i) PyUnicode_1BYTE_DATA(result)[i] = (Py_UCS1) (utf16[i]); break; case PyUnicode_2BYTE_KIND: // note: len16 == len32 u_memcpy(PyUnicode_2BYTE_DATA(result), utf16, len16); break; case PyUnicode_4BYTE_KIND: { UErrorCode status = U_ZERO_ERROR; // note: len16 > len32 (len32 is at least half of len16) u_strToUTF32((UChar32 *) PyUnicode_4BYTE_DATA(result), len32, NULL, utf16, len16, &status); if (U_FAILURE(status)) { Py_DECREF(result); return ICUException(status).reportError(); } break; } default: Py_DECREF(result); return NULL; } return result; } #endif } EXPORT UnicodeString &PyBytes_AsUnicodeString(PyObject *object, const char *encoding, const char *mode, UnicodeString &string) { UErrorCode status = U_ZERO_ERROR; UConverter *conv = ucnv_open(encoding, &status); if (U_FAILURE(status)) throw ICUException(status); _STOPReason stop; char *src; Py_ssize_t len; UChar *buffer, *target; memset(&stop, 0, sizeof(stop)); if (!strcmp(mode, "strict")) { ucnv_setToUCallBack(conv, _stopDecode, &stop, NULL, NULL, &status); if (U_FAILURE(status)) { ucnv_close(conv); throw ICUException(status); } } PyBytes_AsStringAndSize(object, &src, &len); stop.src = src; stop.src_length = len; buffer = target = new UChar[len]; if (buffer == NULL) { ucnv_close(conv); PyErr_NoMemory(); throw ICUException(); } ucnv_toUnicode(conv, &target, target + len, (const char **) &src, src + len, NULL, true, &status); if (U_FAILURE(status)) { const char *reasonName; switch (stop.reason) { case UCNV_UNASSIGNED: reasonName = "the code point is unassigned"; break; case UCNV_ILLEGAL: reasonName = "the code point is illegal"; break; case UCNV_IRREGULAR: reasonName = "the code point is not a regular sequence in the encoding"; break; default: reasonName = "unexpected reason code"; break; } status = U_ZERO_ERROR; PyErr_Format(PyExc_ValueError, "'%s' codec can't decode byte 0x%x in position %d: reason code %d (%s)", ucnv_getName(conv, &status), (int) (unsigned char) stop.chars[0], stop.error_position, stop.reason, reasonName); delete[] buffer; ucnv_close(conv); throw ICUException(); } string.setTo(buffer, target - buffer); delete[] buffer; ucnv_close(conv); return string; } EXPORT UnicodeString &PyObject_AsUnicodeString(PyObject *object, const char *encoding, const char *mode, UnicodeString &string) { if (PyUnicode_Check(object)) { #if PY_VERSION_HEX < 0x03030000 if (sizeof(Py_UNICODE) == sizeof(UChar)) string.setTo((const UChar *) PyUnicode_AS_UNICODE(object), (int32_t) PyUnicode_GET_SIZE(object)); else { int32_t len = (int32_t) PyUnicode_GET_SIZE(object); Py_UNICODE *pchars = PyUnicode_AS_UNICODE(object); string = UnicodeString::fromUTF32((const UChar32 *) pchars, len); } #else PyUnicode_READY(object); switch (PyUnicode_KIND(object)) { case PyUnicode_WCHAR_KIND: { // this code path should be deprecated if (sizeof(Py_UNICODE) == sizeof(UChar)) { Py_ssize_t len; Py_UNICODE *pchars = PyUnicode_AsUnicodeAndSize(object, &len); string.setTo((const UChar *) pchars, len); } else { Py_ssize_t len; Py_UNICODE *pchars = PyUnicode_AsUnicodeAndSize(object, &len); string = UnicodeString::fromUTF32( (const UChar32 *) pchars, len); } break; } case PyUnicode_1BYTE_KIND: { Py_ssize_t len = PyUnicode_GET_LENGTH(object); Py_UCS1 *pchars = PyUnicode_1BYTE_DATA(object); UChar *chars = string.getBuffer(len); if (chars != NULL) { for (int i = 0; i < len; ++i) chars[i] = (UChar) pchars[i]; string.releaseBuffer(len); } break; } case PyUnicode_2BYTE_KIND: { Py_ssize_t len = PyUnicode_GET_LENGTH(object); Py_UCS2 *pchars = PyUnicode_2BYTE_DATA(object); string.setTo((const UChar *) pchars, len); break; } case PyUnicode_4BYTE_KIND: { Py_ssize_t len = PyUnicode_GET_LENGTH(object); Py_UCS4 *pchars = PyUnicode_4BYTE_DATA(object); string = UnicodeString::fromUTF32((const UChar32 *) pchars, len); break; } } #endif } else if (PyBytes_Check(object)) PyBytes_AsUnicodeString(object, encoding, mode, string); else { PyErr_SetObject(PyExc_TypeError, object); throw ICUException(); } return string; } EXPORT UnicodeString &PyObject_AsUnicodeString(PyObject *object, UnicodeString &string) { return PyObject_AsUnicodeString(object, "utf-8", "strict", string); } EXPORT UnicodeString *PyObject_AsUnicodeString(PyObject *object) { if (object == Py_None) return NULL; else { UnicodeString string; try { PyObject_AsUnicodeString(object, string); } catch (ICUException e) { throw e; } return new UnicodeString(string); } } #if PY_VERSION_HEX < 0x02040000 /* Replace some _CheckExact macros for Python < 2.4 since the actual * datetime types are private until then. This is ugly, but allows * support for datetime objects in Python 2.3. */ #include #undef PyDateTime_CheckExact #define PyDateTime_CheckExact(op) \ (!strcmp(Py_TYPE(op)->tp_name, "datetime.datetime")) #undef PyDelta_CheckExact #define PyDelta_CheckExact(op) \ (!strcmp(Py_TYPE(op)->tp_name, "datetime.timedelta")) #endif int isDate(PyObject *object) { if (PyFloat_CheckExact(object)) return 1; return PyDateTime_CheckExact(object); } int isDateExact(PyObject *object) { return PyDateTime_CheckExact(object); } EXPORT UDate PyObject_AsUDate(PyObject *object) { if (PyFloat_CheckExact(object)) return (UDate) (PyFloat_AsDouble(object) * 1000.0); else { if (PyDateTime_CheckExact(object)) { PyObject *tzinfo = PyObject_GetAttrString(object, "tzinfo"); PyObject *utcoffset, *ordinal; if (tzinfo == Py_None) { PyObject *m = PyImport_ImportModule("icu"); PyObject *cls = PyObject_GetAttrString(m, "ICUtzinfo"); tzinfo = PyObject_CallMethodObjArgs(cls, getDefault_NAME, NULL); Py_DECREF(cls); Py_DECREF(m); utcoffset = PyObject_CallMethodObjArgs(tzinfo, utcoffset_NAME, object, NULL); Py_DECREF(tzinfo); } else { utcoffset = PyObject_CallMethodObjArgs(object, utcoffset_NAME, NULL); Py_DECREF(tzinfo); } ordinal = PyObject_CallMethodObjArgs(object, toordinal_NAME, NULL); if (utcoffset != NULL && PyDelta_CheckExact(utcoffset) && ordinal != NULL && PyInt_CheckExact(ordinal)) { #if PY_MAJOR_VERSION >= 3 double ordinalValue = PyLong_AsDouble(ordinal); #else long ordinalValue = PyInt_AsLong(ordinal); #endif double timestamp = (ordinalValue - 719163) * 86400.0 + PyDateTime_DATE_GET_HOUR(object) * 3600.0 + PyDateTime_DATE_GET_MINUTE(object) * 60.0 + (double) PyDateTime_DATE_GET_SECOND(object) + PyDateTime_DATE_GET_MICROSECOND(object) / 1e6 - #ifndef PYPY_VERSION (((PyDateTime_Delta *) utcoffset)->days * 86400.0 + (double) ((PyDateTime_Delta *) utcoffset)->seconds); #else (PyDateTime_DELTA_GET_DAYS( (PyDateTime_Delta *) utcoffset) * 86400.0 + (double) PyDateTime_DELTA_GET_SECONDS( (PyDateTime_Delta *) utcoffset)); #endif Py_DECREF(utcoffset); Py_DECREF(ordinal); return (UDate) (timestamp * 1000.0); } Py_XDECREF(utcoffset); Py_XDECREF(ordinal); } } PyErr_SetObject(PyExc_TypeError, object); throw ICUException(); } int abstract_init(PyObject *self, PyObject *args, PyObject *kwds) { PyObject *err = Py_BuildValue("(sO)", "instantiating class", self->ob_type); PyErr_SetObject(PyExc_NotImplementedError, err); Py_DECREF(err); return -1; } static PyObject *types; void registerType(PyTypeObject *type, classid id) { #if U_ICU_VERSION_HEX < 0x04060000 PyObject *n = PyInt_FromLong((Py_intptr_t) id); #else PyObject *n = PyString_FromString(id); #endif PyObject *list = PyList_New(0); PyObject *bn; PyDict_SetItem(types, n, list); Py_DECREF(list); PyDict_SetItem(types, (PyObject *) type, n); while (type != &UObjectType_) { type = type->tp_base; bn = PyDict_GetItem(types, (PyObject *) type); list = PyDict_GetItem(types, bn); PyList_Append(list, n); } Py_DECREF(n); } int isInstance(PyObject *arg, classid id, PyTypeObject *type) { if (PyObject_TypeCheck(arg, &UObjectType_)) { #if U_ICU_VERSION_HEX < 0x04060000 classid oid = ((t_uobject *) arg)->object->getDynamicClassID(); if (id == oid) return 1; PyObject *bn = PyInt_FromLong((Py_intptr_t) id); PyObject *n = PyInt_FromLong((Py_intptr_t) oid); #else classid oid = typeid(*(((t_uobject *) arg)->object)).name(); if (!strcmp(id, oid)) return 1; PyObject *bn = PyString_FromString(id); PyObject *n = PyString_FromString(oid); #endif PyObject *list = PyDict_GetItem(types, bn); int b = PySequence_Contains(list, n); Py_DECREF(bn); Py_DECREF(n); return b ? b : PyObject_TypeCheck(arg, type); } return 0; } UObject **pl2cpa(PyObject *arg, int *len, classid id, PyTypeObject *type) { if (PySequence_Check(arg)) { *len = PySequence_Size(arg); UObject **array = (UObject **) calloc(*len, sizeof(UObject *)); for (int i = 0; i < *len; i++) { PyObject *obj = PySequence_GetItem(arg, i); if (isInstance(obj, id, type)) { array[i] = ((t_uobject *) obj)->object; Py_DECREF(obj); } else { Py_DECREF(obj); free(array); return NULL; } } return array; } return NULL; } PyObject *cpa2pl(UObject **array, int len, PyObject *(*wrap)(UObject *, int)) { PyObject *list = PyList_New(len); for (int i = 0; i < len; i++) PyList_SET_ITEM(list, i, wrap(array[i], T_OWNED)); return list; } Formattable *toFormattable(PyObject *arg) { UDate date; double d; int i; PY_LONG_LONG l; UnicodeString *u; UnicodeString _u; char *s; if (!parseArg(arg, "d", &d)) return new Formattable(d); if (!parseArg(arg, "i", &i)) return new Formattable(i); if (!parseArg(arg, "L", &l)) return new Formattable((int64_t) l); if (!parseArg(arg, "c", &s)) return new Formattable(s); if (!parseArg(arg, "S", &u, &_u)) return new Formattable(*u); if (!parseArg(arg, "E", &date)) return new Formattable(date, Formattable::kIsDate); return NULL; } Formattable *toFormattableArray(PyObject *arg, int *len, classid id, PyTypeObject *type) { if (PySequence_Check(arg)) { *len = PySequence_Size(arg); Formattable *array = new Formattable[*len + 1]; for (int i = 0; i < *len; i++) { PyObject *obj = PySequence_GetItem(arg, i); if (isInstance(obj, id, type)) { array[i] = *(Formattable *) ((t_uobject *) obj)->object; Py_DECREF(obj); } else { Formattable *f = toFormattable(obj); if (f) { array[i] = *f; delete f; Py_DECREF(obj); } else { Py_DECREF(obj); delete[] array; return NULL; } } } return array; } return NULL; } static UnicodeString *toUnicodeStringArray(PyObject *arg, int *len) { if (PySequence_Check(arg)) { *len = PySequence_Size(arg); UnicodeString *array = new UnicodeString[*len + 1]; for (int i = 0; i < *len; i++) { PyObject *obj = PySequence_GetItem(arg, i); if (PyObject_TypeCheck(obj, &UObjectType_)) { array[i] = *(UnicodeString *) ((t_uobject *) obj)->object; Py_DECREF(obj); } else { try { PyObject_AsUnicodeString(obj, array[i]); } catch (ICUException e) { Py_DECREF(obj); e.reportError(); delete[] array; return NULL; } } } return array; } return NULL; } static double *toDoubleArray(PyObject *arg, int *len) { if (PySequence_Check(arg)) { *len = PySequence_Size(arg); double *array = new double[*len + 1]; for (int i = 0; i < *len; i++) { PyObject *obj = PySequence_GetItem(arg, i); if (PyFloat_Check(obj)) { array[i] = PyFloat_AsDouble(obj); Py_DECREF(obj); } #if PY_MAJOR_VERSION < 3 else if (PyInt_Check(obj)) { array[i] = (double) PyInt_AsLong(obj); Py_DECREF(obj); } #endif else if (PyLong_Check(obj)) { array[i] = PyLong_AsDouble(obj); Py_DECREF(obj); } else { Py_DECREF(obj); delete[] array; return NULL; } } return array; } return NULL; } static UBool *toUBoolArray(PyObject *arg, int *len) { if (PySequence_Check(arg)) { *len = PySequence_Size(arg); UBool *array = new UBool[*len + 1]; for (int i = 0; i < *len; i++) { PyObject *obj = PySequence_GetItem(arg, i); array[i] = (UBool) PyObject_IsTrue(obj); Py_DECREF(obj); } return array; } return NULL; } #if defined(_MSC_VER) || defined(PYPY_VERSION) int __parseArgs(PyObject *args, const char *types, ...) { int count = PyObject_Size(args); va_list list; va_start(list, types); #ifdef PYPY_VERSION return _parseArgs(args, count, types, list); #else return _parseArgs(((PyTupleObject *)(args))->ob_item, count, types, list); #endif } int __parseArg(PyObject *arg, const char *types, ...) { va_list list; va_start(list, types); #ifdef PYPY_VERSION { struct arg_tuple { PyObject *tuple; arg_tuple(PyObject *arg) { tuple = PyTuple_Pack(1, arg); } ~arg_tuple() { Py_DECREF(tuple); } } tuple_arg(arg); return _parseArgs(tuple_arg.tuple, 1, types, list); } #else return _parseArgs(&arg, 1, types, list); #endif } #ifdef PYPY_VERSION int _parseArgs(PyObject *args, int count, const char *types, va_list list) #else int _parseArgs(PyObject **args, int count, const char *types, va_list list) #endif { if (count != strlen(types)) return -1; #else int _parseArgs(PyObject **args, int count, const char *types, ...) { va_list list; if (count != (int) strlen(types)) return -1; va_start(list, types); #endif if (PyErr_Occurred()) return -1; for (int i = 0; i < count; i++) { #ifdef PYPY_VERSION PyObject *arg = PyTuple_GetItem(args, i); #else PyObject *arg = args[i]; #endif switch (types[i]) { case 'c': /* string */ case 'k': /* string and size */ case 'C': /* string, not to be unpacked */ if (PyBytes_Check(arg)) break; return -1; case 's': /* string or unicode, to UnicodeString ref */ case 'u': /* string or unicode, to new UnicodeString ptr */ case 'n': /* string or unicode, to utf8 charsArg */ case 'f': /* string or unicode filename, to charsArg */ if (PyBytes_Check(arg) || PyUnicode_Check(arg)) break; return -1; case 'S': /* string, unicode or UnicodeString */ case 'W': /* string, unicode or UnicodeString, to save */ if (PyBytes_Check(arg) || PyUnicode_Check(arg) || isUnicodeString(arg)) break; return -1; case 'T': /* array of string, unicode or UnicodeString */ if (PySequence_Check(arg)) { if (PySequence_Length(arg) > 0) { PyObject *obj = PySequence_GetItem(arg, 0); int ok = (PyBytes_Check(obj) || PyUnicode_Check(obj) || isUnicodeString(obj)); Py_DECREF(obj); if (ok) break; } else break; } return -1; case 'U': /* UnicodeString */ case 'V': /* UnicodeString and raw arg object */ if (isUnicodeString(arg)) break; return -1; case 'K': /* python object of any type */ break; case 'M': /* python callable */ { if (PyCallable_Check(arg)) break; return -1; } case 'O': /* python object of given type */ { PyTypeObject *type = va_arg(list, PyTypeObject *); if (PyObject_TypeCheck(arg, type)) break; return -1; } case 'P': /* wrapped ICU object */ case 'p': /* wrapped ICU object, to save */ { classid id = va_arg(list, classid); PyTypeObject *type = va_arg(list, PyTypeObject *); if (isInstance(arg, id, type)) break; return -1; } case 'Q': /* array of wrapped ICU object pointers */ case 'R': /* array of wrapped ICU objects */ { classid id = va_arg(list, classid); PyTypeObject *type = va_arg(list, PyTypeObject *); if (PySequence_Check(arg)) { if (PySequence_Length(arg) > 0) { PyObject *obj = PySequence_GetItem(arg, 0); int ok = isInstance(obj, id, type); Py_DECREF(obj); if (ok) break; } else break; } return -1; } case 'D': /* date as UDate float or datetime */ if (isDate(arg)) break; return -1; case 'E': /* date as datetime */ if (isDateExact(arg)) break; return -1; case 'a': /* byte */ if (PyBytes_Check(arg) && (PyBytes_Size(arg) == 1)) break; return -1; case 'B': /* boolean, strict */ if (arg == Py_True || arg == Py_False) break; return -1; case 'b': /* boolean */ break; case 'i': /* int */ if (PyInt_Check(arg)) break; return -1; case 'd': /* double */ if (PyFloat_Check(arg) || PyInt_Check(arg) || PyLong_Check(arg)) break; return -1; case 'F': /* array of double */ if (PySequence_Check(arg)) { if (PySequence_Length(arg) > 0) { PyObject *obj = PySequence_GetItem(arg, 0); int ok = (PyFloat_Check(obj) || PyInt_Check(obj) || PyLong_Check(obj)); Py_DECREF(obj); if (ok) break; } else break; } return -1; case 'G': /* array of bool */ if (PySequence_Check(arg)) break; return -1; case 'L': /* PY_LONG_LONG */ if (PyLong_Check(arg) || PyInt_Check(arg)) break; return -1; default: return -1; } } for (int j = 0; j < count; j++) { #ifdef PYPY_VERSION PyObject *arg = PyTuple_GetItem(args, j); #else PyObject *arg = args[j]; #endif switch (types[j]) { case 'A': /* previous Python arg object */ { PyObject **obj = va_arg(list, PyObject **); #ifdef PYPY_VERSION *obj = PyTuple_GetItem(args, j - 1); #else *obj = args[j - 1]; #endif break; } case 'c': /* string */ { char **c = va_arg(list, char **); *c = PyBytes_AS_STRING(arg); break; } case 'k': /* string and size */ { char **c = va_arg(list, char **); int *l = va_arg(list, int *); *c = PyBytes_AS_STRING(arg); *l = PyBytes_GET_SIZE(arg); break; } case 'C': /* string, not to be unpacked */ { PyObject **obj = va_arg(list, PyObject **); *obj = arg; break; } case 's': /* string or unicode, to UnicodeString ref */ { UnicodeString *u = va_arg(list, UnicodeString *); try { PyObject_AsUnicodeString(arg, *u); } catch (ICUException e) { e.reportError(); return -1; } break; } case 'u': /* string or unicode, to new UnicodeString ptr */ { UnicodeString **u = va_arg(list, UnicodeString **); try { *u = PyObject_AsUnicodeString(arg); } catch (ICUException e) { e.reportError(); return -1; } break; } case 'n': /* string or unicode, to utf8 charsArg */ { charsArg *p = va_arg(list, charsArg *); if (PyUnicode_Check(arg)) { PyObject *bytes = PyUnicode_AsUTF8String(arg); if (bytes == NULL) return -1; p->own(bytes); } else { p->borrow(arg); } break; } case 'f': /* string or unicode filename, to charsArg */ { charsArg *p = va_arg(list, charsArg *); if (PyUnicode_Check(arg)) { #if PY_MAJOR_VERSION >= 3 PyObject *bytes = PyUnicode_EncodeFSDefault(arg); #else // TODO: Figure out fs encoding in a reasonable way PyObject *bytes = PyUnicode_AsUTF8String(arg); #endif if (bytes == NULL) return -1; p->own(bytes); } else { p->borrow(arg); } break; } case 'S': /* string, unicode or UnicodeString */ { UnicodeString **u = va_arg(list, UnicodeString **); UnicodeString *_u = va_arg(list, UnicodeString *); if (PyObject_TypeCheck(arg, &UObjectType_)) *u = (UnicodeString *) ((t_uobject *) arg)->object; else { try { PyObject_AsUnicodeString(arg, *_u); *u = _u; } catch (ICUException e) { e.reportError(); return -1; } } break; } case 'W': /* string, unicode or UnicodeString, to save */ { UnicodeString **u = va_arg(list, UnicodeString **); PyObject **obj = va_arg(list, PyObject **); if (PyObject_TypeCheck(arg, &UObjectType_)) { *u = (UnicodeString *) ((t_uobject *) arg)->object; Py_INCREF(arg); Py_XDECREF(*obj); *obj = arg; } else { try { *u = PyObject_AsUnicodeString(arg); Py_XDECREF(*obj); *obj = wrap_UnicodeString(*u, T_OWNED); } catch (ICUException e) { e.reportError(); return -1; } } break; } case 'T': /* array of string, unicode or UnicodeString */ { UnicodeString **array = va_arg(list, UnicodeString **); int *len = va_arg(list, int *); *array = toUnicodeStringArray(arg, len); if (!*array) return -1; break; } case 'U': /* UnicodeString */ { UnicodeString **u = va_arg(list, UnicodeString **); *u = (UnicodeString *) ((t_uobject *) arg)->object; break; } case 'V': /* UnicodeString and raw arg object */ { UnicodeString **u = va_arg(list, UnicodeString **); PyObject **obj = va_arg(list, PyObject **); *u = (UnicodeString *) ((t_uobject *) arg)->object; *obj = arg; break; } case 'K': /* python object of any type */ case 'M': /* python callable */ case 'O': /* python object of given type */ { PyObject **obj = va_arg(list, PyObject **); *obj = arg; break; } case 'P': /* wrapped ICU object */ { UObject **obj = va_arg(list, UObject **); *obj = ((t_uobject *) arg)->object; break; } case 'p': /* wrapped ICU object, to save */ { UObject **obj = va_arg(list, UObject **); PyObject **pyobj = va_arg(list, PyObject **); *obj = ((t_uobject *) arg)->object; Py_INCREF(arg); Py_XDECREF(*pyobj); *pyobj = arg; break; } case 'Q': /* array of wrapped ICU object pointers */ { UObject ***array = va_arg(list, UObject ***); int *len = va_arg(list, int *); classid id = va_arg(list, classid); PyTypeObject *type = va_arg(list, PyTypeObject *); *array = pl2cpa(arg, len, id, type); if (!*array) return -1; break; } case 'R': /* array of wrapped ICU objects */ { typedef UObject *(*convFn)(PyObject *, int *, classid, PyTypeObject *); UObject **array = va_arg(list, UObject **); int *len = va_arg(list, int *); classid id = va_arg(list, classid); PyTypeObject *type = va_arg(list, PyTypeObject *); convFn fn = va_arg(list, convFn); *array = fn(arg, len, id, type); if (!*array) return -1; break; } case 'D': /* date as UDate float or datetime */ case 'E': /* date as datetime */ { UDate *d = va_arg(list, UDate *); *d = PyObject_AsUDate(arg); break; } case 'a': /* byte */ { unsigned char *a = va_arg(list, unsigned char *); *a = (unsigned char) PyBytes_AS_STRING(arg)[0]; break; } case 'B': /* boolean, strict */ case 'b': /* boolean */ { int *b = va_arg(list, int *); *b = PyObject_IsTrue(arg); break; } case 'i': /* int */ { int *n = va_arg(list, int *); #if PY_MAJOR_VERSION >= 3 if ((*n = PyLong_AsLong(arg)) == -1 && PyErr_Occurred()) return -1; #else *n = PyInt_AsLong(arg); #endif break; } case 'd': /* double */ { double *d = va_arg(list, double *); if (PyFloat_Check(arg)) *d = PyFloat_AsDouble(arg); #if PY_MAJOR_VERSION < 3 else if (PyInt_Check(arg)) *d = (double) PyInt_AsLong(arg); #endif else *d = PyLong_AsDouble(arg); break; } case 'F': /* array of double */ { double **array = va_arg(list, double **); int *len = va_arg(list, int *); *array = toDoubleArray(arg, len); if (!*array) return -1; break; } case 'G': /* array of UBool */ { UBool **array = va_arg(list, UBool **); int *len = va_arg(list, int *); *array = toUBoolArray(arg, len); if (!*array) return -1; break; } case 'L': /* PY_LONG_LONG */ { PY_LONG_LONG *l = va_arg(list, PY_LONG_LONG *); *l = PyLong_AsLongLong(arg); break; } default: return -1; } } return 0; } PyObject *PyErr_SetArgsError(PyObject *self, const char *name, PyObject *args) { if (!PyErr_Occurred()) { PyObject *type = (PyObject *) self->ob_type; PyObject *err = Py_BuildValue("(OsO)", type, name, args); PyErr_SetObject(PyExc_InvalidArgsError, err); Py_DECREF(err); } return NULL; } PyObject *PyErr_SetArgsError(PyTypeObject *type, const char *name, PyObject *args) { if (!PyErr_Occurred()) { PyObject *err = Py_BuildValue("(OsO)", type, name, args); PyErr_SetObject(PyExc_InvalidArgsError, err); Py_DECREF(err); } return NULL; } int isUnicodeString(PyObject *arg) { return (PyObject_TypeCheck(arg, &UObjectType_) && ISINSTANCE(((t_uobject *) arg)->object, UnicodeString)); } int32_t toUChar32(UnicodeString& u, UChar32 *c, UErrorCode& status) { #if U_ICU_VERSION_HEX >= 0x04020000 return u.toUTF32(c, 1, status); #else int32_t len = u.length(); if (len >= 1) *c = u.char32At(0); return len; #endif } UnicodeString fromUChar32(UChar32 c) { #if U_ICU_VERSION_HEX >= 0x04020000 return UnicodeString::fromUTF32(&c, 1); #else return UnicodeString(c); #endif } void _init_common(PyObject *m) { types = PyDict_New(); PyModule_AddObject(m, "__types__", types); #if PY_VERSION_HEX > 0x02040000 PyDateTime_IMPORT; #endif utcoffset_NAME = PyString_FromString("utcoffset"); toordinal_NAME = PyString_FromString("toordinal"); getDefault_NAME = PyString_FromString("getDefault"); } PyICU-1.9.5/common.h0000644000076500000000000002616212745617005014341 0ustar vajdawheel00000000000000/* ==================================================================== * Copyright (c) 2005-2015 Open Source Applications Foundation. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. * ==================================================================== */ #ifndef _common_h #define _common_h #ifdef _MSC_VER #define EXPORT __declspec(dllexport) #else #define EXPORT #endif #include #if !defined(PYPY_VERSION) && defined(PYPY_VERSION_NUM) #define PYPY_VERSION #endif #if PY_VERSION_HEX < 0x02040000 #define Py_RETURN_NONE return Py_INCREF(Py_None), Py_None #define Py_RETURN_TRUE return Py_INCREF(Py_True), Py_True #define Py_RETURN_FALSE return Py_INCREF(Py_False), Py_False #endif #if PY_VERSION_HEX < 0x02050000 typedef int Py_ssize_t; typedef inquiry lenfunc; typedef intargfunc ssizeargfunc; typedef intobjargproc ssizeobjargproc; typedef intintargfunc ssizessizeargfunc; typedef intintobjargproc ssizessizeobjargproc; #endif /* Python 2 uses String and Unicode, Python 3 Bytes and Unicode. * In PyICU, we use Bytes for everything that should be 8 bit in both * environments, i.e. String in Python 2 and Bytes in Python 3. We use * String for everything that should be a String in Python 2 and a * Unicode in Python 3. The assumption is that the argument will * always be ASCII only, and that we want the result to be represented * as a simple string literal without b or u modifier no matter the * environment. The definitions below establish these three flavours. */ #if PY_MAJOR_VERSION >= 3 # define Py_TPFLAGS_CHECKTYPES 0 # define PyInt_FromLong PyLong_FromLong # define PyInt_CheckExact PyLong_CheckExact # define PyInt_Check PyLong_Check # define PyInt_AsLong PyLong_AsLong # define PyString_FromString PyUnicode_FromString # define PyString_FromStringAndSize PyUnicode_FromStringAndSize # define PyString_FromFormatV PyUnicode_FromFormatV # define PyString_FromFormat PyUnicode_FromFormat # define PyString_Format PyUnicode_Format #else # define PyBytes_FromStringAndSize PyString_FromStringAndSize # define PyBytes_Check PyString_Check # define PyBytes_Size PyString_Size # define PyBytes_AsStringAndSize PyString_AsStringAndSize # define PyBytes_AS_STRING PyString_AS_STRING # define PyBytes_GET_SIZE PyString_GET_SIZE # define _PyBytes_Resize _PyString_Resize # ifndef PyVarObject_HEAD_INIT # define PyVarObject_HEAD_INIT(type, size) PyObject_HEAD_INIT(type) size, # endif # ifndef Py_TYPE # define Py_TYPE(ob) (((PyObject*)(ob))->ob_type) # endif #endif #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #define VERSION_HEX(major, minor, patch) \ (((major) << 24) | ((minor) << 16) | ((patch) << 8)) #define U_ICU_VERSION_HEX ((U_ICU_VERSION_MAJOR_NUM << 24) + \ (U_ICU_VERSION_MINOR_NUM << 16) + \ (U_ICU_VERSION_PATCHLEVEL_NUM << 8)) #if U_ICU_VERSION_HEX >= 0x04000000 #include #include #include #include #include #endif #if U_ICU_VERSION_HEX >= 0x04020000 #include #include #include #endif #if U_ICU_VERSION_HEX >= 0x04040000 #include #include #endif #if U_ICU_VERSION_HEX >= 0x04060000 #include #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(50, 0, 0) #include #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(51, 0, 0) #include #include #include #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(53, 0, 0) #include #endif #if U_ICU_VERSION_HEX < 0x04060000 typedef UClassID classid; enum { UObject_ID, Replaceable_ID, MeasureUnit_ID, Measure_ID, StringEnumeration_ID, ForwardCharacterIterator_ID, CharacterIterator_ID, BreakIterator_ID, Format_ID, MeasureFormat_ID, DateFormat_ID, Calendar_ID, Collator_ID, UnicodeMatcher_ID, SearchIterator_ID, ListFormatter_ID, }; #else typedef const char *classid; #endif U_NAMESPACE_USE /* lifted from ustrenum.h */ U_NAMESPACE_BEGIN class U_COMMON_API UStringEnumeration : public StringEnumeration { public: UStringEnumeration(UEnumeration* uenum); virtual ~UStringEnumeration(); virtual int32_t count(UErrorCode& status) const; virtual const UnicodeString* snext(UErrorCode& status); virtual void reset(UErrorCode& status); virtual UClassID getDynamicClassID() const; private: UEnumeration *uenum; // owned }; U_NAMESPACE_END extern PyObject *PyExc_ICUError; extern PyObject *PyExc_InvalidArgsError; void _init_common(PyObject *m); class ICUException { private: PyObject *code; PyObject *msg; public: EXPORT ICUException(); EXPORT ICUException(const ICUException &e); EXPORT ICUException(UErrorCode status); EXPORT ICUException(UErrorCode status, char *format, ...); EXPORT ICUException(UParseError &pe, UErrorCode status); EXPORT ~ICUException(); EXPORT PyObject *reportError(); }; EXPORT PyObject *PyUnicode_FromUnicodeString(const UnicodeString *string); EXPORT PyObject *PyUnicode_FromUnicodeString(const UChar *chars, int size); EXPORT UnicodeString &PyBytes_AsUnicodeString(PyObject *object, const char *encoding, const char *mode, UnicodeString &string); EXPORT UnicodeString &PyObject_AsUnicodeString(PyObject *object, const char *encoding, const char *mode, UnicodeString &string); EXPORT UnicodeString &PyObject_AsUnicodeString(PyObject *object, UnicodeString &string); EXPORT UnicodeString *PyObject_AsUnicodeString(PyObject *object); EXPORT UDate PyObject_AsUDate(PyObject *object); int abstract_init(PyObject *self, PyObject *args, PyObject *kwds); // helper class, to allow argument parsing with proper cleanup class charsArg { private: const char *str; PyObject *obj; void clear() { Py_XDECREF(obj); } public: charsArg() : str(NULL), obj(NULL) {} ~charsArg() { clear(); } const char *c_str() const { return str; } size_t size() const { return strlen(str); } #if PY_VERSION_HEX >= 0x02070000 // Allow using this class wherever a const char * is statically expected operator const char *() const { return str; } #else // Old python APIs were extremely unclean about constness of char strings operator char *() const { return const_cast(str); } #endif // Point to an existing bytes object. We don't own the buffer. void borrow(PyObject *bytes) { clear(); obj = NULL; str = PyBytes_AS_STRING(bytes); } // Point to a newly created bytes object, which we own and will clean. void own(PyObject *bytes) { clear(); obj = bytes; str = PyBytes_AS_STRING(bytes); } }; #if defined(_MSC_VER) || defined(PYPY_VERSION) #define parseArgs __parseArgs #define parseArg __parseArg int __parseArgs(PyObject *args, const char *types, ...); int __parseArg(PyObject *arg, const char *types, ...); #ifdef PYPY_VERSION int _parseArgs(PyObject *args, int count, const char *types, va_list list); #else int _parseArgs(PyObject **args, int count, const char *types, va_list list); #endif #else #define parseArgs(args, types, rest...) \ _parseArgs(((PyTupleObject *)(args))->ob_item, \ PyObject_Size(args), types, ##rest) #define parseArg(arg, types, rest...) \ _parseArgs(&(arg), 1, types, ##rest) int _parseArgs(PyObject **args, int count, const char *types, ...); #endif int isUnicodeString(PyObject *arg); int32_t toUChar32(UnicodeString& u, UChar32 *c, UErrorCode& status); UnicodeString fromUChar32(UChar32 c); int isInstance(PyObject *arg, classid id, PyTypeObject *type); void registerType(PyTypeObject *type, classid id); Formattable *toFormattable(PyObject *arg); Formattable *toFormattableArray(PyObject *arg, int *len, classid id, PyTypeObject *type); UObject **pl2cpa(PyObject *arg, int *len, classid id, PyTypeObject *type); PyObject *cpa2pl(UObject **array, int len, PyObject *(*wrap)(UObject *, int)); PyObject *PyErr_SetArgsError(PyObject *self, const char *name, PyObject *args); PyObject *PyErr_SetArgsError(PyTypeObject *type, const char *name, PyObject *args); #endif /* _common_h */ PyICU-1.9.5/CREDITS0000644000076500000000000000153312513624527013713 0ustar vajdawheel00000000000000 PyICU is a Python extension wrapping IBM's ICU library and wouldn't be possible without the tireless efforts of the people and open source projects below. - the ICU developers, http://icu-project.org - the Open Source Applications Foundation, for hosting the project http://www.osafoundation.org - Andi Vajda, PyICU project founder and maintainer - Christoph Burgmer for the Transliterator Python subclass - Jan Gehring for Freebsd 7 build entries - Christian Kesselheim for Solaris build entries - Jimmy Yuen Ho Wong for TimeZone::getDSTSavings() - Bernd Zeimetz for replacing Makefile with setup.py - Martin von Gagern, Python 3 support, bug fixes - Fredrik Roubert for various bug fixes (see CHANGES) - Markus Scherer for various bug fixes (see CHANGES) - Martin Hosken for bug fixes (see CHANGES) - Thank you all ! PyICU-1.9.5/dateformat.cpp0000644000076500000000000023116612714677206015541 0ustar vajdawheel00000000000000/* ==================================================================== * Copyright (c) 2004-2015 Open Source Applications Foundation. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. * ==================================================================== */ #include "common.h" #include "structmember.h" #include "bases.h" #include "locale.h" #include "format.h" #include "calendar.h" #include "numberformat.h" #include "dateformat.h" #include "macros.h" DECLARE_CONSTANTS_TYPE(UDateTimePatternConflict); DECLARE_CONSTANTS_TYPE(UDateTimePatternField); #if U_ICU_VERSION_HEX >= 0x04040000 DECLARE_CONSTANTS_TYPE(UDateTimePatternMatchOptions); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(54, 0, 0) DECLARE_CONSTANTS_TYPE(UDateRelativeDateTimeFormatterStyle); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(51, 0, 0) DECLARE_CONSTANTS_TYPE(UDisplayContext); DECLARE_CONSTANTS_TYPE(UDisplayContextType); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(53, 0, 0) DECLARE_CONSTANTS_TYPE(UDateDirection); DECLARE_CONSTANTS_TYPE(UDateAbsoluteUnit); DECLARE_CONSTANTS_TYPE(UDateRelativeUnit); DECLARE_CONSTANTS_TYPE(UDateFormatBooleanAttribute); #endif /* DateFormatSymbols */ class t_dateformatsymbols : public _wrapper { public: DateFormatSymbols *object; }; static int t_dateformatsymbols_init(t_dateformatsymbols *self, PyObject *args, PyObject *kwds); static PyObject *t_dateformatsymbols_getEras(t_dateformatsymbols *self); static PyObject *t_dateformatsymbols_setEras(t_dateformatsymbols *self, PyObject *arg); static PyObject *t_dateformatsymbols_getMonths(t_dateformatsymbols *self, PyObject *args); static PyObject *t_dateformatsymbols_setMonths(t_dateformatsymbols *self, PyObject *arg); static PyObject *t_dateformatsymbols_getShortMonths(t_dateformatsymbols *self); static PyObject *t_dateformatsymbols_setShortMonths(t_dateformatsymbols *self, PyObject *arg); static PyObject *t_dateformatsymbols_getWeekdays(t_dateformatsymbols *self, PyObject *args); static PyObject *t_dateformatsymbols_setWeekdays(t_dateformatsymbols *self, PyObject *arg); static PyObject *t_dateformatsymbols_getShortWeekdays(t_dateformatsymbols *self); static PyObject *t_dateformatsymbols_setShortWeekdays(t_dateformatsymbols *self, PyObject *arg); static PyObject *t_dateformatsymbols_getAmPmStrings(t_dateformatsymbols *self); static PyObject *t_dateformatsymbols_setAmPmStrings(t_dateformatsymbols *self, PyObject *arg); static PyObject *t_dateformatsymbols_getLocalPatternChars(t_dateformatsymbols *self, PyObject *args); static PyObject *t_dateformatsymbols_setLocalPatternChars(t_dateformatsymbols *self, PyObject *arg); static PyObject *t_dateformatsymbols_getLocale(t_dateformatsymbols *self, PyObject *args); static PyMethodDef t_dateformatsymbols_methods[] = { DECLARE_METHOD(t_dateformatsymbols, getEras, METH_NOARGS), DECLARE_METHOD(t_dateformatsymbols, setEras, METH_O), DECLARE_METHOD(t_dateformatsymbols, getMonths, METH_VARARGS), DECLARE_METHOD(t_dateformatsymbols, setMonths, METH_O), DECLARE_METHOD(t_dateformatsymbols, getShortMonths, METH_NOARGS), DECLARE_METHOD(t_dateformatsymbols, setShortMonths, METH_O), DECLARE_METHOD(t_dateformatsymbols, getWeekdays, METH_VARARGS), DECLARE_METHOD(t_dateformatsymbols, setWeekdays, METH_O), DECLARE_METHOD(t_dateformatsymbols, getShortWeekdays, METH_NOARGS), DECLARE_METHOD(t_dateformatsymbols, setShortWeekdays, METH_O), DECLARE_METHOD(t_dateformatsymbols, getAmPmStrings, METH_NOARGS), DECLARE_METHOD(t_dateformatsymbols, setAmPmStrings, METH_O), DECLARE_METHOD(t_dateformatsymbols, getLocalPatternChars, METH_VARARGS), DECLARE_METHOD(t_dateformatsymbols, setLocalPatternChars, METH_O), DECLARE_METHOD(t_dateformatsymbols, getLocale, METH_VARARGS), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(DateFormatSymbols, t_dateformatsymbols, UObject, DateFormatSymbols, t_dateformatsymbols_init, NULL); /* DateFormat */ class t_dateformat : public _wrapper { public: DateFormat *object; }; static PyObject *t_dateformat_isLenient(t_dateformat *self); static PyObject *t_dateformat_setLenient(t_dateformat *self, PyObject *arg); static PyObject *t_dateformat_format(t_dateformat *self, PyObject *args); static PyObject *t_dateformat_parse(t_dateformat *self, PyObject *args); static PyObject *t_dateformat_getCalendar(t_dateformat *self); static PyObject *t_dateformat_setCalendar(t_dateformat *self, PyObject *arg); static PyObject *t_dateformat_getNumberFormat(t_dateformat *self); static PyObject *t_dateformat_setNumberFormat(t_dateformat *self, PyObject *arg); static PyObject *t_dateformat_getTimeZone(t_dateformat *self); static PyObject *t_dateformat_setTimeZone(t_dateformat *self, PyObject *arg); static PyObject *t_dateformat_createInstance(PyTypeObject *type); static PyObject *t_dateformat_createTimeInstance(PyTypeObject *type, PyObject *args); static PyObject *t_dateformat_createDateInstance(PyTypeObject *type, PyObject *args); static PyObject *t_dateformat_createDateTimeInstance(PyTypeObject *type, PyObject *args); static PyObject *t_dateformat_getAvailableLocales(PyTypeObject *type); #if U_ICU_VERSION_HEX >= VERSION_HEX(53, 0, 0) static PyObject *t_dateformat_setContext(t_dateformat *self, PyObject *arg); static PyObject *t_dateformat_getContext(t_dateformat *self, PyObject *arg); static PyObject *t_dateformat_setBooleanAttribute(t_dateformat *self, PyObject *args); static PyObject *t_dateformat_getBooleanAttribute(t_dateformat *self, PyObject *arg); #endif static PyMethodDef t_dateformat_methods[] = { DECLARE_METHOD(t_dateformat, isLenient, METH_NOARGS), DECLARE_METHOD(t_dateformat, setLenient, METH_O), DECLARE_METHOD(t_dateformat, format, METH_VARARGS), DECLARE_METHOD(t_dateformat, parse, METH_VARARGS), DECLARE_METHOD(t_dateformat, getCalendar, METH_NOARGS), DECLARE_METHOD(t_dateformat, setCalendar, METH_O), DECLARE_METHOD(t_dateformat, getNumberFormat, METH_NOARGS), DECLARE_METHOD(t_dateformat, setNumberFormat, METH_O), DECLARE_METHOD(t_dateformat, getTimeZone, METH_NOARGS), DECLARE_METHOD(t_dateformat, setTimeZone, METH_O), DECLARE_METHOD(t_dateformat, createInstance, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_dateformat, createTimeInstance, METH_VARARGS | METH_CLASS), DECLARE_METHOD(t_dateformat, createDateInstance, METH_VARARGS | METH_CLASS), DECLARE_METHOD(t_dateformat, createDateTimeInstance, METH_VARARGS | METH_CLASS), DECLARE_METHOD(t_dateformat, getAvailableLocales, METH_NOARGS | METH_CLASS), #if U_ICU_VERSION_HEX >= VERSION_HEX(53, 0, 0) DECLARE_METHOD(t_dateformat, setContext, METH_O), DECLARE_METHOD(t_dateformat, getContext, METH_O), DECLARE_METHOD(t_dateformat, setBooleanAttribute, METH_VARARGS), DECLARE_METHOD(t_dateformat, getBooleanAttribute, METH_O), #endif { NULL, NULL, 0, NULL } }; DECLARE_TYPE(DateFormat, t_dateformat, Format, DateFormat, abstract_init, NULL); /* SimpleDateFormat */ class t_simpledateformat : public _wrapper { public: SimpleDateFormat *object; }; static int t_simpledateformat_init(t_simpledateformat *self, PyObject *args, PyObject *kwds); static PyObject *t_simpledateformat_toPattern(t_simpledateformat *self, PyObject *args); static PyObject *t_simpledateformat_toLocalizedPattern(t_simpledateformat *self, PyObject *args); static PyObject *t_simpledateformat_applyPattern(t_simpledateformat *self, PyObject *arg); static PyObject *t_simpledateformat_applyLocalizedPattern(t_simpledateformat *self, PyObject *arg); static PyObject *t_simpledateformat_get2DigitYearStart(t_simpledateformat *self); static PyObject *t_simpledateformat_set2DigitYearStart(t_simpledateformat *self, PyObject *arg); static PyObject *t_simpledateformat_getDateFormatSymbols(t_simpledateformat *self); static PyObject *t_simpledateformat_setDateFormatSymbols(t_simpledateformat *self, PyObject *arg); static PyMethodDef t_simpledateformat_methods[] = { DECLARE_METHOD(t_simpledateformat, toPattern, METH_VARARGS), DECLARE_METHOD(t_simpledateformat, toLocalizedPattern, METH_VARARGS), DECLARE_METHOD(t_simpledateformat, applyPattern, METH_O), DECLARE_METHOD(t_simpledateformat, applyLocalizedPattern, METH_O), DECLARE_METHOD(t_simpledateformat, get2DigitYearStart, METH_NOARGS), DECLARE_METHOD(t_simpledateformat, set2DigitYearStart, METH_O), DECLARE_METHOD(t_simpledateformat, getDateFormatSymbols, METH_NOARGS), DECLARE_METHOD(t_simpledateformat, setDateFormatSymbols, METH_O), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(SimpleDateFormat, t_simpledateformat, DateFormat, SimpleDateFormat, t_simpledateformat_init, NULL); PyObject *wrap_DateFormat(DateFormat *format) { RETURN_WRAPPED_IF_ISINSTANCE(format, SimpleDateFormat); return wrap_DateFormat(format, T_OWNED); } /* DateTimePatternGenerator */ class t_datetimepatterngenerator : public _wrapper { public: DateTimePatternGenerator *object; }; static PyObject *t_datetimepatterngenerator_createEmptyInstance( PyTypeObject *type); static PyObject *t_datetimepatterngenerator_createInstance( PyTypeObject *type, PyObject *args); static PyObject *t_datetimepatterngenerator_getSkeleton( t_datetimepatterngenerator *self, PyObject *arg); static PyObject *t_datetimepatterngenerator_getBaseSkeleton( t_datetimepatterngenerator *self, PyObject *arg); static PyObject *t_datetimepatterngenerator_addPattern( t_datetimepatterngenerator *self, PyObject *args); static PyObject *t_datetimepatterngenerator_getBestPattern( t_datetimepatterngenerator *self, PyObject *args); static PyObject *t_datetimepatterngenerator_setAppendItemFormat( t_datetimepatterngenerator *self, PyObject *args); static PyObject *t_datetimepatterngenerator_setAppendItemName( t_datetimepatterngenerator *self, PyObject *args); static PyObject *t_datetimepatterngenerator_getAppendItemFormat( t_datetimepatterngenerator *self, PyObject *arg); static PyObject *t_datetimepatterngenerator_getAppendItemName( t_datetimepatterngenerator *self, PyObject *arg); static PyObject *t_datetimepatterngenerator_replaceFieldTypes( t_datetimepatterngenerator *self, PyObject *args); static PyObject *t_datetimepatterngenerator_getSkeletons( t_datetimepatterngenerator *self); static PyObject *t_datetimepatterngenerator_getBaseSkeletons( t_datetimepatterngenerator *self); static PyObject *t_datetimepatterngenerator_getRedundants( t_datetimepatterngenerator *self); static PyObject *t_datetimepatterngenerator_getPatternForSkeleton( t_datetimepatterngenerator *self, PyObject *arg); static PyObject *t_datetimepatterngenerator_setDecimal( t_datetimepatterngenerator *self, PyObject *arg); static PyObject *t_datetimepatterngenerator_getDecimal( t_datetimepatterngenerator *self); #if U_ICU_VERSION_HEX >= VERSION_HEX(56, 0, 0) static PyObject *t_datetimepatterngenerator_staticGetSkeleton( PyTypeObject *type, PyObject *arg); static PyObject *t_datetimepatterngenerator_staticGetBaseSkeleton( PyTypeObject *type, PyObject *arg); #endif static PyMethodDef t_datetimepatterngenerator_methods[] = { DECLARE_METHOD(t_datetimepatterngenerator, createEmptyInstance, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_datetimepatterngenerator, createInstance, METH_VARARGS | METH_CLASS), DECLARE_METHOD(t_datetimepatterngenerator, getSkeleton, METH_O), DECLARE_METHOD(t_datetimepatterngenerator, getBaseSkeleton, METH_O), DECLARE_METHOD(t_datetimepatterngenerator, addPattern, METH_VARARGS), DECLARE_METHOD(t_datetimepatterngenerator, getBestPattern, METH_VARARGS), DECLARE_METHOD(t_datetimepatterngenerator, setAppendItemFormat, METH_VARARGS), DECLARE_METHOD(t_datetimepatterngenerator, setAppendItemName, METH_VARARGS), DECLARE_METHOD(t_datetimepatterngenerator, getAppendItemFormat, METH_O), DECLARE_METHOD(t_datetimepatterngenerator, getAppendItemName, METH_O), DECLARE_METHOD(t_datetimepatterngenerator, replaceFieldTypes, METH_VARARGS), DECLARE_METHOD(t_datetimepatterngenerator, getSkeletons, METH_NOARGS), DECLARE_METHOD(t_datetimepatterngenerator, getBaseSkeletons, METH_NOARGS), DECLARE_METHOD(t_datetimepatterngenerator, getRedundants, METH_NOARGS), DECLARE_METHOD(t_datetimepatterngenerator, getPatternForSkeleton, METH_O), DECLARE_METHOD(t_datetimepatterngenerator, setDecimal, METH_O), DECLARE_METHOD(t_datetimepatterngenerator, getDecimal, METH_NOARGS), #if U_ICU_VERSION_HEX >= VERSION_HEX(56, 0, 0) DECLARE_METHOD(t_datetimepatterngenerator, staticGetSkeleton, METH_O | METH_CLASS), DECLARE_METHOD(t_datetimepatterngenerator, staticGetBaseSkeleton, METH_O | METH_CLASS), #endif { NULL, NULL, 0, NULL } }; DECLARE_TYPE(DateTimePatternGenerator, t_datetimepatterngenerator, UObject, DateTimePatternGenerator, abstract_init, NULL); #if U_ICU_VERSION_HEX >= 0x04000000 /* DateInterval */ class t_dateinterval : public _wrapper { public: DateInterval *object; }; static int t_dateinterval_init(t_dateinterval *self, PyObject *args, PyObject *kwds); static PyObject *t_dateinterval_getFromDate(t_dateinterval *self); static PyObject *t_dateinterval_getToDate(t_dateinterval *self); static PyMethodDef t_dateinterval_methods[] = { DECLARE_METHOD(t_dateinterval, getFromDate, METH_NOARGS), DECLARE_METHOD(t_dateinterval, getToDate, METH_NOARGS), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(DateInterval, t_dateinterval, UObject, DateInterval, t_dateinterval_init, NULL); /* DateIntervalInfo */ class t_dateintervalinfo : public _wrapper { public: DateIntervalInfo *object; }; static int t_dateintervalinfo_init(t_dateintervalinfo *self, PyObject *args, PyObject *kwds); static PyObject *t_dateintervalinfo_getDefaultOrder(t_dateintervalinfo *self); static PyObject *t_dateintervalinfo_setIntervalPattern(t_dateintervalinfo *self, PyObject *args); static PyObject *t_dateintervalinfo_getIntervalPattern(t_dateintervalinfo *self, PyObject *args); static PyObject *t_dateintervalinfo_setFallbackIntervalPattern(t_dateintervalinfo *self, PyObject *arg); static PyObject *t_dateintervalinfo_getFallbackIntervalPattern(t_dateintervalinfo *self, PyObject *args); static PyMethodDef t_dateintervalinfo_methods[] = { DECLARE_METHOD(t_dateintervalinfo, getDefaultOrder, METH_NOARGS), DECLARE_METHOD(t_dateintervalinfo, setIntervalPattern, METH_VARARGS), DECLARE_METHOD(t_dateintervalinfo, getIntervalPattern, METH_VARARGS), DECLARE_METHOD(t_dateintervalinfo, setFallbackIntervalPattern, METH_O), DECLARE_METHOD(t_dateintervalinfo, getFallbackIntervalPattern, METH_VARARGS), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(DateIntervalInfo, t_dateintervalinfo, UObject, DateIntervalInfo, t_dateintervalinfo_init, NULL); /* DateIntervalFormat */ static DateIntervalFormat *DateInterval_format; class t_dateintervalformat : public _wrapper { public: DateIntervalFormat *object; }; static PyObject *t_dateintervalformat_format(t_dateintervalformat *self, PyObject *args); static PyObject *t_dateintervalformat_getDateIntervalInfo(t_dateintervalformat *self); static PyObject *t_dateintervalformat_setDateIntervalInfo(t_dateintervalformat *self, PyObject *arg); static PyObject *t_dateintervalformat_getDateFormat(t_dateintervalformat *self); static PyObject *t_dateintervalformat_parseObject(t_dateintervalformat *self, PyObject *args); static PyObject *t_dateintervalformat_createInstance(PyTypeObject *type, PyObject *args); static PyMethodDef t_dateintervalformat_methods[] = { DECLARE_METHOD(t_dateintervalformat, format, METH_VARARGS), DECLARE_METHOD(t_dateintervalformat, getDateIntervalInfo, METH_NOARGS), DECLARE_METHOD(t_dateintervalformat, setDateIntervalInfo, METH_O), DECLARE_METHOD(t_dateintervalformat, getDateFormat, METH_NOARGS), DECLARE_METHOD(t_dateintervalformat, parseObject, METH_VARARGS), DECLARE_METHOD(t_dateintervalformat, createInstance, METH_VARARGS | METH_CLASS), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(DateIntervalFormat, t_dateintervalformat, Format, DateIntervalFormat, abstract_init, NULL); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(53, 0, 0) /* RelativeDateTimeFormatter */ class t_relativedatetimeformatter : public _wrapper { public: RelativeDateTimeFormatter *object; }; static int t_relativedatetimeformatter_init(t_relativedatetimeformatter *self, PyObject *args, PyObject *kwds); static PyObject *t_relativedatetimeformatter_format( t_relativedatetimeformatter *self, PyObject *args); static PyObject *t_relativedatetimeformatter_combineDateAndTime( t_relativedatetimeformatter *self, PyObject *args); static PyObject *t_relativedatetimeformatter_getNumberFormat( t_relativedatetimeformatter *self); static PyObject *t_relativedatetimeformatter_getCapitalizationContext( t_relativedatetimeformatter *self); static PyObject *t_relativedatetimeformatter_getFormatStyle( t_relativedatetimeformatter *self); static PyMethodDef t_relativedatetimeformatter_methods[] = { DECLARE_METHOD(t_relativedatetimeformatter, format, METH_VARARGS), DECLARE_METHOD(t_relativedatetimeformatter, combineDateAndTime, METH_VARARGS), DECLARE_METHOD(t_relativedatetimeformatter, getNumberFormat, METH_NOARGS), DECLARE_METHOD(t_relativedatetimeformatter, getCapitalizationContext, METH_NOARGS), DECLARE_METHOD(t_relativedatetimeformatter, getFormatStyle, METH_NOARGS), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(RelativeDateTimeFormatter, t_relativedatetimeformatter, UObject, RelativeDateTimeFormatter, t_relativedatetimeformatter_init, NULL); #endif /* DateFormatSymbols */ static int t_dateformatsymbols_init(t_dateformatsymbols *self, PyObject *args, PyObject *kwds) { UnicodeString _u; Locale *locale; DateFormatSymbols *dfs; charsArg type; switch (PyTuple_Size(args)) { case 0: INT_STATUS_CALL(dfs = new DateFormatSymbols(status)); self->object = dfs; self->flags = T_OWNED; break; case 1: if (!parseArgs(args, "P", TYPE_CLASSID(Locale), &locale)) { INT_STATUS_CALL(dfs = new DateFormatSymbols(*locale, status)); self->object = dfs; self->flags = T_OWNED; break; } if (!parseArgs(args, "n", &type)) { INT_STATUS_CALL(dfs = new DateFormatSymbols(type, status)); self->object = dfs; self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; case 2: if (!parseArgs(args, "Pn", TYPE_CLASSID(Locale), &locale, &type)) { INT_STATUS_CALL(dfs = new DateFormatSymbols(*locale, type, status)); self->object = dfs; self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; default: PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; } if (self->object) return 0; return -1; } static PyObject *fromUnicodeStringArray(const UnicodeString *strings, int len, int dispose) { PyObject *list = PyList_New(len); for (int i = 0; i < len; i++) { UnicodeString *u = (UnicodeString *) (strings + i); PyList_SET_ITEM(list, i, PyUnicode_FromUnicodeString(u)); } if (dispose) delete strings; return list; } static PyObject *t_dateformatsymbols_getEras(t_dateformatsymbols *self) { int len; const UnicodeString *eras = self->object->getEras(len); return fromUnicodeStringArray(eras, len, 0); } static PyObject *t_dateformatsymbols_setEras(t_dateformatsymbols *self, PyObject *arg) { UnicodeString *eras; int len; if (!parseArg(arg, "T", &eras, &len)) { self->object->setEras(eras, len); /* copied */ delete[] eras; /* dtfmtsym.cpp code duplicates it */ Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setEras", arg); } static PyObject *t_dateformatsymbols_getMonths(t_dateformatsymbols *self, PyObject *args) { int len; const UnicodeString *months; DateFormatSymbols::DtContextType context; DateFormatSymbols::DtWidthType width; switch (PyTuple_Size(args)) { case 0: months = self->object->getMonths(len); return fromUnicodeStringArray(months, len, 0); case 2: if (!parseArgs(args, "ii", &context, &width)) { months = self->object->getMonths(len, context, width); return fromUnicodeStringArray(months, len, 0); } break; } return PyErr_SetArgsError((PyObject *) self, "getMonths", args); } static PyObject *t_dateformatsymbols_setMonths(t_dateformatsymbols *self, PyObject *arg) { UnicodeString *months; int len; if (!parseArg(arg, "T", &months, &len)) { self->object->setMonths(months, len); /* copied */ delete[] months; /* dtfmtsym.cpp code duplicates it */ Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setMonths", arg); } static PyObject *t_dateformatsymbols_getShortMonths(t_dateformatsymbols *self) { int len; const UnicodeString *months = self->object->getShortMonths(len); return fromUnicodeStringArray(months, len, 0); } static PyObject *t_dateformatsymbols_setShortMonths(t_dateformatsymbols *self, PyObject *arg) { UnicodeString *months; int len; if (!parseArg(arg, "T", &months, &len)) { self->object->setShortMonths(months, len); /* copied */ delete[] months; /* dtfmtsym.cpp code duplicates it */ Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setShortMonths", arg); } static PyObject *t_dateformatsymbols_getWeekdays(t_dateformatsymbols *self, PyObject *args) { int len; const UnicodeString *weekdays; DateFormatSymbols::DtContextType context; DateFormatSymbols::DtWidthType width; switch (PyTuple_Size(args)) { case 0: weekdays = self->object->getWeekdays(len); return fromUnicodeStringArray(weekdays, len, 0); case 2: if (!parseArgs(args, "ii", &context, &width)) { weekdays = self->object->getWeekdays(len, context, width); return fromUnicodeStringArray(weekdays, len, 0); } break; } return PyErr_SetArgsError((PyObject *) self, "getWeekdays", args); } static PyObject *t_dateformatsymbols_setWeekdays(t_dateformatsymbols *self, PyObject *arg) { UnicodeString *weekdays; int len; if (!parseArg(arg, "T", &weekdays, &len)) { self->object->setWeekdays(weekdays, len); /* copied */ delete[] weekdays; /* dtfmtsym.cpp code duplicates it */ Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setWeekdays", arg); } static PyObject *t_dateformatsymbols_getShortWeekdays(t_dateformatsymbols *self) { int len; const UnicodeString *months = self->object->getShortWeekdays(len); return fromUnicodeStringArray(months, len, 0); } static PyObject *t_dateformatsymbols_setShortWeekdays(t_dateformatsymbols *self, PyObject *arg) { UnicodeString *weekdays; int len; if (!parseArg(arg, "T", &weekdays, &len)) { self->object->setShortWeekdays(weekdays, len); /* copied */ delete[] weekdays; /* dtfmtsym.cpp code duplicates it */ Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setShortWeekdays", arg); } static PyObject *t_dateformatsymbols_getAmPmStrings(t_dateformatsymbols *self) { int len; const UnicodeString *strings = self->object->getAmPmStrings(len); return fromUnicodeStringArray(strings, len, 0); } static PyObject *t_dateformatsymbols_setAmPmStrings(t_dateformatsymbols *self, PyObject *arg) { UnicodeString *strings; int len; if (!parseArg(arg, "T", &strings, &len)) { self->object->setAmPmStrings(strings, len); /* copied */ delete[] strings; /* dtfmtsym.cpp code duplicates it */ Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setAmPmStrings", arg); } DEFINE_RICHCMP(DateFormatSymbols, t_dateformatsymbols); static PyObject *t_dateformatsymbols_getLocalPatternChars(t_dateformatsymbols *self, PyObject *args) { UnicodeString *u; UnicodeString _u; switch (PyTuple_Size(args)) { case 0: self->object->getLocalPatternChars(_u); return PyUnicode_FromUnicodeString(&_u); case 1: if (!parseArgs(args, "U", &u)) { self->object->getLocalPatternChars(*u); Py_RETURN_ARG(args, 0); } break; } return PyErr_SetArgsError((PyObject *) self, "getLocalPatternChars", args); } static PyObject *t_dateformatsymbols_setLocalPatternChars(t_dateformatsymbols *self, PyObject *arg) { UnicodeString *u, _u; if (!parseArg(arg, "S", &u, &_u)) { self->object->setLocalPatternChars(*u); /* copied */ Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setLocalPatternChars", arg); } static PyObject *t_dateformatsymbols_getLocale(t_dateformatsymbols *self, PyObject *args) { ULocDataLocaleType type; Locale locale; switch (PyTuple_Size(args)) { case 0: STATUS_CALL(locale = self->object->getLocale(ULOC_VALID_LOCALE, status)); return wrap_Locale(locale); case 1: if (!parseArgs(args, "i", &type)) { STATUS_CALL(locale = self->object->getLocale(type, status)); return wrap_Locale(locale); } break; } return PyErr_SetArgsError((PyObject *) self, "getLocale", args); } /* DateFormat */ static PyObject *t_dateformat_isLenient(t_dateformat *self) { int b = self->object->isLenient(); Py_RETURN_BOOL(b); } static PyObject *t_dateformat_setLenient(t_dateformat *self, PyObject *arg) { int b; if (!parseArg(arg, "b", &b)) { self->object->setLenient(b); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setLenient", arg); } static PyObject *t_dateformat_format(t_dateformat *self, PyObject *args) { UDate date; Calendar *calendar; UnicodeString *u; UnicodeString _u; FieldPosition *fp; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "D", &date)) { self->object->format(date, _u); return PyUnicode_FromUnicodeString(&_u); } if (!parseArgs(args, "P", TYPE_ID(Calendar), &calendar)) { FieldPosition fp0(0); self->object->format(*calendar, _u, fp0); return PyUnicode_FromUnicodeString(&_u); } break; case 2: if (!parseArgs(args, "DP", TYPE_CLASSID(FieldPosition), &date, &fp)) { self->object->format(date, _u, *fp); return PyUnicode_FromUnicodeString(&_u); } if (!parseArgs(args, "PP", TYPE_ID(Calendar), TYPE_CLASSID(FieldPosition), &calendar, &fp)) { self->object->format(*calendar, _u, *fp); return PyUnicode_FromUnicodeString(&_u); } if (!parseArgs(args, "DU", &date, &u)) { self->object->format(date, *u); Py_RETURN_ARG(args, 1); } break; case 3: if (!parseArgs(args, "DUP", TYPE_CLASSID(FieldPosition), &date, &u, &fp)) { self->object->format(date, *u, *fp); Py_RETURN_ARG(args, 1); } if (!parseArgs(args, "PUP", TYPE_ID(Calendar), TYPE_CLASSID(FieldPosition), &calendar, &u, &fp)) { self->object->format(*calendar, *u, *fp); Py_RETURN_ARG(args, 1); } break; } return t_format_format((t_format *) self, args); } static PyObject *t_dateformat_parse(t_dateformat *self, PyObject *args) { UnicodeString *u; UnicodeString _u; Calendar *calendar; ParsePosition *pp; UDate date; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "S", &u, &_u)) { STATUS_CALL(date = self->object->parse(*u, status)); return PyFloat_FromDouble(date / 1000.0); } break; case 2: if (!parseArgs(args, "SP", TYPE_CLASSID(ParsePosition), &u, &_u, &pp)) { pp->setErrorIndex(-1); STATUS_CALL(date = self->object->parse(*u, *pp)); if (pp->getErrorIndex() == -1) Py_RETURN_NONE; return PyFloat_FromDouble(date / 1000.0); } break; case 3: if (!parseArgs(args, "SPP", TYPE_ID(Calendar), TYPE_CLASSID(ParsePosition), &u, &_u, &calendar, &pp)) { pp->setErrorIndex(-1); STATUS_CALL(self->object->parse(*u, *calendar, *pp)); Py_RETURN_NONE; } break; } return PyErr_SetArgsError((PyObject *) self, "parse", args); } static PyObject *t_dateformat_getCalendar(t_dateformat *self) { return wrap_Calendar(self->object->getCalendar()->clone(), T_OWNED); } static PyObject *t_dateformat_setCalendar(t_dateformat *self, PyObject *arg) { Calendar *calendar; if (!parseArg(arg, "P", TYPE_ID(Calendar), &calendar)) { self->object->setCalendar(*calendar); /* copied */ Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setCalendar", arg); } static PyObject *t_dateformat_getNumberFormat(t_dateformat *self) { return wrap_NumberFormat((NumberFormat *) self->object->getNumberFormat()->clone(), T_OWNED); } static PyObject *t_dateformat_setNumberFormat(t_dateformat *self, PyObject *arg) { NumberFormat *format; if (!parseArg(arg, "P", TYPE_CLASSID(NumberFormat), &format)) { self->object->setNumberFormat(*format); /* copied */ Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setNumberFormat", arg); } static PyObject *t_dateformat_getTimeZone(t_dateformat *self) { return wrap_TimeZone(self->object->getTimeZone()); } static PyObject *t_dateformat_setTimeZone(t_dateformat *self, PyObject *arg) { TimeZone *tz; if (!parseArg(arg, "P", TYPE_CLASSID(TimeZone), &tz)) { self->object->setTimeZone(*tz); /* copied */ Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setTimeZone", arg); } static PyObject *t_dateformat_createInstance(PyTypeObject *type) { return wrap_DateFormat(DateFormat::createInstance()); } static PyObject *t_dateformat_createTimeInstance(PyTypeObject *type, PyObject *args) { DateFormat::EStyle style; Locale *locale; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "i", &style)) return wrap_DateFormat(DateFormat::createTimeInstance(style)); break; case 2: if (!parseArgs(args, "iP", TYPE_CLASSID(Locale), &style, &locale)) return wrap_DateFormat(DateFormat::createTimeInstance(style, *locale)); break; } return PyErr_SetArgsError(type, "createTimeInstance", args); } static PyObject *t_dateformat_createDateInstance(PyTypeObject *type, PyObject *args) { DateFormat::EStyle style; Locale *locale; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "i", &style)) return wrap_DateFormat(DateFormat::createDateInstance(style)); break; case 2: if (!parseArgs(args, "iP", TYPE_CLASSID(Locale), &style, &locale)) return wrap_DateFormat(DateFormat::createDateInstance(style, *locale)); break; } return PyErr_SetArgsError(type, "createDateInstance", args); } static PyObject *t_dateformat_createDateTimeInstance(PyTypeObject *type, PyObject *args) { DateFormat::EStyle dateStyle, timeStyle; Locale *locale; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "i", &dateStyle)) return wrap_DateFormat(DateFormat::createDateTimeInstance(dateStyle)); break; case 2: if (!parseArgs(args, "ii", &dateStyle, &timeStyle)) return wrap_DateFormat(DateFormat::createDateTimeInstance(dateStyle, timeStyle)); break; case 3: if (!parseArgs(args, "iiP", TYPE_CLASSID(Locale), &dateStyle, &timeStyle, &locale)) return wrap_DateFormat(DateFormat::createDateTimeInstance(dateStyle, timeStyle, *locale)); break; } return PyErr_SetArgsError(type, "createDateTimeInstance", args); } static PyObject *t_dateformat_getAvailableLocales(PyTypeObject *type) { int count; const Locale *locales = DateFormat::getAvailableLocales(count); PyObject *dict = PyDict_New(); for (int32_t i = 0; i < count; i++) { Locale *locale = (Locale *) locales + i; PyObject *obj = wrap_Locale(locale, 0); PyDict_SetItemString(dict, locale->getName(), obj); Py_DECREF(obj); } return dict; } #if U_ICU_VERSION_HEX >= VERSION_HEX(53, 0, 0) static PyObject *t_dateformat_setContext(t_dateformat *self, PyObject *arg) { int context; if (!parseArg(arg, "i", &context)) { STATUS_CALL(self->object->setContext( (UDisplayContext) context, status)); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setContext", arg); } static PyObject *t_dateformat_getContext(t_dateformat *self, PyObject *arg) { int context, type; if (!parseArg(arg, "i", &type)) { STATUS_CALL(context = self->object->getContext( (UDisplayContextType) type, status)); return PyInt_FromLong(context); } return PyErr_SetArgsError((PyObject *) self, "getContext", arg); } static PyObject *t_dateformat_setBooleanAttribute(t_dateformat *self, PyObject *args) { int attribute, value; if (!parseArgs(args, "ii", &attribute, &value)) { STATUS_CALL(self->object->setBooleanAttribute( (UDateFormatBooleanAttribute) attribute, (UBool) value, status)); Py_RETURN_SELF(); } return PyErr_SetArgsError((PyObject *) self, "setBooleanAttribute", args); } static PyObject *t_dateformat_getBooleanAttribute(t_dateformat *self, PyObject *arg) { int attribute; if (!parseArg(arg, "i", &attribute)) { UBool result; STATUS_CALL(result = self->object->getBooleanAttribute( (UDateFormatBooleanAttribute) attribute, status)); Py_RETURN_BOOL(result); } return PyErr_SetArgsError((PyObject *) self, "getBooleanAttribute", arg); } #endif /* SimpleDateFormat */ static int t_simpledateformat_init(t_simpledateformat *self, PyObject *args, PyObject *kwds) { UnicodeString *u; UnicodeString _u; Locale *locale; DateFormatSymbols *dfs; SimpleDateFormat *format; switch (PyTuple_Size(args)) { case 0: INT_STATUS_CALL(format = new SimpleDateFormat(status)); self->object = format; self->flags = T_OWNED; break; case 1: if (!parseArgs(args, "S", &u, &_u)) { INT_STATUS_CALL(format = new SimpleDateFormat(*u, status)); self->object = format; self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; case 2: if (!parseArgs(args, "SP", TYPE_CLASSID(Locale), &u, &_u, &locale)) { INT_STATUS_CALL(format = new SimpleDateFormat(*u, *locale, status)); self->object = format; self->flags = T_OWNED; break; } if (!parseArgs(args, "SP", TYPE_CLASSID(DateFormatSymbols), &u, &_u, &dfs)) { INT_STATUS_CALL(format = new SimpleDateFormat(*u, *dfs, status)); self->object = format; self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; default: PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; } if (self->object) return 0; return -1; } static PyObject *t_simpledateformat_toPattern(t_simpledateformat *self, PyObject *args) { UnicodeString *u; UnicodeString _u; switch (PyTuple_Size(args)) { case 0: self->object->toPattern(_u); return PyUnicode_FromUnicodeString(&_u); case 1: if (!parseArgs(args, "U", &u)) { self->object->toPattern(*u); Py_RETURN_ARG(args, 0); } break; } return PyErr_SetArgsError((PyObject *) self, "toPattern", args); } static PyObject *t_simpledateformat_toLocalizedPattern(t_simpledateformat *self, PyObject *args) { UnicodeString *u; UnicodeString _u; switch (PyTuple_Size(args)) { case 0: STATUS_CALL(self->object->toLocalizedPattern(_u, status)); return PyUnicode_FromUnicodeString(&_u); case 1: if (!parseArgs(args, "U", &u)) { STATUS_CALL(self->object->toLocalizedPattern(*u, status)); Py_RETURN_ARG(args, 0); } break; } return PyErr_SetArgsError((PyObject *) self, "toLocalizedPattern", args); } static PyObject *t_simpledateformat_applyPattern(t_simpledateformat *self, PyObject *arg) { UnicodeString *u; UnicodeString _u; if (!parseArg(arg, "S", &u, &_u)) { self->object->applyPattern(*u); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "applyPattern", arg); } static PyObject *t_simpledateformat_applyLocalizedPattern(t_simpledateformat *self, PyObject *arg) { UnicodeString *u; UnicodeString _u; if (!parseArg(arg, "S", &u, &_u)) { STATUS_CALL(self->object->applyLocalizedPattern(*u, status)); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "applyLocalizedPattern", arg); } static PyObject *t_simpledateformat_get2DigitYearStart(t_simpledateformat *self) { UDate date; STATUS_CALL(date = self->object->get2DigitYearStart(status)); return PyFloat_FromDouble(date / 1000.0); } static PyObject *t_simpledateformat_set2DigitYearStart(t_simpledateformat *self, PyObject *arg) { UDate date; if (!parseArg(arg, "D", &date)) { STATUS_CALL(self->object->set2DigitYearStart(date, status)); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "set2DigitYearStart", arg); } static PyObject *t_simpledateformat_getDateFormatSymbols(t_simpledateformat *self) { return wrap_DateFormatSymbols(new DateFormatSymbols(*self->object->getDateFormatSymbols()), T_OWNED); } static PyObject *t_simpledateformat_setDateFormatSymbols(t_simpledateformat *self, PyObject *arg) { DateFormatSymbols *dfs; if (!parseArg(arg, "P", TYPE_CLASSID(DateFormatSymbols), &dfs)) { self->object->setDateFormatSymbols(*dfs); /* copied */ Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setDateFormatSymbols", arg); } static PyObject *t_simpledateformat_str(t_simpledateformat *self) { UnicodeString u; self->object->toPattern(u); return PyUnicode_FromUnicodeString(&u); } /* DateTimePatternGenerator */ static PyObject *t_datetimepatterngenerator_createEmptyInstance( PyTypeObject *type) { DateTimePatternGenerator *dtpg; STATUS_CALL(dtpg = DateTimePatternGenerator::createEmptyInstance(status)); return wrap_DateTimePatternGenerator(dtpg, T_OWNED); } static PyObject *t_datetimepatterngenerator_createInstance(PyTypeObject *type, PyObject *args) { DateTimePatternGenerator *dtpg; Locale *locale; switch (PyTuple_Size(args)) { case 0: STATUS_CALL(dtpg = DateTimePatternGenerator::createInstance(status)); break; case 1: if (!parseArgs(args, "P", TYPE_CLASSID(Locale), &locale)) { STATUS_CALL(dtpg = DateTimePatternGenerator::createInstance( *locale, status)); break; } return PyErr_SetArgsError(type, "createInstance", args); default: return PyErr_SetArgsError(type, "createInstance", args); } return wrap_DateTimePatternGenerator(dtpg, T_OWNED); } #if U_ICU_VERSION_HEX >= VERSION_HEX(56, 0, 0) static PyObject *t_datetimepatterngenerator_staticGetSkeleton( PyTypeObject *type, PyObject *arg) { UnicodeString *u, _u; if (!parseArg(arg, "S", &u, &_u)) { UnicodeString result; STATUS_CALL(result = DateTimePatternGenerator::staticGetSkeleton( *u, status)); return PyUnicode_FromUnicodeString(&result); } return PyErr_SetArgsError(type, "staticGetSkeleton", arg); } static PyObject *t_datetimepatterngenerator_staticGetBaseSkeleton( PyTypeObject *type, PyObject *arg) { UnicodeString *u, _u; if (!parseArg(arg, "S", &u, &_u)) { UnicodeString result; STATUS_CALL(result = DateTimePatternGenerator::staticGetBaseSkeleton( *u, status)); return PyUnicode_FromUnicodeString(&result); } return PyErr_SetArgsError(type, "staticGetBaseSkeleton", arg); } #endif static PyObject *t_datetimepatterngenerator_getSkeleton( t_datetimepatterngenerator *self, PyObject *arg) { UnicodeString *u, _u; if (!parseArg(arg, "S", &u, &_u)) { UnicodeString result; STATUS_CALL(result = self->object->getSkeleton(*u, status)); return PyUnicode_FromUnicodeString(&result); } return PyErr_SetArgsError((PyObject *) self, "getSkeleton", arg); } static PyObject *t_datetimepatterngenerator_getBaseSkeleton( t_datetimepatterngenerator *self, PyObject *arg) { UnicodeString *u, _u; if (!parseArg(arg, "S", &u, &_u)) { UnicodeString result; STATUS_CALL(result = self->object->getBaseSkeleton(*u, status)); return PyUnicode_FromUnicodeString(&result); } return PyErr_SetArgsError((PyObject *) self, "staticGetBaseSkeleton", arg); } static PyObject *t_datetimepatterngenerator_addPattern( t_datetimepatterngenerator *self, PyObject *args) { UnicodeString *u, _u; int override; if (!parseArgs(args, "Sb", &u, &_u, &override)) { UDateTimePatternConflict conflict; UnicodeString conflictPattern; STATUS_CALL(conflict = self->object->addPattern( *u, override, conflictPattern, status)); PyObject *result = PyTuple_New(2); PyTuple_SET_ITEM(result, 0, PyInt_FromLong(conflict)); PyTuple_SET_ITEM(result, 1, PyUnicode_FromUnicodeString(&conflictPattern)); return result; } return PyErr_SetArgsError((PyObject *) self, "addPattern", args); } static PyObject *t_datetimepatterngenerator_getBestPattern( t_datetimepatterngenerator *self, PyObject *args) { UnicodeString *u, _u; #if U_ICU_VERSION_HEX >= 0x04040000 int options; #endif switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "S", &u, &_u)) { UnicodeString result; STATUS_CALL(result = self->object->getBestPattern(*u, status)); return PyUnicode_FromUnicodeString(&result); } break; #if U_ICU_VERSION_HEX >= 0x04040000 case 2: if (!parseArgs(args, "Si", &u, &_u, &options)) { UnicodeString result; STATUS_CALL(result = self->object->getBestPattern( *u, (UDateTimePatternMatchOptions) options, status)); return PyUnicode_FromUnicodeString(&result); } break; #endif } return PyErr_SetArgsError((PyObject *) self, "getBestPattern", args); } static PyObject *t_datetimepatterngenerator_setAppendItemFormat( t_datetimepatterngenerator *self, PyObject *args) { UnicodeString *u, _u; int field; if (!parseArgs(args, "iS", &field, &u, &_u)) { self->object->setAppendItemFormat((UDateTimePatternField) field, *u); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setAppendItemFormat", args); } static PyObject *t_datetimepatterngenerator_setAppendItemName( t_datetimepatterngenerator *self, PyObject *args) { UnicodeString *u, _u; int field; if (!parseArgs(args, "iS", &field, &u, &_u)) { self->object->setAppendItemName((UDateTimePatternField) field, *u); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setAppendItemName", args); } static PyObject *t_datetimepatterngenerator_getAppendItemFormat( t_datetimepatterngenerator *self, PyObject *arg) { int field; if (!parseArg(arg, "i", &field)) { const UnicodeString &result = self->object->getAppendItemFormat( (UDateTimePatternField) field); return PyUnicode_FromUnicodeString(&result); } return PyErr_SetArgsError((PyObject *) self, "getAppendItemFormat", arg); } static PyObject *t_datetimepatterngenerator_getAppendItemName( t_datetimepatterngenerator *self, PyObject *arg) { int field; if (!parseArg(arg, "i", &field)) { const UnicodeString &result = self->object->getAppendItemName( (UDateTimePatternField) field); return PyUnicode_FromUnicodeString(&result); } return PyErr_SetArgsError((PyObject *) self, "getAppendItemName", arg); } static PyObject *t_datetimepatterngenerator_replaceFieldTypes( t_datetimepatterngenerator *self, PyObject *args) { UnicodeString *u, _u, *v, _v;; #if U_ICU_VERSION_HEX >= 0x04040000 int options; #endif switch (PyTuple_Size(args)) { case 2: if (!parseArgs(args, "SS", &u, &_u, &v, &_v)) { UnicodeString result; STATUS_CALL(result = self->object->replaceFieldTypes( *u, *v, status)); return PyUnicode_FromUnicodeString(&result); } break; #if U_ICU_VERSION_HEX >= 0x04040000 case 3: if (!parseArgs(args, "SSi", &u, &_u, &v, &_v, &options)) { UnicodeString result; STATUS_CALL(result = self->object->replaceFieldTypes( *u, *v, (UDateTimePatternMatchOptions) options, status)); return PyUnicode_FromUnicodeString(&result); } break; #endif } return PyErr_SetArgsError((PyObject *) self, "replaceFieldTypes", args); } static PyObject *t_datetimepatterngenerator_getSkeletons( t_datetimepatterngenerator *self) { StringEnumeration *se; STATUS_CALL(se = self->object->getSkeletons(status)); return wrap_StringEnumeration(se, T_OWNED); } static PyObject *t_datetimepatterngenerator_getBaseSkeletons( t_datetimepatterngenerator *self) { StringEnumeration *se; STATUS_CALL(se = self->object->getBaseSkeletons(status)); return wrap_StringEnumeration(se, T_OWNED); } static PyObject *t_datetimepatterngenerator_getRedundants( t_datetimepatterngenerator *self) { StringEnumeration *se; STATUS_CALL(se = self->object->getRedundants(status)); return wrap_StringEnumeration(se, T_OWNED); } static PyObject *t_datetimepatterngenerator_getPatternForSkeleton( t_datetimepatterngenerator *self, PyObject *arg) { UnicodeString *u, _u;; if (!parseArg(arg, "S", &u, &_u)) { UnicodeString result; result = self->object->getPatternForSkeleton(*u); return PyUnicode_FromUnicodeString(&result); } return PyErr_SetArgsError((PyObject *) self, "getPatternForSkeleton", arg); } static PyObject *t_datetimepatterngenerator_setDecimal( t_datetimepatterngenerator *self, PyObject *arg) { UnicodeString *u, _u;; if (!parseArg(arg, "S", &u, &_u)) { self->object->setDecimal(*u); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setDecimal", arg); } static PyObject *t_datetimepatterngenerator_getDecimal( t_datetimepatterngenerator *self) { const UnicodeString &result = self->object->getDecimal(); return PyUnicode_FromUnicodeString(&result); } #if U_ICU_VERSION_HEX >= 0x04000000 /* DateInterval */ static int t_dateinterval_init(t_dateinterval *self, PyObject *args, PyObject *kwds) { UDate fromDate, toDate; if (!parseArgs(args, "DD", &fromDate, &toDate)) { self->object = new DateInterval(fromDate, toDate); self->flags = T_OWNED; return 0; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; } static PyObject *t_dateinterval_getFromDate(t_dateinterval *self) { UDate date = self->object->getFromDate(); return PyFloat_FromDouble(date / 1000.0); } static PyObject *t_dateinterval_getToDate(t_dateinterval *self) { UDate date = self->object->getToDate(); return PyFloat_FromDouble(date / 1000.0); } static PyObject *t_dateinterval_str(t_dateinterval *self) { UErrorCode status = U_ZERO_ERROR; UnicodeString u; FieldPosition _fp; DateInterval_format->format(self->object, u, _fp, status); if (U_FAILURE(status)) return ICUException(status).reportError(); return PyUnicode_FromUnicodeString(&u); } DEFINE_RICHCMP(DateInterval, t_dateinterval); /* DateIntervalInfo */ static int t_dateintervalinfo_init(t_dateintervalinfo *self, PyObject *args, PyObject *kwds) { DateIntervalInfo *dii; Locale *locale; switch (PyTuple_Size(args)) { case 0: INT_STATUS_CALL(dii = new DateIntervalInfo(status)); self->object = dii; self->flags = T_OWNED; break; case 1: if (!parseArgs(args, "P", TYPE_CLASSID(Locale), &locale)) { INT_STATUS_CALL(dii = new DateIntervalInfo(*locale, status)); self->object = dii; self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; default: PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; } if (self->object) return 0; return -1; } static PyObject *t_dateintervalinfo_getDefaultOrder(t_dateintervalinfo *self) { UBool b = self->object->getDefaultOrder(); Py_RETURN_BOOL(b); } static PyObject *t_dateintervalinfo_setIntervalPattern(t_dateintervalinfo *self, PyObject *args) { UnicodeString *u0, _u0; UnicodeString *u1, _u1; UCalendarDateFields ucdf; if (!parseArgs(args, "SiS", &u0, &_u0, &ucdf, &u1, &_u1)) { /* u0 transient, u1 copied */ STATUS_CALL(self->object->setIntervalPattern(*u0, ucdf, *u1, status)); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setIntervalPattern", args); } static PyObject *t_dateintervalinfo_getIntervalPattern(t_dateintervalinfo *self, PyObject *args) { UnicodeString *u0, _u0; UnicodeString *u1, _u1; UCalendarDateFields ucdf; switch (PyTuple_Size(args)) { case 2: if (!parseArgs(args, "Si", &u0, &_u0, &ucdf)) { STATUS_CALL(self->object->getIntervalPattern(*u0, ucdf, _u1, status)); return PyUnicode_FromUnicodeString(&_u1); } break; case 3: if (!parseArgs(args, "SiU", &u0, &_u0, &ucdf, &u1)) { STATUS_CALL(self->object->getIntervalPattern(*u0, ucdf, *u1, status)); Py_RETURN_ARG(args, 2); } break; } return PyErr_SetArgsError((PyObject *) self, "getIntervalPattern", args); } static PyObject *t_dateintervalinfo_setFallbackIntervalPattern(t_dateintervalinfo *self, PyObject *arg) { UnicodeString *u, _u; if (!parseArg(arg, "S", &u, &_u)) { /* copied */ STATUS_CALL(self->object->setFallbackIntervalPattern(*u, status)); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setFallbackIntervalPattern", arg); } static PyObject *t_dateintervalinfo_getFallbackIntervalPattern(t_dateintervalinfo *self, PyObject *args) { UnicodeString *u, _u; switch (PyTuple_Size(args)) { case 0: self->object->getFallbackIntervalPattern(_u); return PyUnicode_FromUnicodeString(&_u); case 1: if (!parseArgs(args, "U", &u)) { self->object->getFallbackIntervalPattern(*u); Py_RETURN_ARG(args, 0); } break; } return PyErr_SetArgsError((PyObject *) self, "getFallbackIntervalPattern", args); } DEFINE_RICHCMP(DateIntervalInfo, t_dateintervalinfo); /* DateIntervalFormat */ static PyObject *t_dateintervalformat_format(t_dateintervalformat *self, PyObject *args) { UnicodeString *u, _u; FieldPosition *fp, _fp; DateInterval *di; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "P", TYPE_CLASSID(DateInterval), &di)) { STATUS_CALL(self->object->format(di, _u, _fp, status)); return PyUnicode_FromUnicodeString(&_u); } break; case 2: if (!parseArgs(args, "PU", TYPE_CLASSID(DateInterval), &di, &u)) { STATUS_CALL(self->object->format(di, *u, _fp, status)); Py_RETURN_ARG(args, 1); } if (!parseArgs(args, "PP", TYPE_CLASSID(DateInterval), TYPE_CLASSID(FieldPosition), &di, &fp)) { STATUS_CALL(self->object->format(di, _u, *fp, status)); return PyUnicode_FromUnicodeString(&_u); } break; case 3: if (!parseArgs(args, "PUP", TYPE_CLASSID(DateInterval), TYPE_CLASSID(FieldPosition), &di, &u, &fp)) { STATUS_CALL(self->object->format(di, *u, *fp, status)); Py_RETURN_ARG(args, 1); } break; } return t_format_format((t_format *) self, args); } static PyObject *t_dateintervalformat_getDateIntervalInfo(t_dateintervalformat *self) { const DateIntervalInfo *dii = self->object->getDateIntervalInfo(); return wrap_DateIntervalInfo(new DateIntervalInfo(*dii), T_OWNED); } static PyObject *t_dateintervalformat_setDateIntervalInfo(t_dateintervalformat *self, PyObject *arg) { DateIntervalInfo *dii; if (!parseArg(arg, "P", TYPE_CLASSID(DateIntervalInfo), &dii)) { /* copied */ STATUS_CALL(self->object->setDateIntervalInfo(*dii, status)); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setDateIntervalInfo", arg); } static PyObject *t_dateintervalformat_getDateFormat(t_dateintervalformat *self) { DateFormat *format = (DateFormat *) self->object->getDateFormat()->clone(); return wrap_DateFormat(format); } static PyObject *t_dateintervalformat_parseObject(t_dateintervalformat *self, PyObject *args) { PyErr_SetString(PyExc_NotImplementedError, "DateIntervalFormat.parseObject()"); return NULL; } static PyObject *t_dateintervalformat_createInstance(PyTypeObject *type, PyObject *args) { UnicodeString *u, _u; Locale *locale; DateIntervalInfo *dii; DateIntervalFormat *dif; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "S", &u, &_u)) { STATUS_CALL(dif = DateIntervalFormat::createInstance(*u, status)); return wrap_DateIntervalFormat(dif, T_OWNED); } break; case 2: if (!parseArgs(args, "SP", TYPE_CLASSID(Locale), &u, &_u, &locale)) { STATUS_CALL(dif = DateIntervalFormat::createInstance(*u, *locale, status)); return wrap_DateIntervalFormat(dif, T_OWNED); } if (!parseArgs(args, "SP", TYPE_CLASSID(DateIntervalInfo), &u, &_u, &dii)) { STATUS_CALL(dif = DateIntervalFormat::createInstance(*u, *dii, status)); return wrap_DateIntervalFormat(dif, T_OWNED); } break; case 3: if (!parseArgs(args, "SPP", TYPE_CLASSID(Locale), TYPE_CLASSID(DateIntervalInfo), &u, &_u, &locale, &dii)) { STATUS_CALL(dif = DateIntervalFormat::createInstance(*u, *locale, *dii, status)); return wrap_DateIntervalFormat(dif, T_OWNED); } break; } return PyErr_SetArgsError(type, "createInstance", args); } DEFINE_RICHCMP(DateIntervalFormat, t_dateintervalformat); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(53, 0, 0) /* RelativeDateTimeFormatter */ static int t_relativedatetimeformatter_init(t_relativedatetimeformatter *self, PyObject *args, PyObject *kwds) { Locale *locale; RelativeDateTimeFormatter *fmt; NumberFormat *number_format; UDateRelativeDateTimeFormatterStyle style; UDisplayContext context; switch (PyTuple_Size(args)) { case 0: INT_STATUS_CALL(fmt = new RelativeDateTimeFormatter(status)); self->object = fmt; self->flags = T_OWNED; break; case 1: if (!parseArgs(args, "P", TYPE_CLASSID(Locale), &locale)) { INT_STATUS_CALL(fmt = new RelativeDateTimeFormatter(*locale, status)); self->object = fmt; self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; case 2: if (!parseArgs(args, "PP", TYPE_CLASSID(Locale), TYPE_CLASSID(NumberFormat), &locale, &number_format)) { INT_STATUS_CALL(fmt = new RelativeDateTimeFormatter( *locale, (NumberFormat *) number_format->clone(), status)); self->object = fmt; self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; case 4: if (!parseArgs(args, "PPii", TYPE_CLASSID(Locale), TYPE_CLASSID(NumberFormat), &locale, &number_format, &style, &context)) { INT_STATUS_CALL(fmt = new RelativeDateTimeFormatter( *locale, (NumberFormat *) number_format->clone(), style, context, status)); self->object = fmt; self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; default: PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; } if (self->object) return 0; return -1; } static PyObject *t_relativedatetimeformatter_format( t_relativedatetimeformatter *self, PyObject *args) { UDateDirection direction = UDAT_DIRECTION_PLAIN; UDateAbsoluteUnit abs_unit = UDAT_ABSOLUTE_NOW; UDateRelativeUnit rel_unit = UDAT_RELATIVE_SECONDS; UnicodeString *buffer; double value; switch (PyTuple_Size(args)) { case 0: { UnicodeString result; STATUS_CALL(self->object->format(direction, abs_unit, result, status)); return PyUnicode_FromUnicodeString(&result); } case 1: if (!parseArgs(args, "d", &value)) { UnicodeString result; STATUS_CALL(self->object->format( value, UDAT_DIRECTION_NEXT, rel_unit, result, status)); return PyUnicode_FromUnicodeString(&result); } break; case 2: if (!parseArgs(args, "ii", &direction, &abs_unit)) { UnicodeString result; STATUS_CALL(self->object->format( direction, abs_unit, result, status)); return PyUnicode_FromUnicodeString(&result); } break; case 3: if (!parseArgs(args, "iiU", &direction, &abs_unit, &buffer)) { STATUS_CALL(self->object->format( direction, abs_unit, *buffer, status)); Py_RETURN_ARG(args, 2); } if (!parseArgs(args, "dii", &value, &direction, &rel_unit)) { UnicodeString result; STATUS_CALL(self->object->format( value, direction, rel_unit, result, status)); return PyUnicode_FromUnicodeString(&result); } break; case 4: if (!parseArgs(args, "diiU", &value, &direction, &rel_unit, &buffer)) { STATUS_CALL(self->object->format( value, direction, rel_unit, *buffer, status)); Py_RETURN_ARG(args, 3); } break; } return PyErr_SetArgsError((PyObject *) self, "format", args); } static PyObject *t_relativedatetimeformatter_combineDateAndTime( t_relativedatetimeformatter *self, PyObject *args) { UnicodeString *u, _u, *v, _v; UnicodeString *buffer; switch (PyTuple_Size(args)) { case 2: if (!parseArgs(args, "SS", &u, &_u, &v, &_v)) { UnicodeString result; STATUS_CALL(self->object->combineDateAndTime( *u, *v, result, status)); return PyUnicode_FromUnicodeString(&result); } break; case 3: if (!parseArgs(args, "SSU", &u, &_u, &v, &_v, &buffer)) { STATUS_CALL(self->object->combineDateAndTime( *u, *v, *buffer, status)); Py_RETURN_ARG(args, 2); } break; } return PyErr_SetArgsError((PyObject *) self, "combineDateAndTime", args); } static PyObject *t_relativedatetimeformatter_getNumberFormat( t_relativedatetimeformatter *self) { const NumberFormat &format = self->object->getNumberFormat(); return wrap_NumberFormat(const_cast(&format), 0); } static PyObject *t_relativedatetimeformatter_getCapitalizationContext( t_relativedatetimeformatter *self) { return PyInt_FromLong(self->object->getCapitalizationContext()); } static PyObject *t_relativedatetimeformatter_getFormatStyle( t_relativedatetimeformatter *self) { return PyInt_FromLong(self->object->getFormatStyle()); } #endif void _init_dateformat(PyObject *m) { DateFormatSymbolsType_.tp_richcompare = (richcmpfunc) t_dateformatsymbols_richcmp; SimpleDateFormatType_.tp_str = (reprfunc) t_simpledateformat_str; #if U_ICU_VERSION_HEX >= 0x04000000 DateIntervalType_.tp_str = (reprfunc) t_dateinterval_str; DateIntervalType_.tp_richcompare = (richcmpfunc) t_dateinterval_richcmp; DateIntervalInfoType_.tp_richcompare = (richcmpfunc) t_dateintervalinfo_richcmp; DateIntervalFormatType_.tp_richcompare = (richcmpfunc) t_dateintervalformat_richcmp; #endif INSTALL_CONSTANTS_TYPE(UDateTimePatternConflict, m); INSTALL_CONSTANTS_TYPE(UDateTimePatternField, m); #if U_ICU_VERSION_HEX >= 0x04040000 INSTALL_CONSTANTS_TYPE(UDateTimePatternMatchOptions, m); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(54, 0, 0) INSTALL_CONSTANTS_TYPE(UDateRelativeDateTimeFormatterStyle, m); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(51, 0, 0) INSTALL_CONSTANTS_TYPE(UDisplayContext, m); INSTALL_CONSTANTS_TYPE(UDisplayContextType, m); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(53, 0, 0) INSTALL_CONSTANTS_TYPE(UDateDirection, m); INSTALL_CONSTANTS_TYPE(UDateAbsoluteUnit, m); INSTALL_CONSTANTS_TYPE(UDateRelativeUnit, m); INSTALL_CONSTANTS_TYPE(UDateFormatBooleanAttribute, m); #endif REGISTER_TYPE(DateFormatSymbols, m); INSTALL_TYPE(DateFormat, m); REGISTER_TYPE(SimpleDateFormat, m); REGISTER_TYPE(DateTimePatternGenerator, m); #if U_ICU_VERSION_HEX >= 0x04000000 REGISTER_TYPE(DateInterval, m); REGISTER_TYPE(DateIntervalInfo, m); REGISTER_TYPE(DateIntervalFormat, m); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(53, 0, 0) INSTALL_TYPE(RelativeDateTimeFormatter, m); #endif INSTALL_STATIC_INT(DateFormatSymbols, FORMAT); INSTALL_STATIC_INT(DateFormatSymbols, STANDALONE); INSTALL_STATIC_INT(DateFormatSymbols, WIDE); INSTALL_STATIC_INT(DateFormatSymbols, ABBREVIATED); INSTALL_STATIC_INT(DateFormatSymbols, NARROW); INSTALL_STATIC_INT(DateFormat, kNone); INSTALL_STATIC_INT(DateFormat, kFull); INSTALL_STATIC_INT(DateFormat, kLong); INSTALL_STATIC_INT(DateFormat, kMedium); INSTALL_STATIC_INT(DateFormat, kShort); INSTALL_STATIC_INT(DateFormat, kDateOffset); INSTALL_STATIC_INT(DateFormat, kDateTime); INSTALL_STATIC_INT(DateFormat, kDefault); INSTALL_STATIC_INT(DateFormat, FULL); INSTALL_STATIC_INT(DateFormat, LONG); INSTALL_STATIC_INT(DateFormat, MEDIUM); INSTALL_STATIC_INT(DateFormat, SHORT); INSTALL_STATIC_INT(DateFormat, DEFAULT); INSTALL_STATIC_INT(DateFormat, DATE_OFFSET); INSTALL_STATIC_INT(DateFormat, NONE); INSTALL_STATIC_INT(DateFormat, DATE_TIME); INSTALL_STATIC_INT(DateFormat, kEraField); INSTALL_STATIC_INT(DateFormat, kYearField); INSTALL_STATIC_INT(DateFormat, kMonthField); INSTALL_STATIC_INT(DateFormat, kDateField); INSTALL_STATIC_INT(DateFormat, kHourOfDay1Field); INSTALL_STATIC_INT(DateFormat, kHourOfDay0Field); INSTALL_STATIC_INT(DateFormat, kMinuteField); INSTALL_STATIC_INT(DateFormat, kSecondField); INSTALL_STATIC_INT(DateFormat, kMillisecondField); INSTALL_STATIC_INT(DateFormat, kDayOfWeekField); INSTALL_STATIC_INT(DateFormat, kDayOfYearField); INSTALL_STATIC_INT(DateFormat, kDayOfWeekInMonthField); INSTALL_STATIC_INT(DateFormat, kWeekOfYearField); INSTALL_STATIC_INT(DateFormat, kWeekOfMonthField); INSTALL_STATIC_INT(DateFormat, kAmPmField); INSTALL_STATIC_INT(DateFormat, kHour1Field); INSTALL_STATIC_INT(DateFormat, kHour0Field); INSTALL_STATIC_INT(DateFormat, kTimezoneField); INSTALL_STATIC_INT(DateFormat, kYearWOYField); INSTALL_STATIC_INT(DateFormat, kDOWLocalField); INSTALL_STATIC_INT(DateFormat, kExtendedYearField); INSTALL_STATIC_INT(DateFormat, kJulianDayField); INSTALL_STATIC_INT(DateFormat, kMillisecondsInDayField); INSTALL_STATIC_INT(DateFormat, ERA_FIELD); INSTALL_STATIC_INT(DateFormat, YEAR_FIELD); INSTALL_STATIC_INT(DateFormat, MONTH_FIELD); INSTALL_STATIC_INT(DateFormat, DATE_FIELD); INSTALL_STATIC_INT(DateFormat, HOUR_OF_DAY1_FIELD); INSTALL_STATIC_INT(DateFormat, HOUR_OF_DAY0_FIELD); INSTALL_STATIC_INT(DateFormat, MINUTE_FIELD); INSTALL_STATIC_INT(DateFormat, SECOND_FIELD); INSTALL_STATIC_INT(DateFormat, MILLISECOND_FIELD); INSTALL_STATIC_INT(DateFormat, DAY_OF_WEEK_FIELD); INSTALL_STATIC_INT(DateFormat, DAY_OF_YEAR_FIELD); INSTALL_STATIC_INT(DateFormat, DAY_OF_WEEK_IN_MONTH_FIELD); INSTALL_STATIC_INT(DateFormat, WEEK_OF_YEAR_FIELD); INSTALL_STATIC_INT(DateFormat, WEEK_OF_MONTH_FIELD); INSTALL_STATIC_INT(DateFormat, AM_PM_FIELD); INSTALL_STATIC_INT(DateFormat, HOUR1_FIELD); INSTALL_STATIC_INT(DateFormat, HOUR0_FIELD); INSTALL_STATIC_INT(DateFormat, TIMEZONE_FIELD); INSTALL_ENUM(UDateTimePatternConflict, "NO_CONFLICT", UDATPG_NO_CONFLICT); INSTALL_ENUM(UDateTimePatternConflict, "BASE_CONFLICT", UDATPG_BASE_CONFLICT); INSTALL_ENUM(UDateTimePatternConflict, "CONFLICT", UDATPG_CONFLICT); INSTALL_ENUM(UDateTimePatternConflict, "CONFLICT_COUNT", UDATPG_CONFLICT_COUNT); INSTALL_ENUM(UDateTimePatternField, "ERA_FIELD", UDATPG_ERA_FIELD); INSTALL_ENUM(UDateTimePatternField, "YEAR_FIELD", UDATPG_YEAR_FIELD); INSTALL_ENUM(UDateTimePatternField, "QUARTER_FIELD", UDATPG_QUARTER_FIELD); INSTALL_ENUM(UDateTimePatternField, "MONTH_FIELD", UDATPG_MONTH_FIELD); INSTALL_ENUM(UDateTimePatternField, "WEEK_OF_YEAR_FIELD", UDATPG_WEEK_OF_YEAR_FIELD); INSTALL_ENUM(UDateTimePatternField, "WEEK_OF_MONTH_FIELD", UDATPG_WEEK_OF_MONTH_FIELD); INSTALL_ENUM(UDateTimePatternField, "WEEKDAY_FIELD", UDATPG_WEEKDAY_FIELD); INSTALL_ENUM(UDateTimePatternField, "DAY_OF_YEAR_FIELD", UDATPG_DAY_OF_YEAR_FIELD); INSTALL_ENUM(UDateTimePatternField, "DAY_OF_WEEK_IN_MONTH_FIELD", UDATPG_DAY_OF_WEEK_IN_MONTH_FIELD); INSTALL_ENUM(UDateTimePatternField, "DAY_FIELD", UDATPG_DAY_FIELD); INSTALL_ENUM(UDateTimePatternField, "DAYPERIOD_FIELD", UDATPG_DAYPERIOD_FIELD); INSTALL_ENUM(UDateTimePatternField, "HOUR_FIELD", UDATPG_HOUR_FIELD); INSTALL_ENUM(UDateTimePatternField, "MINUTE_FIELD", UDATPG_MINUTE_FIELD); INSTALL_ENUM(UDateTimePatternField, "SECOND_FIELD", UDATPG_SECOND_FIELD); INSTALL_ENUM(UDateTimePatternField, "FRACTIONAL_SECOND_FIELD", UDATPG_FRACTIONAL_SECOND_FIELD); INSTALL_ENUM(UDateTimePatternField, "ZONE_FIELD", UDATPG_ZONE_FIELD); INSTALL_ENUM(UDateTimePatternField, "FIELD_COUNT", UDATPG_FIELD_COUNT); #if U_ICU_VERSION_HEX >= 0x04040000 INSTALL_ENUM(UDateTimePatternMatchOptions, "NO_OPTIONS", UDATPG_MATCH_NO_OPTIONS); INSTALL_ENUM(UDateTimePatternMatchOptions, "HOUR_FIELD_LENGTH", UDATPG_MATCH_HOUR_FIELD_LENGTH); INSTALL_ENUM(UDateTimePatternMatchOptions, "ALL_FIELDS_LENGTH", UDATPG_MATCH_ALL_FIELDS_LENGTH); INSTALL_STATIC_INT(DateIntervalInfo, kMaxIntervalPatternIndex); #endif #if U_ICU_VERSION_HEX >= 0x04000000 UErrorCode status = U_ZERO_ERROR; DateInterval_format = DateIntervalFormat::createInstance(UDAT_YEAR_ABBR_MONTH_DAY, status); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(54, 0, 0) INSTALL_ENUM(UDateRelativeDateTimeFormatterStyle, "LONG", UDAT_STYLE_LONG); INSTALL_ENUM(UDateRelativeDateTimeFormatterStyle, "SHORT", UDAT_STYLE_SHORT); INSTALL_ENUM(UDateRelativeDateTimeFormatterStyle, "NARROW", UDAT_STYLE_NARROW); INSTALL_ENUM(UDateRelativeDateTimeFormatterStyle, "COUNT", UDAT_STYLE_COUNT); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(51, 0, 0) INSTALL_ENUM(UDisplayContext, "STANDARD_NAMES", UDISPCTX_STANDARD_NAMES); INSTALL_ENUM(UDisplayContext, "DIALECT_NAMES", UDISPCTX_DIALECT_NAMES); INSTALL_ENUM(UDisplayContext, "CAPITALIZATION_NONE", UDISPCTX_CAPITALIZATION_NONE); INSTALL_ENUM(UDisplayContext, "CAPITALIZATION_FOR_MIDDLE_OF_SENTENCE", UDISPCTX_CAPITALIZATION_FOR_MIDDLE_OF_SENTENCE); INSTALL_ENUM(UDisplayContext, "CAPITALIZATION_FOR_BEGINNING_OF_SENTENCE", UDISPCTX_CAPITALIZATION_FOR_BEGINNING_OF_SENTENCE); INSTALL_ENUM(UDisplayContext, "CAPITALIZATION_FOR_UI_LIST_OR_MENU", UDISPCTX_CAPITALIZATION_FOR_UI_LIST_OR_MENU); INSTALL_ENUM(UDisplayContext, "CAPITALIZATION_FOR_STANDALONE", UDISPCTX_CAPITALIZATION_FOR_STANDALONE); INSTALL_ENUM(UDisplayContextType, "TYPE_DIALECT_HANDLING", UDISPCTX_TYPE_DIALECT_HANDLING); INSTALL_ENUM(UDisplayContextType, "TYPE_CAPITALIZATION", UDISPCTX_TYPE_CAPITALIZATION); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(54, 0, 0) INSTALL_ENUM(UDisplayContext, "LENGTH_FULL", UDISPCTX_LENGTH_FULL); INSTALL_ENUM(UDisplayContext, "LENGTH_SHORT", UDISPCTX_LENGTH_SHORT); INSTALL_ENUM(UDisplayContextType, "TYPE_DISPLAY_LENGTH", UDISPCTX_TYPE_DISPLAY_LENGTH); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(53, 0, 0) INSTALL_ENUM(UDateDirection, "LAST_2", UDAT_DIRECTION_LAST_2); INSTALL_ENUM(UDateDirection, "LAST", UDAT_DIRECTION_LAST); INSTALL_ENUM(UDateDirection, "THIS", UDAT_DIRECTION_THIS); INSTALL_ENUM(UDateDirection, "NEXT", UDAT_DIRECTION_NEXT); INSTALL_ENUM(UDateDirection, "NEXT_2", UDAT_DIRECTION_NEXT_2); INSTALL_ENUM(UDateDirection, "PLAIN", UDAT_DIRECTION_PLAIN); INSTALL_ENUM(UDateAbsoluteUnit, "SUNDAY", UDAT_ABSOLUTE_SUNDAY); INSTALL_ENUM(UDateAbsoluteUnit, "MONDAY", UDAT_ABSOLUTE_MONDAY); INSTALL_ENUM(UDateAbsoluteUnit, "TUESDAY", UDAT_ABSOLUTE_TUESDAY); INSTALL_ENUM(UDateAbsoluteUnit, "WEDNESDAY", UDAT_ABSOLUTE_WEDNESDAY); INSTALL_ENUM(UDateAbsoluteUnit, "THURSDAY", UDAT_ABSOLUTE_THURSDAY); INSTALL_ENUM(UDateAbsoluteUnit, "FRIDAY", UDAT_ABSOLUTE_FRIDAY); INSTALL_ENUM(UDateAbsoluteUnit, "SATURDAY", UDAT_ABSOLUTE_SATURDAY); INSTALL_ENUM(UDateAbsoluteUnit, "DAY", UDAT_ABSOLUTE_DAY); INSTALL_ENUM(UDateAbsoluteUnit, "WEEK", UDAT_ABSOLUTE_WEEK); INSTALL_ENUM(UDateAbsoluteUnit, "MONTH", UDAT_ABSOLUTE_MONTH); INSTALL_ENUM(UDateAbsoluteUnit, "YEAR", UDAT_ABSOLUTE_YEAR); INSTALL_ENUM(UDateAbsoluteUnit, "NOW", UDAT_ABSOLUTE_NOW); INSTALL_ENUM(UDateRelativeUnit, "SECONDS", UDAT_RELATIVE_SECONDS); INSTALL_ENUM(UDateRelativeUnit, "MINUTES", UDAT_RELATIVE_MINUTES); INSTALL_ENUM(UDateRelativeUnit, "HOURS", UDAT_RELATIVE_HOURS); INSTALL_ENUM(UDateRelativeUnit, "DAYS", UDAT_RELATIVE_DAYS); INSTALL_ENUM(UDateRelativeUnit, "WEEKS", UDAT_RELATIVE_WEEKS); INSTALL_ENUM(UDateRelativeUnit, "MONTHS", UDAT_RELATIVE_MONTHS); INSTALL_ENUM(UDateRelativeUnit, "YEARS", UDAT_RELATIVE_YEARS); INSTALL_ENUM(UDateFormatBooleanAttribute, "PARSE_ALLOW_WHITESPACE", UDAT_PARSE_ALLOW_WHITESPACE); INSTALL_ENUM(UDateFormatBooleanAttribute, "PARSE_ALLOW_NUMERIC", UDAT_PARSE_ALLOW_NUMERIC); INSTALL_ENUM(UDateFormatBooleanAttribute, "BOOLEAN_ATTRIBUTE_COUNT", UDAT_BOOLEAN_ATTRIBUTE_COUNT); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(56, 0, 0) INSTALL_ENUM(UDateFormatBooleanAttribute, "PARSE_PARTIAL_LITERAL_MATCH", UDAT_PARSE_PARTIAL_LITERAL_MATCH); INSTALL_ENUM(UDateFormatBooleanAttribute, "PARSE_MULTIPLE_PATTERNS_FOR_MATCH", UDAT_PARSE_MULTIPLE_PATTERNS_FOR_MATCH); #endif } PyICU-1.9.5/dateformat.h0000644000076500000000000000266211323445340015166 0ustar vajdawheel00000000000000/* ==================================================================== * Copyright (c) 2004-2010 Open Source Applications Foundation. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. * ==================================================================== */ #ifndef _dateformat_h #define _dateformat_h PyObject *wrap_SimpleDateFormat(SimpleDateFormat *, int); void _init_dateformat(PyObject *m); #endif /* _dateformat_h */ PyICU-1.9.5/docs.py0000644000076500000000000000714711574760361014207 0ustar vajdawheel00000000000000 # ==================================================================== # Copyright (c) 2004-2010 Open Source Applications Foundation. # # Permission is hereby granted, free of charge, to any person obtaining a # copy of this software and associated documentation files (the "Software"), # to deal in the Software without restriction, including without limitation # the rights to use, copy, modify, merge, publish, distribute, sublicense, # and/or sell copies of the Software, and to permit persons to whom the # Software is furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included # in all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS # OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING # FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER # DEALINGS IN THE SOFTWARE. # ==================================================================== from _icu import * from _icu import _install__doc__ _install__doc__(BreakIterator, ''' The BreakIterator class implements methods for finding the location of boundaries in text. BreakIterator is an abstract base class. Instances of BreakIterator maintain a current position and scan over text returning the index of characters where boundaries occur. Line boundary analysis determines where a text string can be broken when line-wrapping. The mechanism correctly handles punctuation and hyphenated words. Sentence boundary analysis allows selection with correct interpretation of periods within numbers and abbreviations, and trailing punctuation marks such as quotation marks and parentheses. Word boundary analysis is used by search and replace functions, as well as within text editing applications that allow the user to select words with a double click. Word selection provides correct interpretation of punctuation marks within and following words. Characters that are not part of a word, such as symbols or punctuation marks, have word-breaks on both sides. Character boundary analysis allows users to interact with characters as they expect to, for example, when moving the cursor through a text string. Character boundary analysis provides correct navigation of through character strings, regardless of how the character is stored. For example, an accented character might be stored as a base character and a diacritical mark. What users consider to be a character can differ between languages. The text boundary positions are found according to the rules described in Unicode Standard Annex #29, Text Boundaries, and Unicode Standard Annex #14, Line Breaking Properties. These are available at http://www.unicode.org/reports/tr14/ and http://www.unicode.org/reports/tr29/. ''') _install__doc__(BreakIterator.__init__, ''' BreakIterator is abstract. Use one of the class instantiators: createWordInstance, createLineInstance, createCharacterInstance, createSentenceInstance or createTitleInstance. ''') _install__doc__(BreakIterator.getText, ''' Return the string over the text being analyzed. ''') _install__doc__(BreakIterator.createLineInstance, ''' Returns an instance of a BreakIterator implementing line breaks. Line breaks are logically possible line breaks, actual line breaks are usually determined based on display width. LineBreak is useful for word wrapping text. ''') PyICU-1.9.5/errors.cpp0000644000076500000000000003350412656222370014714 0ustar vajdawheel00000000000000/* ==================================================================== * Copyright (c) 2004-2010 Open Source Applications Foundation. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. * ==================================================================== */ #include "common.h" #include "structmember.h" #include "errors.h" static void _setMsg(PyObject *messages, UErrorCode code, const char *msg) { PyObject *pycode = PyInt_FromLong((long) code); PyObject *pymsg = PyString_FromString(msg); PyObject_SetItem(messages, pycode, pymsg); Py_DECREF(pycode); Py_DECREF(pymsg); } static void registerErrors(PyObject *messages) { _setMsg(messages, U_USING_FALLBACK_WARNING, "A resource bundle lookup returned a fallback result (not an error)"); _setMsg(messages, U_ERROR_WARNING_START, "Start of information results (semantically successful)"); _setMsg(messages, U_USING_DEFAULT_WARNING, "A resource bundle lookup returned a result from the root locale (not an error)"); _setMsg(messages, U_SAFECLONE_ALLOCATED_WARNING, "A SafeClone operation required allocating memory (informational only)"); _setMsg(messages, U_STATE_OLD_WARNING, "ICU has to use compatibility layer to construct the service. Expect performance/memory usage degradation. Consider upgrading"); _setMsg(messages, U_STRING_NOT_TERMINATED_WARNING, "An output string could not be NUL-terminated because output length==destCapacity."); _setMsg(messages, U_SORT_KEY_TOO_SHORT_WARNING, "Number of levels requested in getBound is higher than the number of levels in the sort key"); _setMsg(messages, U_AMBIGUOUS_ALIAS_WARNING, "This converter alias can go to different converter implementations"); _setMsg(messages, U_DIFFERENT_UCA_VERSION, "ucol_open encountered a mismatch between UCA version and collator image version, so the collator was constructed from rules. No impact to further function"); _setMsg(messages, U_ERROR_WARNING_LIMIT, "This must always be the last warning value to indicate the limit for UErrorCode warnings (last warning code +1)"); _setMsg(messages, U_ZERO_ERROR, "No error, no warning."); _setMsg(messages, U_ILLEGAL_ARGUMENT_ERROR, "Illegal argument"); _setMsg(messages, U_MISSING_RESOURCE_ERROR, "The requested resource cannot be found"); _setMsg(messages, U_INVALID_FORMAT_ERROR, "Data format is not what is expected"); _setMsg(messages, U_FILE_ACCESS_ERROR, "The requested file cannot be found"); _setMsg(messages, U_INTERNAL_PROGRAM_ERROR, "Indicates a bug in the library code"); _setMsg(messages, U_MESSAGE_PARSE_ERROR, "Unable to parse a message (message format)"); _setMsg(messages, U_MEMORY_ALLOCATION_ERROR, "Memory allocation error"); _setMsg(messages, U_INDEX_OUTOFBOUNDS_ERROR, "Trying to access the index that is out of bounds"); _setMsg(messages, U_PARSE_ERROR, "Equivalent to Java ParseException"); _setMsg(messages, U_INVALID_CHAR_FOUND, "Character conversion: Unmappable input sequence. In other APIs: Invalid character."); _setMsg(messages, U_TRUNCATED_CHAR_FOUND, "Character conversion: Incomplete input sequence."); _setMsg(messages, U_ILLEGAL_CHAR_FOUND, "Character conversion: Illegal input sequence/combination of input units.."); _setMsg(messages, U_INVALID_TABLE_FORMAT, "Conversion table file found, but corrupted"); _setMsg(messages, U_INVALID_TABLE_FILE, "Conversion table file not found"); _setMsg(messages, U_BUFFER_OVERFLOW_ERROR, "A result would not fit in the supplied buffer"); _setMsg(messages, U_UNSUPPORTED_ERROR, "Requested operation not supported in current context"); _setMsg(messages, U_RESOURCE_TYPE_MISMATCH, "an operation is requested over a resource that does not support it"); _setMsg(messages, U_ILLEGAL_ESCAPE_SEQUENCE, "ISO-2022 illegal escape sequence"); _setMsg(messages, U_UNSUPPORTED_ESCAPE_SEQUENCE, "ISO-2022 unsupported escape sequence"); _setMsg(messages, U_NO_SPACE_AVAILABLE, "No space available for in-buffer expansion for Arabic shaping"); _setMsg(messages, U_CE_NOT_FOUND_ERROR, "Currently used only while setting variable top, but can be used generally"); _setMsg(messages, U_PRIMARY_TOO_LONG_ERROR, "User tried to set variable top to a primary that is longer than two bytes"); _setMsg(messages, U_STATE_TOO_OLD_ERROR, "ICU cannot construct a service from this state, as it is no longer supported"); _setMsg(messages, U_TOO_MANY_ALIASES_ERROR, "There are too many aliases in the path to the requested resource. It is very possible that a circular alias definition has occurred"); _setMsg(messages, U_ENUM_OUT_OF_SYNC_ERROR, "UEnumeration out of sync with underlying collection"); _setMsg(messages, U_INVARIANT_CONVERSION_ERROR, "Unable to convert a UChar* string to char* with the invariant converter."); _setMsg(messages, U_INVALID_STATE_ERROR, "Requested operation can not be completed with ICU in its current state"); _setMsg(messages, U_COLLATOR_VERSION_MISMATCH, "Collator version is not compatible with the base version"); _setMsg(messages, U_USELESS_COLLATOR_ERROR, "Collator is options only and no base is specified"); _setMsg(messages, U_STANDARD_ERROR_LIMIT, "This must always be the last value to indicate the limit for standard errors"); _setMsg(messages, U_BAD_VARIABLE_DEFINITION, "Missing '$' or duplicate variable name"); _setMsg(messages, U_PARSE_ERROR_START, "Start of Transliterator errors"); _setMsg(messages, U_MALFORMED_RULE, "Elements of a rule are misplaced"); _setMsg(messages, U_MALFORMED_SET, "A UnicodeSet pattern is invalid"); _setMsg(messages, U_MALFORMED_SYMBOL_REFERENCE, "UNUSED as of ICU 2.4"); _setMsg(messages, U_MALFORMED_UNICODE_ESCAPE, "A Unicode escape pattern is invalid"); _setMsg(messages, U_MALFORMED_VARIABLE_DEFINITION, "A variable definition is invalid"); _setMsg(messages, U_MALFORMED_VARIABLE_REFERENCE, "A variable reference is invalid"); _setMsg(messages, U_MISMATCHED_SEGMENT_DELIMITERS, "UNUSED as of ICU 2.4"); _setMsg(messages, U_MISPLACED_ANCHOR_START, "A start anchor appears at an illegal position"); _setMsg(messages, U_MISPLACED_CURSOR_OFFSET, "A cursor offset occurs at an illegal position"); _setMsg(messages, U_MISPLACED_QUANTIFIER, "A quantifier appears after a segment close delimiter"); _setMsg(messages, U_MISSING_OPERATOR, "A rule contains no operator"); _setMsg(messages, U_MISSING_SEGMENT_CLOSE, "UNUSED as of ICU 2.4"); _setMsg(messages, U_MULTIPLE_ANTE_CONTEXTS, "More than one ante context"); _setMsg(messages, U_MULTIPLE_CURSORS, "More than one cursor"); _setMsg(messages, U_MULTIPLE_POST_CONTEXTS, "More than one post context"); _setMsg(messages, U_TRAILING_BACKSLASH, "A dangling backslash"); _setMsg(messages, U_UNDEFINED_SEGMENT_REFERENCE, "A segment reference does not correspond to a defined segment"); _setMsg(messages, U_UNDEFINED_VARIABLE, "A variable reference does not correspond to a defined variable"); _setMsg(messages, U_UNQUOTED_SPECIAL, "A special character was not quoted or escaped"); _setMsg(messages, U_UNTERMINATED_QUOTE, "A closing single quote is missing"); _setMsg(messages, U_RULE_MASK_ERROR, "A rule is hidden by an earlier more general rule"); _setMsg(messages, U_MISPLACED_COMPOUND_FILTER, "A compound filter is in an invalid location"); _setMsg(messages, U_MULTIPLE_COMPOUND_FILTERS, "More than one compound filter"); _setMsg(messages, U_INVALID_RBT_SYNTAX, "A '::id' rule was passed to the RuleBasedTransliterator parser"); _setMsg(messages, U_INVALID_PROPERTY_PATTERN, "UNUSED as of ICU 2.4"); _setMsg(messages, U_MALFORMED_PRAGMA, "A 'use' pragma is invalid"); _setMsg(messages, U_UNCLOSED_SEGMENT, "A closing ')' is missing"); _setMsg(messages, U_ILLEGAL_CHAR_IN_SEGMENT, "UNUSED as of ICU 2.4"); _setMsg(messages, U_VARIABLE_RANGE_EXHAUSTED, "Too many stand-ins generated for the given variable range"); _setMsg(messages, U_VARIABLE_RANGE_OVERLAP, "The variable range overlaps characters used in rules"); _setMsg(messages, U_ILLEGAL_CHARACTER, "A special character is outside its allowed context"); _setMsg(messages, U_INTERNAL_TRANSLITERATOR_ERROR, "Internal transliterator system error"); _setMsg(messages, U_INVALID_ID, "A '::id' rule specifies an unknown transliterator"); _setMsg(messages, U_INVALID_FUNCTION, "A '&fn()' rule specifies an unknown transliterator"); _setMsg(messages, U_PARSE_ERROR_LIMIT, "The limit for Transliterator errors"); _setMsg(messages, U_UNEXPECTED_TOKEN, "Syntax error in format pattern"); _setMsg(messages, U_FMT_PARSE_ERROR_START, "Start of format library errors"); _setMsg(messages, U_MULTIPLE_DECIMAL_SEPARATORS, "More than one decimal separator in number pattern"); _setMsg(messages, U_MULTIPLE_EXPONENTIAL_SYMBOLS, "More than one exponent symbol in number pattern"); _setMsg(messages, U_MALFORMED_EXPONENTIAL_PATTERN, "Grouping symbol in exponent pattern"); _setMsg(messages, U_MULTIPLE_PERCENT_SYMBOLS, "More than one percent symbol in number pattern"); _setMsg(messages, U_MULTIPLE_PERMILL_SYMBOLS, "More than one permill symbol in number pattern"); _setMsg(messages, U_MULTIPLE_PAD_SPECIFIERS, "More than one pad symbol in number pattern"); _setMsg(messages, U_PATTERN_SYNTAX_ERROR, "Syntax error in format pattern"); _setMsg(messages, U_ILLEGAL_PAD_POSITION, "Pad symbol misplaced in number pattern"); _setMsg(messages, U_UNMATCHED_BRACES, "Braces do not match in message pattern"); _setMsg(messages, U_UNSUPPORTED_PROPERTY, "UNUSED as of ICU 2.4"); _setMsg(messages, U_UNSUPPORTED_ATTRIBUTE, "UNUSED as of ICU 2.4"); _setMsg(messages, U_FMT_PARSE_ERROR_LIMIT, "The limit for format library errors"); _setMsg(messages, U_BRK_ERROR_START, "Start of codes indicating Break Iterator failures"); _setMsg(messages, U_BRK_INTERNAL_ERROR, "An internal error (bug) was detected."); _setMsg(messages, U_BRK_HEX_DIGITS_EXPECTED, "Hex digits expected as part of a escaped char in a rule."); _setMsg(messages, U_BRK_SEMICOLON_EXPECTED, "Missing ';' at the end of a RBBI rule."); _setMsg(messages, U_BRK_RULE_SYNTAX, "Syntax error in RBBI rule."); _setMsg(messages, U_BRK_UNCLOSED_SET, "UnicodeSet witing an RBBI rule missing a closing ']'."); _setMsg(messages, U_BRK_ASSIGN_ERROR, "Syntax error in RBBI rule assignment statement."); _setMsg(messages, U_BRK_VARIABLE_REDFINITION, "RBBI rule $Variable redefined."); _setMsg(messages, U_BRK_MISMATCHED_PAREN, "Mis-matched parentheses in an RBBI rule."); _setMsg(messages, U_BRK_NEW_LINE_IN_QUOTED_STRING, "Missing closing quote in an RBBI rule."); _setMsg(messages, U_BRK_UNDEFINED_VARIABLE, "Use of an undefined $Variable in an RBBI rule."); _setMsg(messages, U_BRK_INIT_ERROR, "Initialization failure. Probable missing ICU Data."); _setMsg(messages, U_BRK_RULE_EMPTY_SET, "Rule contains an empty Unicode Set."); _setMsg(messages, U_BRK_UNRECOGNIZED_OPTION, "!!option in RBBI rules not recognized."); _setMsg(messages, U_BRK_MALFORMED_RULE_TAG, "The {nnn} tag on a rule is mal formed"); _setMsg(messages, U_BRK_ERROR_LIMIT, "This must always be the last value to indicate the limit for Break Iterator failures"); _setMsg(messages, U_REGEX_ERROR_START, "Start of codes indicating Regexp failures"); _setMsg(messages, U_REGEX_INTERNAL_ERROR, "An internal error (bug) was detected."); _setMsg(messages, U_REGEX_RULE_SYNTAX, "Syntax error in regexp pattern."); _setMsg(messages, U_REGEX_INVALID_STATE, "RegexMatcher in invalid state for requested operation"); _setMsg(messages, U_REGEX_BAD_ESCAPE_SEQUENCE, "Unrecognized backslash escape sequence in pattern"); _setMsg(messages, U_REGEX_PROPERTY_SYNTAX, "Incorrect Unicode property"); _setMsg(messages, U_REGEX_UNIMPLEMENTED, "Use of regexp feature that is not yet implemented."); _setMsg(messages, U_REGEX_MISMATCHED_PAREN, "Incorrectly nested parentheses in regexp pattern."); _setMsg(messages, U_REGEX_NUMBER_TOO_BIG, "Decimal number is too large."); _setMsg(messages, U_REGEX_BAD_INTERVAL, "Error in {min,max} interval"); _setMsg(messages, U_REGEX_MAX_LT_MIN, "In {min,max}, max is less than min."); _setMsg(messages, U_REGEX_INVALID_BACK_REF, "Back-reference to a non-existent capture group."); _setMsg(messages, U_REGEX_INVALID_FLAG, "Invalid value for match mode flags."); _setMsg(messages, U_REGEX_LOOK_BEHIND_LIMIT, "Look-Behind pattern matches must have a bounded maximum length."); _setMsg(messages, U_REGEX_SET_CONTAINS_STRING, "Regexps cannot have UnicodeSets containing strings."); _setMsg(messages, U_REGEX_ERROR_LIMIT, "This must always be the last value to indicate the limit for regexp errors"); _setMsg(messages, U_ERROR_LIMIT, "This must always be the last value to indicate the limit for UErrorCode (last error code +1)"); } void _init_errors(PyObject *m) { PyObject *messages = PyObject_GetAttrString(PyExc_ICUError, "messages"); registerErrors(messages); Py_DECREF(messages); } PyICU-1.9.5/errors.h0000644000076500000000000000255011323445344014354 0ustar vajdawheel00000000000000/* ==================================================================== * Copyright (c) 2004-2010 Open Source Applications Foundation. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. * ==================================================================== */ #ifndef _errors_h #define _errors_h void _init_errors(PyObject *m); #endif /* _errors_h */ PyICU-1.9.5/format.cpp0000644000076500000000000014547412520066346014701 0ustar vajdawheel00000000000000/* ==================================================================== * Copyright (c) 2004-2014 Open Source Applications Foundation. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. * ==================================================================== */ #include "common.h" #include "structmember.h" #include "bases.h" #include "locale.h" #include "format.h" #include "macros.h" #include "dateformat.h" #include "numberformat.h" #if U_ICU_VERSION_HEX >= 0x04080000 DECLARE_CONSTANTS_TYPE(UTimeUnitFormatStyle); #endif /* FieldPosition */ class t_fieldposition : public _wrapper { public: FieldPosition *object; }; static int t_fieldposition_init(t_fieldposition *self, PyObject *args, PyObject *kwds); static PyObject *t_fieldposition_getField(t_fieldposition *self); static PyObject *t_fieldposition_setField(t_fieldposition *self, PyObject *arg); static PyObject *t_fieldposition_getBeginIndex(t_fieldposition *self); static PyObject *t_fieldposition_setBeginIndex(t_fieldposition *self, PyObject *arg); static PyObject *t_fieldposition_getEndIndex(t_fieldposition *self); static PyObject *t_fieldposition_setEndIndex(t_fieldposition *self, PyObject *arg); static PyMethodDef t_fieldposition_methods[] = { DECLARE_METHOD(t_fieldposition, getField, METH_NOARGS), DECLARE_METHOD(t_fieldposition, setField, METH_O), DECLARE_METHOD(t_fieldposition, getBeginIndex, METH_NOARGS), DECLARE_METHOD(t_fieldposition, setBeginIndex, METH_O), DECLARE_METHOD(t_fieldposition, getEndIndex, METH_NOARGS), DECLARE_METHOD(t_fieldposition, setEndIndex, METH_O), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(FieldPosition, t_fieldposition, UObject, FieldPosition, t_fieldposition_init, NULL); /* ParsePosition */ class t_parseposition : public _wrapper { public: ParsePosition *object; }; static int t_parseposition_init(t_parseposition *self, PyObject *args, PyObject *kwds); static PyObject *t_parseposition_getIndex(t_parseposition *self); static PyObject *t_parseposition_setIndex(t_parseposition *self, PyObject *arg); static PyObject *t_parseposition_getErrorIndex(t_parseposition *self); static PyObject *t_parseposition_setErrorIndex(t_parseposition *self, PyObject *arg); static PyMethodDef t_parseposition_methods[] = { DECLARE_METHOD(t_parseposition, getIndex, METH_NOARGS), DECLARE_METHOD(t_parseposition, setIndex, METH_O), DECLARE_METHOD(t_parseposition, getErrorIndex, METH_NOARGS), DECLARE_METHOD(t_parseposition, setErrorIndex, METH_O), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(ParsePosition, t_parseposition, UObject, ParsePosition, t_parseposition_init, NULL); /* Format */ PyObject *t_format_format(t_format *self, PyObject *args); static PyObject *t_format_parseObject(t_format *self, PyObject *args); static PyObject *t_format_getLocale(t_format *self, PyObject *args); static PyObject *t_format_getLocaleID(t_format *self, PyObject *args); static PyMethodDef t_format_methods[] = { DECLARE_METHOD(t_format, format, METH_VARARGS), DECLARE_METHOD(t_format, parseObject, METH_VARARGS), DECLARE_METHOD(t_format, getLocale, METH_VARARGS), DECLARE_METHOD(t_format, getLocaleID, METH_VARARGS), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(Format, t_format, UObject, Format, abstract_init, NULL); /* MeasureFormat */ class t_measureformat : public _wrapper { public: MeasureFormat *object; PyObject *locale; }; static PyObject *t_measureformat_createCurrencyFormat(PyTypeObject *type, PyObject *args); static PyMethodDef t_measureformat_methods[] = { DECLARE_METHOD(t_measureformat, createCurrencyFormat, METH_VARARGS | METH_CLASS), { NULL, NULL, 0, NULL } }; static void t_measureformat_dealloc(t_measureformat *self) { if (self->flags & T_OWNED) delete self->object; self->object = NULL; Py_CLEAR(self->locale); Py_TYPE(self)->tp_free((PyObject *) self); } DECLARE_TYPE(MeasureFormat, t_measureformat, Format, MeasureFormat, abstract_init, t_measureformat_dealloc); #if U_ICU_VERSION_HEX >= 0x04020000 /* TimeUnitFormat */ class t_timeunitformat : public _wrapper { public: TimeUnitFormat *object; }; static int t_timeunitformat_init(t_timeunitformat *self, PyObject *args, PyObject *kwds); static PyObject *t_timeunitformat_setLocale(t_timeunitformat *self, PyObject *arg); static PyObject *t_timeunitformat_setNumberFormat(t_timeunitformat *self, PyObject *arg); static PyMethodDef t_timeunitformat_methods[] = { DECLARE_METHOD(t_timeunitformat, setLocale, METH_O), DECLARE_METHOD(t_timeunitformat, setNumberFormat, METH_O), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(TimeUnitFormat, t_timeunitformat, MeasureFormat, TimeUnitFormat, t_timeunitformat_init, NULL); #endif /* MessageFormat */ class t_messageformat : public _wrapper { public: MessageFormat *object; }; static int t_messageformat_init(t_messageformat *self, PyObject *args, PyObject *kwds); static PyObject *t_messageformat_getLocale(t_messageformat *self); static PyObject *t_messageformat_setLocale(t_messageformat *self, PyObject *arg); static PyObject *t_messageformat_applyPattern(t_messageformat *self, PyObject *arg); static PyObject *t_messageformat_toPattern(t_messageformat *self, PyObject *args); static PyObject *t_messageformat_getFormats(t_messageformat *self); static PyObject *t_messageformat_setFormats(t_messageformat *self, PyObject *arg); static PyObject *t_messageformat_setFormat(t_messageformat *self, PyObject *args); static PyObject *t_messageformat_format(t_messageformat *self, PyObject *args); static PyObject *t_messageformat_parse(t_messageformat *self, PyObject *args); static PyObject *t_messageformat_formatMessage(PyTypeObject *type, PyObject *args); static PyObject *t_messageformat_mod(t_messageformat *self, PyObject *args); static PyNumberMethods t_messageformat_as_number = { 0, /* nb_add */ 0, /* nb_subtract */ 0, /* nb_multiply */ 0, /* nb_divide */ (binaryfunc) t_messageformat_mod, /* nb_remainder */ }; static PyMethodDef t_messageformat_methods[] = { DECLARE_METHOD(t_messageformat, getLocale, METH_NOARGS), DECLARE_METHOD(t_messageformat, setLocale, METH_O), DECLARE_METHOD(t_messageformat, applyPattern, METH_O), DECLARE_METHOD(t_messageformat, toPattern, METH_VARARGS), DECLARE_METHOD(t_messageformat, getFormats, METH_NOARGS), DECLARE_METHOD(t_messageformat, setFormats, METH_O), DECLARE_METHOD(t_messageformat, setFormat, METH_VARARGS), DECLARE_METHOD(t_messageformat, format, METH_VARARGS), DECLARE_METHOD(t_messageformat, parse, METH_VARARGS), DECLARE_METHOD(t_messageformat, formatMessage, METH_VARARGS | METH_CLASS), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(MessageFormat, t_messageformat, Format, MessageFormat, t_messageformat_init, NULL); #if U_ICU_VERSION_HEX >= 0x04000000 /* PluralRules */ class t_pluralrules : public _wrapper { public: PluralRules *object; }; static int t_pluralrules_init(t_pluralrules *self, PyObject *args, PyObject *kwds); static PyObject *t_pluralrules_select(t_pluralrules *self, PyObject *arg); static PyObject *t_pluralrules_getKeywords(t_pluralrules *self); static PyObject *t_pluralrules_getKeywordOther(t_pluralrules *self); static PyObject *t_pluralrules_isKeyword(t_pluralrules *self, PyObject *arg); static PyObject *t_pluralrules_createRules(PyTypeObject *type, PyObject *arg); static PyObject *t_pluralrules_createDefaultRules(PyTypeObject *type); static PyObject *t_pluralrules_forLocale(PyTypeObject *type, PyObject *arg); static PyMethodDef t_pluralrules_methods[] = { DECLARE_METHOD(t_pluralrules, select, METH_O), DECLARE_METHOD(t_pluralrules, getKeywords, METH_NOARGS), DECLARE_METHOD(t_pluralrules, getKeywordOther, METH_NOARGS), DECLARE_METHOD(t_pluralrules, isKeyword, METH_O), DECLARE_METHOD(t_pluralrules, createRules, METH_O | METH_CLASS), DECLARE_METHOD(t_pluralrules, createDefaultRules, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_pluralrules, forLocale, METH_O | METH_CLASS), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(PluralRules, t_pluralrules, UObject, PluralRules, t_pluralrules_init, NULL); /* PluralFormat */ class t_pluralformat : public _wrapper { public: PluralFormat *object; PyObject *numberformat; }; static int t_pluralformat_init(t_pluralformat *self, PyObject *args, PyObject *kwds); static PyObject *t_pluralformat_setLocale(t_pluralformat *self, PyObject *arg); static PyObject *t_pluralformat_setNumberFormat(t_pluralformat *self, PyObject *arg); static PyObject *t_pluralformat_toPattern(t_pluralformat *self, PyObject *args); static PyObject *t_pluralformat_applyPattern(t_pluralformat *self, PyObject *arg); static PyObject *t_pluralformat_format(t_pluralformat *self, PyObject *args); static PyMethodDef t_pluralformat_methods[] = { DECLARE_METHOD(t_pluralformat, setLocale, METH_O), DECLARE_METHOD(t_pluralformat, setNumberFormat, METH_O), DECLARE_METHOD(t_pluralformat, toPattern, METH_VARARGS), DECLARE_METHOD(t_pluralformat, applyPattern, METH_O), DECLARE_METHOD(t_pluralformat, format, METH_VARARGS), { NULL, NULL, 0, NULL } }; static void t_pluralformat_dealloc(t_pluralformat *self) { if (self->flags & T_OWNED) delete self->object; self->object = NULL; Py_CLEAR(self->numberformat); Py_TYPE(self)->tp_free((PyObject *) self); } DECLARE_TYPE(PluralFormat, t_pluralformat, Format, PluralFormat, t_pluralformat_init, t_pluralformat_dealloc); #endif #if U_ICU_VERSION_HEX >= 0x04040000 /* SelectFormat */ class t_selectformat : public _wrapper { public: SelectFormat *object; }; static int t_selectformat_init(t_selectformat *self, PyObject *args, PyObject *kwds); static PyObject *t_selectformat_applyPattern(t_selectformat *self, PyObject *arg); static PyObject *t_selectformat_toPattern(t_selectformat *self, PyObject *args); static PyObject *t_selectformat_format(t_selectformat *self, PyObject *args); static PyObject *t_selectformat_parseObject(t_selectformat *self, PyObject *args); static PyMethodDef t_selectformat_methods[] = { DECLARE_METHOD(t_selectformat, applyPattern, METH_O), DECLARE_METHOD(t_selectformat, toPattern, METH_VARARGS), DECLARE_METHOD(t_selectformat, format, METH_VARARGS), DECLARE_METHOD(t_selectformat, parseObject, METH_VARARGS), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(SelectFormat, t_selectformat, Format, SelectFormat, t_selectformat_init, NULL); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(50, 0, 0) class t_listformatter : public _wrapper { public: ListFormatter *object; }; static PyObject *t_listformatter_format(t_listformatter *self, PyObject *arg); static PyObject *t_listformatter_createInstance(PyTypeObject *type, PyObject *args); static PyMethodDef t_listformatter_methods[] = { DECLARE_METHOD(t_listformatter, format, METH_O), DECLARE_METHOD(t_listformatter, createInstance, METH_VARARGS | METH_CLASS), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(ListFormatter, t_listformatter, UObject, ListFormatter, abstract_init, NULL); #endif /* FieldPosition */ static int t_fieldposition_init(t_fieldposition *self, PyObject *args, PyObject *kwds) { int i; switch (PyTuple_Size(args)) { case 0: self->object = new FieldPosition(); self->flags = T_OWNED; break; case 1: if (!parseArgs(args, "i", &i)) { self->object = new FieldPosition(i); self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; default: PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; } if (self->object) return 0; return -1; } static PyObject *t_fieldposition_getField(t_fieldposition *self) { return PyInt_FromLong(self->object->getField()); } static PyObject *t_fieldposition_setField(t_fieldposition *self, PyObject *arg) { int i; if (!parseArg(arg, "i", &i)) { self->object->setField(i); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setField", arg); } static PyObject *t_fieldposition_getBeginIndex(t_fieldposition *self) { return PyInt_FromLong(self->object->getBeginIndex()); } static PyObject *t_fieldposition_setBeginIndex(t_fieldposition *self, PyObject *arg) { int i; if (!parseArg(arg, "i", &i)) { self->object->setBeginIndex(i); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setBeginIndex", arg); } static PyObject *t_fieldposition_getEndIndex(t_fieldposition *self) { return PyInt_FromLong(self->object->getEndIndex()); } static PyObject *t_fieldposition_setEndIndex(t_fieldposition *self, PyObject *arg) { int i; if (!parseArg(arg, "i", &i)) { self->object->setEndIndex(i); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setEndIndex", arg); } static PyObject *t_fieldposition_richcmp(t_fieldposition *self, PyObject *arg, int op) { int b = 0; FieldPosition *i; if (!parseArg(arg, "P", TYPE_CLASSID(FieldPosition), &i)) { switch (op) { case Py_EQ: case Py_NE: b = *self->object == *i; if (op == Py_EQ) Py_RETURN_BOOL(b); Py_RETURN_BOOL(!b); case Py_LT: case Py_LE: case Py_GT: case Py_GE: PyErr_SetNone(PyExc_NotImplementedError); return NULL; } } return PyErr_SetArgsError((PyObject *) self, "__richcmp__", arg); } /* ParsePosition */ static int t_parseposition_init(t_parseposition *self, PyObject *args, PyObject *kwds) { int i; switch (PyTuple_Size(args)) { case 0: self->object = new ParsePosition(); self->flags = T_OWNED; break; case 1: if (!parseArgs(args, "i", &i)) { self->object = new ParsePosition(i); self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; default: PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; } if (self->object) return 0; return -1; } static PyObject *t_parseposition_getIndex(t_parseposition *self) { return PyInt_FromLong(self->object->getIndex()); } static PyObject *t_parseposition_setIndex(t_parseposition *self, PyObject *arg) { int i; if (!parseArg(arg, "i", &i)) { self->object->setIndex(i); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setIndex", arg); } static PyObject *t_parseposition_getErrorIndex(t_parseposition *self) { return PyInt_FromLong(self->object->getErrorIndex()); } static PyObject *t_parseposition_setErrorIndex(t_parseposition *self, PyObject *arg) { int i; if (!parseArg(arg, "i", &i)) { self->object->setErrorIndex(i); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setErrorIndex", arg); } static PyObject *t_parseposition_richcmp(t_parseposition *self, PyObject *arg, int op) { int b = 0; ParsePosition *i; if (!parseArg(arg, "P", TYPE_CLASSID(ParsePosition), &i)) { switch (op) { case Py_EQ: case Py_NE: b = *self->object == *i; if (op == Py_EQ) Py_RETURN_BOOL(b); Py_RETURN_BOOL(!b); case Py_LT: case Py_LE: case Py_GT: case Py_GE: PyErr_SetNone(PyExc_NotImplementedError); return NULL; } } return PyErr_SetArgsError((PyObject *) self, "__richcmp__", arg); } /* Format */ PyObject *t_format_format(t_format *self, PyObject *args) { UnicodeString *u; UnicodeString _u; Formattable *obj; FieldPosition *fp; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "P", TYPE_CLASSID(Formattable), &obj)) { STATUS_CALL(self->object->format(*obj, _u, status)); return PyUnicode_FromUnicodeString(&_u); } break; case 2: if (!parseArgs(args, "PU", TYPE_CLASSID(Formattable), &obj, &u)) { STATUS_CALL(self->object->format(*obj, *u, status)); Py_RETURN_ARG(args, 1); } if (!parseArgs(args, "PP", TYPE_CLASSID(Formattable), TYPE_CLASSID(FieldPosition), &obj, &fp)) { STATUS_CALL(self->object->format(*obj, _u, *fp, status)); return PyUnicode_FromUnicodeString(&_u); } break; case 3: if (!parseArgs(args, "PUP", TYPE_CLASSID(Formattable), TYPE_CLASSID(FieldPosition), &obj, &u, &fp)) { STATUS_CALL(self->object->format(*obj, *u, *fp, status)); Py_RETURN_ARG(args, 1); } break; } return PyErr_SetArgsError((PyObject *) self, "format", args); } static PyObject *t_format_parseObject(t_format *self, PyObject *args) { UnicodeString *u; UnicodeString _u; Formattable obj; ParsePosition *pp; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "S", &u, &_u)) { STATUS_CALL(self->object->parseObject(*u, obj, status)); return wrap_Formattable(obj); } break; case 2: if (!parseArgs(args, "SP", TYPE_CLASSID(ParsePosition), &u, &_u, &pp)) { pp->setErrorIndex(-1); self->object->parseObject(*u, obj, *pp); if (pp->getErrorIndex() != -1) Py_RETURN_NONE; return wrap_Formattable(obj); } break; } return PyErr_SetArgsError((PyObject *) self, "parseObject", args); } static PyObject *t_format_getLocale(t_format *self, PyObject *args) { ULocDataLocaleType type; Locale locale; switch (PyTuple_Size(args)) { case 0: STATUS_CALL(locale = self->object->getLocale(ULOC_VALID_LOCALE, status)); return wrap_Locale(locale); case 1: if (!parseArgs(args, "i", &type)) { STATUS_CALL(locale = self->object->getLocale(type, status)); return wrap_Locale(locale); } break; } return PyErr_SetArgsError((PyObject *) self, "getLocale", args); } static PyObject *t_format_getLocaleID(t_format *self, PyObject *args) { ULocDataLocaleType type; const char *id; switch (PyTuple_Size(args)) { case 0: STATUS_CALL(id = self->object->getLocaleID(ULOC_VALID_LOCALE, status)); return PyString_FromString(id); case 1: if (!parseArgs(args, "i", &type)) { STATUS_CALL(id = self->object->getLocaleID(type, status)); return PyString_FromString(id); } break; } return PyErr_SetArgsError((PyObject *) self, "getLocaleID", args); } static PyObject *t_format_richcmp(t_format *self, PyObject *arg, int op) { int b = 0; Format *i; if (!parseArg(arg, "P", TYPE_ID(Format), &i)) { switch (op) { case Py_EQ: case Py_NE: b = *self->object == *i; if (op == Py_EQ) Py_RETURN_BOOL(b); Py_RETURN_BOOL(!b); case Py_LT: case Py_LE: case Py_GT: case Py_GE: PyErr_SetNone(PyExc_NotImplementedError); return NULL; } } return PyErr_SetArgsError((PyObject *) self, "__richcmp__", arg); } /* MeasureFormat */ static PyObject *t_measureformat_createCurrencyFormat(PyTypeObject *type, PyObject *args) { MeasureFormat *format; Locale *locale; PyObject *localeObj = NULL; switch (PyTuple_Size(args)) { case 0: STATUS_CALL(format = MeasureFormat::createCurrencyFormat(status)); return wrap_MeasureFormat(format, T_OWNED); case 1: if (!parseArgs(args, "p", TYPE_CLASSID(Locale), &locale, &localeObj)) { UErrorCode status = U_ZERO_ERROR; MeasureFormat *format = MeasureFormat::createCurrencyFormat(*locale, status); if (U_FAILURE(status)) { Py_XDECREF(localeObj); return ICUException(status).reportError(); } PyObject *result = wrap_MeasureFormat(format, T_OWNED); t_measureformat *self = (t_measureformat *) result; self->locale = localeObj; return result; } break; } return PyErr_SetArgsError(type, "createCurrencyFormat", args); } #if U_ICU_VERSION_HEX >= 0x04020000 /* TimeUnitFormat */ static int t_timeunitformat_init(t_timeunitformat *self, PyObject *args, PyObject *kwds) { #if U_ICU_VERSION_HEX >= 0x04080000 UTimeUnitFormatStyle style; #else TimeUnitFormat::EStyle style; #endif Locale *locale; switch (PyTuple_Size(args)) { case 0: INT_STATUS_CALL(self->object = new TimeUnitFormat(status)); self->flags = T_OWNED; break; case 1: if (!parseArgs(args, "P", TYPE_CLASSID(Locale), &locale)) { INT_STATUS_CALL(self->object = new TimeUnitFormat(*locale, status)); self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; case 2: if (!parseArgs(args, "Pi", TYPE_CLASSID(Locale), &locale, &style)) { INT_STATUS_CALL(self->object = new TimeUnitFormat(*locale, style, status)); self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; default: PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; } if (self->object) return 0; return -1; } static PyObject *t_timeunitformat_setLocale(t_timeunitformat *self, PyObject *arg) { Locale *locale; if (!parseArg(arg, "P", TYPE_CLASSID(Locale), &locale)) { STATUS_CALL(self->object->setLocale(*locale, status)); /* copied */ Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setLocale", arg); } static PyObject *t_timeunitformat_setNumberFormat(t_timeunitformat *self, PyObject *arg) { NumberFormat *format; if (!parseArg(arg, "P", TYPE_CLASSID(NumberFormat), &format)) /* copied */ { STATUS_CALL(self->object->setNumberFormat(*format, status)); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setNumberFormat", arg); } #endif /* MessageFormat */ static int t_messageformat_init(t_messageformat *self, PyObject *args, PyObject *kwds) { UnicodeString *u, _u; Locale *locale; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "S", &u, &_u)) { MessageFormat *format; INT_STATUS_CALL(format = new MessageFormat(*u, status)); self->object = format; self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; case 2: if (!parseArgs(args, "SP", TYPE_CLASSID(Locale), &u, &_u, &locale)) { MessageFormat *format; INT_STATUS_PARSER_CALL(format = new MessageFormat(*u, *locale, parseError, status)); self->object = format; self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; default: PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; } if (self->object) return 0; return -1; } static PyObject *t_messageformat_getLocale(t_messageformat *self) { return wrap_Locale(self->object->getLocale()); } static PyObject *t_messageformat_setLocale(t_messageformat *self, PyObject *arg) { Locale *locale; if (!parseArg(arg, "P", TYPE_CLASSID(Locale), &locale)) { self->object->setLocale(*locale); /* copied */ Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setLocale", arg); } static PyObject *t_messageformat_applyPattern(t_messageformat *self, PyObject *arg) { UnicodeString *u, _u; if (!parseArg(arg, "S", &u, &_u)) { STATUS_PARSER_CALL(self->object->applyPattern(*u, parseError, status)); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "applyPattern", arg); } static PyObject *t_messageformat_toPattern(t_messageformat *self, PyObject *args) { UnicodeString *u, _u; switch (PyTuple_Size(args)) { case 0: self->object->toPattern(_u); return PyUnicode_FromUnicodeString(&_u); case 1: if (!parseArgs(args, "U", &u)) { self->object->toPattern(*u); Py_RETURN_ARG(args, 0); } break; } return PyErr_SetArgsError((PyObject *) self, "toPattern", args); } PyObject *wrap_Format(Format *format) { RETURN_WRAPPED_IF_ISINSTANCE(format, SimpleDateFormat); RETURN_WRAPPED_IF_ISINSTANCE(format, MessageFormat); #if U_ICU_VERSION_HEX >= 0x04000000 RETURN_WRAPPED_IF_ISINSTANCE(format, PluralFormat); #endif #if U_ICU_VERSION_HEX >= 0x04020000 RETURN_WRAPPED_IF_ISINSTANCE(format, TimeUnitFormat); #endif #if U_ICU_VERSION_HEX >= 0x04040000 RETURN_WRAPPED_IF_ISINSTANCE(format, SelectFormat); #endif RETURN_WRAPPED_IF_ISINSTANCE(format, ChoiceFormat); RETURN_WRAPPED_IF_ISINSTANCE(format, DecimalFormat); RETURN_WRAPPED_IF_ISINSTANCE(format, RuleBasedNumberFormat); return wrap_Format(format, T_OWNED); } static PyObject *t_messageformat_getFormats(t_messageformat *self) { int count; const Format **formats = self->object->getFormats(count); PyObject *list = PyList_New(count); for (int i = 0; i < count; i++) { PyObject *obj = wrap_Format(formats[i]->clone()); PyList_SET_ITEM(list, i, obj); } return list; } static PyObject *t_messageformat_setFormats(t_messageformat *self, PyObject *arg) { const Format **formats; int len; if (!parseArg(arg, "Q", TYPE_ID(Format), &formats, &len, TYPE_ID(Format))) { self->object->setFormats(formats, len); /* copied */ free(formats); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setFormats", arg); } static PyObject *t_messageformat_setFormat(t_messageformat *self, PyObject *args) { Format *format; int i; if (!parseArgs(args, "iP", TYPE_ID(Format), &i, &format)) { self->object->setFormat(i, *format); /* copied */ Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setFormat", args); } static PyObject *t_messageformat_format(t_messageformat *self, PyObject *args) { Formattable *f; UnicodeString *u, _u; FieldPosition *fp, _fp; int len, u_len; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "R", TYPE_CLASSID(Formattable), &f, &len, TYPE_CLASSID(Formattable), toFormattableArray)) { STATUS_CALL( { self->object->format(f, len, _u, _fp, status); delete[] f; }); return PyUnicode_FromUnicodeString(&_u); } break; case 2: if (!parseArgs(args, "RP", TYPE_CLASSID(Formattable), TYPE_CLASSID(FieldPosition), &f, &len, TYPE_CLASSID(Formattable), toFormattableArray, &fp)) { STATUS_CALL( { self->object->format(f, len, _u, *fp, status); delete[] f; }); return PyUnicode_FromUnicodeString(&_u); } if (!parseArgs(args, "RU", TYPE_CLASSID(Formattable), &f, &len, TYPE_CLASSID(Formattable), toFormattableArray, &u)) { STATUS_CALL( { self->object->format(f, len, *u, _fp, status); delete[] f; }); Py_RETURN_ARG(args, 1); } #if U_ICU_VERSION_HEX >= VERSION_HEX(4, 0, 0) if (!parseArgs(args, "TR", TYPE_CLASSID(Formattable), &u, &u_len, &f, &len, TYPE_CLASSID(Formattable), toFormattableArray)) { STATUS_CALL( { self->object->format(u, f, len < u_len ? len : u_len, _u, status); delete[] u; delete[] f; }); return PyUnicode_FromUnicodeString(&_u); } #endif break; case 3: if (!parseArgs(args, "RUP", TYPE_CLASSID(Formattable), TYPE_CLASSID(FieldPosition), &f, &len, TYPE_CLASSID(Formattable), toFormattableArray, &u, &fp)) { STATUS_CALL( { self->object->format(f, len, *u, *fp, status); delete[] f; }); Py_RETURN_ARG(args, 1); } break; } return t_format_format((t_format *) self, args); } static PyObject *fromFormattableArray(Formattable *formattables, int len, int dispose) { PyObject *list = PyList_New(len); for (int i = 0; i < len; i++) PyList_SET_ITEM(list, i, wrap_Formattable(formattables[i])); if (dispose) delete formattables; return list; } static PyObject *t_messageformat_parse(t_messageformat *self, PyObject *args) { Formattable *f; int len; UnicodeString *u; UnicodeString _u; ParsePosition *pp; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "S", &u, &_u)) { STATUS_CALL(f = self->object->parse(*u, len, status)); return fromFormattableArray(f, len, 1); } break; case 2: if (!parseArgs(args, "SP", TYPE_CLASSID(ParsePosition), &u, &_u, &pp)) { pp->setErrorIndex(-1); f = self->object->parse(*u, *pp, len); if (pp->getErrorIndex() != -1) Py_RETURN_NONE; return fromFormattableArray(f, len, 1); } break; } return PyErr_SetArgsError((PyObject *) self, "parse", args); } static PyObject *t_messageformat_formatMessage(PyTypeObject *type, PyObject *args) { Formattable *f; int len; UnicodeString *u, *v; UnicodeString _u, _v; switch (PyTuple_Size(args)) { case 2: if (!parseArgs(args, "SR", TYPE_CLASSID(Formattable), &u, &_u, &f, &len, TYPE_CLASSID(Formattable), toFormattableArray)) { STATUS_CALL( { MessageFormat::format(*u, f, len, _v, status); delete[] f; }); return PyUnicode_FromUnicodeString(&_v); } break; case 3: if (!parseArgs(args, "SRU", TYPE_CLASSID(Formattable), &u, &_u, &f, &len, TYPE_CLASSID(Formattable), toFormattableArray, &v)) { STATUS_CALL( { MessageFormat::format(*u, f, len, *v, status); delete[] f; }); Py_RETURN_ARG(args, 2); } break; } return PyErr_SetArgsError(type, "formatMessage", args); } static PyObject *t_messageformat_str(t_messageformat *self) { UnicodeString u; self->object->toPattern(u); return PyUnicode_FromUnicodeString(&u); } static PyObject *t_messageformat_mod(t_messageformat *self, PyObject *args) { int len; Formattable *f = toFormattableArray(args, &len, TYPE_CLASSID(Formattable)); UnicodeString _u; FieldPosition _fp; if (!f) { PyErr_SetObject(PyExc_TypeError, args); return NULL; } STATUS_CALL( { self->object->format(f, len, _u, _fp, status); delete[] f; }); return PyUnicode_FromUnicodeString(&_u); } #if U_ICU_VERSION_HEX >= 0x04000000 /* PluralRules */ static int t_pluralrules_init(t_pluralrules *self, PyObject *args, PyObject *kwds) { if (PyTuple_Size(args) == 0) { INT_STATUS_CALL(self->object = new PluralRules(status)); self->flags = T_OWNED; return 0; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; } static PyObject *t_pluralrules_select(t_pluralrules *self, PyObject *arg) { UnicodeString u; int32_t n; double d; if (!parseArg(arg, "i", &n)) u = self->object->select(n); else if (!parseArg(arg, "d", &d)) u = self->object->select(d); else return PyErr_SetArgsError((PyObject *) self, "select", arg); return PyUnicode_FromUnicodeString(&u); } static PyObject *t_pluralrules_getKeywords(t_pluralrules *self) { StringEnumeration *se; STATUS_CALL(se = self->object->getKeywords(status)); return wrap_StringEnumeration(se, T_OWNED); } static PyObject *t_pluralrules_getKeywordOther(t_pluralrules *self) { UnicodeString u = self->object->getKeywordOther(); return PyUnicode_FromUnicodeString(&u); } static PyObject *t_pluralrules_isKeyword(t_pluralrules *self, PyObject *arg) { UnicodeString *u, _u; if (!parseArg(arg, "S", &u, &_u)) { UBool b = self->object->isKeyword(*u); Py_RETURN_BOOL(b); } return PyErr_SetArgsError((PyObject *) self, "isKeyword", arg); } static PyObject *t_pluralrules_createRules(PyTypeObject *type, PyObject *arg) { UnicodeString *u, _u; if (!parseArg(arg, "S", &u, &_u)) { PluralRules *rules; STATUS_CALL(rules = PluralRules::createRules(*u, status)); return wrap_PluralRules(rules, T_OWNED); } return PyErr_SetArgsError(type, "createRules", arg); } static PyObject *t_pluralrules_createDefaultRules(PyTypeObject *type) { PluralRules *rules; STATUS_CALL(rules = PluralRules::createDefaultRules(status)); return wrap_PluralRules(rules, T_OWNED); } static PyObject *t_pluralrules_forLocale(PyTypeObject *type, PyObject *arg) { Locale *locale; if (!parseArg(arg, "P", TYPE_CLASSID(Locale), &locale)) { PluralRules *rules; STATUS_CALL(rules = PluralRules::forLocale(*locale, status)); return wrap_PluralRules(rules, T_OWNED); } return PyErr_SetArgsError(type, "forLocale", arg); } static PyObject *t_pluralrules_richcmp(t_pluralrules *self, PyObject *arg, int op) { int b = 0; PluralRules *rules; if (!parseArg(arg, "P", TYPE_CLASSID(PluralRules), &rules)) { switch (op) { case Py_EQ: case Py_NE: b = *self->object == *rules; if (op == Py_EQ) Py_RETURN_BOOL(b); Py_RETURN_BOOL(!b); case Py_LT: case Py_LE: case Py_GT: case Py_GE: PyErr_SetNone(PyExc_NotImplementedError); return NULL; } } return PyErr_SetArgsError((PyObject *) self, "__richcmp__", arg); } /* PluralFormat */ static int t_pluralformat_init(t_pluralformat *self, PyObject *args, PyObject *kwds) { Locale *locale; PluralRules *rules; UnicodeString *u, _u; switch (PyTuple_Size(args)) { case 0: INT_STATUS_CALL(self->object = new PluralFormat(status)); self->flags = T_OWNED; break; case 1: if (!parseArgs(args, "P", TYPE_CLASSID(Locale), &locale)) { INT_STATUS_CALL(self->object = new PluralFormat(*locale, status)); self->flags = T_OWNED; break; } if (!parseArgs(args, "P", TYPE_CLASSID(PluralRules), &rules)) { INT_STATUS_CALL(self->object = new PluralFormat(*rules, status)); self->flags = T_OWNED; break; } if (!parseArgs(args, "S", &u, &_u)) { INT_STATUS_CALL(self->object = new PluralFormat(*u, status)); self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; case 2: if (!parseArgs(args, "PP", TYPE_CLASSID(Locale), TYPE_CLASSID(PluralRules), &locale, &rules)) { INT_STATUS_CALL(self->object = new PluralFormat(*locale, *rules, status)); self->flags = T_OWNED; break; } if (!parseArgs(args, "PS", TYPE_CLASSID(Locale), &locale, &u, &_u)) { INT_STATUS_CALL(self->object = new PluralFormat(*locale, *u, status)); self->flags = T_OWNED; break; } if (!parseArgs(args, "PS", TYPE_CLASSID(PluralRules), &rules, &u, &_u)) { INT_STATUS_CALL(self->object = new PluralFormat(*rules, *u, status)); self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; case 3: if (!parseArgs(args, "PPS", TYPE_CLASSID(Locale), TYPE_CLASSID(PluralRules), &locale, &rules, &u, &_u)) { INT_STATUS_CALL(self->object = new PluralFormat(*locale, *rules, *u, status)); self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; default: PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; } if (self->object) return 0; return -1; } static PyObject *t_pluralformat_setLocale(t_pluralformat *self, PyObject *arg) { Locale *locale; if (!parseArg(arg, "P", TYPE_CLASSID(Locale), &locale)) { STATUS_CALL(self->object->setLocale(*locale, status)); /* copied */ Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setLocale", arg); } static PyObject *t_pluralformat_setNumberFormat(t_pluralformat *self, PyObject *arg) { NumberFormat *format; if (!parseArg(arg, "p", TYPE_CLASSID(NumberFormat), &format, &self->numberformat)) /* ref'd */ { STATUS_CALL(self->object->setNumberFormat(format, status)); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setNumberFormat", arg); } static PyObject *t_pluralformat_toPattern(t_pluralformat *self, PyObject *args) { UnicodeString *u, _u; switch (PyTuple_Size(args)) { case 0: self->object->toPattern(_u); return PyUnicode_FromUnicodeString(&_u); case 1: if (!parseArgs(args, "U", &u)) { self->object->toPattern(*u); Py_RETURN_ARG(args, 0); } break; } return PyErr_SetArgsError((PyObject *) self, "toPattern", args); } static PyObject *t_pluralformat_applyPattern(t_pluralformat *self, PyObject *arg) { UnicodeString *u, _u; if (!parseArg(arg, "S", &u, &_u)) { STATUS_CALL(self->object->applyPattern(*u, status)); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "applyPattern", arg); } static PyObject *t_pluralformat_format(t_pluralformat *self, PyObject *args) { UnicodeString *u, _u; FieldPosition *fp, _fp; double d; int n; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "i", &n)) { STATUS_CALL(_u = self->object->format(n, status)); return PyUnicode_FromUnicodeString(&_u); } if (!parseArgs(args, "d", &d)) { STATUS_CALL(_u = self->object->format(d, status)); return PyUnicode_FromUnicodeString(&_u); } break; case 2: if (!parseArgs(args, "iS", &n, &u, &_u)) { STATUS_CALL(self->object->format(n, *u, _fp, status)); Py_RETURN_ARG(args, 1); } if (!parseArgs(args, "dS", &d, &u, &_u)) { STATUS_CALL(self->object->format(d, *u, _fp, status)); Py_RETURN_ARG(args, 1); } break; case 3: if (!parseArgs(args, "iSP", TYPE_CLASSID(FieldPosition), &n, &u, &_u, &fp)) { STATUS_CALL(self->object->format(n, *u, *fp, status)); Py_RETURN_ARG(args, 1); } if (!parseArgs(args, "dSP", TYPE_CLASSID(FieldPosition), &d, &u, &_u, &fp)) { STATUS_CALL(self->object->format(d, *u, *fp, status)); Py_RETURN_ARG(args, 1); } break; } return t_format_format((t_format *) self, args); } static PyObject *t_pluralformat_str(t_pluralformat *self) { UnicodeString u; self->object->toPattern(u); return PyUnicode_FromUnicodeString(&u); } #endif #if U_ICU_VERSION_HEX >= 0x04040000 /* SelectFormat */ static int t_selectformat_init(t_selectformat *self, PyObject *args, PyObject *kwds) { UnicodeString *u, _u; if (!parseArgs(args, "S", &u, &_u)) { SelectFormat *format; INT_STATUS_CALL(format = new SelectFormat(*u, status)); self->object = format; self->flags = T_OWNED; return 0; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; } static PyObject *t_selectformat_applyPattern(t_selectformat *self, PyObject *arg) { UnicodeString *u, _u; if (!parseArg(arg, "S", &u, &_u)) { STATUS_CALL(self->object->applyPattern(*u, status)); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "applyPattern", arg); } static PyObject *t_selectformat_toPattern(t_selectformat *self, PyObject *args) { UnicodeString *u, _u; switch (PyTuple_Size(args)) { case 0: self->object->toPattern(_u); return PyUnicode_FromUnicodeString(&_u); case 1: if (!parseArgs(args, "U", &u)) { self->object->toPattern(*u); Py_RETURN_ARG(args, 0); } break; } return PyErr_SetArgsError((PyObject *) self, "toPattern", args); } PyObject *t_selectformat_format(t_selectformat *self, PyObject *args) { UnicodeString *u0, _u0; UnicodeString *u1, _u1; Formattable *obj; FieldPosition *fp, _fp; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "P", TYPE_CLASSID(Formattable), &obj)) { STATUS_CALL(self->object->format(*obj, _u1, _fp, status)); return PyUnicode_FromUnicodeString(&_u1); } break; if (!parseArgs(args, "S", &u0, &_u0, &obj)) { STATUS_CALL(self->object->format(*u0, _u1, _fp, status)); return PyUnicode_FromUnicodeString(&_u1); } break; case 2: if (!parseArgs(args, "PU", TYPE_CLASSID(Formattable), &obj, &u1)) { STATUS_CALL(self->object->format(*obj, *u1, _fp, status)); Py_RETURN_ARG(args, 1); } if (!parseArgs(args, "SU", &u0, &_u0, &u1)) { STATUS_CALL(self->object->format(*u0, *u1, _fp, status)); Py_RETURN_ARG(args, 1); } if (!parseArgs(args, "PP", TYPE_CLASSID(Formattable), TYPE_CLASSID(FieldPosition), &obj, &fp)) { STATUS_CALL(self->object->format(*obj, _u1, *fp, status)); return PyUnicode_FromUnicodeString(&_u1); } if (!parseArgs(args, "SP", TYPE_CLASSID(FieldPosition), &u0, &_u0, &fp)) { STATUS_CALL(self->object->format(*u0, _u1, *fp, status)); return PyUnicode_FromUnicodeString(&_u1); } break; case 3: if (!parseArgs(args, "PUP", TYPE_CLASSID(Formattable), TYPE_CLASSID(FieldPosition), &obj, &u1, &fp)) { STATUS_CALL(self->object->format(*obj, *u1, *fp, status)); Py_RETURN_ARG(args, 1); } if (!parseArgs(args, "SUP", TYPE_CLASSID(FieldPosition), &u0, &_u0, &u1, &fp)) { STATUS_CALL(self->object->format(*u0, *u1, *fp, status)); Py_RETURN_ARG(args, 1); } break; } return PyErr_SetArgsError((PyObject *) self, "format", args); } static PyObject *t_selectformat_parseObject(t_selectformat *self, PyObject *args) { PyErr_SetString(PyExc_NotImplementedError, "SelectFormat.parseObject()"); return NULL; } static PyObject *t_selectformat_str(t_selectformat *self) { UnicodeString u; self->object->toPattern(u); return PyUnicode_FromUnicodeString(&u); } #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(50, 0, 0) /* ListFormatter */ static PyObject *t_listformatter_format(t_listformatter *self, PyObject *arg) { UnicodeString *array; int count; if (!parseArg(arg, "T", &array, &count)) { UnicodeString u; STATUS_CALL(self->object->format(array, (int32_t) count, u, status)); return PyUnicode_FromUnicodeString(&u); } return PyErr_SetArgsError((PyObject *) self, "format", arg); } static PyObject *t_listformatter_createInstance(PyTypeObject *type, PyObject *args) { ListFormatter *formatter; Locale *locale; switch (PyTuple_Size(args)) { case 0: STATUS_CALL(formatter = ListFormatter::createInstance(status)); return wrap_ListFormatter(formatter, T_OWNED); case 1: if (!parseArgs(args, "P", TYPE_CLASSID(Locale), &locale)) { STATUS_CALL(formatter = ListFormatter::createInstance( *locale, status)); return wrap_ListFormatter(formatter, T_OWNED); } break; } return PyErr_SetArgsError(type, "createInstance", args); } #endif void _init_format(PyObject *m) { FieldPositionType_.tp_richcompare = (richcmpfunc) t_fieldposition_richcmp; ParsePositionType_.tp_richcompare = (richcmpfunc) t_parseposition_richcmp; FormatType_.tp_richcompare = (richcmpfunc) t_format_richcmp; MessageFormatType_.tp_str = (reprfunc) t_messageformat_str; MessageFormatType_.tp_as_number = &t_messageformat_as_number; MessageFormatType_.tp_flags |= Py_TPFLAGS_CHECKTYPES; #if U_ICU_VERSION_HEX >= 0x04000000 PluralRulesType_.tp_richcompare = (richcmpfunc) t_pluralrules_richcmp; PluralFormatType_.tp_str = (reprfunc) t_pluralformat_str; #endif #if U_ICU_VERSION_HEX >= 0x04040000 SelectFormatType_.tp_str = (reprfunc) t_selectformat_str; #endif REGISTER_TYPE(FieldPosition, m); REGISTER_TYPE(ParsePosition, m); INSTALL_TYPE(Format, m); INSTALL_TYPE(MeasureFormat, m); REGISTER_TYPE(MessageFormat, m); #if U_ICU_VERSION_HEX >= 0x04000000 REGISTER_TYPE(PluralRules, m); REGISTER_TYPE(PluralFormat, m); #endif #if U_ICU_VERSION_HEX >= 0x04020000 REGISTER_TYPE(TimeUnitFormat, m); #endif #if U_ICU_VERSION_HEX >= 0x04040000 REGISTER_TYPE(SelectFormat, m); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(50, 0, 0) INSTALL_TYPE(ListFormatter, m); #endif INSTALL_STATIC_INT(FieldPosition, DONT_CARE); #if U_ICU_VERSION_HEX >= 0x04020000 && U_ICU_VERSION_HEX < 0x04080000 INSTALL_STATIC_INT(TimeUnitFormat, kFull); INSTALL_STATIC_INT(TimeUnitFormat, kAbbreviate); #endif #if U_ICU_VERSION_HEX >= 0x04080000 INSTALL_CONSTANTS_TYPE(UTimeUnitFormatStyle, m); INSTALL_ENUM(UTimeUnitFormatStyle, "FULL", UTMUTFMT_FULL_STYLE); INSTALL_ENUM(UTimeUnitFormatStyle, "ABBREVIATED", UTMUTFMT_ABBREVIATED_STYLE); #endif } PyICU-1.9.5/format.h0000644000076500000000000000346612520066224014333 0ustar vajdawheel00000000000000/* ==================================================================== * Copyright (c) 2004-2010 Open Source Applications Foundation. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. * ==================================================================== */ #ifndef _format_h #define _format_h class t_format : public _wrapper { public: Format *object; }; extern PyTypeObject FormatType_; extern PyTypeObject FieldPositionType_; extern PyTypeObject ParsePositionType_; #if U_ICU_VERSION_HEX >= 0x04000000 extern PyTypeObject PluralRulesType_; #endif PyObject *t_format_format(t_format *self, PyObject *args); PyObject *wrap_Format(Format *format); #if U_ICU_VERSION_HEX >= 0x04000000 PyObject *wrap_PluralRules(PluralRules *rules, int flag); #endif void _init_format(PyObject *m); #endif /* _format_h */ PyICU-1.9.5/icu.py0000644000076500000000000000301112053756207014016 0ustar vajdawheel00000000000000 # ==================================================================== # Copyright (c) 2004-2010 Open Source Applications Foundation. # # Permission is hereby granted, free of charge, to any person obtaining a # copy of this software and associated documentation files (the "Software"), # to deal in the Software without restriction, including without limitation # the rights to use, copy, modify, merge, publish, distribute, sublicense, # and/or sell copies of the Software, and to permit persons to whom the # Software is furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included # in all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS # OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING # FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER # DEALINGS IN THE SOFTWARE. # ==================================================================== class ICUError(Exception): messages = {} def __str__(self): return "%s, error code: %d" %(self.args[1], self.args[0]) def getErrorCode(self): return self.args[0] class InvalidArgsError(Exception): pass from docs import * PyICU-1.9.5/idna.cpp0000644000076500000000000002214412520067652014311 0ustar vajdawheel00000000000000/* ==================================================================== * Copyright (c) 2004-2015 Open Source Applications Foundation. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. * ==================================================================== */ #include #include #include "common.h" #include "structmember.h" #include "bases.h" #include "idna.h" #include "macros.h" #if U_ICU_VERSION_HEX >= VERSION_HEX(55, 1, 0) /* IDNAInfo */ class t_idnainfo : public _wrapper { public: UIDNAInfo *object; UIDNAInfo info; }; static int t_idnainfo_init(t_idnainfo *self, PyObject *args, PyObject *kwds); static PyObject *t_idnainfo_isTransitionalDifferent(t_idnainfo *self); static PyObject *t_idnainfo_errors(t_idnainfo *self); static PyMethodDef t_idnainfo_methods[] = { DECLARE_METHOD(t_idnainfo, isTransitionalDifferent, METH_NOARGS), DECLARE_METHOD(t_idnainfo, errors, METH_NOARGS), { NULL, NULL, 0, NULL } }; static void t_idnainfo_dealloc(t_idnainfo *self) { Py_TYPE(self)->tp_free((PyObject *) self); } DECLARE_STRUCT(IDNAInfo, t_idnainfo, UIDNAInfo, t_idnainfo_init, t_idnainfo_dealloc); /* IDNA */ class t_idna : public _wrapper { public: UIDNA *object; }; typedef int32_t (*idna_fn)( const UIDNA *idna, const UChar *text, int32_t len, UChar *dest, int capacity, UIDNAInfo *info, UErrorCode *status); static int t_idna_init(t_idna *self, PyObject *args, PyObject *kwds); static PyObject *t_idna_labelToASCII(t_idna *self, PyObject *args); static PyObject *t_idna_labelToUnicode(t_idna *self, PyObject *args); static PyObject *t_idna_nameToASCII(t_idna *self, PyObject *args); static PyObject *t_idna_nameToUnicode(t_idna *self, PyObject *args); static PyMethodDef t_idna_methods[] = { DECLARE_METHOD(t_idna, labelToASCII, METH_VARARGS), DECLARE_METHOD(t_idna, labelToUnicode, METH_VARARGS), DECLARE_METHOD(t_idna, nameToASCII, METH_VARARGS), DECLARE_METHOD(t_idna, nameToUnicode, METH_VARARGS), { NULL, NULL, 0, NULL } }; static void t_idna_dealloc(t_idna *self) { if (self->object != NULL) { uidna_close(self->object); self->object = NULL; } Py_TYPE(self)->tp_free((PyObject *) self); } DECLARE_STRUCT(IDNA, t_idna, UIDNA, t_idna_init, t_idna_dealloc); /* IDNAInfo */ static int t_idnainfo_init(t_idnainfo *self, PyObject *args, PyObject *kwds) { switch (PyTuple_Size(args)) { case 0: memset(&self->info, 0, sizeof(UIDNAInfo)); self->info.size = sizeof(UIDNAInfo); self->object = &self->info; self->flags = T_OWNED; return 0; default: PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; } } static PyObject *t_idnainfo_isTransitionalDifferent(t_idnainfo *self) { Py_RETURN_BOOL(self->info.isTransitionalDifferent); } static PyObject *t_idnainfo_errors(t_idnainfo *self) { return PyInt_FromLong(self->info.errors); } /* IDNA */ static int t_idna_init(t_idna *self, PyObject *args, PyObject *kwds) { uint32_t options; switch (PyTuple_Size(args)) { case 0: INT_STATUS_CALL(self->object = uidna_openUTS46(UIDNA_DEFAULT, &status)); self->flags = T_OWNED; return 0; case 1: if (!parseArgs(args, "i", &options)) { INT_STATUS_CALL(self->object = uidna_openUTS46(options, &status)); self->flags = T_OWNED; return 0; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; default: PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; } } static PyObject *apply(idna_fn fn, const char *fn_name, t_idna *self, PyObject *args) { UnicodeString *u; UnicodeString _u; t_idnainfo *infoArg; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "S", &u, &_u)) { const size_t len = u->length(); const size_t capacity = len * 4 + 32; UErrorCode status = U_ZERO_ERROR; UChar *dest = new UChar[capacity]; UIDNAInfo info = UIDNA_INFO_INITIALIZER; PyObject *result; size_t size; if (!dest) { PyErr_SetNone(PyExc_MemoryError); return NULL; } size = (*fn)(self->object, u->getBuffer(), len, dest, capacity, &info, &status); if (U_FAILURE(status)) { delete[] dest; return ICUException(status).reportError(); } result = PyUnicode_FromUnicodeString(dest, size); delete[] dest; return result; } break; case 2: if (!parseArgs(args, "SO", &IDNAInfoType_, &u, &_u, &infoArg)) { const size_t len = u->length(); const size_t capacity = len * 4 + 32; UErrorCode status = U_ZERO_ERROR; UChar *dest = new UChar[capacity]; PyObject *result; size_t size; if (!dest) { PyErr_SetNone(PyExc_MemoryError); return NULL; } size = (*fn)(self->object, u->getBuffer(), len, dest, capacity, infoArg->object, &status); if (U_FAILURE(status)) { delete[] dest; return ICUException(status).reportError(); } result = PyUnicode_FromUnicodeString(dest, size); delete[] dest; return result; } break; } return PyErr_SetArgsError((PyObject *) self, fn_name, args); } static PyObject *t_idna_labelToASCII(t_idna *self, PyObject *args) { return apply(uidna_labelToASCII, "labelToASCII", self, args); } static PyObject *t_idna_labelToUnicode(t_idna *self, PyObject *args) { return apply(uidna_labelToUnicode, "labelToUnicode", self, args); } static PyObject *t_idna_nameToASCII(t_idna *self, PyObject *args) { return apply(uidna_nameToASCII, "nameToASCII", self, args); } static PyObject *t_idna_nameToUnicode(t_idna *self, PyObject *args) { return apply(uidna_nameToUnicode, "nameToUnicode", self, args); } #endif void _init_idna(PyObject *m) { #if U_ICU_VERSION_HEX >= VERSION_HEX(55, 1, 0) INSTALL_STRUCT(IDNAInfo, m); INSTALL_STRUCT(IDNA, m); INSTALL_ENUM(IDNAInfo, "ERROR_EMPTY_LABEL", UIDNA_ERROR_EMPTY_LABEL); INSTALL_ENUM(IDNAInfo, "ERROR_LABEL_TOO_LONG", UIDNA_ERROR_LABEL_TOO_LONG); INSTALL_ENUM(IDNAInfo, "ERROR_DOMAIN_NAME_TOO_LONG", UIDNA_ERROR_DOMAIN_NAME_TOO_LONG); INSTALL_ENUM(IDNAInfo, "ERROR_LEADING_HYPHEN", UIDNA_ERROR_LEADING_HYPHEN); INSTALL_ENUM(IDNAInfo, "ERROR_TRAILING_HYPHEN", UIDNA_ERROR_TRAILING_HYPHEN); INSTALL_ENUM(IDNAInfo, "ERROR_HYPHEN_3_4", UIDNA_ERROR_HYPHEN_3_4); INSTALL_ENUM(IDNAInfo, "ERROR_LEADING_COMBINING_MARK", UIDNA_ERROR_LEADING_COMBINING_MARK); INSTALL_ENUM(IDNAInfo, "ERROR_DISALLOWED", UIDNA_ERROR_DISALLOWED); INSTALL_ENUM(IDNAInfo, "ERROR_PUNYCODE", UIDNA_ERROR_PUNYCODE); INSTALL_ENUM(IDNAInfo, "ERROR_LABEL_HAS_DOT", UIDNA_ERROR_LABEL_HAS_DOT); INSTALL_ENUM(IDNAInfo, "ERROR_INVALID_ACE_LABEL", UIDNA_ERROR_INVALID_ACE_LABEL); INSTALL_ENUM(IDNAInfo, "ERROR_BIDI", UIDNA_ERROR_BIDI); INSTALL_ENUM(IDNAInfo, "ERROR_CONTEXTJ", UIDNA_ERROR_CONTEXTJ); INSTALL_ENUM(IDNAInfo, "ERROR_CONTEXTO_PUNCTUATION", UIDNA_ERROR_CONTEXTO_PUNCTUATION); INSTALL_ENUM(IDNAInfo, "ERROR_CONTEXTO_DIGITS", UIDNA_ERROR_CONTEXTO_DIGITS); INSTALL_ENUM(IDNA, "DEFAULT", UIDNA_DEFAULT); INSTALL_ENUM(IDNA, "USE_STD3_RULES", UIDNA_USE_STD3_RULES); INSTALL_ENUM(IDNA, "CHECK_BIDI", UIDNA_CHECK_BIDI); INSTALL_ENUM(IDNA, "CHECK_CONTEXTJ", UIDNA_CHECK_CONTEXTJ); INSTALL_ENUM(IDNA, "CHECK_NONTRANSITIONAL_TO_ASCII", UIDNA_NONTRANSITIONAL_TO_ASCII); INSTALL_ENUM(IDNA, "CHECK_NONTRANSITIONAL_TO_UNICODE", UIDNA_NONTRANSITIONAL_TO_UNICODE); INSTALL_ENUM(IDNA, "CHECK_CONTEXT0", UIDNA_CHECK_CONTEXTO); #endif } PyICU-1.9.5/idna.h0000644000076500000000000000264212520067650013755 0ustar vajdawheel00000000000000/* ==================================================================== * Copyright (c) 2004-2015 Open Source Applications Foundation. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. * ==================================================================== */ #ifndef _idna_h #define _idna_h extern PyTypeObject IDNAInfoType_; extern PyTypeObject IDNAType_; void _init_idna(PyObject *m); #endif /* _idna_h */ PyICU-1.9.5/iterators.cpp0000644000076500000000000013333313007204363015406 0ustar vajdawheel00000000000000/* ==================================================================== * Copyright (c) 2004-2011 Open Source Applications Foundation. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. * ==================================================================== */ #include "common.h" #include "structmember.h" #include "bases.h" #include "locale.h" #include "iterators.h" #include "macros.h" /* ForwardCharacterIterator */ class t_forwardcharacteriterator : public _wrapper { public: ForwardCharacterIterator *object; }; static PyObject *t_forwardcharacteriterator_nextPostInc(t_forwardcharacteriterator *self); static PyObject *t_forwardcharacteriterator_next32PostInc(t_forwardcharacteriterator *self); static PyObject *t_forwardcharacteriterator_hasNext(t_forwardcharacteriterator *self); static PyMethodDef t_forwardcharacteriterator_methods[] = { DECLARE_METHOD(t_forwardcharacteriterator, nextPostInc, METH_NOARGS), DECLARE_METHOD(t_forwardcharacteriterator, next32PostInc, METH_NOARGS), DECLARE_METHOD(t_forwardcharacteriterator, hasNext, METH_NOARGS), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(ForwardCharacterIterator, t_forwardcharacteriterator, UObject, ForwardCharacterIterator, abstract_init, NULL); /* CharacterIterator */ class t_characteriterator : public _wrapper { public: CharacterIterator *object; }; static PyObject *t_characteriterator_first(t_characteriterator *self); static PyObject *t_characteriterator_firstPostInc(t_characteriterator *self); static PyObject *t_characteriterator_first32(t_characteriterator *self); static PyObject *t_characteriterator_first32PostInc(t_characteriterator *self); static PyObject *t_characteriterator_last(t_characteriterator *self); static PyObject *t_characteriterator_last32(t_characteriterator *self); static PyObject *t_characteriterator_current(t_characteriterator *self); static PyObject *t_characteriterator_current32(t_characteriterator *self); static PyObject *t_characteriterator_next(t_characteriterator *self); static PyObject *t_characteriterator_next32(t_characteriterator *self); static PyObject *t_characteriterator_previous(t_characteriterator *self); static PyObject *t_characteriterator_previous32(t_characteriterator *self); static PyObject *t_characteriterator_setToStart(t_characteriterator *self); static PyObject *t_characteriterator_setToEnd(t_characteriterator *self); static PyObject *t_characteriterator_setIndex(t_characteriterator *self, PyObject *arg); static PyObject *t_characteriterator_setIndex32(t_characteriterator *self, PyObject *arg); static PyObject *t_characteriterator_hasPrevious(t_characteriterator *self); static PyObject *t_characteriterator_startIndex(t_characteriterator *self); static PyObject *t_characteriterator_endIndex(t_characteriterator *self); static PyObject *t_characteriterator_getIndex(t_characteriterator *self); static PyObject *t_characteriterator_getLength(t_characteriterator *self); static PyObject *t_characteriterator_move(t_characteriterator *self, PyObject *args); static PyObject *t_characteriterator_getText(t_characteriterator *self, PyObject *args); static PyMethodDef t_characteriterator_methods[] = { DECLARE_METHOD(t_characteriterator, first, METH_NOARGS), DECLARE_METHOD(t_characteriterator, firstPostInc, METH_NOARGS), DECLARE_METHOD(t_characteriterator, first32, METH_NOARGS), DECLARE_METHOD(t_characteriterator, first32PostInc, METH_NOARGS), DECLARE_METHOD(t_characteriterator, last, METH_NOARGS), DECLARE_METHOD(t_characteriterator, last32, METH_NOARGS), DECLARE_METHOD(t_characteriterator, current, METH_NOARGS), DECLARE_METHOD(t_characteriterator, current32, METH_NOARGS), DECLARE_METHOD(t_characteriterator, next, METH_NOARGS), DECLARE_METHOD(t_characteriterator, next32, METH_NOARGS), DECLARE_METHOD(t_characteriterator, previous, METH_NOARGS), DECLARE_METHOD(t_characteriterator, previous32, METH_NOARGS), DECLARE_METHOD(t_characteriterator, setToStart, METH_NOARGS), DECLARE_METHOD(t_characteriterator, setToEnd, METH_NOARGS), DECLARE_METHOD(t_characteriterator, setIndex, METH_O), DECLARE_METHOD(t_characteriterator, setIndex32, METH_O), DECLARE_METHOD(t_characteriterator, hasPrevious, METH_NOARGS), DECLARE_METHOD(t_characteriterator, startIndex, METH_NOARGS), DECLARE_METHOD(t_characteriterator, endIndex, METH_NOARGS), DECLARE_METHOD(t_characteriterator, getIndex, METH_NOARGS), DECLARE_METHOD(t_characteriterator, getLength, METH_NOARGS), DECLARE_METHOD(t_characteriterator, move, METH_VARARGS), DECLARE_METHOD(t_characteriterator, getText, METH_VARARGS), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(CharacterIterator, t_characteriterator, ForwardCharacterIterator, CharacterIterator, abstract_init, NULL); /* UCharCharacterIterator */ class t_ucharcharacteriterator : public _wrapper { public: UCharCharacterIterator *object; PyObject *text; }; static int t_ucharcharacteriterator_init(t_ucharcharacteriterator *self, PyObject *args, PyObject *kwds); static PyObject *t_ucharcharacteriterator_setText(t_ucharcharacteriterator *self, PyObject *args); static PyMethodDef t_ucharcharacteriterator_methods[] = { DECLARE_METHOD(t_ucharcharacteriterator, setText, METH_VARARGS), { NULL, NULL, 0, NULL } }; static void t_ucharcharacteriterator_dealloc(t_ucharcharacteriterator *self) { if (self->flags & T_OWNED) delete self->object; self->object = NULL; Py_CLEAR(self->text); Py_TYPE(self)->tp_free((PyObject *) self); } DECLARE_TYPE(UCharCharacterIterator, t_ucharcharacteriterator, CharacterIterator, UCharCharacterIterator, t_ucharcharacteriterator_init, t_ucharcharacteriterator_dealloc); /* StringCharacterIterator */ class t_stringcharacteriterator : public _wrapper { public: StringCharacterIterator *object; }; static int t_stringcharacteriterator_init(t_stringcharacteriterator *self, PyObject *args, PyObject *kwds); static PyObject *t_stringcharacteriterator_setText(t_stringcharacteriterator *self, PyObject *args); static PyMethodDef t_stringcharacteriterator_methods[] = { DECLARE_METHOD(t_stringcharacteriterator, setText, METH_VARARGS), { NULL, NULL, 0, NULL } }; static void t_stringcharacteriterator_dealloc(t_stringcharacteriterator *self) { if (self->flags & T_OWNED) delete self->object; self->object = NULL; Py_TYPE(self)->tp_free((PyObject *) self); } DECLARE_TYPE(StringCharacterIterator, t_stringcharacteriterator, UCharCharacterIterator, StringCharacterIterator, t_stringcharacteriterator_init, t_stringcharacteriterator_dealloc); /* BreakIterator */ class t_breakiterator : public _wrapper { public: BreakIterator *object; PyObject *text; }; static PyObject *t_breakiterator_getText(t_breakiterator *self); static PyObject *t_breakiterator_setText(t_breakiterator *self, PyObject *arg); static PyObject *t_breakiterator_first(t_breakiterator *self); static PyObject *t_breakiterator_last(t_breakiterator *self); static PyObject *t_breakiterator_previous(t_breakiterator *self); static PyObject *t_breakiterator_nextBoundary(t_breakiterator *self, PyObject *args); static PyObject *t_breakiterator_current(t_breakiterator *self); static PyObject *t_breakiterator_following(t_breakiterator *self, PyObject *arg); static PyObject *t_breakiterator_preceding(t_breakiterator *self, PyObject *arg); static PyObject *t_breakiterator_isBoundary(t_breakiterator *self, PyObject *arg); static PyObject *t_breakiterator_getLocale(t_breakiterator *self, PyObject *args); static PyObject *t_breakiterator_getLocaleID(t_breakiterator *self, PyObject *args); static PyObject *t_breakiterator_createWordInstance(PyTypeObject *type, PyObject *arg); static PyObject *t_breakiterator_createLineInstance(PyTypeObject *type, PyObject *arg); static PyObject *t_breakiterator_createCharacterInstance(PyTypeObject *type, PyObject *arg); static PyObject *t_breakiterator_createSentenceInstance(PyTypeObject *type, PyObject *arg); static PyObject *t_breakiterator_createTitleInstance(PyTypeObject *type, PyObject *arg); static PyObject *t_breakiterator_getAvailableLocales(PyTypeObject *type); static PyObject *t_breakiterator_getDisplayName(PyTypeObject *type, PyObject *args); static PyMethodDef t_breakiterator_methods[] = { DECLARE_METHOD(t_breakiterator, getText, METH_NOARGS), DECLARE_METHOD(t_breakiterator, setText, METH_O), DECLARE_METHOD(t_breakiterator, first, METH_NOARGS), DECLARE_METHOD(t_breakiterator, last, METH_NOARGS), DECLARE_METHOD(t_breakiterator, previous, METH_NOARGS), DECLARE_METHOD(t_breakiterator, nextBoundary, METH_VARARGS), DECLARE_METHOD(t_breakiterator, current, METH_NOARGS), DECLARE_METHOD(t_breakiterator, following, METH_O), DECLARE_METHOD(t_breakiterator, preceding, METH_O), DECLARE_METHOD(t_breakiterator, isBoundary, METH_O), DECLARE_METHOD(t_breakiterator, getLocale, METH_VARARGS), DECLARE_METHOD(t_breakiterator, getLocaleID, METH_VARARGS), DECLARE_METHOD(t_breakiterator, createWordInstance, METH_O | METH_CLASS), DECLARE_METHOD(t_breakiterator, createLineInstance, METH_O | METH_CLASS), DECLARE_METHOD(t_breakiterator, createCharacterInstance, METH_O | METH_CLASS), DECLARE_METHOD(t_breakiterator, createSentenceInstance, METH_O | METH_CLASS), DECLARE_METHOD(t_breakiterator, createTitleInstance, METH_O | METH_CLASS), DECLARE_METHOD(t_breakiterator, getAvailableLocales, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_breakiterator, getDisplayName, METH_VARARGS | METH_CLASS), { NULL, NULL, 0, NULL } }; static void t_breakiterator_dealloc(t_breakiterator *self) { if (self->flags & T_OWNED) delete self->object; self->object = NULL; Py_CLEAR(self->text); Py_TYPE(self)->tp_free((PyObject *) self); } DECLARE_TYPE(BreakIterator, t_breakiterator, UObject, BreakIterator, abstract_init, t_breakiterator_dealloc); /* RuleBasedBreakIterator */ class t_rulebasedbreakiterator : public _wrapper { public: RuleBasedBreakIterator *object; PyObject *text; /* used by inherited BreakIterator.setText() */ }; static int t_rulebasedbreakiterator_init(t_rulebasedbreakiterator *self, PyObject *args, PyObject *kwds); static PyObject *t_rulebasedbreakiterator_getRules(t_rulebasedbreakiterator *self, PyObject *args); static PyObject *t_rulebasedbreakiterator_getRuleStatus(t_rulebasedbreakiterator *self); static PyMethodDef t_rulebasedbreakiterator_methods[] = { DECLARE_METHOD(t_rulebasedbreakiterator, getRules, METH_VARARGS), DECLARE_METHOD(t_rulebasedbreakiterator, getRuleStatus, METH_NOARGS), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(RuleBasedBreakIterator, t_rulebasedbreakiterator, BreakIterator, RuleBasedBreakIterator, t_rulebasedbreakiterator_init, NULL); /* DictionaryBasedBreakIterator */ class t_dictionarybasedbreakiterator : public _wrapper { public: DictionaryBasedBreakIterator *object; }; static int t_dictionarybasedbreakiterator_init(t_dictionarybasedbreakiterator *self, PyObject *args, PyObject *kwds); static PyMethodDef t_dictionarybasedbreakiterator_methods[] = { { NULL, NULL, 0, NULL } }; DECLARE_TYPE(DictionaryBasedBreakIterator, t_dictionarybasedbreakiterator, RuleBasedBreakIterator, DictionaryBasedBreakIterator, t_dictionarybasedbreakiterator_init, NULL); /* CanonicalIterator */ class t_canonicaliterator : public _wrapper { public: CanonicalIterator *object; }; static int t_canonicaliterator_init(t_canonicaliterator *self, PyObject *args, PyObject *kwds); static PyObject *t_canonicaliterator_getSource(t_canonicaliterator *self, PyObject *args); static PyObject *t_canonicaliterator_setSource(t_canonicaliterator *self, PyObject *arg); static PyObject *t_canonicaliterator_reset(t_canonicaliterator *self); static PyObject *t_canonicaliterator_next(t_canonicaliterator *self, PyObject *args); static PyMethodDef t_canonicaliterator_methods[] = { DECLARE_METHOD(t_canonicaliterator, getSource, METH_VARARGS), DECLARE_METHOD(t_canonicaliterator, setSource, METH_O), DECLARE_METHOD(t_canonicaliterator, next, METH_VARARGS), DECLARE_METHOD(t_canonicaliterator, reset, METH_NOARGS), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(CanonicalIterator, t_canonicaliterator, UObject, CanonicalIterator, t_canonicaliterator_init, NULL); /* CollationElementIterator */ class t_collationelementiterator : public _wrapper { public: CollationElementIterator *object; }; static PyObject *t_collationelementiterator_reset(t_collationelementiterator *self); static PyObject *t_collationelementiterator_next(t_collationelementiterator *self); static PyObject *t_collationelementiterator_previous(t_collationelementiterator *self); static PyObject *t_collationelementiterator_setText(t_collationelementiterator *self, PyObject *arg); static PyObject *t_collationelementiterator_getOffset(t_collationelementiterator *self); static PyObject *t_collationelementiterator_setOffset(t_collationelementiterator *self, PyObject *arg); static PyObject *t_collationelementiterator_getMaxExpansion(t_collationelementiterator *self, PyObject *arg); static PyObject *t_collationelementiterator_strengthOrder(t_collationelementiterator *self, PyObject *arg); static PyObject *t_collationelementiterator_primaryOrder(PyTypeObject *type, PyObject *arg); static PyObject *t_collationelementiterator_secondaryOrder(PyTypeObject *type, PyObject *arg); static PyObject *t_collationelementiterator_tertiaryOrder(PyTypeObject *type, PyObject *arg); static PyObject *t_collationelementiterator_isIgnorable(PyTypeObject *type, PyObject *arg); static PyMethodDef t_collationelementiterator_methods[] = { DECLARE_METHOD(t_collationelementiterator, setText, METH_O), DECLARE_METHOD(t_collationelementiterator, next, METH_VARARGS), DECLARE_METHOD(t_collationelementiterator, previous, METH_VARARGS), DECLARE_METHOD(t_collationelementiterator, reset, METH_NOARGS), DECLARE_METHOD(t_collationelementiterator, getOffset, METH_NOARGS), DECLARE_METHOD(t_collationelementiterator, setOffset, METH_O), DECLARE_METHOD(t_collationelementiterator, getMaxExpansion, METH_O), DECLARE_METHOD(t_collationelementiterator, strengthOrder, METH_O), DECLARE_METHOD(t_collationelementiterator, primaryOrder, METH_O | METH_CLASS), DECLARE_METHOD(t_collationelementiterator, secondaryOrder, METH_O | METH_CLASS), DECLARE_METHOD(t_collationelementiterator, tertiaryOrder, METH_O | METH_CLASS), DECLARE_METHOD(t_collationelementiterator, isIgnorable, METH_O | METH_CLASS), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(CollationElementIterator, t_collationelementiterator, UObject, CollationElementIterator, abstract_init, NULL); /* ForwardCharacterIterator */ static PyObject *t_forwardcharacteriterator_nextPostInc(t_forwardcharacteriterator *self) { UChar c = self->object->nextPostInc(); if (c == ForwardCharacterIterator::DONE) { PyErr_SetNone(PyExc_StopIteration); return NULL; } return PyInt_FromLong(c); } static PyObject *t_forwardcharacteriterator_next32PostInc(t_forwardcharacteriterator *self) { UChar32 c = self->object->next32PostInc(); if (c == ForwardCharacterIterator::DONE) { PyErr_SetNone(PyExc_StopIteration); return NULL; } return PyInt_FromLong(c); } static PyObject *t_forwardcharacteriterator_hasNext(t_forwardcharacteriterator *self) { int b = self->object->hasNext(); Py_RETURN_BOOL(b); } static PyObject *t_forwardcharacteriterator_iter(t_forwardcharacteriterator *self) { Py_RETURN_SELF(); } static PyObject *t_forwardcharacteriterator_richcmp(t_forwardcharacteriterator *self, PyObject *arg, int op) { int b = 0; ForwardCharacterIterator *i; if (!parseArg(arg, "P", TYPE_ID(ForwardCharacterIterator), &i)) { switch (op) { case Py_EQ: case Py_NE: b = *self->object == *i; if (op == Py_EQ) Py_RETURN_BOOL(b); Py_RETURN_BOOL(!b); case Py_LT: case Py_LE: case Py_GT: case Py_GE: PyErr_SetNone(PyExc_NotImplementedError); return NULL; } } return PyErr_SetArgsError((PyObject *) self, "__richcmp__", arg); } /* CharacterIterator */ static PyObject *t_characteriterator_first(t_characteriterator *self) { return PyInt_FromLong((long) self->object->first()); } static PyObject *t_characteriterator_firstPostInc(t_characteriterator *self) { return PyInt_FromLong((long) self->object->firstPostInc()); } static PyObject *t_characteriterator_first32(t_characteriterator *self) { return PyInt_FromLong((long) self->object->first32()); } static PyObject *t_characteriterator_first32PostInc(t_characteriterator *self) { return PyInt_FromLong((long) self->object->first32PostInc()); } static PyObject *t_characteriterator_last(t_characteriterator *self) { return PyInt_FromLong((long) self->object->last()); } static PyObject *t_characteriterator_last32(t_characteriterator *self) { return PyInt_FromLong((long) self->object->last32()); } static PyObject *t_characteriterator_current(t_characteriterator *self) { return PyInt_FromLong((long) self->object->current()); } static PyObject *t_characteriterator_current32(t_characteriterator *self) { return PyInt_FromLong((long) self->object->current32()); } static PyObject *t_characteriterator_next(t_characteriterator *self) { return PyInt_FromLong((long) self->object->next()); } static PyObject *t_characteriterator_next32(t_characteriterator *self) { return PyInt_FromLong((long) self->object->next32()); } static PyObject *t_characteriterator_previous(t_characteriterator *self) { return PyInt_FromLong((long) self->object->previous()); } static PyObject *t_characteriterator_previous32(t_characteriterator *self) { return PyInt_FromLong((long) self->object->previous32()); } static PyObject *t_characteriterator_setToStart(t_characteriterator *self) { return PyInt_FromLong((long) self->object->setToStart()); } static PyObject *t_characteriterator_setToEnd(t_characteriterator *self) { return PyInt_FromLong((long) self->object->setToEnd()); } static PyObject *t_characteriterator_setIndex(t_characteriterator *self, PyObject *arg) { int i; if (!parseArg(arg, "i", &i)) return PyInt_FromLong((long) self->object->setIndex(i)); return PyErr_SetArgsError((PyObject *) self, "setIndex", arg); } static PyObject *t_characteriterator_setIndex32(t_characteriterator *self, PyObject *arg) { int i; if (!parseArg(arg, "i", &i)) return PyInt_FromLong((long) self->object->setIndex32(i)); return PyErr_SetArgsError((PyObject *) self, "setIndex32", arg); } static PyObject *t_characteriterator_hasPrevious(t_characteriterator *self) { int b = self->object->hasPrevious(); Py_RETURN_BOOL(b); } static PyObject *t_characteriterator_startIndex(t_characteriterator *self) { return PyInt_FromLong((long) self->object->startIndex()); } static PyObject *t_characteriterator_endIndex(t_characteriterator *self) { return PyInt_FromLong((long) self->object->endIndex()); } static PyObject *t_characteriterator_getIndex(t_characteriterator *self) { return PyInt_FromLong((long) self->object->getIndex()); } static PyObject *t_characteriterator_getLength(t_characteriterator *self) { return PyInt_FromLong((long) self->object->getLength()); } static PyObject *t_characteriterator_move(t_characteriterator *self, PyObject *args) { int delta; CharacterIterator::EOrigin origin; if (!parseArgs(args, "ii", &delta, &origin)) return PyInt_FromLong((long) self->object->move(delta, origin)); return PyErr_SetArgsError((PyObject *) self, "move", args); } static PyObject *t_characteriterator_getText(t_characteriterator *self, PyObject *args) { UnicodeString *u; UnicodeString _u; switch (PyTuple_Size(args)) { case 0: self->object->getText(_u); return PyUnicode_FromUnicodeString(&_u); case 1: if (!parseArgs(args, "U", &u)) { self->object->getText(*u); Py_RETURN_ARG(args, 0); } break; } return PyErr_SetArgsError((PyObject *) self, "getText", args); } /* UCharCharacterIterator */ static int t_ucharcharacteriterator_init(t_ucharcharacteriterator *self, PyObject *args, PyObject *kwds) { UnicodeString *u; int len, start, end, pos; switch (PyTuple_Size(args)) { case 2: if (!parseArgs(args, "Wi", &u, &self->text, &len)) { self->object = new UCharCharacterIterator(u->getTerminatedBuffer(), len); self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; case 3: if (!parseArgs(args, "Wii", &u, &self->text, &len, &pos)) { self->object = new UCharCharacterIterator(u->getTerminatedBuffer(), len, pos); self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; case 5: if (!parseArgs(args, "Wiiii", &u, &self->text, &len, &start, &end, &pos)) { self->object = new UCharCharacterIterator(u->getTerminatedBuffer(), len, start, end, pos); self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; default: PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; } if (self->object) return 0; return -1; } static PyObject *t_ucharcharacteriterator_setText(t_ucharcharacteriterator *self, PyObject *args) { UnicodeString *u; int32_t length; if (!parseArgs(args, "Wi", &u, &self->text, &length)) { self->object->setText(u->getTerminatedBuffer(), length); /* ref'd */ Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setText", args); } /* StringCharacterIterator */ static int t_stringcharacteriterator_init(t_stringcharacteriterator *self, PyObject *args, PyObject *kwds) { UnicodeString *u, _u; int start, end, pos; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "S", &u, &_u)) { self->object = new StringCharacterIterator(*u); self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; case 2: if (!parseArgs(args, "Si", &u, &_u, &pos)) { self->object = new StringCharacterIterator(*u, pos); self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; case 4: if (!parseArgs(args, "Siii", &u, &_u, &start, &end, &pos)) { self->object = new StringCharacterIterator(*u, start, end, pos); self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; default: PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; } if (self->object) return 0; return -1; } static PyObject *t_stringcharacteriterator_setText(t_stringcharacteriterator *self, PyObject *args) { UnicodeString *u, _u; if (!parseArgs(args, "S", &u, &_u)) { self->object->setText(*u); /* copied */ Py_RETURN_NONE; } return t_ucharcharacteriterator_setText((t_ucharcharacteriterator *) self, args); } /* BreakIterator */ static PyObject *t_breakiterator_getText(t_breakiterator *self) { CharacterIterator *iterator = self->object->getText().clone(); return wrap_CharacterIterator(iterator, T_OWNED); } static PyObject *t_breakiterator_setText(t_breakiterator *self, PyObject *arg) { UnicodeString *u; if (!parseArg(arg, "W", &u, &self->text)) { self->object->setText(*u); /* ref'd */ Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setText", arg); } static PyObject *t_breakiterator_first(t_breakiterator *self) { return PyInt_FromLong(self->object->first()); } static PyObject *t_breakiterator_last(t_breakiterator *self) { return PyInt_FromLong(self->object->last()); } static PyObject *t_breakiterator_previous(t_breakiterator *self) { return PyInt_FromLong(self->object->previous()); } static PyObject *t_breakiterator_nextBoundary(t_breakiterator *self, PyObject *args) { int32_t n; switch (PyTuple_Size(args)) { case 0: return PyInt_FromLong(self->object->next()); case 1: if (!parseArgs(args, "i", &n)) return PyInt_FromLong(self->object->next(n)); break; } return PyErr_SetArgsError((PyObject *) self, "nextBoundary", args); } static PyObject *t_breakiterator_current(t_breakiterator *self) { return PyInt_FromLong(self->object->current()); } static PyObject *t_breakiterator_following(t_breakiterator *self, PyObject *arg) { int32_t offset; if (!parseArg(arg, "i", &offset)) return PyInt_FromLong(self->object->following(offset)); return PyErr_SetArgsError((PyObject *) self, "following", arg); } static PyObject *t_breakiterator_preceding(t_breakiterator *self, PyObject *arg) { int32_t offset; if (!parseArg(arg, "i", &offset)) return PyInt_FromLong(self->object->preceding(offset)); return PyErr_SetArgsError((PyObject *) self, "preceding", arg); } static PyObject *t_breakiterator_isBoundary(t_breakiterator *self, PyObject *arg) { int32_t i; if (!parseArg(arg, "i", &i)) { int b = self->object->isBoundary(i); Py_RETURN_BOOL(b); } return PyErr_SetArgsError((PyObject *) self, "isBoundary", arg); } static PyObject *t_breakiterator_getLocale(t_breakiterator *self, PyObject *args) { ULocDataLocaleType type; Locale locale; switch (PyTuple_Size(args)) { case 0: STATUS_CALL(locale = self->object->getLocale(ULOC_VALID_LOCALE, status)); return wrap_Locale(locale); case 1: if (!parseArgs(args, "i", &type)) { STATUS_CALL(locale = self->object->getLocale(type, status)); return wrap_Locale(locale); } break; } return PyErr_SetArgsError((PyObject *) self, "getLocale", args); } static PyObject *t_breakiterator_getLocaleID(t_breakiterator *self, PyObject *args) { ULocDataLocaleType type; const char *id; switch (PyTuple_Size(args)) { case 0: STATUS_CALL(id = self->object->getLocaleID(ULOC_VALID_LOCALE, status)); return PyString_FromString(id); case 1: if (!parseArgs(args, "i", &type)) { STATUS_CALL(id = self->object->getLocaleID(type, status)); return PyString_FromString(id); } break; } return PyErr_SetArgsError((PyObject *) self, "getLocaleID", args); } static inline PyObject *wrap_BreakIterator(BreakIterator *iterator) { #if U_ICU_VERSION_HEX < 0x04060000 if (iterator->getDynamicClassID() == RuleBasedBreakIterator::getStaticClassID()) return wrap_RuleBasedBreakIterator( (RuleBasedBreakIterator *) iterator, T_OWNED); #else if (dynamic_cast(iterator) != NULL) return wrap_RuleBasedBreakIterator( (RuleBasedBreakIterator *) iterator, T_OWNED); #endif return wrap_BreakIterator(iterator, T_OWNED); } static PyObject *t_breakiterator_createWordInstance(PyTypeObject *type, PyObject *arg) { Locale *locale; BreakIterator *iterator; if (!parseArg(arg, "P", TYPE_CLASSID(Locale), &locale)) { STATUS_CALL(iterator = BreakIterator::createWordInstance(*locale, status)); return wrap_BreakIterator(iterator); } return PyErr_SetArgsError(type, "createWordInstance", arg); } static PyObject *t_breakiterator_createLineInstance(PyTypeObject *type, PyObject *arg) { Locale *locale; BreakIterator *iterator; if (!parseArg(arg, "P", TYPE_CLASSID(Locale), &locale)) { STATUS_CALL(iterator = BreakIterator::createLineInstance(*locale, status)); return wrap_BreakIterator(iterator); } return PyErr_SetArgsError(type, "createLineInstance", arg); } static PyObject *t_breakiterator_createCharacterInstance(PyTypeObject *type, PyObject *arg) { Locale *locale; BreakIterator *iterator; if (!parseArg(arg, "P", TYPE_CLASSID(Locale), &locale)) { STATUS_CALL(iterator = BreakIterator::createCharacterInstance(*locale, status)); return wrap_BreakIterator(iterator); } return PyErr_SetArgsError(type, "createCharacterInstance", arg); } static PyObject *t_breakiterator_createSentenceInstance(PyTypeObject *type, PyObject *arg) { Locale *locale; BreakIterator *iterator; if (!parseArg(arg, "P", TYPE_CLASSID(Locale), &locale)) { STATUS_CALL(iterator = BreakIterator::createSentenceInstance(*locale, status)); return wrap_BreakIterator(iterator); } return PyErr_SetArgsError(type, "createSentenceInstance", arg); } static PyObject *t_breakiterator_createTitleInstance(PyTypeObject *type, PyObject *arg) { Locale *locale; BreakIterator *iterator; if (!parseArg(arg, "P", TYPE_CLASSID(Locale), &locale)) { STATUS_CALL(iterator = BreakIterator::createTitleInstance(*locale, status)); return wrap_BreakIterator(iterator); } return PyErr_SetArgsError(type, "createTitleInstance", arg); } static PyObject *t_breakiterator_getAvailableLocales(PyTypeObject *type) { int count; const Locale *locales = BreakIterator::getAvailableLocales(count); PyObject *dict = PyDict_New(); for (int32_t i = 0; i < count; i++) { Locale *locale = (Locale *) locales + i; PyObject *obj = wrap_Locale(locale, 0); PyDict_SetItemString(dict, locale->getName(), obj); Py_DECREF(obj); } return dict; } static PyObject *t_breakiterator_getDisplayName(PyTypeObject *type, PyObject *args) { Locale *locale, *display; UnicodeString *u; UnicodeString _u; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "P", TYPE_CLASSID(Locale), &locale)) { BreakIterator::getDisplayName(*locale, _u); return PyUnicode_FromUnicodeString(&_u); } break; case 2: if (!parseArgs(args, "PU", TYPE_CLASSID(Locale), &locale, &u)) { BreakIterator::getDisplayName(*locale, *u); Py_RETURN_ARG(args, 1); } break; if (!parseArgs(args, "PP", TYPE_CLASSID(Locale), TYPE_CLASSID(Locale), &locale, &display)) { BreakIterator::getDisplayName(*locale, *display, _u); return PyUnicode_FromUnicodeString(&_u); } break; case 3: if (!parseArgs(args, "PPU", TYPE_CLASSID(Locale), TYPE_CLASSID(Locale), &locale, &display, &u)) { BreakIterator::getDisplayName(*locale, *display, *u); Py_RETURN_ARG(args, 2); } break; } return PyErr_SetArgsError(type, "getDisplayName", args); } static PyObject *t_breakiterator_iter(t_breakiterator *self) { Py_RETURN_SELF(); } static PyObject *t_breakiterator_iter_next(t_breakiterator *self) { int n = self->object->next(); if (n == BreakIterator::DONE) { PyErr_SetNone(PyExc_StopIteration); return NULL; } return PyInt_FromLong(n); } static PyObject *t_breakiterator_richcmp(t_breakiterator *self, PyObject *arg, int op) { int b = 0; BreakIterator *i; if (!parseArg(arg, "P", TYPE_ID(BreakIterator), &i)) { switch (op) { case Py_EQ: case Py_NE: b = *self->object == *i; if (op == Py_EQ) Py_RETURN_BOOL(b); Py_RETURN_BOOL(!b); case Py_LT: case Py_LE: case Py_GT: case Py_GE: PyErr_SetNone(PyExc_NotImplementedError); return NULL; } } return PyErr_SetArgsError((PyObject *) self, "__richcmp__", arg); } /* RuleBasedBreakIterator */ static int t_rulebasedbreakiterator_init(t_rulebasedbreakiterator *self, PyObject *args, PyObject *kwds) { UnicodeString *u, _u; charsArg path, name; switch (PyTuple_Size(args)) { case 0: self->object = new RuleBasedBreakIterator(); self->flags = T_OWNED; break; case 1: if (!parseArgs(args, "S", &u, &_u)) { RuleBasedBreakIterator *iterator; INT_STATUS_PARSER_CALL(iterator = new RuleBasedBreakIterator(*u, parseError, status)); self->object = iterator; self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; case 2: if (!parseArg(args, "fn", &path, &name)) { RuleBasedBreakIterator *iterator; UDataMemory *data; UErrorCode status; status = U_ZERO_ERROR; data = udata_open(path, NULL, name, &status); if (U_FAILURE(status)) { ICUException(status).reportError(); return -1; } status = U_ZERO_ERROR; iterator = new RuleBasedBreakIterator(data, status); if (U_FAILURE(status)) { udata_close(data); ICUException(status).reportError(); return -1; } self->object = iterator; self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; default: PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; } if (self->object) return 0; return -1; } static PyObject *t_rulebasedbreakiterator_getRules(t_rulebasedbreakiterator *self, PyObject *args) { switch (PyTuple_Size(args)) { case 0: { UnicodeString u = self->object->getRules(); return PyUnicode_FromUnicodeString(&u); } case 1: { UnicodeString *u; if (!parseArgs(args, "U", &u)) { u->setTo(self->object->getRules()); Py_RETURN_ARG(args, 0); } break; } } return PyErr_SetArgsError((PyObject *) self, "getRules", args); } static PyObject *t_rulebasedbreakiterator_getRuleStatus(t_rulebasedbreakiterator *self) { return PyInt_FromLong(self->object->getRuleStatus()); } /* DictionaryBasedBreakIterator */ static int t_dictionarybasedbreakiterator_init(t_dictionarybasedbreakiterator *self, PyObject *args, PyObject *kwds) { switch (PyTuple_Size(args)) { case 0: self->object = new DictionaryBasedBreakIterator(); self->flags = T_OWNED; break; default: PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; } if (self->object) return 0; return -1; } /* CanonicalIterator */ static int t_canonicaliterator_init(t_canonicaliterator *self, PyObject *args, PyObject *kwds) { UnicodeString *u; UnicodeString _u; if (!parseArgs(args, "S", &u, &_u)) { CanonicalIterator *iterator; INT_STATUS_CALL(iterator = new CanonicalIterator(*u, status)); self->object = iterator; self->flags = T_OWNED; return 0; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; } static PyObject *t_canonicaliterator_getSource(t_canonicaliterator *self, PyObject *args) { UnicodeString *u; UnicodeString _u; switch (PyTuple_Size(args)) { case 0: _u = self->object->getSource(); return PyUnicode_FromUnicodeString(&_u); case 1: if (!parseArgs(args, "U", &u)) { u->setTo(self->object->getSource()); Py_RETURN_ARG(args, 0); } break; } return PyErr_SetArgsError((PyObject *) self, "getSource", args); } static PyObject *t_canonicaliterator_setSource(t_canonicaliterator *self, PyObject *arg) { UnicodeString *u, _u; if (!parseArg(arg, "S", &u, &_u)) { STATUS_CALL(self->object->setSource(*u, status)); /* transient */ Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setSource", arg); } static PyObject *t_canonicaliterator_reset(t_canonicaliterator *self) { self->object->reset(); Py_RETURN_NONE; } static PyObject *t_canonicaliterator_next(t_canonicaliterator *self, PyObject *args) { UnicodeString *u; UnicodeString _u; switch (PyTuple_Size(args)) { case 0: _u = self->object->next(); if (_u.isBogus()) Py_RETURN_NONE; return PyUnicode_FromUnicodeString(&_u); case 1: if (!parseArgs(args, "U", &u)) { u->setTo(self->object->next()); Py_RETURN_ARG(args, 0); } break; } return PyErr_SetArgsError((PyObject *) self, "next", args); } static PyObject *t_canonicaliterator_iter(t_canonicaliterator *self) { self->object->reset(); Py_RETURN_SELF(); } static PyObject *t_canonicaliterator_iter_next(t_canonicaliterator *self) { UnicodeString u = self->object->next(); if (u.isBogus()) { PyErr_SetNone(PyExc_StopIteration); return NULL; } return PyUnicode_FromUnicodeString(&u); } /* CollationElementIterator */ static PyObject *t_collationelementiterator_reset(t_collationelementiterator *self) { self->object->reset(); Py_RETURN_NONE; } static PyObject *t_collationelementiterator_next(t_collationelementiterator *self) { int i; STATUS_CALL(i = self->object->next(status)); return PyInt_FromLong(i); } static PyObject *t_collationelementiterator_previous(t_collationelementiterator *self) { int i; STATUS_CALL(i = self->object->previous(status)); return PyInt_FromLong(i); } static PyObject *t_collationelementiterator_setText(t_collationelementiterator *self, PyObject *arg) { UnicodeString *u, _u; if (!parseArg(arg, "S", &u, &_u)) { STATUS_CALL(self->object->setText(*u, status)); /* copied */ Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setText", arg); } static PyObject *t_collationelementiterator_getOffset(t_collationelementiterator *self) { return PyInt_FromLong(self->object->getOffset()); } static PyObject *t_collationelementiterator_setOffset(t_collationelementiterator *self, PyObject *arg) { int offset; if (!parseArg(arg, "i", &offset)) { STATUS_CALL(self->object->setOffset(offset, status)); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setOffset", arg); } static PyObject *t_collationelementiterator_getMaxExpansion(t_collationelementiterator *self, PyObject *arg) { int i; if (!parseArg(arg, "i", &i)) return PyInt_FromLong(self->object->getMaxExpansion(i)); return PyErr_SetArgsError((PyObject *) self, "getMaxExpansion", arg); } static PyObject *t_collationelementiterator_strengthOrder(t_collationelementiterator *self, PyObject *arg) { int i; if (!parseArg(arg, "i", &i)) return PyInt_FromLong(self->object->strengthOrder(i)); return PyErr_SetArgsError((PyObject *) self, "strengthOrder", arg); } static PyObject *t_collationelementiterator_primaryOrder(PyTypeObject *type, PyObject *arg) { int i; if (!parseArg(arg, "i", &i)) return PyInt_FromLong(CollationElementIterator::primaryOrder(i)); return PyErr_SetArgsError(type, "primaryOrder", arg); } static PyObject *t_collationelementiterator_secondaryOrder(PyTypeObject *type, PyObject *arg) { int i; if (!parseArg(arg, "i", &i)) return PyInt_FromLong(CollationElementIterator::secondaryOrder(i)); return PyErr_SetArgsError(type, "secondaryOrder", arg); } static PyObject *t_collationelementiterator_tertiaryOrder(PyTypeObject *type, PyObject *arg) { int i; if (!parseArg(arg, "i", &i)) return PyInt_FromLong(CollationElementIterator::tertiaryOrder(i)); return PyErr_SetArgsError(type, "tertiaryOrder", arg); } static PyObject *t_collationelementiterator_isIgnorable(PyTypeObject *type, PyObject *arg) { int i; if (!parseArg(arg, "i", &i)) { i = CollationElementIterator::isIgnorable(i); Py_RETURN_BOOL(i); } return PyErr_SetArgsError(type, "isIgnorable", arg); } static PyObject *t_collationelementiterator_iter(t_collationelementiterator *self) { self->object->reset(); Py_RETURN_SELF(); } static PyObject *t_collationelementiterator_iter_next(t_collationelementiterator *self) { int n; STATUS_CALL(n = self->object->next(status)); if (n == CollationElementIterator::NULLORDER) { PyErr_SetNone(PyExc_StopIteration); return NULL; } return PyInt_FromLong(n); } DEFINE_RICHCMP(CollationElementIterator, t_collationelementiterator); void _init_iterators(PyObject *m) { ForwardCharacterIteratorType_.tp_iter = (getiterfunc) t_forwardcharacteriterator_iter; ForwardCharacterIteratorType_.tp_iternext = (iternextfunc) t_forwardcharacteriterator_nextPostInc; ForwardCharacterIteratorType_.tp_richcompare = (richcmpfunc) t_forwardcharacteriterator_richcmp; BreakIteratorType_.tp_iter = (getiterfunc) t_breakiterator_iter; BreakIteratorType_.tp_iternext = (iternextfunc) t_breakiterator_iter_next; BreakIteratorType_.tp_richcompare = (richcmpfunc) t_breakiterator_richcmp; CanonicalIteratorType_.tp_iter = (getiterfunc) t_canonicaliterator_iter; CanonicalIteratorType_.tp_iternext = (iternextfunc) t_canonicaliterator_iter_next; CollationElementIteratorType_.tp_iter = (getiterfunc) t_collationelementiterator_iter; CollationElementIteratorType_.tp_iternext = (iternextfunc) t_collationelementiterator_iter_next; CollationElementIteratorType_.tp_richcompare = (richcmpfunc) t_collationelementiterator_richcmp; INSTALL_TYPE(ForwardCharacterIterator, m); INSTALL_TYPE(CharacterIterator, m); REGISTER_TYPE(UCharCharacterIterator, m); REGISTER_TYPE(StringCharacterIterator, m); INSTALL_TYPE(BreakIterator, m); REGISTER_TYPE(RuleBasedBreakIterator, m); REGISTER_TYPE(DictionaryBasedBreakIterator, m); REGISTER_TYPE(CanonicalIterator, m); REGISTER_TYPE(CollationElementIterator, m); INSTALL_STATIC_INT(ForwardCharacterIterator, DONE); INSTALL_STATIC_INT(BreakIterator, DONE); INSTALL_STATIC_INT(CharacterIterator, kStart); INSTALL_STATIC_INT(CharacterIterator, kCurrent); INSTALL_STATIC_INT(CharacterIterator, kEnd); INSTALL_STATIC_INT(CollationElementIterator, NULLORDER); } PyICU-1.9.5/iterators.h0000644000076500000000000000310712520065705015052 0ustar vajdawheel00000000000000/* ==================================================================== * Copyright (c) 2004-2010 Open Source Applications Foundation. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. * ==================================================================== */ #ifndef _iterators_h #define _iterators_h extern PyTypeObject BreakIteratorType_; extern PyTypeObject CharacterIteratorType_; extern PyTypeObject CollationElementIteratorType_; PyObject *wrap_CollationElementIterator(CollationElementIterator *, int); void _init_iterators(PyObject *m); #endif /* _iterators_h */ PyICU-1.9.5/layoutengine.cpp0000644000076500000000000007332013007152361016074 0ustar vajdawheel00000000000000/* ==================================================================== * Copyright (c) 2011-2011 Open Source Applications Foundation. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. * ==================================================================== */ #include "common.h" #include "structmember.h" #if U_ICU_VERSION_HEX < VERSION_HEX(58, 0, 0) #include #include #include #include #include "bases.h" #include "layoutengine.h" #include "macros.h" DECLARE_CONSTANTS_TYPE(ScriptCode); DECLARE_CONSTANTS_TYPE(LanguageCode); static PyObject *getFontTable_NAME; /* LEFontInstance */ class t_lefontinstance : public _wrapper { public: LEFontInstance *object; }; U_NAMESPACE_BEGIN class U_EXPORT PythonLEFontInstance : public LEFontInstance { public: /** * ICU "poor man's RTTI", returns a UClassID for the actual class. */ virtual UClassID getDynamicClassID() const; /** * ICU "poor man's RTTI", returns a UClassID for this class. */ static UClassID getStaticClassID(); PythonLEFontInstance(t_lefontinstance *t_self) : self(t_self) { tables = PyDict_New(); } /** * Destructor. */ virtual ~PythonLEFontInstance() { Py_DECREF(tables); } le_int32 get_le_int32(const char *name) const { PyObject *s = PyString_FromString(name); PyObject *result = PyObject_CallMethodObjArgs((PyObject *) self, s, NULL); Py_DECREF(s); if (result != NULL) { int n; if (!parseArg(result, "i", &n)) { Py_DECREF(result); return (le_int32) n; } } return 0; } float get_float(const char *name) const { PyObject *s = PyString_FromString(name); PyObject *result = PyObject_CallMethodObjArgs((PyObject *) self, s, NULL); Py_DECREF(s); if (result != NULL) { double d; if (!parseArg(result, "d", &d)) { Py_DECREF(result); return (float) d; } } return 0.0f; } /** * LEFontInstance API. */ virtual const void *getFontTable(LETag tableTag, size_t &length) const { length = -1; return getFontTable(tableTag); } virtual const void *getFontTable(LETag tag) const { #if PY_MAJOR_VERSION >= 3 PyObject *key = PyUnicode_FromStringAndSize(NULL, 4); Py_UNICODE *s = PyUnicode_AS_UNICODE(key); #else PyObject *key = PyString_FromStringAndSize(NULL, 4); char *s = PyString_AS_STRING(key); #endif for (int i = 0; i < 4; ++i) { s[3 - i] = tag & 0xff; tag >>= 8; } PyObject *result = PyDict_GetItem(tables, key); if (result == NULL) { result = PyObject_CallMethodObjArgs((PyObject *) self, getFontTable_NAME, key, NULL); if (result == NULL) { if (PyErr_ExceptionMatches(PyExc_KeyError)) PyErr_Clear(); Py_DECREF(key); return NULL; } #if PY_MAJOR_VERSION >= 3 if (!PyBytes_CheckExact(result)) #else if (!PyString_CheckExact(result)) #endif { PyErr_SetObject(PyExc_TypeError, result); Py_DECREF(result); Py_DECREF(key); return NULL; } PyDict_SetItem(tables, key, result); Py_DECREF(result); Py_DECREF(key); } else Py_DECREF(key); #if PY_MAJOR_VERSION >= 3 return PyBytes_AS_STRING(result); #else return PyString_AS_STRING(result); #endif } virtual le_int32 getAscent() const { return get_le_int32("getAscent"); } virtual le_int32 getDescent() const { return get_le_int32("getDescent"); } virtual le_int32 getLeading() const { return get_le_int32("getLeading"); } virtual le_int32 getUnitsPerEM() const { return get_le_int32("getUnitsPerEm"); } virtual LEGlyphID mapCharToGlyph(LEUnicode32 u) const { PyObject *name = PyString_FromString("mapCharToGlyph"); PyObject *n = PyInt_FromLong(u); PyObject *result = PyObject_CallMethodObjArgs((PyObject *) self, name, n, NULL); Py_DECREF(n); Py_DECREF(name); if (result != NULL) { int id; if (!parseArg(result, "i", &id)) { Py_DECREF(result); return id; } } return 0; } virtual LEGlyphID mapCharToGlyph(LEUnicode32 u, const LECharMapper *mapper) const { return LEFontInstance::mapCharToGlyph(u, mapper); } virtual LEGlyphID mapCharToGlyph(LEUnicode32 u, const LECharMapper *mapper, le_bool filterZeroWidth) const { return LEFontInstance::mapCharToGlyph(u, mapper, filterZeroWidth); } virtual void getGlyphAdvance(LEGlyphID glyph, LEPoint &advance) const { PyObject *name = PyString_FromString("getGlyphAdvance"); PyObject *g = PyInt_FromLong(LE_GET_GLYPH(glyph)); PyObject *result = PyObject_CallMethodObjArgs((PyObject *) self, name, g, NULL); Py_DECREF(g); Py_DECREF(name); if (result != NULL) { PyArg_ParseTuple(result, "ff", &advance.fX, &advance.fY); Py_DECREF(result); } } virtual le_bool getGlyphPoint(LEGlyphID glyph, le_int32 pointNumber, LEPoint &point) const { PyObject *name = PyString_FromString("getGlyphPoint"); PyObject *g = PyInt_FromLong(LE_GET_GLYPH(glyph)); PyObject *pn = PyInt_FromLong(pointNumber); PyObject *result = PyObject_CallMethodObjArgs((PyObject *) self, name, g, pn, NULL); Py_DECREF(pn); Py_DECREF(g); Py_DECREF(name); if (result != NULL) { PyArg_ParseTuple(result, "ff", &point.fX, &point.fY); Py_DECREF(result); return true; } return false; } virtual float getXPixelsPerEm() const { return get_float("getXPixelsPerEm"); } virtual float getYPixelsPerEm() const { return get_float("getYPixelsPerEm"); } virtual float getScaleFactorX() const { return get_float("getScaleFactorX"); } virtual float getScaleFactorY() const { return get_float("getScaleFactorY"); } private: t_lefontinstance *self; PyObject *tables; }; U_NAMESPACE_END UOBJECT_DEFINE_RTTI_IMPLEMENTATION(PythonLEFontInstance); DEFINE_ABSTRACT(t_lefontinstance, LEFontInstance, getFontTable); DEFINE_ABSTRACT(t_lefontinstance, LEFontInstance, getAscent); DEFINE_ABSTRACT(t_lefontinstance, LEFontInstance, getDescent); DEFINE_ABSTRACT(t_lefontinstance, LEFontInstance, getLeading); DEFINE_ABSTRACT(t_lefontinstance, LEFontInstance, canDisplay); DEFINE_ABSTRACT(t_lefontinstance, LEFontInstance, getUnitsPerEm); DEFINE_ABSTRACT(t_lefontinstance, LEFontInstance, mapCharToGlyph); DEFINE_ABSTRACT(t_lefontinstance, LEFontInstance, getGlyphAdvance); DEFINE_ABSTRACT(t_lefontinstance, LEFontInstance, getGlyphPoint); DEFINE_ABSTRACT(t_lefontinstance, LEFontInstance, getXPixelsPerEm); DEFINE_ABSTRACT(t_lefontinstance, LEFontInstance, getYPixelsPerEm); DEFINE_ABSTRACT(t_lefontinstance, LEFontInstance, getScaleFactorX); DEFINE_ABSTRACT(t_lefontinstance, LEFontInstance, getScaleFactorY); static PyMethodDef t_lefontinstance_methods[] = { DECLARE_METHOD(t_lefontinstance, getFontTable, METH_O), DECLARE_METHOD(t_lefontinstance, getAscent, METH_NOARGS), DECLARE_METHOD(t_lefontinstance, getDescent, METH_NOARGS), DECLARE_METHOD(t_lefontinstance, getLeading, METH_NOARGS), DECLARE_METHOD(t_lefontinstance, canDisplay, METH_O), DECLARE_METHOD(t_lefontinstance, getUnitsPerEm, METH_NOARGS), DECLARE_METHOD(t_lefontinstance, mapCharToGlyph, METH_O), DECLARE_METHOD(t_lefontinstance, getGlyphAdvance, METH_O), DECLARE_METHOD(t_lefontinstance, getGlyphPoint, METH_VARARGS), DECLARE_METHOD(t_lefontinstance, getXPixelsPerEm, METH_NOARGS), DECLARE_METHOD(t_lefontinstance, getYPixelsPerEm, METH_NOARGS), DECLARE_METHOD(t_lefontinstance, getScaleFactorX, METH_NOARGS), DECLARE_METHOD(t_lefontinstance, getScaleFactorY, METH_NOARGS), { NULL, NULL, 0, NULL } }; static int t_lefontinstance_init(t_lefontinstance *self, PyObject *args, PyObject *kwds); DECLARE_TYPE(LEFontInstance, t_lefontinstance, UObject, LEFontInstance, t_lefontinstance_init, NULL); static int t_lefontinstance_init(t_lefontinstance *self, PyObject *args, PyObject *kwds) { if (PyTuple_Size(args) == 0) { self->object = new PythonLEFontInstance(self); self->flags = T_OWNED; return 0; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; } /* LayoutEngine */ class t_layoutengine : public _wrapper { public: LayoutEngine *object; }; static PyObject *t_layoutengine_layoutEngineFactory(PyTypeObject *type, PyObject *args); static PyObject *t_layoutengine_layoutChars(t_layoutengine *self, PyObject *args); static PyObject *t_layoutengine_getGlyphCount(t_layoutengine *self); static PyObject *t_layoutengine_getGlyphs(t_layoutengine *self); static PyObject *t_layoutengine_getCharIndices(t_layoutengine *self); static PyObject *t_layoutengine_getGlyphPositions(t_layoutengine *self); static PyObject *t_layoutengine_getGlyphPosition(t_layoutengine *self, PyObject *arg); static PyMethodDef t_layoutengine_methods[] = { DECLARE_METHOD(t_layoutengine, layoutEngineFactory, METH_VARARGS | METH_CLASS), DECLARE_METHOD(t_layoutengine, layoutChars, METH_VARARGS), DECLARE_METHOD(t_layoutengine, getGlyphCount, METH_NOARGS), DECLARE_METHOD(t_layoutengine, getGlyphs, METH_NOARGS), DECLARE_METHOD(t_layoutengine, getCharIndices, METH_NOARGS), DECLARE_METHOD(t_layoutengine, getGlyphPositions, METH_NOARGS), DECLARE_METHOD(t_layoutengine, getGlyphPosition, METH_O), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(LayoutEngine, t_layoutengine, UObject, LayoutEngine, abstract_init, NULL); static PyObject *t_layoutengine_layoutEngineFactory(PyTypeObject *type, PyObject *args) { LayoutEngine *le = NULL; LEFontInstance *fe; le_int32 script, language, typo_flag; switch (PyTuple_Size(args)) { case 3: if (!parseArgs(args, "Pii", TYPE_CLASSID(LEFontInstance), &fe, &script, &language)) { STATUS_CALL( le = LayoutEngine::layoutEngineFactory( fe, script, language, (LEErrorCode &) status)); break; } return PyErr_SetArgsError((PyObject *) type, "__init__", args); case 4: if (!parseArgs(args, "Piii", TYPE_CLASSID(LEFontInstance), &fe, &script, &language, &typo_flag)) { STATUS_CALL( le = LayoutEngine::layoutEngineFactory( fe, script, language, typo_flag, (LEErrorCode &) status)); break; } return PyErr_SetArgsError((PyObject *) type, "__init__", args); default: return PyErr_SetArgsError((PyObject *) type, "__init__", args); } return wrap_LayoutEngine(le, T_OWNED); } static PyObject *t_layoutengine_layoutChars(t_layoutengine *self, PyObject *args) { UnicodeString *u0, _u0; le_int32 n, offset, count; double x, y; int rtl; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "S", &u0, &_u0)) { STATUS_CALL( n = self->object->layoutChars( (const LEUnicode *) (u0->getBuffer()), 0, u0->length(), u0->length(), false, 0.0f, 0.0f, (LEErrorCode &) status)); return PyInt_FromLong(n); } break; case 3: if (!parseArgs(args, "Sii", &u0, &_u0, &offset, &count)) { STATUS_CALL( n = self->object->layoutChars( (const LEUnicode *) (u0->getBuffer()), offset, count, u0->length(), false, 0.0f, 0.0f, (LEErrorCode &) status)); return PyInt_FromLong(n); } break; case 4: if (!parseArgs(args, "Siii", &u0, &_u0, &offset, &count, &rtl)) { STATUS_CALL( n = self->object->layoutChars( (const LEUnicode *) (u0->getBuffer()), offset, count, u0->length(), rtl, 0.0f, 0.0f, (LEErrorCode &) status)); return PyInt_FromLong(n); } break; case 6: if (!parseArgs(args, "Siiidd", &u0, &_u0, &offset, &count, &rtl, &x, &y)) { STATUS_CALL( n = self->object->layoutChars( (const LEUnicode *) (u0->getBuffer()), offset, count, u0->length(), rtl, (float) x, (float) y, (LEErrorCode &) status)); return PyInt_FromLong(n); } break; } return PyErr_SetArgsError((PyObject *) self, "layoutChars", args); } static PyObject *t_layoutengine_getGlyphCount(t_layoutengine *self) { return PyInt_FromLong(self->object->getGlyphCount()); } static PyObject *t_layoutengine_getGlyphs(t_layoutengine *self) { le_int32 num = self->object->getGlyphCount(); LEGlyphID *glyphs = new LEGlyphID[num]; PyObject *tuple; STATUS_CALL(self->object->getGlyphs(glyphs, (LEErrorCode &) status)); tuple = PyTuple_New(num); for (int i = 0; i < num; i++) PyTuple_SET_ITEM(tuple, i, PyInt_FromLong(glyphs[i])); delete[] glyphs; return tuple; } static PyObject *t_layoutengine_getCharIndices(t_layoutengine *self) { le_int32 num = self->object->getGlyphCount(); le_int32 *charIndices = new le_int32[num]; PyObject *tuple; STATUS_CALL(self->object->getCharIndices(charIndices, (LEErrorCode &) status)); tuple = PyTuple_New(num); for (int i = 0; i < num; i++) PyTuple_SET_ITEM(tuple, i, PyInt_FromLong(charIndices[i])); delete[] charIndices; return tuple; } static PyObject *t_layoutengine_getGlyphPositions(t_layoutengine *self) { le_int32 num = self->object->getGlyphCount() + 1; float *positions = new float[num * 2]; PyObject *tuple; STATUS_CALL(self->object->getGlyphPositions(positions, (LEErrorCode &) status)); tuple = PyTuple_New(num); for (int i = 0; i < num; i++) PyTuple_SET_ITEM(tuple, i, Py_BuildValue("(ff)", positions[2 * i], positions[2 * i + 1])); delete[] positions; return tuple; } static PyObject *t_layoutengine_getGlyphPosition(t_layoutengine *self, PyObject *arg) { le_int32 n; float x, y; if (!parseArg(arg, "i", &n)) { STATUS_CALL(self->object->getGlyphPosition(n, x, y, (LEErrorCode &) status)); return Py_BuildValue("(ff)", x, y); } return PyErr_SetArgsError((PyObject *) self, "getGlyphPosition", arg); } void _init_layoutengine(PyObject *m) { INSTALL_CONSTANTS_TYPE(ScriptCode, m); INSTALL_CONSTANTS_TYPE(LanguageCode, m); REGISTER_TYPE(LEFontInstance, m); REGISTER_TYPE(LayoutEngine, m); INSTALL_ENUM(ScriptCode, "zyyy", zyyyScriptCode); #if U_ICU_VERSION_HEX >= 0x04040200 INSTALL_ENUM(ScriptCode, "zinh", zinhScriptCode); #endif INSTALL_ENUM(ScriptCode, "qaai", qaaiScriptCode); INSTALL_ENUM(ScriptCode, "arab", arabScriptCode); INSTALL_ENUM(ScriptCode, "armn", armnScriptCode); INSTALL_ENUM(ScriptCode, "beng", bengScriptCode); INSTALL_ENUM(ScriptCode, "bopo", bopoScriptCode); INSTALL_ENUM(ScriptCode, "cher", cherScriptCode); INSTALL_ENUM(ScriptCode, "copt", coptScriptCode); INSTALL_ENUM(ScriptCode, "cyrl", cyrlScriptCode); INSTALL_ENUM(ScriptCode, "dsrt", dsrtScriptCode); INSTALL_ENUM(ScriptCode, "deva", devaScriptCode); INSTALL_ENUM(ScriptCode, "ethi", ethiScriptCode); INSTALL_ENUM(ScriptCode, "geor", georScriptCode); INSTALL_ENUM(ScriptCode, "goth", gothScriptCode); INSTALL_ENUM(ScriptCode, "grek", grekScriptCode); INSTALL_ENUM(ScriptCode, "gujr", gujrScriptCode); INSTALL_ENUM(ScriptCode, "guru", guruScriptCode); INSTALL_ENUM(ScriptCode, "hani", haniScriptCode); INSTALL_ENUM(ScriptCode, "hang", hangScriptCode); INSTALL_ENUM(ScriptCode, "hebr", hebrScriptCode); INSTALL_ENUM(ScriptCode, "hira", hiraScriptCode); INSTALL_ENUM(ScriptCode, "knda", kndaScriptCode); INSTALL_ENUM(ScriptCode, "kana", kanaScriptCode); INSTALL_ENUM(ScriptCode, "khmr", khmrScriptCode); INSTALL_ENUM(ScriptCode, "laoo", laooScriptCode); INSTALL_ENUM(ScriptCode, "latn", latnScriptCode); INSTALL_ENUM(ScriptCode, "mlym", mlymScriptCode); INSTALL_ENUM(ScriptCode, "mong", mongScriptCode); INSTALL_ENUM(ScriptCode, "mymr", mymrScriptCode); INSTALL_ENUM(ScriptCode, "ogam", ogamScriptCode); INSTALL_ENUM(ScriptCode, "ital", italScriptCode); INSTALL_ENUM(ScriptCode, "orya", oryaScriptCode); INSTALL_ENUM(ScriptCode, "runr", runrScriptCode); INSTALL_ENUM(ScriptCode, "sinh", sinhScriptCode); INSTALL_ENUM(ScriptCode, "syrc", syrcScriptCode); INSTALL_ENUM(ScriptCode, "taml", tamlScriptCode); INSTALL_ENUM(ScriptCode, "telu", teluScriptCode); INSTALL_ENUM(ScriptCode, "thaa", thaaScriptCode); INSTALL_ENUM(ScriptCode, "thai", thaiScriptCode); INSTALL_ENUM(ScriptCode, "tibt", tibtScriptCode); INSTALL_ENUM(ScriptCode, "cans", cansScriptCode); INSTALL_ENUM(ScriptCode, "yiii", yiiiScriptCode); INSTALL_ENUM(ScriptCode, "tglg", tglgScriptCode); INSTALL_ENUM(ScriptCode, "hano", hanoScriptCode); INSTALL_ENUM(ScriptCode, "buhd", buhdScriptCode); INSTALL_ENUM(ScriptCode, "tagb", tagbScriptCode); INSTALL_ENUM(ScriptCode, "brai", braiScriptCode); INSTALL_ENUM(ScriptCode, "cprt", cprtScriptCode); INSTALL_ENUM(ScriptCode, "limb", limbScriptCode); INSTALL_ENUM(ScriptCode, "linb", linbScriptCode); INSTALL_ENUM(ScriptCode, "osma", osmaScriptCode); INSTALL_ENUM(ScriptCode, "shaw", shawScriptCode); INSTALL_ENUM(ScriptCode, "tale", taleScriptCode); INSTALL_ENUM(ScriptCode, "ugar", ugarScriptCode); INSTALL_ENUM(ScriptCode, "hrkt", hrktScriptCode); INSTALL_ENUM(ScriptCode, "bugi", bugiScriptCode); INSTALL_ENUM(ScriptCode, "glag", glagScriptCode); INSTALL_ENUM(ScriptCode, "khar", kharScriptCode); INSTALL_ENUM(ScriptCode, "sylo", syloScriptCode); INSTALL_ENUM(ScriptCode, "talu", taluScriptCode); INSTALL_ENUM(ScriptCode, "tfng", tfngScriptCode); INSTALL_ENUM(ScriptCode, "xpeo", xpeoScriptCode); INSTALL_ENUM(ScriptCode, "bali", baliScriptCode); INSTALL_ENUM(ScriptCode, "batk", batkScriptCode); INSTALL_ENUM(ScriptCode, "blis", blisScriptCode); INSTALL_ENUM(ScriptCode, "brah", brahScriptCode); INSTALL_ENUM(ScriptCode, "cham", chamScriptCode); INSTALL_ENUM(ScriptCode, "cirt", cirtScriptCode); INSTALL_ENUM(ScriptCode, "cyrs", cyrsScriptCode); INSTALL_ENUM(ScriptCode, "egyd", egydScriptCode); INSTALL_ENUM(ScriptCode, "egyh", egyhScriptCode); INSTALL_ENUM(ScriptCode, "egyp", egypScriptCode); INSTALL_ENUM(ScriptCode, "geok", geokScriptCode); INSTALL_ENUM(ScriptCode, "hans", hansScriptCode); INSTALL_ENUM(ScriptCode, "hant", hantScriptCode); INSTALL_ENUM(ScriptCode, "hmng", hmngScriptCode); INSTALL_ENUM(ScriptCode, "hung", hungScriptCode); INSTALL_ENUM(ScriptCode, "inds", indsScriptCode); INSTALL_ENUM(ScriptCode, "java", javaScriptCode); INSTALL_ENUM(ScriptCode, "kali", kaliScriptCode); INSTALL_ENUM(ScriptCode, "latf", latfScriptCode); INSTALL_ENUM(ScriptCode, "latg", latgScriptCode); INSTALL_ENUM(ScriptCode, "lepc", lepcScriptCode); INSTALL_ENUM(ScriptCode, "lina", linaScriptCode); INSTALL_ENUM(ScriptCode, "mand", mandScriptCode); INSTALL_ENUM(ScriptCode, "maya", mayaScriptCode); INSTALL_ENUM(ScriptCode, "mero", meroScriptCode); INSTALL_ENUM(ScriptCode, "nkoo", nkooScriptCode); INSTALL_ENUM(ScriptCode, "orkh", orkhScriptCode); INSTALL_ENUM(ScriptCode, "perm", permScriptCode); INSTALL_ENUM(ScriptCode, "phag", phagScriptCode); INSTALL_ENUM(ScriptCode, "phnx", phnxScriptCode); INSTALL_ENUM(ScriptCode, "plrd", plrdScriptCode); INSTALL_ENUM(ScriptCode, "roro", roroScriptCode); INSTALL_ENUM(ScriptCode, "sara", saraScriptCode); INSTALL_ENUM(ScriptCode, "syre", syreScriptCode); INSTALL_ENUM(ScriptCode, "syrj", syrjScriptCode); INSTALL_ENUM(ScriptCode, "syrn", syrnScriptCode); INSTALL_ENUM(ScriptCode, "teng", tengScriptCode); INSTALL_ENUM(ScriptCode, "vaii", vaiiScriptCode); INSTALL_ENUM(ScriptCode, "visp", vispScriptCode); INSTALL_ENUM(ScriptCode, "xsux", xsuxScriptCode); INSTALL_ENUM(ScriptCode, "zxxx", zxxxScriptCode); INSTALL_ENUM(ScriptCode, "zzzz", zzzzScriptCode); INSTALL_ENUM(ScriptCode, "cari", cariScriptCode); INSTALL_ENUM(ScriptCode, "jpan", jpanScriptCode); INSTALL_ENUM(ScriptCode, "lana", lanaScriptCode); INSTALL_ENUM(ScriptCode, "lyci", lyciScriptCode); INSTALL_ENUM(ScriptCode, "lydi", lydiScriptCode); INSTALL_ENUM(ScriptCode, "olck", olckScriptCode); INSTALL_ENUM(ScriptCode, "rjng", rjngScriptCode); INSTALL_ENUM(ScriptCode, "saur", saurScriptCode); INSTALL_ENUM(ScriptCode, "sgnw", sgnwScriptCode); INSTALL_ENUM(ScriptCode, "sund", sundScriptCode); INSTALL_ENUM(ScriptCode, "moon", moonScriptCode); INSTALL_ENUM(ScriptCode, "mtei", mteiScriptCode); #if U_ICU_VERSION_HEX >= 0x04000000 INSTALL_ENUM(ScriptCode, "armi", armiScriptCode); INSTALL_ENUM(ScriptCode, "avst", avstScriptCode); INSTALL_ENUM(ScriptCode, "cakm", cakmScriptCode); INSTALL_ENUM(ScriptCode, "kore", koreScriptCode); INSTALL_ENUM(ScriptCode, "kthi", kthiScriptCode); INSTALL_ENUM(ScriptCode, "mani", maniScriptCode); INSTALL_ENUM(ScriptCode, "phli", phliScriptCode); INSTALL_ENUM(ScriptCode, "phlp", phlpScriptCode); INSTALL_ENUM(ScriptCode, "phlv", phlvScriptCode); INSTALL_ENUM(ScriptCode, "prti", prtiScriptCode); INSTALL_ENUM(ScriptCode, "samr", samrScriptCode); INSTALL_ENUM(ScriptCode, "tavt", tavtScriptCode); INSTALL_ENUM(ScriptCode, "zmth", zmthScriptCode); INSTALL_ENUM(ScriptCode, "zsym", zsymScriptCode); #if U_ICU_VERSION_HEX >= 0x04040000 INSTALL_ENUM(ScriptCode, "bamu", bamuScriptCode); INSTALL_ENUM(ScriptCode, "lisu", lisuScriptCode); INSTALL_ENUM(ScriptCode, "nkgb", nkgbScriptCode); INSTALL_ENUM(ScriptCode, "sarb", sarbScriptCode); #if U_ICU_VERSION_HEX >= 0x04060000 INSTALL_ENUM(ScriptCode, "bass", bassScriptCode); INSTALL_ENUM(ScriptCode, "dupl", duplScriptCode); INSTALL_ENUM(ScriptCode, "elba", elbaScriptCode); INSTALL_ENUM(ScriptCode, "gran", granScriptCode); INSTALL_ENUM(ScriptCode, "kpel", kpelScriptCode); INSTALL_ENUM(ScriptCode, "loma", lomaScriptCode); INSTALL_ENUM(ScriptCode, "mend", mendScriptCode); INSTALL_ENUM(ScriptCode, "merc", mercScriptCode); INSTALL_ENUM(ScriptCode, "narb", narbScriptCode); INSTALL_ENUM(ScriptCode, "nbat", nbatScriptCode); INSTALL_ENUM(ScriptCode, "palm", palmScriptCode); INSTALL_ENUM(ScriptCode, "sind", sindScriptCode); INSTALL_ENUM(ScriptCode, "wara", waraScriptCode); #if U_ICU_VERSION_HEX >= VERSION_HEX(49, 0, 0) INSTALL_ENUM(ScriptCode, "afak", afakScriptCode); INSTALL_ENUM(ScriptCode, "jurc", jurcScriptCode); INSTALL_ENUM(ScriptCode, "khoj", khojScriptCode); INSTALL_ENUM(ScriptCode, "mroo", mrooScriptCode); INSTALL_ENUM(ScriptCode, "nshu", nshuScriptCode); INSTALL_ENUM(ScriptCode, "shrd", shrdScriptCode); INSTALL_ENUM(ScriptCode, "sora", soraScriptCode); INSTALL_ENUM(ScriptCode, "takr", takrScriptCode); INSTALL_ENUM(ScriptCode, "tang", tangScriptCode); INSTALL_ENUM(ScriptCode, "tirh", tirhScriptCode); INSTALL_ENUM(ScriptCode, "wole", woleScriptCode); #endif /* 49.0 */ #endif /* 4.6 */ #endif /* 4.4 */ #endif /* 4.0 */ INSTALL_ENUM(LanguageCode, "nul", nullLanguageCode); INSTALL_ENUM(LanguageCode, "ara", araLanguageCode); INSTALL_ENUM(LanguageCode, "asm", asmLanguageCode); INSTALL_ENUM(LanguageCode, "ben", benLanguageCode); INSTALL_ENUM(LanguageCode, "far", farLanguageCode); INSTALL_ENUM(LanguageCode, "guj", gujLanguageCode); INSTALL_ENUM(LanguageCode, "hin", hinLanguageCode); INSTALL_ENUM(LanguageCode, "iwr", iwrLanguageCode); INSTALL_ENUM(LanguageCode, "jii", jiiLanguageCode); INSTALL_ENUM(LanguageCode, "jan", janLanguageCode); INSTALL_ENUM(LanguageCode, "kan", kanLanguageCode); INSTALL_ENUM(LanguageCode, "kok", kokLanguageCode); INSTALL_ENUM(LanguageCode, "kor", korLanguageCode); INSTALL_ENUM(LanguageCode, "ksh", kshLanguageCode); INSTALL_ENUM(LanguageCode, "mal", malLanguageCode); INSTALL_ENUM(LanguageCode, "mar", marLanguageCode); INSTALL_ENUM(LanguageCode, "mlr", mlrLanguageCode); INSTALL_ENUM(LanguageCode, "mni", mniLanguageCode); INSTALL_ENUM(LanguageCode, "ori", oriLanguageCode); INSTALL_ENUM(LanguageCode, "san", sanLanguageCode); INSTALL_ENUM(LanguageCode, "snd", sndLanguageCode); INSTALL_ENUM(LanguageCode, "snh", snhLanguageCode); INSTALL_ENUM(LanguageCode, "syr", syrLanguageCode); INSTALL_ENUM(LanguageCode, "tam", tamLanguageCode); INSTALL_ENUM(LanguageCode, "tel", telLanguageCode); INSTALL_ENUM(LanguageCode, "tha", thaLanguageCode); INSTALL_ENUM(LanguageCode, "urd", urdLanguageCode); INSTALL_ENUM(LanguageCode, "zhp", zhpLanguageCode); INSTALL_ENUM(LanguageCode, "zhs", zhsLanguageCode); INSTALL_ENUM(LanguageCode, "zht", zhtLanguageCode); #if U_ICU_VERSION_HEX >= 0x04000000 INSTALL_ENUM(LanguageCode, "afk", afkLanguageCode); INSTALL_ENUM(LanguageCode, "bel", belLanguageCode); INSTALL_ENUM(LanguageCode, "bgr", bgrLanguageCode); INSTALL_ENUM(LanguageCode, "cat", catLanguageCode); INSTALL_ENUM(LanguageCode, "che", cheLanguageCode); INSTALL_ENUM(LanguageCode, "cop", copLanguageCode); INSTALL_ENUM(LanguageCode, "csy", csyLanguageCode); INSTALL_ENUM(LanguageCode, "dan", danLanguageCode); INSTALL_ENUM(LanguageCode, "deu", deuLanguageCode); INSTALL_ENUM(LanguageCode, "dzn", dznLanguageCode); INSTALL_ENUM(LanguageCode, "ell", ellLanguageCode); INSTALL_ENUM(LanguageCode, "eng", engLanguageCode); INSTALL_ENUM(LanguageCode, "esp", espLanguageCode); INSTALL_ENUM(LanguageCode, "eti", etiLanguageCode); INSTALL_ENUM(LanguageCode, "euq", euqLanguageCode); INSTALL_ENUM(LanguageCode, "fin", finLanguageCode); INSTALL_ENUM(LanguageCode, "fra", fraLanguageCode); INSTALL_ENUM(LanguageCode, "gae", gaeLanguageCode); INSTALL_ENUM(LanguageCode, "hau", hauLanguageCode); INSTALL_ENUM(LanguageCode, "hrv", hrvLanguageCode); INSTALL_ENUM(LanguageCode, "hun", hunLanguageCode); INSTALL_ENUM(LanguageCode, "hye", hyeLanguageCode); INSTALL_ENUM(LanguageCode, "ind", indLanguageCode); INSTALL_ENUM(LanguageCode, "ita", itaLanguageCode); INSTALL_ENUM(LanguageCode, "khm", khmLanguageCode); INSTALL_ENUM(LanguageCode, "mng", mngLanguageCode); INSTALL_ENUM(LanguageCode, "mts", mtsLanguageCode); INSTALL_ENUM(LanguageCode, "nep", nepLanguageCode); INSTALL_ENUM(LanguageCode, "nld", nldLanguageCode); INSTALL_ENUM(LanguageCode, "pas", pasLanguageCode); INSTALL_ENUM(LanguageCode, "plk", plkLanguageCode); INSTALL_ENUM(LanguageCode, "ptg", ptgLanguageCode); INSTALL_ENUM(LanguageCode, "rom", romLanguageCode); INSTALL_ENUM(LanguageCode, "rus", rusLanguageCode); INSTALL_ENUM(LanguageCode, "sky", skyLanguageCode); INSTALL_ENUM(LanguageCode, "slv", slvLanguageCode); INSTALL_ENUM(LanguageCode, "sqi", sqiLanguageCode); INSTALL_ENUM(LanguageCode, "srb", srbLanguageCode); INSTALL_ENUM(LanguageCode, "sve", sveLanguageCode); INSTALL_ENUM(LanguageCode, "tib", tibLanguageCode); INSTALL_ENUM(LanguageCode, "trk", trkLanguageCode); INSTALL_ENUM(LanguageCode, "wel", welLanguageCode); #endif /* 4.0 */ getFontTable_NAME = PyString_FromString("getFontTable"); } #endif /* < 58 */ PyICU-1.9.5/layoutengine.h0000644000076500000000000000257713007152472015552 0ustar vajdawheel00000000000000/* ==================================================================== * Copyright (c) 2011-2011 Open Source Applications Foundation. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. * ==================================================================== */ #ifndef _layoutengine_h #define _layoutengine_h void _init_layoutengine(PyObject *m); #endif /* _layoutengine_h */ PyICU-1.9.5/LICENSE0000644000076500000000000000240410413621043013661 0ustar vajdawheel00000000000000/* ==================================================================== * Copyright (c) 2005 Open Source Applications Foundation. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. * ==================================================================== */ PyICU-1.9.5/locale.cpp0000644000076500000000000013460312724163315014640 0ustar vajdawheel00000000000000/* ==================================================================== * Copyright (c) 2004-2014 Open Source Applications Foundation. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. * ==================================================================== */ #include #include #if defined(_MSC_VER) || defined(__WIN32) #include #else #include #include #include #endif #include "common.h" #include "structmember.h" #include "bases.h" #include "locale.h" #include "macros.h" #include "unicodeset.h" DECLARE_CONSTANTS_TYPE(ULocDataLocaleType); DECLARE_CONSTANTS_TYPE(UResType); DECLARE_CONSTANTS_TYPE(ULocaleDataDelimiterType); DECLARE_CONSTANTS_TYPE(ULocaleDataExemplarSetType); DECLARE_CONSTANTS_TYPE(UMeasurementSystem); /* Locale */ class t_locale : public _wrapper { public: Locale *object; }; static int t_locale_init(t_locale *self, PyObject *args, PyObject *kwds); static PyObject *t_locale_getLanguage(t_locale *self); static PyObject *t_locale_getScript(t_locale *self); static PyObject *t_locale_getCountry(t_locale *self); static PyObject *t_locale_getVariant(t_locale *self); static PyObject *t_locale_getName(t_locale *self); static PyObject *t_locale_getBaseName(t_locale *self); static PyObject *t_locale_getISO3Language(t_locale *self); static PyObject *t_locale_getISO3Country(t_locale *self); static PyObject *t_locale_getLCID(t_locale *self); static PyObject *t_locale_getDisplayLanguage(t_locale *self, PyObject *args); static PyObject *t_locale_getDisplayScript(t_locale *self, PyObject *args); static PyObject *t_locale_getDisplayCountry(t_locale *self, PyObject *args); static PyObject *t_locale_getDisplayVariant(t_locale *self, PyObject *args); static PyObject *t_locale_getDisplayName(t_locale *self, PyObject *args); static PyObject *t_locale_createKeywords(t_locale *self); static PyObject *t_locale_getKeywordValue(t_locale *self, PyObject *arg); #if U_ICU_VERSION_HEX >= VERSION_HEX(49, 0, 0) static PyObject *t_locale_setKeywordValue(t_locale *self, PyObject *args); static PyObject *t_locale_removeKeywordValue(t_locale *self, PyObject *arg); #endif static PyObject *t_locale_isBogus(t_locale *self); static PyObject *t_locale_setToBogus(t_locale *self); #if U_ICU_VERSION_HEX >= 0x04000000 static PyObject *t_locale_addLikelySubtags(t_locale *self); static PyObject *t_locale_minimizeSubtags(t_locale *self); #endif #if U_ICU_VERSION_HEX >= 0x04040000 static PyObject *t_locale_getRoot(PyTypeObject *type); #endif static PyObject *t_locale_getEnglish(PyTypeObject *type); static PyObject *t_locale_getFrench(PyTypeObject *type); static PyObject *t_locale_getGerman(PyTypeObject *type); static PyObject *t_locale_getItalian(PyTypeObject *type); static PyObject *t_locale_getJapanese(PyTypeObject *type); static PyObject *t_locale_getKorean(PyTypeObject *type); static PyObject *t_locale_getChinese(PyTypeObject *type); static PyObject *t_locale_getSimplifiedChinese(PyTypeObject *type); static PyObject *t_locale_getTraditionalChinese(PyTypeObject *type); static PyObject *t_locale_getFrance(PyTypeObject *type); static PyObject *t_locale_getGermany(PyTypeObject *type); static PyObject *t_locale_getItaly(PyTypeObject *type); static PyObject *t_locale_getJapan(PyTypeObject *type); static PyObject *t_locale_getKorea(PyTypeObject *type); static PyObject *t_locale_getChina(PyTypeObject *type); static PyObject *t_locale_getPRC(PyTypeObject *type); static PyObject *t_locale_getTaiwan(PyTypeObject *type); static PyObject *t_locale_getUK(PyTypeObject *type); static PyObject *t_locale_getUS(PyTypeObject *type); static PyObject *t_locale_getCanada(PyTypeObject *type); static PyObject *t_locale_getCanadaFrench(PyTypeObject *type); static PyObject *t_locale_getDefault(PyTypeObject *type); static PyObject *t_locale_setDefault(PyTypeObject *type, PyObject *args); static PyObject *t_locale_createFromName(PyTypeObject *type, PyObject *args); static PyObject *t_locale_createCanonical(PyTypeObject *type, PyObject *arg); static PyObject *t_locale_getAvailableLocales(PyTypeObject *type); static PyObject *t_locale_getISOCountries(PyTypeObject *type); static PyObject *t_locale_getISOLanguages(PyTypeObject *type); static PyMethodDef t_locale_methods[] = { DECLARE_METHOD(t_locale, getLanguage, METH_NOARGS), DECLARE_METHOD(t_locale, getScript, METH_NOARGS), DECLARE_METHOD(t_locale, getCountry, METH_NOARGS), DECLARE_METHOD(t_locale, getVariant, METH_NOARGS), DECLARE_METHOD(t_locale, getName, METH_NOARGS), DECLARE_METHOD(t_locale, getBaseName, METH_NOARGS), DECLARE_METHOD(t_locale, getISO3Language, METH_NOARGS), DECLARE_METHOD(t_locale, getISO3Country, METH_NOARGS), DECLARE_METHOD(t_locale, getLCID, METH_NOARGS), DECLARE_METHOD(t_locale, getDisplayLanguage, METH_VARARGS), DECLARE_METHOD(t_locale, getDisplayScript, METH_VARARGS), DECLARE_METHOD(t_locale, getDisplayCountry, METH_VARARGS), DECLARE_METHOD(t_locale, getDisplayVariant, METH_VARARGS), DECLARE_METHOD(t_locale, getDisplayName, METH_VARARGS), DECLARE_METHOD(t_locale, createKeywords, METH_NOARGS), DECLARE_METHOD(t_locale, getKeywordValue, METH_O), #if U_ICU_VERSION_HEX >= VERSION_HEX(49, 0, 0) DECLARE_METHOD(t_locale, setKeywordValue, METH_VARARGS), DECLARE_METHOD(t_locale, removeKeywordValue, METH_O), #endif DECLARE_METHOD(t_locale, isBogus, METH_NOARGS), DECLARE_METHOD(t_locale, setToBogus, METH_NOARGS), #if U_ICU_VERSION_HEX >= 0x04000000 DECLARE_METHOD(t_locale, addLikelySubtags, METH_NOARGS), DECLARE_METHOD(t_locale, minimizeSubtags, METH_NOARGS), #endif #if U_ICU_VERSION_HEX >= 0x04040000 DECLARE_METHOD(t_locale, getRoot, METH_NOARGS | METH_CLASS), #endif DECLARE_METHOD(t_locale, getEnglish, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_locale, getFrench, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_locale, getGerman, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_locale, getItalian, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_locale, getJapanese, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_locale, getKorean, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_locale, getChinese, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_locale, getSimplifiedChinese, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_locale, getTraditionalChinese, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_locale, getFrance, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_locale, getGermany, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_locale, getItaly, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_locale, getJapan, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_locale, getKorea, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_locale, getChina, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_locale, getPRC, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_locale, getTaiwan, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_locale, getUK, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_locale, getUS, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_locale, getCanada, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_locale, getCanadaFrench, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_locale, getDefault, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_locale, setDefault, METH_VARARGS | METH_CLASS), DECLARE_METHOD(t_locale, createFromName, METH_VARARGS | METH_CLASS), DECLARE_METHOD(t_locale, createCanonical, METH_O | METH_CLASS), DECLARE_METHOD(t_locale, getAvailableLocales, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_locale, getISOCountries, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_locale, getISOLanguages, METH_NOARGS | METH_CLASS), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(Locale, t_locale, UObject, Locale, t_locale_init, NULL); PyObject *wrap_Locale(const Locale &locale) { return wrap_Locale(new Locale(locale), T_OWNED); } /* ResourceBundle */ class t_resourcebundle : public _wrapper { public: ResourceBundle *object; }; static int t_resourcebundle_init(t_resourcebundle *self, PyObject *args, PyObject *kwds); static PyObject *t_resourcebundle_getSize(t_resourcebundle *self); static PyObject *t_resourcebundle_getString(t_resourcebundle *self, PyObject *args); static PyObject *t_resourcebundle_getUInt(t_resourcebundle *self); static PyObject *t_resourcebundle_getInt(t_resourcebundle *self); static PyObject *t_resourcebundle_getKey(t_resourcebundle *self); static PyObject *t_resourcebundle_getName(t_resourcebundle *self); static PyObject *t_resourcebundle_getType(t_resourcebundle *self); static PyObject *t_resourcebundle_hasNext(t_resourcebundle *self); static PyObject *t_resourcebundle_resetIterator(t_resourcebundle *self); static PyObject *t_resourcebundle_getNext(t_resourcebundle *self); static PyObject *t_resourcebundle_getNextString(t_resourcebundle *self, PyObject *args); static PyObject *t_resourcebundle_get(t_resourcebundle *self, PyObject *arg); static PyObject *t_resourcebundle_getWithFallback(t_resourcebundle *self, PyObject *arg); static PyObject *t_resourcebundle_getStringEx(t_resourcebundle *self, PyObject *args); static PyObject *t_resourcebundle_getVersionNumber(t_resourcebundle *self); static PyObject *t_resourcebundle_getBinary(t_resourcebundle *self); static PyObject *t_resourcebundle_getIntVector(t_resourcebundle *self); static PyObject *t_resourcebundle_getLocale(t_resourcebundle *self, PyObject *args); #ifndef PYPY_VERSION static PyObject *t_resourcebundle_setAppData(PyTypeObject *type, PyObject *args); #endif static PyMethodDef t_resourcebundle_methods[] = { DECLARE_METHOD(t_resourcebundle, getSize, METH_NOARGS), DECLARE_METHOD(t_resourcebundle, getString, METH_VARARGS), DECLARE_METHOD(t_resourcebundle, getUInt, METH_NOARGS), DECLARE_METHOD(t_resourcebundle, getInt, METH_NOARGS), DECLARE_METHOD(t_resourcebundle, getKey, METH_NOARGS), DECLARE_METHOD(t_resourcebundle, getName, METH_NOARGS), DECLARE_METHOD(t_resourcebundle, getType, METH_NOARGS), DECLARE_METHOD(t_resourcebundle, hasNext, METH_NOARGS), DECLARE_METHOD(t_resourcebundle, resetIterator, METH_NOARGS), DECLARE_METHOD(t_resourcebundle, getNext, METH_NOARGS), DECLARE_METHOD(t_resourcebundle, getNextString, METH_VARARGS), DECLARE_METHOD(t_resourcebundle, get, METH_O), DECLARE_METHOD(t_resourcebundle, getWithFallback, METH_O), DECLARE_METHOD(t_resourcebundle, getStringEx, METH_VARARGS), DECLARE_METHOD(t_resourcebundle, getVersionNumber, METH_NOARGS), DECLARE_METHOD(t_resourcebundle, getBinary, METH_NOARGS), DECLARE_METHOD(t_resourcebundle, getIntVector, METH_NOARGS), DECLARE_METHOD(t_resourcebundle, getLocale, METH_VARARGS), #ifndef PYPY_VERSION DECLARE_METHOD(t_resourcebundle, setAppData, METH_CLASS | METH_VARARGS), #endif { NULL, NULL, 0, NULL } }; DECLARE_TYPE(ResourceBundle, t_resourcebundle, UObject, ResourceBundle, t_resourcebundle_init, NULL); static PyObject *wrap_ResourceBundle(const ResourceBundle &resourcebundle) { return wrap_ResourceBundle(new ResourceBundle(resourcebundle), T_OWNED); } /* LocaleData */ class t_localedata : public _wrapper { public: ULocaleData *object; char *locale_id; }; static int t_localedata_init(t_localedata *self, PyObject *args, PyObject *kwds); static PyObject *t_localedata_getNoSubstitute(t_localedata *self); static PyObject *t_localedata_setNoSubstitute(t_localedata *self, PyObject *arg); static PyObject *t_localedata_getPaperSize(t_localedata *self); static PyObject *t_localedata_getLocaleDisplayPattern(t_localedata *self); static PyObject *t_localedata_getLocaleSeparator(t_localedata *self); static PyObject *t_localedata_getDelimiter(t_localedata *self, PyObject *arg); static PyObject *t_localedata_getMeasurementSystem(t_localedata *self); static PyObject *t_localedata_getExemplarSet(t_localedata *self, PyObject *args); static PyMethodDef t_localedata_methods[] = { DECLARE_METHOD(t_localedata, getNoSubstitute, METH_NOARGS), DECLARE_METHOD(t_localedata, setNoSubstitute, METH_O), DECLARE_METHOD(t_localedata, getPaperSize, METH_NOARGS), DECLARE_METHOD(t_localedata, getLocaleDisplayPattern, METH_NOARGS), DECLARE_METHOD(t_localedata, getLocaleSeparator, METH_NOARGS), DECLARE_METHOD(t_localedata, getDelimiter, METH_O), DECLARE_METHOD(t_localedata, getMeasurementSystem, METH_NOARGS), DECLARE_METHOD(t_localedata, getExemplarSet, METH_VARARGS), { NULL, NULL, 0, NULL } }; static void t_localedata_dealloc(t_localedata *self) { if (self->object) { ulocdata_close(self->object); self->object = NULL; } free(self->locale_id); self->locale_id = NULL; Py_TYPE(self)->tp_free((PyObject *) self); } DECLARE_STRUCT(LocaleData, t_localedata, ULocaleData, t_localedata_init, t_localedata_dealloc); /* Locale */ static int t_locale_init(t_locale *self, PyObject *args, PyObject *kwds) { charsArg language, country, variant; int lcid, len; switch (PyTuple_Size(args)) { case 0: self->object = new Locale(); self->flags = T_OWNED; break; case 1: if (!parseArgs(args, "n", &language)) { self->object = new Locale(language); self->flags = T_OWNED; break; } if (!parseArgs(args, "i", &lcid)) { char code[128]; INT_STATUS_CALL(len = uloc_getLocaleForLCID( lcid, code, sizeof(code), &status)); if ((size_t) len < sizeof(code)) { self->object = new Locale(code); self->flags = T_OWNED; } break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; case 2: if (!parseArgs(args, "nn", &language, &country)) { self->object = new Locale(language, country); self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; case 3: if (!parseArgs(args, "nnn", &language, &country, &variant)) { self->object = new Locale(language, country, variant); self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; default: PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; } if (self->object) return 0; return -1; } static PyObject *t_locale_getLanguage(t_locale *self) { return PyString_FromString(self->object->getLanguage()); } static PyObject *t_locale_getScript(t_locale *self) { return PyString_FromString(self->object->getScript()); } static PyObject *t_locale_getCountry(t_locale *self) { return PyString_FromString(self->object->getCountry()); } static PyObject *t_locale_getVariant(t_locale *self) { return PyString_FromString(self->object->getVariant()); } static PyObject *t_locale_getName(t_locale *self) { return PyString_FromString(self->object->getName()); } static PyObject *t_locale_getBaseName(t_locale *self) { return PyString_FromString(self->object->getBaseName()); } static PyObject *t_locale_getISO3Language(t_locale *self) { return PyString_FromString(self->object->getISO3Language()); } static PyObject *t_locale_getISO3Country(t_locale *self) { return PyString_FromString(self->object->getISO3Country()); } static PyObject *t_locale_getLCID(t_locale *self) { return PyInt_FromLong(self->object->getLCID()); } static PyObject *t_locale_getDisplayLanguage(t_locale *self, PyObject *args) { Locale *locale; UnicodeString *u; UnicodeString _u; switch (PyTuple_Size(args)) { case 0: self->object->getDisplayLanguage(_u); return PyUnicode_FromUnicodeString(&_u); case 1: if (!parseArgs(args, "P", TYPE_CLASSID(Locale), &locale)) { self->object->getDisplayLanguage(*locale, _u); return PyUnicode_FromUnicodeString(&_u); } if (!parseArgs(args, "U", &u)) { self->object->getDisplayLanguage(*u); Py_RETURN_ARG(args, 0); } break; case 2: if (!parseArgs(args, "PU", TYPE_CLASSID(Locale), &locale, &u)) { self->object->getDisplayLanguage(*locale, *u); Py_RETURN_ARG(args, 1); } break; } return PyErr_SetArgsError((PyObject *) self, "getDisplayLanguage", args); } static PyObject *t_locale_getDisplayScript(t_locale *self, PyObject *args) { Locale *locale; UnicodeString *u; UnicodeString _u; switch (PyTuple_Size(args)) { case 0: self->object->getDisplayScript(_u); return PyUnicode_FromUnicodeString(&_u); case 1: if (!parseArgs(args, "P", TYPE_CLASSID(Locale), &locale)) { self->object->getDisplayScript(*locale, _u); return PyUnicode_FromUnicodeString(&_u); } if (!parseArgs(args, "U", &u)) { self->object->getDisplayScript(*u); Py_RETURN_ARG(args, 0); } break; case 2: if (!parseArgs(args, "PU", TYPE_CLASSID(Locale), &locale, &u)) { self->object->getDisplayScript(*locale, *u); Py_RETURN_ARG(args, 1); } break; } return PyErr_SetArgsError((PyObject *) self, "getDisplayScript", args); } static PyObject *t_locale_getDisplayCountry(t_locale *self, PyObject *args) { Locale *locale; UnicodeString *u; UnicodeString _u; switch (PyTuple_Size(args)) { case 0: self->object->getDisplayCountry(_u); return PyUnicode_FromUnicodeString(&_u); case 1: if (!parseArgs(args, "P", TYPE_CLASSID(Locale), &locale)) { self->object->getDisplayCountry(*locale, _u); return PyUnicode_FromUnicodeString(&_u); } if (!parseArgs(args, "U", &u)) { self->object->getDisplayCountry(*u); Py_RETURN_ARG(args, 0); } break; case 2: if (!parseArgs(args, "PU", TYPE_CLASSID(Locale), &locale, &u)) { self->object->getDisplayCountry(*locale, *u); Py_RETURN_ARG(args, 1); } break; } return PyErr_SetArgsError((PyObject *) self, "getDisplayCountry", args); } static PyObject *t_locale_getDisplayVariant(t_locale *self, PyObject *args) { Locale *locale; UnicodeString *u; UnicodeString _u; switch (PyTuple_Size(args)) { case 0: self->object->getDisplayVariant(_u); return PyUnicode_FromUnicodeString(&_u); case 1: if (!parseArgs(args, "P", TYPE_CLASSID(Locale), &locale)) { self->object->getDisplayVariant(*locale, _u); return PyUnicode_FromUnicodeString(&_u); } if (!parseArgs(args, "U", &u)) { self->object->getDisplayVariant(*u); Py_RETURN_ARG(args, 0); } break; case 2: if (!parseArgs(args, "PU", TYPE_CLASSID(Locale), &locale, &u)) { self->object->getDisplayVariant(*locale, *u); Py_RETURN_ARG(args, 1); } break; } return PyErr_SetArgsError((PyObject *) self, "getDisplayVariant", args); } static PyObject *t_locale_getDisplayName(t_locale *self, PyObject *args) { Locale *locale; UnicodeString *u; UnicodeString _u; switch (PyTuple_Size(args)) { case 0: self->object->getDisplayName(_u); return PyUnicode_FromUnicodeString(&_u); case 1: if (!parseArgs(args, "P", TYPE_CLASSID(Locale), &locale)) { self->object->getDisplayName(*locale, _u); return PyUnicode_FromUnicodeString(&_u); } if (!parseArgs(args, "U", &u)) { self->object->getDisplayName(*u); Py_RETURN_ARG(args, 0); } break; case 2: if (!parseArgs(args, "PU", TYPE_CLASSID(Locale), &locale, &u)) { self->object->getDisplayName(*locale, *u); Py_RETURN_ARG(args, 1); } break; } return PyErr_SetArgsError((PyObject *) self, "getDisplayName", args); } static PyObject *t_locale_createKeywords(t_locale *self) { StringEnumeration *se; STATUS_CALL(se = self->object->createKeywords(status)); return wrap_StringEnumeration(se, T_OWNED); } static PyObject *t_locale_getKeywordValue(t_locale *self, PyObject *arg) { charsArg name; if (!parseArg(arg, "n", &name)) { char buf[ULOC_FULLNAME_CAPACITY]; int32_t len; STATUS_CALL(len = self->object->getKeywordValue( name, buf, sizeof(buf) - 1, status)); if (len == 0) Py_RETURN_NONE; return PyString_FromStringAndSize(buf, len); } return PyErr_SetArgsError((PyObject *) self, "getKeywordValue", arg); } #if U_ICU_VERSION_HEX >= VERSION_HEX(49, 0, 0) static PyObject *t_locale_setKeywordValue(t_locale *self, PyObject *args) { charsArg name, value; if (!parseArgs(args, "nn", &name, &value)) { STATUS_CALL(self->object->setKeywordValue(name, value, status)); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setKeywordValue", args); } static PyObject *t_locale_removeKeywordValue(t_locale *self, PyObject *arg) { charsArg name; if (!parseArg(arg, "n", &name)) { STATUS_CALL(self->object->setKeywordValue(name, "", status)); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "removeKeywordValue", arg); } #endif static PyObject *t_locale_isBogus(t_locale *self) { int retval = self->object->isBogus(); Py_RETURN_BOOL(retval); } static PyObject *t_locale_setToBogus(t_locale *self) { self->object->setToBogus(); Py_RETURN_NONE; } #if U_ICU_VERSION_HEX >= 0x04000000 static PyObject *t_locale_addLikelySubtags(t_locale *self) { char maximized[128]; int32_t size; API_STATUS_CALL(size, uloc_addLikelySubtags, (self->object->getName(), maximized, sizeof(maximized), &status)); return PyString_FromStringAndSize(maximized, size); } static PyObject *t_locale_minimizeSubtags(t_locale *self) { char minimized[128]; int32_t size; API_STATUS_CALL(size, uloc_minimizeSubtags, (self->object->getName(), minimized, sizeof(minimized), &status)); return PyString_FromStringAndSize(minimized, size); } #endif #if U_ICU_VERSION_HEX >= 0x04040000 static PyObject *t_locale_getRoot(PyTypeObject *self) { return wrap_Locale(Locale::getRoot()); } #endif static PyObject *t_locale_getEnglish(PyTypeObject *self) { return wrap_Locale(Locale::getEnglish()); } static PyObject *t_locale_getFrench(PyTypeObject *self) { return wrap_Locale(Locale::getFrench()); } static PyObject *t_locale_getGerman(PyTypeObject *self) { return wrap_Locale(Locale::getGerman()); } static PyObject *t_locale_getItalian(PyTypeObject *self) { return wrap_Locale(Locale::getItalian()); } static PyObject *t_locale_getJapanese(PyTypeObject *self) { return wrap_Locale(Locale::getJapanese()); } static PyObject *t_locale_getKorean(PyTypeObject *self) { return wrap_Locale(Locale::getKorean()); } static PyObject *t_locale_getChinese(PyTypeObject *self) { return wrap_Locale(Locale::getChinese()); } static PyObject *t_locale_getSimplifiedChinese(PyTypeObject *self) { return wrap_Locale(Locale::getSimplifiedChinese()); } static PyObject *t_locale_getTraditionalChinese(PyTypeObject *self) { return wrap_Locale(Locale::getTraditionalChinese()); } static PyObject *t_locale_getFrance(PyTypeObject *self) { return wrap_Locale(Locale::getFrance()); } static PyObject *t_locale_getGermany(PyTypeObject *self) { return wrap_Locale(Locale::getGermany()); } static PyObject *t_locale_getItaly(PyTypeObject *self) { return wrap_Locale(Locale::getItaly()); } static PyObject *t_locale_getJapan(PyTypeObject *self) { return wrap_Locale(Locale::getJapan()); } static PyObject *t_locale_getKorea(PyTypeObject *self) { return wrap_Locale(Locale::getKorea()); } static PyObject *t_locale_getChina(PyTypeObject *self) { return wrap_Locale(Locale::getChina()); } static PyObject *t_locale_getPRC(PyTypeObject *self) { return wrap_Locale(Locale::getPRC()); } static PyObject *t_locale_getTaiwan(PyTypeObject *self) { return wrap_Locale(Locale::getTaiwan()); } static PyObject *t_locale_getUK(PyTypeObject *self) { return wrap_Locale(Locale::getUK()); } static PyObject *t_locale_getUS(PyTypeObject *self) { return wrap_Locale(Locale::getUS()); } static PyObject *t_locale_getCanada(PyTypeObject *self) { return wrap_Locale(Locale::getCanada()); } static PyObject *t_locale_getCanadaFrench(PyTypeObject *self) { return wrap_Locale(Locale::getCanadaFrench()); } static PyObject *t_locale_getDefault(PyTypeObject *self) { return wrap_Locale(Locale::getDefault()); } static PyObject *t_locale_setDefault(PyTypeObject *type, PyObject *args) { Locale *locale; switch (PyTuple_Size(args)) { case 0: STATUS_CALL(Locale::setDefault(NULL, status)); Py_RETURN_NONE; case 1: if (!parseArgs(args, "P", TYPE_CLASSID(Locale), &locale)) { STATUS_CALL(Locale::setDefault(*locale, status)); /* transient */ Py_RETURN_NONE; } break; } return PyErr_SetArgsError(type, "setDefault", args); } static PyObject *t_locale_createFromName(PyTypeObject *type, PyObject *args) { Locale locale; charsArg name; switch (PyTuple_Size(args)) { case 0: locale = Locale::createFromName(NULL); return wrap_Locale(locale); case 1: if (!parseArgs(args, "n", &name)) { locale = Locale::createFromName(name); return wrap_Locale(locale); } break; } return PyErr_SetArgsError(type, "createFromName", args); } static PyObject *t_locale_createCanonical(PyTypeObject *type, PyObject *arg) { Locale locale; charsArg name; if (!parseArg(arg, "n", &name)) { locale = Locale::createCanonical(name); return wrap_Locale(locale); } return PyErr_SetArgsError(type, "createCanonical", arg); } static PyObject *t_locale_getAvailableLocales(PyTypeObject *type) { int count; const Locale *locales = Locale::getAvailableLocales(count); PyObject *dict = PyDict_New(); for (int32_t i = 0; i < count; i++) { Locale *locale = (Locale *) locales + i; PyObject *obj = wrap_Locale(locale, 0); PyDict_SetItemString(dict, locale->getName(), obj); Py_DECREF(obj); } return dict; } static PyObject *t_locale_getISOCountries(PyTypeObject *type) { const char *const *countries = Locale::getISOCountries(); PyObject *list; int len = 0; while (countries[len] != NULL) len += 1; list = PyList_New(len); for (int i = 0; i < len; i++) { PyObject *str = PyString_FromStringAndSize(countries[i], 2); PyList_SET_ITEM(list, i, str); } return list; } static PyObject *t_locale_getISOLanguages(PyTypeObject *type) { const char *const *languages = Locale::getISOLanguages(); PyObject *list; int len = 0; while (languages[len] != NULL) len += 1; list = PyList_New(len); for (int i = 0; i < len; i++) { PyObject *str = PyString_FromString(languages[i]); PyList_SET_ITEM(list, i, str); } return list; } static PyObject *t_locale_str(t_locale *self) { return PyString_FromString(self->object->getName()); } static long t_locale_hash(t_locale *self) { return (long) self->object->hashCode(); } /* ResourceBundle */ static int t_resourcebundle_init(t_resourcebundle *self, PyObject *args, PyObject *kwds) { UnicodeString *u, _u; Locale *locale; ResourceBundle *bundle; switch (PyTuple_Size(args)) { case 0: INT_STATUS_CALL(bundle = new ResourceBundle(status)); self->object = bundle; self->flags = T_OWNED; break; case 1: if (!parseArgs(args, "S", &u, &_u)) { INT_STATUS_CALL(bundle = new ResourceBundle(*u, status)); self->object = bundle; self->flags = T_OWNED; break; } case 2: if (!parseArgs(args, "SP", TYPE_CLASSID(Locale), &u, &_u, &locale)) { INT_STATUS_CALL(bundle = new ResourceBundle(*u, *locale, status)); self->object = bundle; self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; } if (self->object) return 0; return -1; } static PyObject *t_resourcebundle_getSize(t_resourcebundle *self) { return PyInt_FromLong(self->object->getSize()); } static PyObject *t_resourcebundle_getString(t_resourcebundle *self, PyObject *args) { UnicodeString *u, _u; switch (PyTuple_Size(args)) { case 0: STATUS_CALL(_u = self->object->getString(status)); return PyUnicode_FromUnicodeString(&_u); case 1: if (!parseArgs(args, "U", &u)) { STATUS_CALL(u->setTo(self->object->getString(status))); Py_RETURN_ARG(args, 0); } break; } return PyErr_SetArgsError((PyObject *) self, "getString", args); } static PyObject *t_resourcebundle_getUInt(t_resourcebundle *self) { int n; STATUS_CALL(n = self->object->getUInt(status)); return PyInt_FromLong(n); } static PyObject *t_resourcebundle_getInt(t_resourcebundle *self) { int n; STATUS_CALL(n = self->object->getInt(status)); return PyInt_FromLong(n); } static PyObject *t_resourcebundle_getKey(t_resourcebundle *self) { return PyString_FromString(self->object->getKey()); } static PyObject *t_resourcebundle_getName(t_resourcebundle *self) { return PyString_FromString(self->object->getName()); } static PyObject *t_resourcebundle_getType(t_resourcebundle *self) { return PyInt_FromLong((long) self->object->getType()); } static PyObject *t_resourcebundle_hasNext(t_resourcebundle *self) { int b = self->object->hasNext(); Py_RETURN_BOOL(b); } static PyObject *t_resourcebundle_resetIterator(t_resourcebundle *self) { self->object->resetIterator(); Py_RETURN_NONE; } static PyObject *t_resourcebundle_getNext(t_resourcebundle *self) { UErrorCode status = U_ZERO_ERROR; ResourceBundle rb = self->object->getNext(status); if (U_FAILURE(status)) return ICUException(status).reportError(); return wrap_ResourceBundle(rb); } static PyObject *t_resourcebundle_getNextString(t_resourcebundle *self, PyObject *args) { UnicodeString *u; UnicodeString _u; switch (PyTuple_Size(args)) { case 0: STATUS_CALL(_u = self->object->getNextString(status)); return PyUnicode_FromUnicodeString(&_u); case 1: if (!parseArgs(args, "U", &u)) { STATUS_CALL(u->setTo(self->object->getNextString(status))); Py_RETURN_ARG(args, 0); } break; } return PyErr_SetArgsError((PyObject *) self, "getNextString", args); } static PyObject *t_resourcebundle_get(t_resourcebundle *self, PyObject *arg) { UErrorCode status = U_ZERO_ERROR; charsArg key; int i; if (!parseArg(arg, "i", &i)) { ResourceBundle rb = self->object->get(i, status); if (U_FAILURE(status)) return ICUException(status).reportError(); return wrap_ResourceBundle(rb); } if (!parseArg(arg, "n", &key)) { ResourceBundle rb = self->object->get(key, status); if (U_FAILURE(status)) return ICUException(status).reportError(); return wrap_ResourceBundle(rb); } return PyErr_SetArgsError((PyObject *) self, "get", arg); } static PyObject *t_resourcebundle_getWithFallback(t_resourcebundle *self, PyObject *arg) { UErrorCode status = U_ZERO_ERROR; charsArg key; if (!parseArg(arg, "n", &key)) { ResourceBundle rb = self->object->getWithFallback(key, status); if (U_FAILURE(status)) return ICUException(status).reportError(); return wrap_ResourceBundle(rb); } return PyErr_SetArgsError((PyObject *) self, "getWithFallback", arg); } static PyObject *t_resourcebundle_getStringEx(t_resourcebundle *self, PyObject *args) { UnicodeString *u; UnicodeString _u; charsArg key; int i; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "i", &i)) { STATUS_CALL(_u = self->object->getStringEx(i, status)); return PyUnicode_FromUnicodeString(&_u); } if (!parseArgs(args, "n", &key)) { STATUS_CALL(_u = self->object->getStringEx(key, status)); return PyUnicode_FromUnicodeString(&_u); } case 2: if (!parseArgs(args, "iU", &i, &u)) { STATUS_CALL(u->setTo(self->object->getStringEx(i, status))); Py_RETURN_ARG(args, 1); } if (!parseArgs(args, "nU", &key, &u)) { STATUS_CALL(u->setTo(self->object->getStringEx(key, status))); Py_RETURN_ARG(args, 1); } break; } return PyErr_SetArgsError((PyObject *) self, "getStringEx", args); } static PyObject *t_resourcebundle_getVersionNumber(t_resourcebundle *self) { return PyString_FromString(self->object->getVersionNumber()); } static PyObject *t_resourcebundle_getBinary(t_resourcebundle *self) { int32_t len; const uint8_t *data; STATUS_CALL(data = self->object->getBinary(len, status)); return PyString_FromStringAndSize((const char *) data, len); } static PyObject *t_resourcebundle_getIntVector(t_resourcebundle *self) { int32_t len; const int32_t *data; STATUS_CALL(data = self->object->getIntVector(len, status)); PyObject *list = PyList_New(len); for (int i = 0; i < len; i++) PyList_SET_ITEM(list, i, PyInt_FromLong(data[i])); return list; } static PyObject *t_resourcebundle_getLocale(t_resourcebundle *self, PyObject *args) { ULocDataLocaleType type; switch (PyTuple_Size(args)) { case 0: return wrap_Locale(self->object->getLocale()); case 1: if (!parseArgs(args, "i", &type)) { Locale locale; STATUS_CALL(locale = self->object->getLocale(type, status)); return wrap_Locale(locale); } break; } return PyErr_SetArgsError((PyObject *) self, "getLocale", args); } #ifndef PYPY_VERSION #if defined(_MSC_VER) || defined(__WIN32) static PyObject *t_resourcebundle_setAppData(PyTypeObject *type, PyObject *args) { charsArg packageName, path; if (!parseArgs(args, "nf", &packageName, &path)) { HANDLE fd = CreateFile(path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL); UErrorCode status = U_ZERO_ERROR; DWORD dwSize; HANDLE hMap; LPVOID data; if (fd == INVALID_HANDLE_VALUE) return PyErr_SetFromWindowsErrWithFilename(0, path); dwSize = GetFileSize(fd, NULL); if (dwSize == INVALID_FILE_SIZE) { PyErr_SetFromWindowsErrWithFilename(0, path); CloseHandle(fd); return NULL; } hMap = CreateFileMapping(fd, NULL, PAGE_READONLY, 0, dwSize, NULL); if (!hMap) { PyErr_SetFromWindowsErrWithFilename(0, path); CloseHandle(fd); return NULL; } CloseHandle(fd); data = MapViewOfFile(hMap, FILE_MAP_READ, 0, 0, 0); if (!data) { PyErr_SetFromWindowsErrWithFilename(0, path); CloseHandle(hMap); return NULL; } CloseHandle(hMap); udata_setAppData(packageName, data, &status); if (U_FAILURE(status)) { UnmapViewOfFile(data); return ICUException(status).reportError(); } Py_RETURN_NONE; } return PyErr_SetArgsError(type, "setAppData", args); } #else static PyObject *t_resourcebundle_setAppData(PyTypeObject *type, PyObject *args) { charsArg packageName, path; if (!parseArgs(args, "nf", &packageName, &path)) { int fd = open(path, O_RDONLY); UErrorCode status = U_ZERO_ERROR; struct stat buf; void *data; if (fd < 0) return PyErr_SetFromErrnoWithFilename(PyExc_ValueError, path); if (fstat(fd, &buf) < 0) { PyErr_SetFromErrnoWithFilename(PyExc_ValueError, path); close(fd); return NULL; } data = mmap(NULL, buf.st_size, PROT_READ, MAP_SHARED, fd, 0); if (data == MAP_FAILED) { PyErr_SetFromErrnoWithFilename(PyExc_ValueError, path); close(fd); return NULL; } close(fd); udata_setAppData(packageName, data, &status); if (U_FAILURE(status)) { munmap(data, buf.st_size); return ICUException(status).reportError(); } Py_RETURN_NONE; } return PyErr_SetArgsError(type, "setAppData", args); } #endif #endif // !PYPY_VERSION static PyObject *t_resourcebundle_iter(t_resourcebundle *self) { self->object->resetIterator(); Py_INCREF(self); return (PyObject *) self; } static PyObject *t_resourcebundle_next(t_resourcebundle *self) { if (self->object->hasNext()) { UErrorCode status = U_ZERO_ERROR; ResourceBundle rb = self->object->getNext(status); if (U_FAILURE(status)) return ICUException(status).reportError(); return wrap_ResourceBundle(rb); } PyErr_SetNone(PyExc_StopIteration); return NULL; } static PyObject *t_resourcebundle_str(t_resourcebundle *self) { switch (self->object->getType()) { case URES_NONE: return PyString_FromString("URES_NONE"); case URES_STRING: return PyString_FromString("URES_STRING"); case URES_BINARY: return PyString_FromString("URES_BINARY"); case URES_TABLE: return PyString_FromString("URES_TABLE"); case URES_ALIAS: return PyString_FromString("URES_ALIAS"); case URES_ARRAY: return PyString_FromString("URES_ARRAY"); case URES_INT_VECTOR: return PyString_FromString("URES_INT_VECTOR"); case RES_RESERVED: return PyString_FromString("RES_RESERVED"); default: return PyString_FromString("unknown"); } } /* LocaleData */ static int t_localedata_init(t_localedata *self, PyObject *args, PyObject *kwds) { charsArg id; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "n", &id)) { ULocaleData *locale_data; INT_STATUS_CALL(locale_data = ulocdata_open(id, &status)); self->object = locale_data; self->locale_id = strdup((const char *) id); self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; default: PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; } if (self->object) return 0; return -1; } static PyObject *t_localedata_getNoSubstitute(t_localedata *self) { if (ulocdata_getNoSubstitute(self->object)) Py_RETURN_TRUE; Py_RETURN_FALSE; } static PyObject *t_localedata_setNoSubstitute(t_localedata *self, PyObject *arg) { int setting; if (!parseArg(arg, "b", &setting)) { ulocdata_setNoSubstitute(self->object, setting); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setNoSubstitute", arg); } static PyObject *t_localedata_getPaperSize(t_localedata *self) { int32_t width, height; STATUS_CALL(ulocdata_getPaperSize(self->locale_id, &width, &height, &status)); return Py_BuildValue("ii", width, height); } static PyObject *t_localedata_getLocaleDisplayPattern(t_localedata *self) { UChar buffer[256]; int size; STATUS_CALL(size = ulocdata_getLocaleDisplayPattern(self->object, buffer, 255, &status)); return PyUnicode_FromUnicodeString(buffer, size); } static PyObject *t_localedata_getLocaleSeparator(t_localedata *self) { UChar buffer[256]; int size; STATUS_CALL(size = ulocdata_getLocaleSeparator(self->object, buffer, 255, &status)); return PyUnicode_FromUnicodeString(buffer, size); } static PyObject *t_localedata_getDelimiter(t_localedata *self, PyObject *arg) { ULocaleDataDelimiterType type; if (!parseArg(arg, "i", &type)) { UChar buffer[256]; int size; STATUS_CALL(size = ulocdata_getDelimiter(self->object, type, buffer, 255, &status)); return PyUnicode_FromUnicodeString(buffer, size); } return PyErr_SetArgsError((PyObject *) self, "getDelimiter", arg); } static PyObject *t_localedata_getMeasurementSystem(t_localedata *self) { UMeasurementSystem ms; STATUS_CALL(ms = ulocdata_getMeasurementSystem(self->locale_id, &status)); return PyInt_FromLong(ms); } static PyObject *t_localedata_getExemplarSet(t_localedata *self, PyObject *args) { int options; ULocaleDataExemplarSetType type; switch (PyTuple_Size(args)) { case 0: { USet *set; STATUS_CALL(set = ulocdata_getExemplarSet(self->object, NULL, 0, ULOCDATA_ES_STANDARD, &status)); return wrap_UnicodeSet(UnicodeSet::fromUSet(set), T_OWNED); } break; case 1: if (!parseArgs(args, "i", &type)) { USet *set; STATUS_CALL(set = ulocdata_getExemplarSet(self->object, NULL, 0, type, &status)); return wrap_UnicodeSet(UnicodeSet::fromUSet(set), T_OWNED); } break; case 2: if (!parseArgs(args, "ii", &options, &type)) { USet *set; STATUS_CALL(set = ulocdata_getExemplarSet(self->object, NULL, options, type, &status)); return wrap_UnicodeSet(UnicodeSet::fromUSet(set), T_OWNED); } } return PyErr_SetArgsError((PyObject *) self, "getExemplarSet", args); } void _init_locale(PyObject *m) { LocaleType_.tp_str = (reprfunc) t_locale_str; LocaleType_.tp_hash = (hashfunc) t_locale_hash; ResourceBundleType_.tp_iter = (getiterfunc) t_resourcebundle_iter; ResourceBundleType_.tp_iternext = (iternextfunc) t_resourcebundle_next; ResourceBundleType_.tp_str = (reprfunc) t_resourcebundle_str; INSTALL_CONSTANTS_TYPE(ULocDataLocaleType, m); INSTALL_CONSTANTS_TYPE(UResType, m); INSTALL_CONSTANTS_TYPE(ULocaleDataDelimiterType, m); INSTALL_CONSTANTS_TYPE(ULocaleDataExemplarSetType, m); INSTALL_CONSTANTS_TYPE(UMeasurementSystem, m); REGISTER_TYPE(Locale, m); REGISTER_TYPE(ResourceBundle, m); INSTALL_STRUCT(LocaleData, m); INSTALL_ENUM(ULocDataLocaleType, "ACTUAL_LOCALE", ULOC_ACTUAL_LOCALE); INSTALL_ENUM(ULocDataLocaleType, "VALID_LOCALE", ULOC_VALID_LOCALE); INSTALL_ENUM(UResType, "NONE", URES_NONE); INSTALL_ENUM(UResType, "STRING", URES_STRING); INSTALL_ENUM(UResType, "BINARY", URES_BINARY); INSTALL_ENUM(UResType, "TABLE", URES_TABLE); INSTALL_ENUM(UResType, "ALIAS", URES_ALIAS); INSTALL_ENUM(UResType, "INT", URES_INT); INSTALL_ENUM(UResType, "ARRAY", URES_ARRAY); INSTALL_ENUM(UResType, "INT_VECTOR", URES_INT_VECTOR); INSTALL_ENUM(UResType, "RESERVED", RES_RESERVED); INSTALL_ENUM(ULocaleDataDelimiterType, "QUOTATION_START", ULOCDATA_QUOTATION_START); INSTALL_ENUM(ULocaleDataDelimiterType, "QUOTATION_END", ULOCDATA_QUOTATION_END); INSTALL_ENUM(ULocaleDataDelimiterType, "ALT_QUOTATION_START", ULOCDATA_ALT_QUOTATION_START); INSTALL_ENUM(ULocaleDataDelimiterType, "ALT_QUOTATION_END", ULOCDATA_ALT_QUOTATION_END); INSTALL_ENUM(ULocaleDataExemplarSetType, "ES_STANDARD", ULOCDATA_ES_STANDARD); INSTALL_ENUM(ULocaleDataExemplarSetType, "ES_AUXILIARY", ULOCDATA_ES_AUXILIARY); #if U_ICU_VERSION_HEX >= 0x04080000 INSTALL_ENUM(ULocaleDataExemplarSetType, "ES_INDEX", ULOCDATA_ES_INDEX); #endif INSTALL_ENUM(UMeasurementSystem, "SI", UMS_SI); INSTALL_ENUM(UMeasurementSystem, "US", UMS_US); // options for LocaleData.getExemplarSet() INSTALL_MODULE_INT(m, USET_IGNORE_SPACE); INSTALL_MODULE_INT(m, USET_CASE_INSENSITIVE); INSTALL_MODULE_INT(m, USET_ADD_CASE_MAPPINGS); } PyICU-1.9.5/locale.h0000644000076500000000000000275212520065472014303 0ustar vajdawheel00000000000000/* ==================================================================== * Copyright (c) 2004-2010 Open Source Applications Foundation. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. * ==================================================================== */ #ifndef _locale_h #define _locale_h extern PyTypeObject LocaleType_; PyObject *wrap_Locale(Locale *locale, int flags); PyObject *wrap_Locale(const Locale &locale); void _init_locale(PyObject *m); #endif /* _locale_h */ PyICU-1.9.5/macros.h0000644000076500000000000006121212724163175014331 0ustar vajdawheel00000000000000/* ==================================================================== * Copyright (c) 2004-2011 Open Source Applications Foundation. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. * ==================================================================== */ #ifndef _macros_h #define _macros_h PyObject *make_descriptor(PyObject *value); PyObject *make_descriptor(PyTypeObject *value); PyObject *make_descriptor(PyObject *(*get)(PyObject *)); #define PYTHON_CALL(action) \ { \ action; \ if (PyErr_Occurred()) \ return NULL; \ } #define INT_PYTHON_CALL(action) \ { \ action; \ if (PyErr_Occurred()) \ return -1; \ } #define STATUS_CALL(action) \ { \ UErrorCode status = U_ZERO_ERROR; \ action; \ if (U_FAILURE(status)) \ return ICUException(status).reportError(); \ } #define API_STATUS_CALL(var, api, args) \ { \ UErrorCode status = U_ZERO_ERROR; \ var = api args; \ if (U_FAILURE(status)) \ return ICUException(status).reportError(); \ } #define STATUS_PYTHON_CALL(action) \ { \ UErrorCode status = U_ZERO_ERROR; \ action; \ if (U_FAILURE(status)) \ return ICUException(status).reportError(); \ if (PyErr_Occurred()) \ return NULL; \ } #define STATUS_PARSER_CALL(action) \ { \ UErrorCode status = U_ZERO_ERROR; \ UParseError parseError; \ action; \ if (U_FAILURE(status)) \ return ICUException(parseError, status).reportError(); \ } #define STATUS_PARSER_PYTHON_CALL(action) \ { \ UErrorCode status = U_ZERO_ERROR; \ UParseError parseError; \ action; \ if (U_FAILURE(status)) \ return ICUException(parseError, status).reportError(); \ if (PyErr_Occurred()) \ return NULL; \ } #define INT_STATUS_CALL(action) \ { \ UErrorCode status = U_ZERO_ERROR; \ action; \ if (U_FAILURE(status)) \ { \ ICUException(status).reportError(); \ return -1; \ } \ } #define INT_STATUS_PYTHON_CALL(action) \ { \ UErrorCode status = U_ZERO_ERROR; \ action; \ if (U_FAILURE(status)) \ { \ ICUException(status).reportError(); \ return -1; \ } \ if (PyErr_Occurred()) \ return -1; \ } #define INT_STATUS_PARSER_CALL(action) \ { \ UErrorCode status = U_ZERO_ERROR; \ UParseError parseError; \ action; \ if (U_FAILURE(status)) \ { \ ICUException(parseError, status).reportError(); \ return -1; \ } \ } #define INT_STATUS_PARSER_PYTHON_CALL(action) \ { \ UErrorCode status = U_ZERO_ERROR; \ UParseError parseError; \ action; \ if (U_FAILURE(status)) \ { \ ICUException(parseError, status).reportError(); \ return -1; \ } \ if (PyErr_Occurred()) \ return -1; \ } #define DECLARE_METHOD(type, name, flags) \ { #name, (PyCFunction) type##_##name, flags, "" } #define DECLARE_TYPE(name, t_name, base, icuClass, init, dealloc) \ PyTypeObject name##Type_ = { \ PyVarObject_HEAD_INIT(NULL, 0) \ /* tp_name */ "icu."#name, \ /* tp_basicsize */ sizeof(t_name), \ /* tp_itemsize */ 0, \ /* tp_dealloc */ (destructor)dealloc, \ /* tp_print */ 0, \ /* tp_getattr */ 0, \ /* tp_setattr */ 0, \ /* tp_compare */ 0, \ /* tp_repr */ 0, \ /* tp_as_number */ 0, \ /* tp_as_sequence */ 0, \ /* tp_as_mapping */ 0, \ /* tp_hash */ 0, \ /* tp_call */ 0, \ /* tp_str */ 0, \ /* tp_getattro */ 0, \ /* tp_setattro */ 0, \ /* tp_as_buffer */ 0, \ /* tp_flags */ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, \ /* tp_doc */ #name" objects", \ /* tp_traverse */ 0, \ /* tp_clear */ 0, \ /* tp_richcompare */ 0, \ /* tp_weaklistoffset */ 0, \ /* tp_iter */ 0, \ /* tp_iternext */ 0, \ /* tp_methods */ t_name##_methods, \ /* tp_members */ 0, \ /* tp_getset */ 0, \ /* tp_base */ &base##Type_, \ /* tp_dict */ 0, \ /* tp_descr_get */ 0, \ /* tp_descr_set */ 0, \ /* tp_dictoffset */ 0, \ /* tp_init */ (initproc)init, \ /* tp_alloc */ 0, \ /* tp_new */ 0, \ }; \ PyObject *wrap_##name(icuClass *object, int flags) \ { \ if (object) \ { \ t_name *self = (t_name *) name##Type_.tp_alloc(&name##Type_, 0); \ if (self) \ { \ self->object = object; \ self->flags = flags; \ } \ return (PyObject *) self; \ } \ Py_RETURN_NONE; \ } #define DECLARE_STRUCT(name, t_name, icuStruct, init, dealloc) \ static PyObject *t_name##_new(PyTypeObject *type, \ PyObject *args, PyObject *kwds) \ { \ t_name *self = (t_name *) type->tp_alloc(type, 0); \ if (self) \ { \ self->object = NULL; \ self->flags = 0; \ } \ return (PyObject *) self; \ } \ PyTypeObject name##Type_ = { \ PyVarObject_HEAD_INIT(NULL, 0) \ /* tp_name */ "icu."#name, \ /* tp_basicsize */ sizeof(t_name), \ /* tp_itemsize */ 0, \ /* tp_dealloc */ (destructor)t_name##_dealloc, \ /* tp_print */ 0, \ /* tp_getattr */ 0, \ /* tp_setattr */ 0, \ /* tp_compare */ 0, \ /* tp_repr */ 0, \ /* tp_as_number */ 0, \ /* tp_as_sequence */ 0, \ /* tp_as_mapping */ 0, \ /* tp_hash */ 0, \ /* tp_call */ 0, \ /* tp_str */ 0, \ /* tp_getattro */ 0, \ /* tp_setattro */ 0, \ /* tp_as_buffer */ 0, \ /* tp_flags */ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, \ /* tp_doc */ #name" objects", \ /* tp_traverse */ 0, \ /* tp_clear */ 0, \ /* tp_richcompare */ 0, \ /* tp_weaklistoffset */ 0, \ /* tp_iter */ 0, \ /* tp_iternext */ 0, \ /* tp_methods */ t_name##_methods, \ /* tp_members */ 0, \ /* tp_getset */ 0, \ /* tp_base */ 0, \ /* tp_dict */ 0, \ /* tp_descr_get */ 0, \ /* tp_descr_set */ 0, \ /* tp_dictoffset */ 0, \ /* tp_init */ (initproc)init, \ /* tp_alloc */ 0, \ /* tp_new */ (newfunc)t_name##_new, \ }; \ PyObject *wrap_##name(icuStruct *object, int flags) \ { \ if (object) \ { \ t_name *self = (t_name *) name##Type_.tp_alloc(&name##Type_, 0); \ if (self) \ { \ self->object = object; \ self->flags = flags; \ } \ return (PyObject *) self; \ } \ Py_RETURN_NONE; \ } #define DECLARE_CONSTANTS_TYPE(name) \ PyTypeObject name##Type_ = { \ PyVarObject_HEAD_INIT(NULL, 0) \ /* tp_name */ "icu."#name, \ /* tp_basicsize */ 0, \ /* tp_itemsize */ 0, \ }; #if U_ICU_VERSION_HEX < 0x04060000 #define TYPE_CLASSID(className) \ className::getStaticClassID(), &className##Type_ #define TYPE_ID(className) \ (UClassID) (className##_ID), &className##Type_ #else #define TYPE_CLASSID(className) \ typeid(className).name(), &className##Type_ #define TYPE_ID(className) \ typeid(className).name(), &className##Type_ #endif #if U_ICU_VERSION_HEX < 0x04060000 #define INSTALL_TYPE(className, module) \ if (PyType_Ready(&className##Type_) == 0) \ { \ Py_INCREF(&className##Type_); \ PyModule_AddObject(module, #className, \ (PyObject *) &className##Type_); \ registerType(&className##Type_, (UClassID) className##_ID); \ } #define REGISTER_TYPE(className, module) \ if (PyType_Ready(&className##Type_) == 0) \ { \ Py_INCREF(&className##Type_); \ PyModule_AddObject(module, #className, \ (PyObject *) &className##Type_); \ registerType(&className##Type_, className::getStaticClassID()); \ } #else #define INSTALL_TYPE(className, module) \ if (PyType_Ready(&className##Type_) == 0) \ { \ Py_INCREF(&className##Type_); \ PyModule_AddObject(module, #className, \ (PyObject *) &className##Type_); \ registerType(&className##Type_, typeid(className).name()); \ } #define REGISTER_TYPE(className, module) \ if (PyType_Ready(&className##Type_) == 0) \ { \ Py_INCREF(&className##Type_); \ PyModule_AddObject(module, #className, \ (PyObject *) &className##Type_); \ registerType(&className##Type_, typeid(className).name()); \ } #endif #define INSTALL_STRUCT(name, module) \ if (PyType_Ready(&name##Type_) == 0) \ { \ Py_INCREF(&name##Type_); \ PyModule_AddObject(module, #name, (PyObject *) &name##Type_); \ } #define INSTALL_CONSTANTS_TYPE(name, module) \ if (PyType_Ready(&name##Type_) == 0) \ { \ Py_INCREF(&name##Type_); \ PyModule_AddObject(module, #name, (PyObject *) &name##Type_); \ } #define INSTALL_MODULE_INT(module, name) \ PyModule_AddIntConstant(module, #name, name); #define INSTALL_STATIC_INT(type, name) \ PyDict_SetItemString(type##Type_.tp_dict, #name, \ make_descriptor(PyInt_FromLong(type::name))) #define INSTALL_ENUM(type, name, value) \ PyDict_SetItemString(type##Type_.tp_dict, name, \ make_descriptor(PyInt_FromLong(value))) #define Py_RETURN_BOOL(b) \ { \ if (b) \ Py_RETURN_TRUE; \ else \ Py_RETURN_FALSE; \ } #define Py_RETURN_ARG(args, n) \ { \ PyObject *arg = PyTuple_GET_ITEM(args, n); \ Py_INCREF(arg); \ return arg; \ } #define Py_RETURN_SELF() \ { \ Py_INCREF(self); \ return (PyObject *) self; \ } #define DEFINE_RICHCMP(name, t_name) \ static PyObject *t_name ## _richcmp(t_name *self, \ PyObject *arg, int op) \ { \ int b = 0; \ name *object; \ if (!parseArg(arg, "P", TYPE_CLASSID(name), &object)) \ { \ switch (op) { \ case Py_EQ: \ case Py_NE: \ b = *self->object == *object; \ if (op == Py_EQ) \ Py_RETURN_BOOL(b); \ Py_RETURN_BOOL(!b); \ case Py_LT: \ case Py_LE: \ case Py_GT: \ case Py_GE: \ PyErr_SetNone(PyExc_NotImplementedError); \ return NULL; \ } \ } \ return PyErr_SetArgsError((PyObject *) self, "__richcmp__", arg); \ } #define DEFINE_ABSTRACT(t_name, name, method) \ static PyObject *t_name##_##method(t_name *self, PyObject *arg) \ { \ return PyErr_Format(PyExc_NotImplementedError, \ "%s.%s() is abstract", #name, #method); \ } #if U_ICU_VERSION_HEX < 0x04060000 #define ISINSTANCE(obj, type) \ ((obj)->getDynamicClassID() == type::getStaticClassID()) #else #define ISINSTANCE(obj, type) \ (dynamic_cast(obj) != NULL) #endif #define RETURN_WRAPPED_IF_ISINSTANCE(obj, type) \ if (ISINSTANCE(obj, type)) \ return wrap_##type((type *)(obj), T_OWNED) #endif /* _macros_h */ PyICU-1.9.5/MANIFEST.in0000644000076500000000000000071212523523163014422 0ustar vajdawheel00000000000000include README.md include bases.h include calendar.h include char.h include charset.h include collator.h include common.h include dateformat.h include errors.h include format.h include idna.h include iterators.h include layoutengine.h include locale.h include macros.h include normalizer.h include numberformat.h include regex.h include script.h include search.h include shape.h include spoof.h include transliterator.h include tzinfo.h include unicodeset.h PyICU-1.9.5/normalizer.cpp0000644000076500000000000005511012520066416015554 0ustar vajdawheel00000000000000/* ==================================================================== * Copyright (c) 2010-2010 Open Source Applications Foundation. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. * ==================================================================== */ #include "common.h" #include "structmember.h" #include "bases.h" #include "iterators.h" #include "normalizer.h" #include "unicodeset.h" #include "macros.h" DECLARE_CONSTANTS_TYPE(UNormalizationMode); DECLARE_CONSTANTS_TYPE(UNormalizationCheckResult); #if U_ICU_VERSION_HEX >= 0x04040000 DECLARE_CONSTANTS_TYPE(UNormalizationMode2); #endif /* Normalizer */ class t_normalizer : public _wrapper { public: Normalizer *object; }; static int t_normalizer_init(t_normalizer *self, PyObject *args, PyObject *kwds); static PyObject *t_normalizer_current(t_normalizer *self); static PyObject *t_normalizer_first(t_normalizer *self); static PyObject *t_normalizer_last(t_normalizer *self); static PyObject *t_normalizer_nextCharacter(t_normalizer *self); static PyObject *t_normalizer_previous(t_normalizer *self); static PyObject *t_normalizer_reset(t_normalizer *self); static PyObject *t_normalizer_setIndexOnly(t_normalizer *self, PyObject *arg); static PyObject *t_normalizer_getIndex(t_normalizer *self); static PyObject *t_normalizer_startIndex(t_normalizer *self); static PyObject *t_normalizer_endIndex(t_normalizer *self); static PyObject *t_normalizer_setMode(t_normalizer *self, PyObject *arg); static PyObject *t_normalizer_getUMode(t_normalizer *self); static PyObject *t_normalizer_getText(t_normalizer *self); static PyObject *t_normalizer_setText(t_normalizer *self, PyObject *arg); static PyObject *t_normalizer_normalize(PyTypeObject *type, PyObject *args); static PyObject *t_normalizer_compose(PyTypeObject *type, PyObject *args); static PyObject *t_normalizer_decompose(PyTypeObject *type, PyObject *args); static PyObject *t_normalizer_quickCheck(PyTypeObject *type, PyObject *args); static PyObject *t_normalizer_isNormalized(PyTypeObject *type, PyObject *args); static PyObject *t_normalizer_concatenate(PyTypeObject *type, PyObject *args); static PyObject *t_normalizer_compare(PyTypeObject *type, PyObject *args); static PyMethodDef t_normalizer_methods[] = { DECLARE_METHOD(t_normalizer, current, METH_NOARGS), DECLARE_METHOD(t_normalizer, first, METH_NOARGS), DECLARE_METHOD(t_normalizer, last, METH_NOARGS), DECLARE_METHOD(t_normalizer, nextCharacter, METH_NOARGS), DECLARE_METHOD(t_normalizer, previous, METH_NOARGS), DECLARE_METHOD(t_normalizer, reset, METH_NOARGS), DECLARE_METHOD(t_normalizer, setIndexOnly, METH_O), DECLARE_METHOD(t_normalizer, getIndex, METH_NOARGS), DECLARE_METHOD(t_normalizer, startIndex, METH_NOARGS), DECLARE_METHOD(t_normalizer, endIndex, METH_NOARGS), DECLARE_METHOD(t_normalizer, setMode, METH_O), DECLARE_METHOD(t_normalizer, getUMode, METH_NOARGS), DECLARE_METHOD(t_normalizer, getText, METH_NOARGS), DECLARE_METHOD(t_normalizer, setText, METH_O), DECLARE_METHOD(t_normalizer, normalize, METH_VARARGS | METH_CLASS), DECLARE_METHOD(t_normalizer, compose, METH_VARARGS | METH_CLASS), DECLARE_METHOD(t_normalizer, decompose, METH_VARARGS | METH_CLASS), DECLARE_METHOD(t_normalizer, quickCheck, METH_VARARGS | METH_CLASS), DECLARE_METHOD(t_normalizer, isNormalized, METH_VARARGS | METH_CLASS), DECLARE_METHOD(t_normalizer, concatenate, METH_VARARGS | METH_CLASS), DECLARE_METHOD(t_normalizer, compare, METH_VARARGS | METH_CLASS), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(Normalizer, t_normalizer, UObject, Normalizer, t_normalizer_init, NULL); #if U_ICU_VERSION_HEX >= 0x04040000 /* Normalizer2 */ class t_normalizer2 : public _wrapper { public: Normalizer2 *object; }; static PyObject *t_normalizer2_normalize(t_normalizer2 *self, PyObject *args); static PyObject *t_normalizer2_normalizeSecondAndAppend(t_normalizer2 *self, PyObject *args); static PyObject *t_normalizer2_append(t_normalizer2 *self, PyObject *args); static PyObject *t_normalizer2_isNormalized(t_normalizer2 *self, PyObject *arg); static PyObject *t_normalizer2_quickCheck(t_normalizer2 *self, PyObject *arg); static PyObject *t_normalizer2_spanQuickCheckYes(t_normalizer2 *self, PyObject *arg); static PyObject *t_normalizer2_hasBoundaryBefore(t_normalizer2 *self, PyObject *arg); static PyObject *t_normalizer2_hasBoundaryAfter(t_normalizer2 *self, PyObject *arg); static PyObject *t_normalizer2_isInert(t_normalizer2 *self, PyObject *arg); static PyObject *t_normalizer2_getInstance(PyTypeObject *type, PyObject *args); static PyMethodDef t_normalizer2_methods[] = { DECLARE_METHOD(t_normalizer2, normalize, METH_VARARGS), DECLARE_METHOD(t_normalizer2, normalizeSecondAndAppend, METH_VARARGS), DECLARE_METHOD(t_normalizer2, append, METH_VARARGS), DECLARE_METHOD(t_normalizer2, isNormalized, METH_O), DECLARE_METHOD(t_normalizer2, quickCheck, METH_O), DECLARE_METHOD(t_normalizer2, spanQuickCheckYes, METH_O), DECLARE_METHOD(t_normalizer2, hasBoundaryBefore, METH_O), DECLARE_METHOD(t_normalizer2, hasBoundaryAfter, METH_O), DECLARE_METHOD(t_normalizer2, isInert, METH_O), DECLARE_METHOD(t_normalizer2, getInstance, METH_VARARGS | METH_CLASS), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(Normalizer2, t_normalizer2, UObject, Normalizer2, abstract_init, NULL); /* FilteredNormalizer2 */ class t_filterednormalizer2 : public _wrapper { public: FilteredNormalizer2 *object; PyObject *normalizer; PyObject *filter; }; static int t_filterednormalizer2_init(t_filterednormalizer2 *self, PyObject *args, PyObject *kwds); static PyMethodDef t_filterednormalizer2_methods[] = { { NULL, NULL, 0, NULL } }; static void t_filterednormalizer2_dealloc(t_filterednormalizer2 *self) { if (self->flags & T_OWNED) delete self->object; self->object = NULL; Py_CLEAR(self->normalizer); Py_CLEAR(self->filter); Py_TYPE(self)->tp_free((PyObject *) self); } DECLARE_TYPE(FilteredNormalizer2, t_filterednormalizer2, Normalizer2, FilteredNormalizer2, t_filterednormalizer2_init, t_filterednormalizer2_dealloc); #endif /* Normalizer */ static int t_normalizer_init(t_normalizer *self, PyObject *args, PyObject *kwds) { UnicodeString *u, _u; UNormalizationMode mode; CharacterIterator *iterator; switch (PyTuple_Size(args)) { case 2: if (!parseArgs(args, "Si", &u, &_u, &mode)) { self->object = new Normalizer(*u, mode); self->flags = T_OWNED; break; } if (!parseArgs(args, "Pi", TYPE_ID(CharacterIterator), &iterator, &mode)) { self->object = new Normalizer(*iterator, mode); self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; default: PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; } if (self->object) return 0; return -1; } static PyObject *t_normalizer_current(t_normalizer *self) { UChar32 c = self->object->current(); return PyInt_FromLong(c); } static PyObject *t_normalizer_first(t_normalizer *self) { UChar32 c = self->object->first(); return PyInt_FromLong(c); } static PyObject *t_normalizer_last(t_normalizer *self) { UChar32 c = self->object->last(); return PyInt_FromLong(c); } static PyObject *t_normalizer_nextCharacter(t_normalizer *self) { UChar32 c = self->object->next(); return PyInt_FromLong(c); } static PyObject *t_normalizer_previous(t_normalizer *self) { UChar32 c = self->object->previous(); return PyInt_FromLong(c); } static PyObject *t_normalizer_reset(t_normalizer *self) { self->object->reset(); Py_RETURN_NONE; } static PyObject *t_normalizer_setIndexOnly(t_normalizer *self, PyObject *arg) { int32_t index; if (!parseArg(arg, "i", &index)) { self->object->setIndexOnly(index); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setIndexOnly", arg); } static PyObject *t_normalizer_getIndex(t_normalizer *self) { int32_t index = self->object->getIndex(); return PyInt_FromLong(index); } static PyObject *t_normalizer_startIndex(t_normalizer *self) { int32_t index = self->object->startIndex(); return PyInt_FromLong(index); } static PyObject *t_normalizer_endIndex(t_normalizer *self) { int32_t index = self->object->endIndex(); return PyInt_FromLong(index); } static PyObject *t_normalizer_setMode(t_normalizer *self, PyObject *arg) { UNormalizationMode mode; if (!parseArg(arg, "i", &mode) && mode >= UNORM_NONE && mode < UNORM_MODE_COUNT) { self->object->setMode(mode); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setMode", arg); } static PyObject *t_normalizer_getUMode(t_normalizer *self) { UNormalizationMode mode = self->object->getUMode(); return PyInt_FromLong(mode); } static PyObject *t_normalizer_getText(t_normalizer *self) { UnicodeString u; self->object->getText(u); return PyUnicode_FromUnicodeString(&u); } static PyObject *t_normalizer_setText(t_normalizer *self, PyObject *arg) { UnicodeString *u, _u; CharacterIterator *iterator; if (!parseArg(arg, "S", &u, &_u)) { STATUS_CALL(self->object->setText(*u, status)); /* copied */ Py_RETURN_NONE; } if (!parseArg(arg, "P", TYPE_ID(CharacterIterator), &iterator)) { STATUS_CALL(self->object->setText(*iterator, status)); /* copied */ Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setText", arg); } static PyObject *t_normalizer_normalize(PyTypeObject *type, PyObject *args) { UnicodeString *u, _u, target; UNormalizationMode mode; int32_t options; if (!parseArgs(args, "Sii", &u, &_u, &mode, &options)) { STATUS_CALL(Normalizer::normalize(*u, mode, options, target, status)); return PyUnicode_FromUnicodeString(&target); } return PyErr_SetArgsError(type, "normalize", args); } static PyObject *t_normalizer_compose(PyTypeObject *type, PyObject *args) { UnicodeString *u, _u, target; UBool compat; int32_t options; if (!parseArgs(args, "SBi", &u, &_u, &compat, &options)) { STATUS_CALL(Normalizer::compose(*u, compat, options, target, status)); return PyUnicode_FromUnicodeString(&target); } return PyErr_SetArgsError(type, "compose", args); } static PyObject *t_normalizer_decompose(PyTypeObject *type, PyObject *args) { UnicodeString *u, _u, target; UBool compat; int32_t options; if (!parseArgs(args, "SBi", &u, &_u, &compat, &options)) { STATUS_CALL(Normalizer::decompose(*u, compat, options, target, status)); return PyUnicode_FromUnicodeString(&target); } return PyErr_SetArgsError(type, "decompose", args); } static PyObject *t_normalizer_quickCheck(PyTypeObject *type, PyObject *args) { UnicodeString *u, *_u; UNormalizationMode mode; int32_t options; switch (PyTuple_Size(args)) { case 2: if (!parseArgs(args, "Si", &u, &_u, &mode)) { UNormalizationCheckResult uncr; STATUS_CALL(uncr = Normalizer::quickCheck(*u, mode, status)); return PyInt_FromLong(uncr); } break; case 3: if (!parseArgs(args, "Sii", &u, &_u, &mode, &options)) { UNormalizationCheckResult uncr; STATUS_CALL(uncr = Normalizer::quickCheck(*u, mode, options, status)); return PyInt_FromLong(uncr); } break; } return PyErr_SetArgsError(type, "quickCheck", args); } static PyObject *t_normalizer_isNormalized(PyTypeObject *type, PyObject *args) { UnicodeString *u, *_u; UNormalizationMode mode; int32_t options; UBool b; switch (PyTuple_Size(args)) { case 2: if (!parseArgs(args, "Si", &u, &_u, &mode)) { STATUS_CALL(b = Normalizer::isNormalized(*u, mode, status)); Py_RETURN_BOOL(b); } break; case 3: if (!parseArgs(args, "Sii", &u, &_u, &mode, &options)) { STATUS_CALL(b = Normalizer::isNormalized(*u, mode, options, status)); Py_RETURN_BOOL(b); } break; } return PyErr_SetArgsError(type, "isNormalized", args); } static PyObject *t_normalizer_concatenate(PyTypeObject *type, PyObject *args) { UnicodeString *u0, *_u0; UnicodeString *u1, *_u1; UnicodeString u; UNormalizationMode mode; int32_t options; if (!parseArgs(args, "SSii", &u0, &_u0, &u1, &_u1, &mode, &options)) { STATUS_CALL(Normalizer::concatenate(*u0, *u1, u, mode, options, status)); return PyUnicode_FromUnicodeString(&u); } return PyErr_SetArgsError(type, "concatenate", args); } static PyObject *t_normalizer_compare(PyTypeObject *type, PyObject *args) { UnicodeString *u0, *_u0; UnicodeString *u1, *_u1; int32_t options, n; if (!parseArgs(args, "SSi", &u0, &_u0, &u1, &_u1, &options)) { STATUS_CALL(n = Normalizer::compare(*u0, *u1, options, status)); return PyInt_FromLong(n); } return PyErr_SetArgsError(type, "compare", args); } static PyObject *t_normalizer_richcmp(t_normalizer *self, PyObject *arg, int op) { Normalizer *normalizer; int b = 0; if (!parseArg(arg, "P", TYPE_CLASSID(Normalizer), &normalizer)) { switch (op) { case Py_EQ: case Py_NE: b = *self->object == *normalizer; if (op == Py_EQ) Py_RETURN_BOOL(b); Py_RETURN_BOOL(!b); case Py_LT: case Py_LE: case Py_GT: case Py_GE: PyErr_SetNone(PyExc_NotImplementedError); return NULL; } } return PyErr_SetArgsError((PyObject *) self, "__richcmp__", arg); } static long t_normalizer_hash(t_normalizer *self) { return (long) self->object->hashCode(); } static PyObject *t_normalizer_iter(t_normalizer *self) { Py_RETURN_SELF(); } static PyObject *t_normalizer_iter_next(t_normalizer *self) { if (self->object->getIndex() < self->object->endIndex()) { UChar32 c = self->object->next(); return PyInt_FromLong(c); } PyErr_SetNone(PyExc_StopIteration); return NULL; } #if U_ICU_VERSION_HEX >= 0x04040000 /* Normalizer2 */ static PyObject *t_normalizer2_normalize(t_normalizer2 *self, PyObject *args) { UnicodeString *u, _u, *result; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "S", &u, &_u)) { UnicodeString dest; STATUS_CALL(self->object->normalize(*u, dest, status)); return PyUnicode_FromUnicodeString(&dest); } break; case 2: if (!parseArgs(args, "SU", &u, &_u, &result)) { STATUS_CALL(self->object->normalize(*u, *result, status)); Py_RETURN_ARG(args, 1); } break; } return PyErr_SetArgsError((PyObject *) self, "normalize", args); } static PyObject *t_normalizer2_normalizeSecondAndAppend(t_normalizer2 *self, PyObject *args) { UnicodeString *u, _u, *result; if (!parseArgs(args, "US", &result, &u, &_u)) { STATUS_CALL(self->object->normalizeSecondAndAppend(*result, *u, status)); Py_RETURN_ARG(args, 0); } return PyErr_SetArgsError((PyObject *) self, "normalizeSecondAndAppend", args); } static PyObject *t_normalizer2_append(t_normalizer2 *self, PyObject *args) { UnicodeString *u, _u, *result; if (!parseArgs(args, "US", &result, &u, &_u)) { STATUS_CALL(self->object->append(*result, *u, status)); Py_RETURN_ARG(args, 0); } return PyErr_SetArgsError((PyObject *) self, "append", args); } static PyObject *t_normalizer2_isNormalized(t_normalizer2 *self, PyObject *arg) { UnicodeString *u, _u; if (!parseArg(arg, "S", &u, &_u)) { UBool b; STATUS_CALL(b = self->object->isNormalized(*u, status)); Py_RETURN_BOOL(b); } return PyErr_SetArgsError((PyObject *) self, "isNormalized", arg); } static PyObject *t_normalizer2_quickCheck(t_normalizer2 *self, PyObject *arg) { UnicodeString *u, _u; if (!parseArg(arg, "S", &u, &_u)) { UNormalizationCheckResult uncr; STATUS_CALL(uncr = self->object->quickCheck(*u, status)); return PyInt_FromLong(uncr); } return PyErr_SetArgsError((PyObject *) self, "quickCheck", arg); } static PyObject *t_normalizer2_spanQuickCheckYes(t_normalizer2 *self, PyObject *arg) { UnicodeString *u, _u; if (!parseArg(arg, "S", &u, &_u)) { int32_t end; STATUS_CALL(end = self->object->spanQuickCheckYes(*u, status)); return PyInt_FromLong(end); } return PyErr_SetArgsError((PyObject *) self, "spanQuickCheckYes", arg); } static PyObject *t_normalizer2_hasBoundaryBefore(t_normalizer2 *self, PyObject *arg) { UnicodeString *u, _u; if (!parseArg(arg, "S", &u, &_u)) { UChar32 c; int32_t len; UBool b; STATUS_CALL(len = toUChar32(*u, &c, status)); if (len == 1) { b = self->object->hasBoundaryBefore(c); Py_RETURN_BOOL(b); } } return PyErr_SetArgsError((PyObject *) self, "hasBoundaryBefore", arg); } static PyObject *t_normalizer2_hasBoundaryAfter(t_normalizer2 *self, PyObject *arg) { UnicodeString *u, _u; if (!parseArg(arg, "S", &u, &_u)) { UChar32 c; int32_t len; UBool b; STATUS_CALL(len = toUChar32(*u, &c, status)); if (len == 1) { b = self->object->hasBoundaryAfter(c); Py_RETURN_BOOL(b); } } return PyErr_SetArgsError((PyObject *) self, "hasBoundaryAfter", arg); } static PyObject *t_normalizer2_isInert(t_normalizer2 *self, PyObject *arg) { UnicodeString *u, _u; if (!parseArg(arg, "S", &u, &_u)) { UChar32 c; int32_t len; UBool b; STATUS_CALL(len = toUChar32(*u, &c, status)); if (len == 1) { b = self->object->isInert(c); Py_RETURN_BOOL(b); } } return PyErr_SetArgsError((PyObject *) self, "isInert", arg); } static PyObject *t_normalizer2_getInstance(PyTypeObject *type, PyObject *args) { const char *packageName, *name; UNormalization2Mode mode; const Normalizer2 *normalizer; if (PyArg_ParseTuple(args, "zsi", &packageName, &name, &mode)) { STATUS_CALL(normalizer = Normalizer2::getInstance(packageName, name, mode, status)); return wrap_Normalizer2((Normalizer2 *) normalizer, 0); } return PyErr_SetArgsError(type, "getInstance", args); } /* FilteredNormalizer2 */ static int t_filterednormalizer2_init(t_filterednormalizer2 *self, PyObject *args, PyObject *kwds) { Normalizer2 *normalizer; UnicodeSet *filter; if (!parseArgs(args, "pp", TYPE_CLASSID(Normalizer2), TYPE_CLASSID(UnicodeSet), &normalizer, &self->normalizer, &filter, &self->filter)) { self->object = new FilteredNormalizer2(*normalizer, *filter); self->flags = T_OWNED; return 0; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; } #endif void _init_normalizer(PyObject *m) { NormalizerType_.tp_richcompare = (richcmpfunc) t_normalizer_richcmp; NormalizerType_.tp_hash = (hashfunc) t_normalizer_hash; NormalizerType_.tp_iter = (getiterfunc) t_normalizer_iter; NormalizerType_.tp_iternext = (iternextfunc) t_normalizer_iter_next; REGISTER_TYPE(Normalizer, m); #if U_ICU_VERSION_HEX >= 0x04040000 REGISTER_TYPE(Normalizer2, m); REGISTER_TYPE(FilteredNormalizer2, m); #endif INSTALL_CONSTANTS_TYPE(UNormalizationMode, m); INSTALL_CONSTANTS_TYPE(UNormalizationCheckResult, m); #if U_ICU_VERSION_HEX >= 0x04040000 INSTALL_CONSTANTS_TYPE(UNormalizationMode2, m); #endif INSTALL_ENUM(UNormalizationMode, "NONE", UNORM_NONE); INSTALL_ENUM(UNormalizationMode, "NFD", UNORM_NFD); INSTALL_ENUM(UNormalizationMode, "NFKD", UNORM_NFKD); INSTALL_ENUM(UNormalizationMode, "NFC", UNORM_NFC); INSTALL_ENUM(UNormalizationMode, "DEFAULT", UNORM_DEFAULT); INSTALL_ENUM(UNormalizationMode, "NFKC", UNORM_NFKC); INSTALL_ENUM(UNormalizationMode, "FCD", UNORM_FCD); INSTALL_ENUM(UNormalizationCheckResult, "NO", UNORM_NO); INSTALL_ENUM(UNormalizationCheckResult, "YES", UNORM_YES); INSTALL_ENUM(UNormalizationCheckResult, "MAYBE", UNORM_MAYBE); #if U_ICU_VERSION_HEX >= 0x04040000 INSTALL_ENUM(UNormalizationMode2, "COMPOSE", UNORM2_COMPOSE); INSTALL_ENUM(UNormalizationMode2, "DECOMPOSE", UNORM2_DECOMPOSE); INSTALL_ENUM(UNormalizationMode2, "FCD", UNORM2_FCD); INSTALL_ENUM(UNormalizationMode2, "COMPOSE_CONTIGUOUS", UNORM2_COMPOSE_CONTIGUOUS); #endif } PyICU-1.9.5/normalizer.h0000644000076500000000000000256711344037065015232 0ustar vajdawheel00000000000000/* ==================================================================== * Copyright (c) 2010-2010 Open Source Applications Foundation. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. * ==================================================================== */ #ifndef _normalizer_h #define _normalizer_h void _init_normalizer(PyObject *m); #endif /* _normalizer_h */ PyICU-1.9.5/numberformat.cpp0000644000076500000000000023715413010705477016107 0ustar vajdawheel00000000000000/* ==================================================================== * Copyright (c) 2004-2011 Open Source Applications Foundation. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. * ==================================================================== */ #include "common.h" #include "structmember.h" #include "bases.h" #include "locale.h" #include "format.h" #include "numberformat.h" #include "macros.h" #if U_HAVE_RBNF DECLARE_CONSTANTS_TYPE(URBNFRuleSetTag); #endif #if U_ICU_VERSION_HEX >= 0x04080000 DECLARE_CONSTANTS_TYPE(UCurrencySpacing); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(51, 0, 0) DECLARE_CONSTANTS_TYPE(UNumberCompactStyle); #endif /* DecimalFormatSymbols */ class t_decimalformatsymbols : public _wrapper { public: DecimalFormatSymbols *object; }; static int t_decimalformatsymbols_init(t_decimalformatsymbols *self, PyObject *args, PyObject *kwds); static PyObject *t_decimalformatsymbols_getSymbol(t_decimalformatsymbols *self, PyObject *args); static PyObject *t_decimalformatsymbols_setSymbol(t_decimalformatsymbols *self, PyObject *args); static PyObject *t_decimalformatsymbols_getLocale(t_decimalformatsymbols *self, PyObject *args); #if U_ICU_VERSION_HEX >= 0x04020000 static PyObject *t_decimalformatsymbols_getPatternForCurrencySpacing(t_decimalformatsymbols *self, PyObject *args); static PyObject *t_decimalformatsymbols_setPatternForCurrencySpacing(t_decimalformatsymbols *self, PyObject *args); #endif static PyMethodDef t_decimalformatsymbols_methods[] = { DECLARE_METHOD(t_decimalformatsymbols, getSymbol, METH_VARARGS), DECLARE_METHOD(t_decimalformatsymbols, setSymbol, METH_VARARGS), DECLARE_METHOD(t_decimalformatsymbols, getLocale, METH_VARARGS), #if U_ICU_VERSION_HEX >= 0x04020000 DECLARE_METHOD(t_decimalformatsymbols, getPatternForCurrencySpacing, METH_VARARGS), DECLARE_METHOD(t_decimalformatsymbols, setPatternForCurrencySpacing, METH_VARARGS), #endif { NULL, NULL, 0, NULL } }; DECLARE_TYPE(DecimalFormatSymbols, t_decimalformatsymbols, UObject, DecimalFormatSymbols, t_decimalformatsymbols_init, NULL); /* NumberFormat */ class t_numberformat : public _wrapper { public: NumberFormat *object; }; static PyObject *t_numberformat_format(t_numberformat *self, PyObject *args); static PyObject *t_numberformat_parse(t_numberformat *self, PyObject *args); static PyObject *t_numberformat_parseCurrency(t_numberformat *self, PyObject *args); static PyObject *t_numberformat_isParseIntegerOnly(t_numberformat *self); static PyObject *t_numberformat_setParseIntegerOnly(t_numberformat *self, PyObject *arg); static PyObject *t_numberformat_isGroupingUsed(t_numberformat *self); static PyObject *t_numberformat_setGroupingUsed(t_numberformat *self, PyObject *arg); static PyObject *t_numberformat_getMaximumIntegerDigits(t_numberformat *self); static PyObject *t_numberformat_setMaximumIntegerDigits(t_numberformat *self, PyObject *arg); static PyObject *t_numberformat_getMinimumIntegerDigits(t_numberformat *self); static PyObject *t_numberformat_setMinimumIntegerDigits(t_numberformat *self, PyObject *arg); static PyObject *t_numberformat_getMaximumFractionDigits(t_numberformat *self); static PyObject *t_numberformat_setMaximumFractionDigits(t_numberformat *self, PyObject *arg); static PyObject *t_numberformat_getMinimumFractionDigits(t_numberformat *self); static PyObject *t_numberformat_setMinimumFractionDigits(t_numberformat *self, PyObject *arg); #if U_ICU_VERSION_HEX >= 0x04080000 static PyObject *t_numberformat_isLenient(t_numberformat *self); static PyObject *t_numberformat_setLenient(t_numberformat *self, PyObject *arg); #endif static PyObject *t_numberformat_getCurrency(t_numberformat *self); static PyObject *t_numberformat_setCurrency(t_numberformat *self, PyObject *arg); static PyObject *t_numberformat_createInstance(PyTypeObject *type, PyObject *args); static PyObject *t_numberformat_createCurrencyInstance(PyTypeObject *type, PyObject *args); static PyObject *t_numberformat_createPercentInstance(PyTypeObject *type, PyObject *args); static PyObject *t_numberformat_createScientificInstance(PyTypeObject *type, PyObject *args); static PyObject *t_numberformat_getAvailableLocales(PyTypeObject *type); static PyMethodDef t_numberformat_methods[] = { DECLARE_METHOD(t_numberformat, format, METH_VARARGS), DECLARE_METHOD(t_numberformat, parse, METH_VARARGS), DECLARE_METHOD(t_numberformat, parseCurrency, METH_VARARGS), DECLARE_METHOD(t_numberformat, isParseIntegerOnly, METH_NOARGS), DECLARE_METHOD(t_numberformat, setParseIntegerOnly, METH_O), DECLARE_METHOD(t_numberformat, isGroupingUsed, METH_NOARGS), DECLARE_METHOD(t_numberformat, setGroupingUsed, METH_O), DECLARE_METHOD(t_numberformat, getMaximumIntegerDigits, METH_NOARGS), DECLARE_METHOD(t_numberformat, setMaximumIntegerDigits, METH_O), DECLARE_METHOD(t_numberformat, getMinimumIntegerDigits, METH_NOARGS), DECLARE_METHOD(t_numberformat, setMinimumIntegerDigits, METH_O), DECLARE_METHOD(t_numberformat, getMaximumFractionDigits, METH_NOARGS), DECLARE_METHOD(t_numberformat, setMaximumFractionDigits, METH_O), DECLARE_METHOD(t_numberformat, getMinimumFractionDigits, METH_NOARGS), DECLARE_METHOD(t_numberformat, setMinimumFractionDigits, METH_O), #if U_ICU_VERSION_HEX >= 0x04080000 DECLARE_METHOD(t_numberformat, isLenient, METH_NOARGS), DECLARE_METHOD(t_numberformat, setLenient, METH_O), #endif DECLARE_METHOD(t_numberformat, getCurrency, METH_NOARGS), DECLARE_METHOD(t_numberformat, setCurrency, METH_O), DECLARE_METHOD(t_numberformat, createInstance, METH_VARARGS | METH_CLASS), DECLARE_METHOD(t_numberformat, createCurrencyInstance, METH_VARARGS | METH_CLASS), DECLARE_METHOD(t_numberformat, createPercentInstance, METH_VARARGS | METH_CLASS), DECLARE_METHOD(t_numberformat, createScientificInstance, METH_VARARGS | METH_CLASS), DECLARE_METHOD(t_numberformat, getAvailableLocales, METH_NOARGS | METH_CLASS), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(NumberFormat, t_numberformat, Format, NumberFormat, abstract_init, NULL); #if U_ICU_VERSION_HEX >= 0x04020000 /* CurrencyPluralInfo */ class t_currencypluralinfo : public _wrapper { public: CurrencyPluralInfo *object; }; static int t_currencypluralinfo_init(t_currencypluralinfo *self, PyObject *args, PyObject *kwds); static PyObject *t_currencypluralinfo_getPluralRules(t_currencypluralinfo *self); static PyObject *t_currencypluralinfo_setPluralRules(t_currencypluralinfo *self, PyObject *arg); static PyObject *t_currencypluralinfo_getCurrencyPluralPattern(t_currencypluralinfo *self, PyObject *args); static PyObject *t_currencypluralinfo_setCurrencyPluralPattern(t_currencypluralinfo *self, PyObject *args); static PyObject *t_currencypluralinfo_getLocale(t_currencypluralinfo *self); static PyObject *t_currencypluralinfo_setLocale(t_currencypluralinfo *self, PyObject *arg); static PyMethodDef t_currencypluralinfo_methods[] = { DECLARE_METHOD(t_currencypluralinfo, getPluralRules, METH_NOARGS), DECLARE_METHOD(t_currencypluralinfo, setPluralRules, METH_O), DECLARE_METHOD(t_currencypluralinfo, getCurrencyPluralPattern, METH_VARARGS), DECLARE_METHOD(t_currencypluralinfo, setCurrencyPluralPattern, METH_VARARGS), DECLARE_METHOD(t_currencypluralinfo, getLocale, METH_NOARGS), DECLARE_METHOD(t_currencypluralinfo, setLocale, METH_O), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(CurrencyPluralInfo, t_currencypluralinfo, UObject, CurrencyPluralInfo, t_currencypluralinfo_init, NULL); #endif /* DecimalFormat */ class t_decimalformat : public _wrapper { public: DecimalFormat *object; }; static int t_decimalformat_init(t_decimalformat *self, PyObject *args, PyObject *kwds); static PyObject *t_decimalformat_getPositivePrefix(t_decimalformat *self, PyObject *args); static PyObject *t_decimalformat_setPositivePrefix(t_decimalformat *self, PyObject *arg); static PyObject *t_decimalformat_getNegativePrefix(t_decimalformat *self, PyObject *args); static PyObject *t_decimalformat_setNegativePrefix(t_decimalformat *self, PyObject *arg); static PyObject *t_decimalformat_getPositiveSuffix(t_decimalformat *self, PyObject *args); static PyObject *t_decimalformat_setPositiveSuffix(t_decimalformat *self, PyObject *arg); static PyObject *t_decimalformat_getNegativeSuffix(t_decimalformat *self, PyObject *args); static PyObject *t_decimalformat_setNegativeSuffix(t_decimalformat *self, PyObject *arg); static PyObject *t_decimalformat_getMultiplier(t_decimalformat *self); static PyObject *t_decimalformat_setMultiplier(t_decimalformat *self, PyObject *arg); static PyObject *t_decimalformat_getRoundingIncrement(t_decimalformat *self); static PyObject *t_decimalformat_setRoundingIncrement(t_decimalformat *self, PyObject *arg); static PyObject *t_decimalformat_getRoundingMode(t_decimalformat *self); static PyObject *t_decimalformat_setRoundingMode(t_decimalformat *self, PyObject *arg); static PyObject *t_decimalformat_getFormatWidth(t_decimalformat *self); static PyObject *t_decimalformat_setFormatWidth(t_decimalformat *self, PyObject *arg); static PyObject *t_decimalformat_getPadCharacterString(t_decimalformat *self, PyObject *args); static PyObject *t_decimalformat_setPadCharacter(t_decimalformat *self, PyObject *arg); static PyObject *t_decimalformat_getPadPosition(t_decimalformat *self); static PyObject *t_decimalformat_setPadPosition(t_decimalformat *self, PyObject *arg); static PyObject *t_decimalformat_isScientificNotation(t_decimalformat *self); static PyObject *t_decimalformat_setScientificNotation(t_decimalformat *self, PyObject *arg); static PyObject *t_decimalformat_getMinimumExponentDigits(t_decimalformat *self); static PyObject *t_decimalformat_setMinimumExponentDigits(t_decimalformat *self, PyObject *arg); static PyObject *t_decimalformat_isExponentSignAlwaysShown(t_decimalformat *self); static PyObject *t_decimalformat_setExponentSignAlwaysShown(t_decimalformat *self, PyObject *arg); static PyObject *t_decimalformat_isDecimalSeparatorAlwaysShown(t_decimalformat *self); static PyObject *t_decimalformat_setDecimalSeparatorAlwaysShown(t_decimalformat *self, PyObject *arg); static PyObject *t_decimalformat_getGroupingSize(t_decimalformat *self); static PyObject *t_decimalformat_setGroupingSize(t_decimalformat *self, PyObject *arg); static PyObject *t_decimalformat_getSecondaryGroupingSize(t_decimalformat *self); static PyObject *t_decimalformat_setSecondaryGroupingSize(t_decimalformat *self, PyObject *arg); static PyObject *t_decimalformat_toPattern(t_decimalformat *self, PyObject *args); static PyObject *t_decimalformat_toLocalizedPattern(t_decimalformat *self, PyObject *args); static PyObject *t_decimalformat_applyPattern(t_decimalformat *self, PyObject *arg); static PyObject *t_decimalformat_applyLocalizedPattern(t_decimalformat *self, PyObject *arg); static PyObject *t_decimalformat_getMaximumSignificantDigits(t_decimalformat *self); static PyObject *t_decimalformat_setMaximumSignificantDigits(t_decimalformat *self, PyObject *arg); static PyObject *t_decimalformat_getMinimumSignificantDigits(t_decimalformat *self); static PyObject *t_decimalformat_setMinimumSignificantDigits(t_decimalformat *self, PyObject *arg); static PyObject *t_decimalformat_areSignificantDigitsUsed(t_decimalformat *self); static PyObject *t_decimalformat_setSignificantDigitsUsed(t_decimalformat *self, PyObject *arg); static PyObject *t_decimalformat_getDecimalFormatSymbols(t_decimalformat *self); static PyObject *t_decimalformat_setDecimalFormatSymbols(t_decimalformat *self, PyObject *arg); #if U_ICU_VERSION_HEX >= 0x04020000 static PyObject *t_decimalformat_getCurrencyPluralInfo(t_decimalformat *self); static PyObject *t_decimalformat_setCurrencyPluralInfo(t_decimalformat *self, PyObject *arg); #endif static PyMethodDef t_decimalformat_methods[] = { DECLARE_METHOD(t_decimalformat, getPositivePrefix, METH_VARARGS), DECLARE_METHOD(t_decimalformat, setPositivePrefix, METH_O), DECLARE_METHOD(t_decimalformat, getNegativePrefix, METH_VARARGS), DECLARE_METHOD(t_decimalformat, setNegativePrefix, METH_O), DECLARE_METHOD(t_decimalformat, getPositiveSuffix, METH_VARARGS), DECLARE_METHOD(t_decimalformat, setPositiveSuffix, METH_O), DECLARE_METHOD(t_decimalformat, getNegativeSuffix, METH_VARARGS), DECLARE_METHOD(t_decimalformat, setNegativeSuffix, METH_O), DECLARE_METHOD(t_decimalformat, getMultiplier, METH_NOARGS), DECLARE_METHOD(t_decimalformat, setMultiplier, METH_O), DECLARE_METHOD(t_decimalformat, getRoundingIncrement, METH_NOARGS), DECLARE_METHOD(t_decimalformat, setRoundingIncrement, METH_O), DECLARE_METHOD(t_decimalformat, getRoundingMode, METH_NOARGS), DECLARE_METHOD(t_decimalformat, setRoundingMode, METH_O), DECLARE_METHOD(t_decimalformat, getFormatWidth, METH_NOARGS), DECLARE_METHOD(t_decimalformat, setFormatWidth, METH_O), DECLARE_METHOD(t_decimalformat, getPadCharacterString, METH_VARARGS), DECLARE_METHOD(t_decimalformat, setPadCharacter, METH_O), DECLARE_METHOD(t_decimalformat, getPadPosition, METH_NOARGS), DECLARE_METHOD(t_decimalformat, setPadPosition, METH_O), DECLARE_METHOD(t_decimalformat, isScientificNotation, METH_NOARGS), DECLARE_METHOD(t_decimalformat, setScientificNotation, METH_O), DECLARE_METHOD(t_decimalformat, getMinimumExponentDigits, METH_NOARGS), DECLARE_METHOD(t_decimalformat, setMinimumExponentDigits, METH_O), DECLARE_METHOD(t_decimalformat, isExponentSignAlwaysShown, METH_NOARGS), DECLARE_METHOD(t_decimalformat, setExponentSignAlwaysShown, METH_O), DECLARE_METHOD(t_decimalformat, isDecimalSeparatorAlwaysShown, METH_NOARGS), DECLARE_METHOD(t_decimalformat, setDecimalSeparatorAlwaysShown, METH_O), DECLARE_METHOD(t_decimalformat, getGroupingSize, METH_NOARGS), DECLARE_METHOD(t_decimalformat, setGroupingSize, METH_O), DECLARE_METHOD(t_decimalformat, getSecondaryGroupingSize, METH_NOARGS), DECLARE_METHOD(t_decimalformat, setSecondaryGroupingSize, METH_O), DECLARE_METHOD(t_decimalformat, toPattern, METH_VARARGS), DECLARE_METHOD(t_decimalformat, toLocalizedPattern, METH_VARARGS), DECLARE_METHOD(t_decimalformat, applyPattern, METH_O), DECLARE_METHOD(t_decimalformat, applyLocalizedPattern, METH_O), DECLARE_METHOD(t_decimalformat, getMaximumSignificantDigits, METH_NOARGS), DECLARE_METHOD(t_decimalformat, setMaximumSignificantDigits, METH_O), DECLARE_METHOD(t_decimalformat, getMinimumSignificantDigits, METH_NOARGS), DECLARE_METHOD(t_decimalformat, setMinimumSignificantDigits, METH_O), DECLARE_METHOD(t_decimalformat, areSignificantDigitsUsed, METH_NOARGS), DECLARE_METHOD(t_decimalformat, setSignificantDigitsUsed, METH_O), DECLARE_METHOD(t_decimalformat, getDecimalFormatSymbols, METH_NOARGS), DECLARE_METHOD(t_decimalformat, setDecimalFormatSymbols, METH_O), #if U_ICU_VERSION_HEX >= 0x04020000 DECLARE_METHOD(t_decimalformat, getCurrencyPluralInfo, METH_NOARGS), DECLARE_METHOD(t_decimalformat, setCurrencyPluralInfo, METH_O), #endif { NULL, NULL, 0, NULL } }; DECLARE_TYPE(DecimalFormat, t_decimalformat, NumberFormat, DecimalFormat, t_decimalformat_init, NULL); #if U_ICU_VERSION_HEX >= VERSION_HEX(51, 0, 0) /* CompactDecimalFormat */ class t_compactdecimalformat : public _wrapper { public: CompactDecimalFormat *object; }; static PyObject *t_compactdecimalformat_createInstance(PyTypeObject *type, PyObject *args); static PyMethodDef t_compactdecimalformat_methods[] = { DECLARE_METHOD(t_compactdecimalformat, createInstance, METH_VARARGS | METH_CLASS), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(CompactDecimalFormat, t_compactdecimalformat, DecimalFormat, CompactDecimalFormat, abstract_init, NULL); #endif /* RuleBasedNumberFormat */ class t_rulebasednumberformat : public _wrapper { public: RuleBasedNumberFormat *object; }; static int t_rulebasednumberformat_init(t_rulebasednumberformat *self, PyObject *args, PyObject *kwds); static PyObject *t_rulebasednumberformat_getRules(t_rulebasednumberformat *self, PyObject *args); static PyObject *t_rulebasednumberformat_getNumberOfRuleSetNames(t_rulebasednumberformat *self); static PyObject *t_rulebasednumberformat_getRuleSetName(t_rulebasednumberformat *self, PyObject *args); static PyObject *t_rulebasednumberformat_getNumberOfRuleSetDisplayNameLocales(t_rulebasednumberformat *self); static PyObject *t_rulebasednumberformat_getRuleSetDisplayName(t_rulebasednumberformat *self, PyObject *args); static PyObject *t_rulebasednumberformat_format(t_rulebasednumberformat *self, PyObject *args); static PyObject *t_rulebasednumberformat_isLenient(t_rulebasednumberformat *self); static PyObject *t_rulebasednumberformat_setLenient(t_rulebasednumberformat *self, PyObject *arg); static PyObject *t_rulebasednumberformat_getDefaultRuleSetName(t_rulebasednumberformat *self, PyObject *args); static PyObject *t_rulebasednumberformat_setDefaultRuleSet(t_rulebasednumberformat *self, PyObject *arg); static PyMethodDef t_rulebasednumberformat_methods[] = { DECLARE_METHOD(t_rulebasednumberformat, getRules, METH_VARARGS), DECLARE_METHOD(t_rulebasednumberformat, getNumberOfRuleSetNames, METH_NOARGS), DECLARE_METHOD(t_rulebasednumberformat, getRuleSetName, METH_VARARGS), DECLARE_METHOD(t_rulebasednumberformat, getNumberOfRuleSetDisplayNameLocales, METH_NOARGS), DECLARE_METHOD(t_rulebasednumberformat, getRuleSetDisplayName, METH_VARARGS), DECLARE_METHOD(t_rulebasednumberformat, format, METH_VARARGS), DECLARE_METHOD(t_rulebasednumberformat, isLenient, METH_NOARGS), DECLARE_METHOD(t_rulebasednumberformat, setLenient, METH_O), DECLARE_METHOD(t_rulebasednumberformat, getDefaultRuleSetName, METH_VARARGS), DECLARE_METHOD(t_rulebasednumberformat, setDefaultRuleSet, METH_O), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(RuleBasedNumberFormat, t_rulebasednumberformat, NumberFormat, RuleBasedNumberFormat, t_rulebasednumberformat_init, NULL); PyObject *wrap_NumberFormat(NumberFormat *format) { RETURN_WRAPPED_IF_ISINSTANCE(format, DecimalFormat); RETURN_WRAPPED_IF_ISINSTANCE(format, RuleBasedNumberFormat); return wrap_NumberFormat(format, T_OWNED); } /* ChoiceFormat */ class t_choiceformat : public _wrapper { public: ChoiceFormat *object; }; static int t_choiceformat_init(t_choiceformat *self, PyObject *args, PyObject *kwds); static PyObject *t_choiceformat_toPattern(t_choiceformat *self, PyObject *args); static PyObject *t_choiceformat_applyPattern(t_choiceformat *self, PyObject *arg); static PyObject *t_choiceformat_setChoices(t_choiceformat *self, PyObject *args); static PyObject *t_choiceformat_getLimits(t_choiceformat *self); static PyObject *t_choiceformat_getClosures(t_choiceformat *self); static PyObject *t_choiceformat_getFormats(t_choiceformat *self); static PyObject *t_choiceformat_format(t_choiceformat *self, PyObject *args); static PyMethodDef t_choiceformat_methods[] = { DECLARE_METHOD(t_choiceformat, toPattern, METH_VARARGS), DECLARE_METHOD(t_choiceformat, applyPattern, METH_O), DECLARE_METHOD(t_choiceformat, setChoices, METH_VARARGS), DECLARE_METHOD(t_choiceformat, getLimits, METH_NOARGS), DECLARE_METHOD(t_choiceformat, getClosures, METH_NOARGS), DECLARE_METHOD(t_choiceformat, getFormats, METH_NOARGS), DECLARE_METHOD(t_choiceformat, format, METH_VARARGS), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(ChoiceFormat, t_choiceformat, NumberFormat, ChoiceFormat, t_choiceformat_init, NULL); /* DecimalFormatSymbols */ static int t_decimalformatsymbols_init(t_decimalformatsymbols *self, PyObject *args, PyObject *kwds) { Locale *locale; DecimalFormatSymbols *dfs; switch (PyTuple_Size(args)) { case 0: INT_STATUS_CALL(dfs = new DecimalFormatSymbols(status)); self->object = dfs; self->flags = T_OWNED; break; case 1: if (!parseArgs(args, "P", TYPE_CLASSID(Locale), &locale)) { INT_STATUS_CALL(dfs = new DecimalFormatSymbols(*locale, status)); self->object = dfs; self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; default: PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; } if (self->object) return 0; return -1; } static PyObject *t_decimalformatsymbols_getSymbol(t_decimalformatsymbols *self, PyObject *args) { DecimalFormatSymbols::ENumberFormatSymbol symbol; UnicodeString *u; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "i", &symbol)) { UnicodeString u = self->object->getSymbol(symbol); return PyUnicode_FromUnicodeString(&u); } case 2: if (!parseArgs(args, "iU", &symbol, &u)) { u->setTo(self->object->getSymbol(symbol)); Py_RETURN_ARG(args, 1); } break; } return PyErr_SetArgsError((PyObject *) self, "getSymbol", args); } static PyObject *t_decimalformatsymbols_setSymbol(t_decimalformatsymbols *self, PyObject *args) { DecimalFormatSymbols::ENumberFormatSymbol symbol; UnicodeString *u, _u; if (!parseArgs(args, "iS", &symbol, &u, &_u)) { self->object->setSymbol(symbol, *u); /* copied */ Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setSymbol", args); } static PyObject *t_decimalformatsymbols_getLocale(t_decimalformatsymbols *self, PyObject *args) { ULocDataLocaleType type; Locale locale; switch (PyTuple_Size(args)) { case 0: STATUS_CALL(locale = self->object->getLocale(ULOC_VALID_LOCALE, status)); return wrap_Locale(locale); case 1: if (!parseArgs(args, "i", &type)) { STATUS_CALL(locale = self->object->getLocale(type, status)); return wrap_Locale(locale); } break; } return PyErr_SetArgsError((PyObject *) self, "getLocale", args); } #if U_ICU_VERSION_HEX >= 0x04020000 static PyObject *t_decimalformatsymbols_getPatternForCurrencySpacing(t_decimalformatsymbols *self, PyObject *args) { #if U_ICU_VERSION_HEX >= 0x04080000 UCurrencySpacing type; #else DecimalFormatSymbols::ECurrencySpacing type; #endif UBool beforeCurrency; if (!parseArgs(args, "ib", &type, &beforeCurrency)) { UnicodeString u; STATUS_CALL(u = self->object->getPatternForCurrencySpacing(type, beforeCurrency, status)); return PyUnicode_FromUnicodeString(&u); } return PyErr_SetArgsError((PyObject *) self, "getPatternForCurrencySpacing", args); } static PyObject *t_decimalformatsymbols_setPatternForCurrencySpacing(t_decimalformatsymbols *self, PyObject *args) { UnicodeString *u, _u; #if U_ICU_VERSION_HEX >= 0x04080000 UCurrencySpacing type; #else DecimalFormatSymbols::ECurrencySpacing type; #endif UBool beforeCurrency; if (!parseArgs(args, "ibS", &type, &beforeCurrency, &u, &_u)) { /* copied */ self->object->setPatternForCurrencySpacing(type, beforeCurrency, *u); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setPatternForCurrencySpacing", args); } #endif DEFINE_RICHCMP(DecimalFormatSymbols, t_decimalformatsymbols); /* NumberFormat */ static PyObject *t_numberformat_format(t_numberformat *self, PyObject *args) { UnicodeString *u; UnicodeString _u; double d; int i; PY_LONG_LONG l; FieldPosition *fp; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "d", &d)) { self->object->format(d, _u); return PyUnicode_FromUnicodeString(&_u); } if (!parseArgs(args, "i", &i)) { self->object->format(i, _u); return PyUnicode_FromUnicodeString(&_u); } if (!parseArgs(args, "L", &l)) { self->object->format((int64_t) l, _u); return PyUnicode_FromUnicodeString(&_u); } break; case 2: if (!parseArgs(args, "dP", TYPE_CLASSID(FieldPosition), &d, &fp)) { self->object->format(d, _u, *fp); return PyUnicode_FromUnicodeString(&_u); } if (!parseArgs(args, "iP", TYPE_CLASSID(FieldPosition), &i, &fp)) { self->object->format(i, _u, *fp); return PyUnicode_FromUnicodeString(&_u); } if (!parseArgs(args, "LP", TYPE_CLASSID(FieldPosition), &l, &fp)) { self->object->format((int64_t) l, _u, *fp); return PyUnicode_FromUnicodeString(&_u); } break; case 3: if (!parseArgs(args, "dUP", TYPE_CLASSID(FieldPosition), &d, &u, &fp)) { self->object->format(d, *u, *fp); Py_RETURN_ARG(args, 1); } if (!parseArgs(args, "iUP", TYPE_CLASSID(FieldPosition), &i, &u, &fp)) { self->object->format(i, *u, *fp); Py_RETURN_ARG(args, 1); } if (!parseArgs(args, "LUP", TYPE_CLASSID(FieldPosition), &l, &u, &fp)) { self->object->format((int64_t) l, *u, *fp); Py_RETURN_ARG(args, 1); } break; } return t_format_format((t_format *) self, args); } static PyObject *t_numberformat_parse(t_numberformat *self, PyObject *args) { UnicodeString *u; UnicodeString _u; Formattable *f; ParsePosition *pp; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "S", &u, &_u)) { Formattable result; STATUS_CALL(self->object->parse(*u, result, status)); return wrap_Formattable(result); } break; case 2: if (!parseArgs(args, "SP", TYPE_CLASSID(Formattable), &u, &_u, &f)) { STATUS_CALL(self->object->parse(*u, *f, status)); Py_RETURN_ARG(args, 1); } if (!parseArgs(args, "SP", TYPE_CLASSID(ParsePosition), &u, &_u, &pp)) { Formattable result; pp->setErrorIndex(-1); self->object->parse(*u, result, *pp); if (pp->getErrorIndex() != -1) Py_RETURN_NONE; return wrap_Formattable(result); } break; case 3: if (!parseArgs(args, "SPP", TYPE_CLASSID(Formattable), TYPE_CLASSID(ParsePosition), &u, &_u, &f, &pp)) { pp->setErrorIndex(-1); self->object->parse(*u, *f, *pp); if (pp->getErrorIndex() != -1) Py_RETURN_NONE; Py_RETURN_ARG(args, 1); } break; } return PyErr_SetArgsError((PyObject *) self, "parse", args); } #if U_ICU_VERSION_HEX < VERSION_HEX(49, 0, 0) static PyObject *t_numberformat_parseCurrency(t_numberformat *self, PyObject *args) { UnicodeString *u; UnicodeString _u; Formattable *f; ParsePosition *pp; ParsePosition _pp; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "S", &u, &_u)) { Formattable result; _pp.setErrorIndex(-1); self->object->parseCurrency(*u, result, _pp); if (_pp.getErrorIndex() != -1) Py_RETURN_NONE; return wrap_Formattable(result); } break; case 2: if (!parseArgs(args, "SP", TYPE_CLASSID(Formattable), &u, &_u, &f)) { _pp.setErrorIndex(-1); self->object->parseCurrency(*u, *f, _pp); if (_pp.getErrorIndex() != -1) Py_RETURN_NONE; Py_RETURN_ARG(args, 1); } if (!parseArgs(args, "SP", TYPE_CLASSID(ParsePosition), &u, &_u, &pp)) { Formattable result; pp->setErrorIndex(-1); self->object->parseCurrency(*u, result, *pp); if (pp->getErrorIndex() != -1) Py_RETURN_NONE; return wrap_Formattable(result); } break; case 3: if (!parseArgs(args, "SPP", TYPE_CLASSID(Formattable), TYPE_CLASSID(ParsePosition), &u, &_u, &f, &pp)) { pp->setErrorIndex(-1); self->object->parseCurrency(*u, *f, *pp); if (pp->getErrorIndex() != -1) Py_RETURN_NONE; Py_RETURN_ARG(args, 1); } break; } return PyErr_SetArgsError((PyObject *) self, "parseCurrency", args); } #else static PyObject *t_numberformat_parseCurrency(t_numberformat *self, PyObject *args) { UnicodeString _u, *u; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "S", &u, &_u)) { CurrencyAmount *a; ParsePosition _pp; _pp.setErrorIndex(-1); a = self->object->parseCurrency(*u, _pp); if (_pp.getErrorIndex() != -1) Py_RETURN_NONE; return wrap_CurrencyAmount(a, T_OWNED); } break; } return PyErr_SetArgsError((PyObject *) self, "parseCurrency", args); } #endif static PyObject *t_numberformat_isParseIntegerOnly(t_numberformat *self) { int b = self->object->isParseIntegerOnly(); Py_RETURN_BOOL(b); } static PyObject *t_numberformat_setParseIntegerOnly(t_numberformat *self, PyObject *arg) { int b; if (!parseArg(arg, "b", &b)) { self->object->setParseIntegerOnly(b); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setParseIntegerOnly", arg); } static PyObject *t_numberformat_isGroupingUsed(t_numberformat *self) { int b = self->object->isGroupingUsed(); Py_RETURN_BOOL(b); } static PyObject *t_numberformat_setGroupingUsed(t_numberformat *self, PyObject *arg) { int b; if (!parseArg(arg, "b", &b)) { self->object->setGroupingUsed(b); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setGroupingUsed", arg); } static PyObject *t_numberformat_getMaximumIntegerDigits(t_numberformat *self) { int n = self->object->getMaximumIntegerDigits(); return PyInt_FromLong(n); } static PyObject *t_numberformat_setMaximumIntegerDigits(t_numberformat *self, PyObject *arg) { int n; if (!parseArg(arg, "i", &n)) { self->object->setMaximumIntegerDigits(n); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setMaximumIntegerDigits", arg); } static PyObject *t_numberformat_getMinimumIntegerDigits(t_numberformat *self) { int n = self->object->getMinimumIntegerDigits(); return PyInt_FromLong(n); } static PyObject *t_numberformat_setMinimumIntegerDigits(t_numberformat *self, PyObject *arg) { int n; if (!parseArg(arg, "i", &n)) { self->object->setMinimumIntegerDigits(n); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setMinimumIntegerDigits", arg); } static PyObject *t_numberformat_getMaximumFractionDigits(t_numberformat *self) { int n = self->object->getMaximumFractionDigits(); return PyInt_FromLong(n); } static PyObject *t_numberformat_setMaximumFractionDigits(t_numberformat *self, PyObject *arg) { int n; if (!parseArg(arg, "i", &n)) { self->object->setMaximumFractionDigits(n); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setMaximumFractionDigits", arg); } static PyObject *t_numberformat_getMinimumFractionDigits(t_numberformat *self) { int n = self->object->getMinimumFractionDigits(); return PyInt_FromLong(n); } static PyObject *t_numberformat_setMinimumFractionDigits(t_numberformat *self, PyObject *arg) { int n; if (!parseArg(arg, "i", &n)) { self->object->setMinimumFractionDigits(n); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setMinimumFractionDigits", arg); } #if U_ICU_VERSION_HEX >= 0x04080000 static PyObject *t_numberformat_isLenient(t_numberformat *self) { UBool n = self->object->isLenient(); Py_RETURN_BOOL(n); } static PyObject *t_numberformat_setLenient(t_numberformat *self, PyObject *arg) { int b; if (!parseArg(arg, "b", &b)) { self->object->setLenient(b); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setLenient", arg); } #endif static PyObject *t_numberformat_getCurrency(t_numberformat *self) { UnicodeString u(self->object->getCurrency()); return PyUnicode_FromUnicodeString(&u); } static PyObject *t_numberformat_setCurrency(t_numberformat *self, PyObject *arg) { UnicodeString *u, _u; if (!parseArg(arg, "S", &u, &_u)) { /* copied */ STATUS_CALL(self->object->setCurrency(u->getBuffer(), status)); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setCurrency", arg); } static PyObject *t_numberformat_createInstance(PyTypeObject *type, PyObject *args) { NumberFormat *format; Locale *locale; switch (PyTuple_Size(args)) { case 0: STATUS_CALL(format = NumberFormat::createInstance(status)); return wrap_NumberFormat(format); case 1: if (!parseArgs(args, "P", TYPE_CLASSID(Locale), &locale)) { STATUS_CALL(format = NumberFormat::createInstance(*locale, status)); return wrap_NumberFormat(format); } break; } return PyErr_SetArgsError(type, "createInstance", args); } static PyObject *t_numberformat_createCurrencyInstance(PyTypeObject *type, PyObject *args) { NumberFormat *format; Locale *locale; switch (PyTuple_Size(args)) { case 0: STATUS_CALL(format = NumberFormat::createCurrencyInstance(status)); return wrap_NumberFormat(format); case 1: if (!parseArgs(args, "P", TYPE_CLASSID(Locale), &locale)) { STATUS_CALL(format = NumberFormat::createCurrencyInstance(*locale, status)); return wrap_NumberFormat(format); } break; } return PyErr_SetArgsError(type, "createCurrencyInstance", args); } static PyObject *t_numberformat_createPercentInstance(PyTypeObject *type, PyObject *args) { NumberFormat *format; Locale *locale; switch (PyTuple_Size(args)) { case 0: STATUS_CALL(format = NumberFormat::createPercentInstance(status)); return wrap_NumberFormat(format); case 1: if (!parseArgs(args, "P", TYPE_CLASSID(Locale), &locale)) { STATUS_CALL(format = NumberFormat::createPercentInstance(*locale, status)); return wrap_NumberFormat(format); } break; } return PyErr_SetArgsError(type, "createPercentInstance", args); } static PyObject *t_numberformat_createScientificInstance(PyTypeObject *type, PyObject *args) { NumberFormat *format; Locale *locale; switch (PyTuple_Size(args)) { case 0: STATUS_CALL(format = NumberFormat::createScientificInstance(status)); return wrap_NumberFormat(format); case 1: if (!parseArgs(args, "P", TYPE_CLASSID(Locale), &locale)) { STATUS_CALL(format = NumberFormat::createScientificInstance(*locale, status)); return wrap_NumberFormat(format); } break; } return PyErr_SetArgsError(type, "createScientificInstance", args); } static PyObject *t_numberformat_getAvailableLocales(PyTypeObject *type) { int count; const Locale *locales = NumberFormat::getAvailableLocales(count); PyObject *dict = PyDict_New(); for (int32_t i = 0; i < count; i++) { Locale *locale = (Locale *) locales + i; PyObject *obj = wrap_Locale(locale, 0); PyDict_SetItemString(dict, locale->getName(), obj); Py_DECREF(obj); } return dict; } #if U_ICU_VERSION_HEX >= 0x04020000 /* CurrencyPluralInfo */ static int t_currencypluralinfo_init(t_currencypluralinfo *self, PyObject *args, PyObject *kwds) { Locale *locale; switch (PyTuple_Size(args)) { case 0: INT_STATUS_CALL(self->object = new CurrencyPluralInfo(status)); self->flags = T_OWNED; break; case 1: if (!parseArgs(args, "P", TYPE_CLASSID(Locale), &locale)) { INT_STATUS_CALL(self->object = new CurrencyPluralInfo(*locale, status)); self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; break; default: PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; } if (self->object) return 0; return -1; } static PyObject *t_currencypluralinfo_getPluralRules(t_currencypluralinfo *self) { return wrap_PluralRules(self->object->getPluralRules()->clone(), T_OWNED); } static PyObject *t_currencypluralinfo_setPluralRules(t_currencypluralinfo *self, PyObject *arg) { UnicodeString *u, _u; if (!parseArg(arg, "S", &u, &_u)) { STATUS_CALL(self->object->setPluralRules(*u, status)); /* transient */ Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setPluralRules", arg); } static PyObject *t_currencypluralinfo_getCurrencyPluralPattern(t_currencypluralinfo *self, PyObject *args) { UnicodeString *u0, _u0; UnicodeString *u1, _u1; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "S", &u0, &_u0)) { self->object->getCurrencyPluralPattern(*u0, _u1); return PyUnicode_FromUnicodeString(&_u1); } break; case 2: if (!parseArgs(args, "SU", &u0, &_u0, &u1)) { self->object->getCurrencyPluralPattern(*u0, *u1); Py_RETURN_ARG(args, 1); } break; } return PyErr_SetArgsError((PyObject *) self, "getCurrencyPluralPattern", args); } static PyObject *t_currencypluralinfo_setCurrencyPluralPattern(t_currencypluralinfo *self, PyObject *args) { UnicodeString *u0, _u0; UnicodeString *u1, _u1; if (!parseArgs(args, "SS", &u0, &u1)) { /* u0 transient, u1 copied */ STATUS_CALL(self->object->setCurrencyPluralPattern(*u0, *u1, status)); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setCurrencyPluralPattern", args); } static PyObject *t_currencypluralinfo_getLocale(t_currencypluralinfo *self) { return wrap_Locale(self->object->getLocale()); } static PyObject *t_currencypluralinfo_setLocale(t_currencypluralinfo *self, PyObject *arg) { Locale *locale; if (!parseArg(arg, "P", TYPE_CLASSID(Locale), &locale)) { STATUS_CALL(self->object->setLocale(*locale, status)); /* copied */ Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setLocale", arg); } DEFINE_RICHCMP(CurrencyPluralInfo, t_currencypluralinfo); #endif /* DecimalFormat */ static int t_decimalformat_init(t_decimalformat *self, PyObject *args, PyObject *kwds) { DecimalFormat *format; DecimalFormatSymbols *dfs; UnicodeString *u, _u; switch (PyTuple_Size(args)) { case 0: INT_STATUS_CALL(format = new DecimalFormat(status)); self->object = format; self->flags = T_OWNED; break; case 1: if (!parseArgs(args, "S", &u, &_u)) { INT_STATUS_CALL(format = new DecimalFormat(*u, status)); self->object = format; self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; case 2: if (!parseArgs(args, "SP", TYPE_CLASSID(DecimalFormatSymbols), &u, &_u, &dfs)) { INT_STATUS_CALL(format = new DecimalFormat(*u, *dfs, status)); self->object = format; self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; default: PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; } if (self->object) return 0; return -1; } static PyObject *t_decimalformat_getPositivePrefix(t_decimalformat *self, PyObject *args) { UnicodeString *u, _u; switch (PyTuple_Size(args)) { case 0: self->object->getPositivePrefix(_u); return PyUnicode_FromUnicodeString(&_u); case 1: if (!parseArgs(args, "U", &u)) { self->object->getPositivePrefix(*u); Py_RETURN_ARG(args, 0); } break; } return PyErr_SetArgsError((PyObject *) self, "getPositivePrefix", args); } static PyObject *t_decimalformat_setPositivePrefix(t_decimalformat *self, PyObject *arg) { UnicodeString *u, _u; if (!parseArg(arg, "S", &u, &_u)) { self->object->setPositivePrefix(*u); /* copied */ Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setPositivePrefix", arg); } static PyObject *t_decimalformat_getNegativePrefix(t_decimalformat *self, PyObject *args) { UnicodeString *u, _u; switch (PyTuple_Size(args)) { case 0: self->object->getNegativePrefix(_u); return PyUnicode_FromUnicodeString(&_u); case 1: if (!parseArgs(args, "U", &u)) { self->object->getNegativePrefix(*u); Py_RETURN_ARG(args, 0); } break; } return PyErr_SetArgsError((PyObject *) self, "getNegativePrefix", args); } static PyObject *t_decimalformat_setNegativePrefix(t_decimalformat *self, PyObject *arg) { UnicodeString *u, _u; if (!parseArg(arg, "S", &u, &_u)) { self->object->setNegativePrefix(*u); /* copied */ Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setNegativePrefix", arg); } static PyObject *t_decimalformat_getPositiveSuffix(t_decimalformat *self, PyObject *args) { UnicodeString *u, _u; switch (PyTuple_Size(args)) { case 0: self->object->getPositiveSuffix(_u); return PyUnicode_FromUnicodeString(&_u); case 1: if (!parseArgs(args, "U", &u)) { self->object->getPositiveSuffix(*u); Py_RETURN_ARG(args, 0); } break; } return PyErr_SetArgsError((PyObject *) self, "getPositiveSuffix", args); } static PyObject *t_decimalformat_setPositiveSuffix(t_decimalformat *self, PyObject *arg) { UnicodeString *u, _u; if (!parseArg(arg, "S", &u, &_u)) { self->object->setPositiveSuffix(*u); /* copied */ Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setPositiveSuffix", arg); } static PyObject *t_decimalformat_getNegativeSuffix(t_decimalformat *self, PyObject *args) { UnicodeString *u, _u; switch (PyTuple_Size(args)) { case 0: self->object->getNegativeSuffix(_u); return PyUnicode_FromUnicodeString(&_u); case 1: if (!parseArgs(args, "U", &u)) { self->object->getNegativeSuffix(*u); Py_RETURN_ARG(args, 0); } break; } return PyErr_SetArgsError((PyObject *) self, "getNegativeSuffix", args); } static PyObject *t_decimalformat_setNegativeSuffix(t_decimalformat *self, PyObject *arg) { UnicodeString *u, _u; if (!parseArg(arg, "S", &u, &_u)) { self->object->setNegativeSuffix(*u); /* copied */ Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setNegativeSuffix", arg); } static PyObject *t_decimalformat_getMultiplier(t_decimalformat *self) { return PyInt_FromLong(self->object->getMultiplier()); } static PyObject *t_decimalformat_setMultiplier(t_decimalformat *self, PyObject *arg) { int n; if (!parseArg(arg, "i", &n)) { self->object->setMultiplier(n); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setMultiplier", arg); } static PyObject *t_decimalformat_getRoundingIncrement(t_decimalformat *self) { return PyFloat_FromDouble(self->object->getRoundingIncrement()); } static PyObject *t_decimalformat_setRoundingIncrement(t_decimalformat *self, PyObject *arg) { double d; if (!parseArg(arg, "d", &d)) { self->object->setRoundingIncrement(d); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setRoundingIncrement", arg); } static PyObject *t_decimalformat_getRoundingMode(t_decimalformat *self) { DecimalFormat::ERoundingMode mode = self->object->getRoundingMode(); return PyInt_FromLong(mode); } static PyObject *t_decimalformat_setRoundingMode(t_decimalformat *self, PyObject *arg) { DecimalFormat::ERoundingMode mode; if (!parseArg(arg, "i", &mode)) { self->object->setRoundingMode(mode); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setRoundingMode", arg); } static PyObject *t_decimalformat_getFormatWidth(t_decimalformat *self) { return PyInt_FromLong(self->object->getFormatWidth()); } static PyObject *t_decimalformat_setFormatWidth(t_decimalformat *self, PyObject *arg) { int width; if (!parseArg(arg, "i", &width)) { self->object->setFormatWidth(width); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setFormatWidth", arg); } static PyObject *t_decimalformat_getPadCharacterString(t_decimalformat *self, PyObject *args) { UnicodeString *u; switch (PyTuple_Size(args)) { case 0: { UnicodeString u = self->object->getPadCharacterString(); return PyUnicode_FromUnicodeString(&u); } case 1: if (!parseArgs(args, "U", &u)) { u->setTo(self->object->getPadCharacterString()); Py_RETURN_ARG(args, 0); } break; } return PyErr_SetArgsError((PyObject *) self, "getPadCharacterString", args); } static PyObject *t_decimalformat_setPadCharacter(t_decimalformat *self, PyObject *arg) { UnicodeString *u, _u; if (!parseArg(arg, "S", &u, &_u)) { self->object->setPadCharacter(*u); /* copied */ Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setPadCharacter", arg); } static PyObject *t_decimalformat_getPadPosition(t_decimalformat *self) { return PyInt_FromLong(self->object->getPadPosition()); } static PyObject *t_decimalformat_setPadPosition(t_decimalformat *self, PyObject *arg) { DecimalFormat::EPadPosition pos; if (!parseArg(arg, "i", &pos)) { self->object->setPadPosition(pos); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setPadPosition", arg); } static PyObject *t_decimalformat_isScientificNotation(t_decimalformat *self) { int b = self->object->isScientificNotation(); Py_RETURN_BOOL(b); } static PyObject *t_decimalformat_setScientificNotation(t_decimalformat *self, PyObject *arg) { int b; if (!parseArg(arg, "b", &b)) { self->object->setScientificNotation(b); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setScientificNotation", arg); } static PyObject *t_decimalformat_getMinimumExponentDigits(t_decimalformat *self) { return PyInt_FromLong(self->object->getMinimumExponentDigits()); } static PyObject *t_decimalformat_setMinimumExponentDigits(t_decimalformat *self, PyObject *arg) { int digits; if (!parseArg(arg, "i", &digits)) { self->object->setMinimumExponentDigits(digits); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setMinimumExponentDigits", arg); } static PyObject *t_decimalformat_isExponentSignAlwaysShown(t_decimalformat *self) { int b = self->object->isExponentSignAlwaysShown(); Py_RETURN_BOOL(b); } static PyObject *t_decimalformat_setExponentSignAlwaysShown(t_decimalformat *self, PyObject *arg) { int b; if (!parseArg(arg, "b", &b)) { self->object->setExponentSignAlwaysShown(b); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setExponentSignAlwaysShown", arg); } static PyObject *t_decimalformat_isDecimalSeparatorAlwaysShown(t_decimalformat *self) { int b = self->object->isDecimalSeparatorAlwaysShown(); Py_RETURN_BOOL(b); } static PyObject *t_decimalformat_setDecimalSeparatorAlwaysShown(t_decimalformat *self, PyObject *arg) { int b; if (!parseArg(arg, "b", &b)) { self->object->setDecimalSeparatorAlwaysShown(b); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setDecimalSeparatorAlwaysShown", arg); } static PyObject *t_decimalformat_getGroupingSize(t_decimalformat *self) { return PyInt_FromLong(self->object->getGroupingSize()); } static PyObject *t_decimalformat_setGroupingSize(t_decimalformat *self, PyObject *arg) { int size; if (!parseArg(arg, "i", &size)) { self->object->setGroupingSize(size); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setGroupingSize", arg); } static PyObject *t_decimalformat_getSecondaryGroupingSize(t_decimalformat *self) { return PyInt_FromLong(self->object->getSecondaryGroupingSize()); } static PyObject *t_decimalformat_setSecondaryGroupingSize(t_decimalformat *self, PyObject *arg) { int size; if (!parseArg(arg, "i", &size)) { self->object->setSecondaryGroupingSize(size); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setSecondaryGroupingSize", arg); } static PyObject *t_decimalformat_toPattern(t_decimalformat *self, PyObject *args) { UnicodeString *u; UnicodeString _u; switch (PyTuple_Size(args)) { case 0: self->object->toPattern(_u); return PyUnicode_FromUnicodeString(&_u); case 1: if (!parseArgs(args, "U", &u)) { self->object->toPattern(*u); Py_RETURN_ARG(args, 0); } break; } return PyErr_SetArgsError((PyObject *) self, "toPattern", args); } static PyObject *t_decimalformat_toLocalizedPattern(t_decimalformat *self, PyObject *args) { UnicodeString *u; UnicodeString _u; switch (PyTuple_Size(args)) { case 0: self->object->toLocalizedPattern(_u); return PyUnicode_FromUnicodeString(&_u); case 1: if (!parseArgs(args, "U", &u)) { self->object->toLocalizedPattern(*u); Py_RETURN_ARG(args, 0); } break; } return PyErr_SetArgsError((PyObject *) self, "toLocalizedPattern", args); } static PyObject *t_decimalformat_applyPattern(t_decimalformat *self, PyObject *arg) { UnicodeString *u; UnicodeString _u; if (!parseArg(arg, "S", &u, &_u)) { STATUS_CALL(self->object->applyPattern(*u, status)); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "applyPattern", arg); } static PyObject *t_decimalformat_applyLocalizedPattern(t_decimalformat *self, PyObject *arg) { UnicodeString *u; UnicodeString _u; if (!parseArg(arg, "S", &u, &_u)) { STATUS_CALL(self->object->applyLocalizedPattern(*u, status)); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "applyLocalizedPattern", arg); } static PyObject *t_decimalformat_getMaximumSignificantDigits(t_decimalformat *self) { return PyInt_FromLong(self->object->getMaximumSignificantDigits()); } static PyObject *t_decimalformat_setMaximumSignificantDigits(t_decimalformat *self, PyObject *arg) { int digits; if (!parseArg(arg, "i", &digits)) { self->object->setMaximumSignificantDigits(digits); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setMaximumSignificantDigits", arg); } static PyObject *t_decimalformat_getMinimumSignificantDigits(t_decimalformat *self) { return PyInt_FromLong(self->object->getMinimumSignificantDigits()); } static PyObject *t_decimalformat_setMinimumSignificantDigits(t_decimalformat *self, PyObject *arg) { int digits; if (!parseArg(arg, "i", &digits)) { self->object->setMinimumSignificantDigits(digits); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setMinimumSignificantDigits", arg); } static PyObject *t_decimalformat_areSignificantDigitsUsed(t_decimalformat *self) { int b = self->object->areSignificantDigitsUsed(); Py_RETURN_BOOL(b); } static PyObject *t_decimalformat_setSignificantDigitsUsed(t_decimalformat *self, PyObject *arg) { int b; if (!parseArg(arg, "b", &b)) { self->object->setSignificantDigitsUsed(b); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setSignificantDigitsUsed", arg); } static PyObject *t_decimalformat_getDecimalFormatSymbols(t_decimalformat *self) { const DecimalFormatSymbols *dfs = self->object->getDecimalFormatSymbols(); return wrap_DecimalFormatSymbols(new DecimalFormatSymbols(*dfs), T_OWNED); } static PyObject *t_decimalformat_setDecimalFormatSymbols(t_decimalformat *self, PyObject *arg) { DecimalFormatSymbols *dfs; if (!parseArg(arg, "P", TYPE_CLASSID(DecimalFormatSymbols), &dfs)) { self->object->adoptDecimalFormatSymbols(new DecimalFormatSymbols(*dfs)); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setDecimalFormatSymbols", arg); } #if U_ICU_VERSION_HEX >= 0x04020000 static PyObject *t_decimalformat_getCurrencyPluralInfo(t_decimalformat *self) { const CurrencyPluralInfo *cpi = self->object->getCurrencyPluralInfo(); return wrap_CurrencyPluralInfo(cpi->clone(), T_OWNED); } static PyObject *t_decimalformat_setCurrencyPluralInfo(t_decimalformat *self, PyObject *arg) { CurrencyPluralInfo *cpi; if (!parseArg(arg, "P", TYPE_CLASSID(CurrencyPluralInfo), &cpi)) { self->object->adoptCurrencyPluralInfo(cpi->clone()); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setCurrencyPluralInfo", arg); } #endif static PyObject *t_decimalformat_str(t_decimalformat *self) { UnicodeString u; self->object->toPattern(u); return PyUnicode_FromUnicodeString(&u); } #if U_ICU_VERSION_HEX >= VERSION_HEX(51, 0, 0) /* CompactDecimalFormat */ static PyObject *t_compactdecimalformat_createInstance(PyTypeObject *type, PyObject *args) { CompactDecimalFormat *format; Locale *locale; UNumberCompactStyle style; switch (PyTuple_Size(args)) { case 2: if (!parseArgs(args, "Pi", TYPE_CLASSID(Locale), &locale, &style)) { STATUS_CALL(format = CompactDecimalFormat::createInstance( *locale, style, status)); return wrap_CompactDecimalFormat(format, T_OWNED); } break; } return PyErr_SetArgsError(type, "createInstance", args); } #endif /* RuleBasedNumberFormat */ static int t_rulebasednumberformat_init(t_rulebasednumberformat *self, PyObject *args, PyObject *kwds) { UnicodeString *u, *v; UnicodeString _u, _v; Locale *locale; RuleBasedNumberFormat *rbf; #if U_HAVE_RBNF URBNFRuleSetTag tag; #endif switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "S", &u, &_u)) { INT_STATUS_PARSER_CALL(rbf = new RuleBasedNumberFormat(*u, parseError, status)); self->object = rbf; self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; case 2: if (!parseArgs(args, "SS", &u, &_u, &v, &_v)) { INT_STATUS_PARSER_CALL(rbf = new RuleBasedNumberFormat(*u, *v, parseError, status)); self->object = rbf; self->flags = T_OWNED; break; } if (!parseArgs(args, "SP", TYPE_CLASSID(Locale), &u, &_u, &locale)) { INT_STATUS_PARSER_CALL(rbf = new RuleBasedNumberFormat(*u, *locale, parseError, status)); self->object = rbf; self->flags = T_OWNED; break; } #if U_HAVE_RBNF if (!parseArgs(args, "iP", TYPE_CLASSID(Locale), &tag, &locale)) { INT_STATUS_CALL(rbf = new RuleBasedNumberFormat(tag, *locale, status)); self->object = rbf; self->flags = T_OWNED; break; } #endif PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; case 3: if (!parseArgs(args, "SSP", TYPE_CLASSID(Locale), &u, &_u, &v, &_v, &locale)) { INT_STATUS_PARSER_CALL(rbf = new RuleBasedNumberFormat(*u, *v, *locale, parseError, status)); self->object = rbf; self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; default: PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; } if (self->object) return 0; return -1; } static PyObject *t_rulebasednumberformat_getRules(t_rulebasednumberformat *self, PyObject *args) { UnicodeString *u; switch (PyTuple_Size(args)) { case 0: { UnicodeString u = self->object->getRules(); return PyUnicode_FromUnicodeString(&u); } case 1: if (!parseArgs(args, "U", &u)) { u->setTo(self->object->getRules()); Py_RETURN_ARG(args, 0); } break; } return PyErr_SetArgsError((PyObject *) self, "getRules", args); } static PyObject *t_rulebasednumberformat_getNumberOfRuleSetNames(t_rulebasednumberformat *self) { return PyInt_FromLong(self->object->getNumberOfRuleSetNames()); } static PyObject *t_rulebasednumberformat_getRuleSetName(t_rulebasednumberformat *self, PyObject *args) { int index; UnicodeString *u; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "i", &index)) { UnicodeString u = self->object->getRuleSetName(index); return PyUnicode_FromUnicodeString(&u); } case 2: if (!parseArgs(args, "iU", &index, &u)) { u->setTo(self->object->getRuleSetName(index)); Py_RETURN_ARG(args, 1); } break; } return PyErr_SetArgsError((PyObject *) self, "getRuleSetName", args); } static PyObject *t_rulebasednumberformat_getNumberOfRuleSetDisplayNameLocales(t_rulebasednumberformat *self) { return PyInt_FromLong(self->object->getNumberOfRuleSetDisplayNameLocales()); } static PyObject *t_rulebasednumberformat_getRuleSetDisplayName(t_rulebasednumberformat *self, PyObject *args) { int index; Locale *locale; UnicodeString *u; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "i", &index)) { UnicodeString u = self->object->getRuleSetDisplayName(index); return PyUnicode_FromUnicodeString(&u); } case 2: if (!parseArgs(args, "iP", TYPE_CLASSID(Locale), &index, &locale)) { UnicodeString u = self->object->getRuleSetDisplayName(index, *locale); return PyUnicode_FromUnicodeString(&u); } if (!parseArgs(args, "iU", &index, &u)) { u->setTo(self->object->getRuleSetDisplayName(index)); Py_RETURN_ARG(args, 1); } break; case 3: if (!parseArgs(args, "iPU", TYPE_CLASSID(Locale), &index, &locale, &u)) { u->setTo(self->object->getRuleSetDisplayName(index, *locale)); Py_RETURN_ARG(args, 2); } break; } return PyErr_SetArgsError((PyObject *) self, "getRuleSetDisplayName", args); } static PyObject *t_rulebasednumberformat_format(t_rulebasednumberformat *self, PyObject *args) { UnicodeString *u, *v; UnicodeString _u, _v; double d; int i; PY_LONG_LONG l; FieldPosition *fp; switch (PyTuple_Size(args)) { case 3: if (!parseArgs(args, "dSP", TYPE_CLASSID(FieldPosition), &d, &u, &_u, &fp)) { STATUS_CALL(self->object->format(d, *u, _v, *fp, status)); return PyUnicode_FromUnicodeString(&_v); } if (!parseArgs(args, "iSP", TYPE_CLASSID(FieldPosition), &i, &u, &_u, &fp)) { STATUS_CALL(self->object->format(i, *u, _v, *fp, status)); return PyUnicode_FromUnicodeString(&_v); } if (!parseArgs(args, "LSP", TYPE_CLASSID(FieldPosition), &l, &u, &_u, &fp)) { STATUS_CALL(self->object->format((int64_t) l, *u, _v, *fp, status)); return PyUnicode_FromUnicodeString(&_v); } case 4: if (!parseArgs(args, "dSUP", TYPE_CLASSID(FieldPosition), &d, &u, &_u, &v, &fp)) { STATUS_CALL(self->object->format(d, *u, *v, *fp, status)); Py_RETURN_ARG(args, 2); } if (!parseArgs(args, "iSUP", TYPE_CLASSID(FieldPosition), &i, &u, &_u, &v, &fp)) { STATUS_CALL(self->object->format(i, *u, *v, *fp, status)); Py_RETURN_ARG(args, 2); } if (!parseArgs(args, "LSUP", TYPE_CLASSID(FieldPosition), &l, &u, &_u, &v, &fp)) { STATUS_CALL(self->object->format((int64_t) l, *u, *v, *fp, status)); Py_RETURN_ARG(args, 2); } break; } return t_numberformat_format((t_numberformat *) self, args); } static PyObject *t_rulebasednumberformat_isLenient(t_rulebasednumberformat *self) { int b = self->object->isLenient(); Py_RETURN_BOOL(b); } static PyObject *t_rulebasednumberformat_setLenient(t_rulebasednumberformat *self, PyObject *arg) { int b; if (!parseArg(arg, "b", &b)) { self->object->setLenient(b); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setLenient", arg); } static PyObject *t_rulebasednumberformat_getDefaultRuleSetName(t_rulebasednumberformat *self, PyObject *args) { UnicodeString *u; switch (PyTuple_Size(args)) { case 0: { UnicodeString _u = self->object->getDefaultRuleSetName(); return PyUnicode_FromUnicodeString(&_u); } case 1: if (!parseArgs(args, "U", &u)) { u->setTo(self->object->getDefaultRuleSetName()); Py_RETURN_ARG(args, 0); } break; } return PyErr_SetArgsError((PyObject *) self, "getDefaultRuleSetName", args); } static PyObject *t_rulebasednumberformat_setDefaultRuleSet(t_rulebasednumberformat *self, PyObject *arg) { UnicodeString *u, _u; if (!parseArg(arg, "S", &u, &_u)) { /* transient */ STATUS_CALL(self->object->setDefaultRuleSet(*u, status)); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setDefaultRuleSet", arg); } static PyObject *t_rulebasednumberformat_str(t_rulebasednumberformat *self) { UnicodeString u = self->object->getRules(); return PyUnicode_FromUnicodeString(&u); } /* ChoiceFormat */ static int t_choiceformat_init(t_choiceformat *self, PyObject *args, PyObject *kwds) { UnicodeString *u; UnicodeString _u; ChoiceFormat *cf; double *limits; int limitCount; UBool *closures; int closureCount; UnicodeString *formats; int formatCount; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "S", &u, &_u)) { INT_STATUS_CALL(cf = new ChoiceFormat(*u, status)); self->object = cf; self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; case 2: if (!parseArgs(args, "FT", &limits, &limitCount, &formats, &formatCount)) { cf = new ChoiceFormat(limits, formats, limitCount); delete[] limits; delete[] formats; self->object = cf; self->flags = T_OWNED; break; } case 3: if (!parseArgs(args, "FGT", &limits, &limitCount, &closures, &closureCount, &formats, &formatCount)) { cf = new ChoiceFormat(limits, closures, formats, limitCount); delete[] limits; delete[] closures; delete[] formats; self->object = cf; self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; default: PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; } if (self->object) return 0; return -1; } static PyObject *t_choiceformat_toPattern(t_choiceformat *self, PyObject *args) { UnicodeString *u; UnicodeString _u; switch (PyTuple_Size(args)) { case 0: self->object->toPattern(_u); return PyUnicode_FromUnicodeString(&_u); case 1: if (!parseArgs(args, "U", &u)) { self->object->toPattern(*u); Py_RETURN_ARG(args, 0); } break; } return PyErr_SetArgsError((PyObject *) self, "toPattern", args); } static PyObject *t_choiceformat_applyPattern(t_choiceformat *self, PyObject *arg) { UnicodeString *u; UnicodeString _u; if (!parseArg(arg, "S", &u, &_u)) { STATUS_CALL(self->object->applyPattern(*u, status)); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "applyPattern", arg); } static PyObject *t_choiceformat_setChoices(t_choiceformat *self, PyObject *args) { double *limits; int limitCount; UBool *closures; int closureCount; UnicodeString *formats; int formatCount; switch (PyTuple_Size(args)) { case 2: if (!parseArgs(args, "FT", &limits, &limitCount, &formats, &formatCount)) { self->object->setChoices(limits, formats, limitCount); delete[] limits; delete[] formats; Py_RETURN_NONE; } break; case 3: if (!parseArgs(args, "FGT", &limits, &limitCount, &closures, &closureCount, &formats, &formatCount)) { self->object->setChoices(limits, closures, formats, limitCount); delete[] limits; delete[] closures; delete[] formats; Py_RETURN_NONE; } break; } return PyErr_SetArgsError((PyObject *) self, "setChoices", args); } static PyObject *fromDoubleArray(double *array, int len, int dispose) { PyObject *list = PyList_New(len); for (int i = 0; i < len; i++) PyList_SET_ITEM(list, i, PyFloat_FromDouble(array[i])); if (dispose) delete array; return list; } static PyObject *fromUBoolArray(UBool *array, int len, int dispose) { PyObject *list = PyList_New(len); for (int i = 0; i < len; i++) { PyObject *obj = array[i] ? Py_True : Py_False; Py_INCREF(obj); PyList_SET_ITEM(list, i, obj); } if (dispose) delete array; return list; } static PyObject *fromUnicodeStringArray(UnicodeString *array, int len, int dispose) { PyObject *list = PyList_New(len); for (int i = 0; i < len; i++) PyList_SET_ITEM(list, i, PyUnicode_FromUnicodeString(array + i)); if (dispose) delete array; return list; } static PyObject *t_choiceformat_getLimits(t_choiceformat *self) { int len; const double *array = self->object->getLimits(len); return fromDoubleArray((double *) array, len, 0); } static PyObject *t_choiceformat_getClosures(t_choiceformat *self) { int len; const UBool *closures = self->object->getClosures(len); return fromUBoolArray((UBool *) closures, len, 0); } static PyObject *t_choiceformat_getFormats(t_choiceformat *self) { int len; const UnicodeString *formats = self->object->getFormats(len); return fromUnicodeStringArray((UnicodeString *) formats, len, 0); } static PyObject *t_choiceformat_format(t_choiceformat *self, PyObject *args) { Formattable *f; int len; UnicodeString *u; UnicodeString _u; FieldPosition *fp; switch (PyTuple_Size(args)) { case 2: if (!parseArgs(args, "RP", TYPE_CLASSID(Formattable), TYPE_CLASSID(FieldPosition), &f, &len, TYPE_CLASSID(Formattable), toFormattableArray, &fp)) { STATUS_CALL( { self->object->format(f, len, _u, *fp, status); delete[] f; }); return PyUnicode_FromUnicodeString(&_u); } break; case 3: if (!parseArgs(args, "RUP", TYPE_CLASSID(Formattable), &f, &len, TYPE_CLASSID(Formattable), toFormattableArray, &u, &fp)) { STATUS_CALL( { self->object->format(f, len, *u, *fp, status); delete[] f; }); Py_RETURN_ARG(args, 1); } break; } return t_numberformat_format((t_numberformat *) self, args); } static PyObject *t_choiceformat_str(t_choiceformat *self) { UnicodeString u; self->object->toPattern(u); return PyUnicode_FromUnicodeString(&u); } void _init_numberformat(PyObject *m) { DecimalFormatSymbolsType_.tp_richcompare = (richcmpfunc) t_decimalformatsymbols_richcmp; #if U_ICU_VERSION_HEX >= 0x04020000 CurrencyPluralInfoType_.tp_richcompare = (richcmpfunc) t_currencypluralinfo_richcmp; #endif DecimalFormatType_.tp_str = (reprfunc) t_decimalformat_str; RuleBasedNumberFormatType_.tp_str = (reprfunc) t_rulebasednumberformat_str; ChoiceFormatType_.tp_str = (reprfunc) t_choiceformat_str; REGISTER_TYPE(DecimalFormatSymbols, m); REGISTER_TYPE(NumberFormat, m); #if U_ICU_VERSION_HEX >= 0x04020000 REGISTER_TYPE(CurrencyPluralInfo, m); #endif REGISTER_TYPE(DecimalFormat, m); #if U_ICU_VERSION_HEX >= VERSION_HEX(51, 0, 0) REGISTER_TYPE(CompactDecimalFormat, m); #endif REGISTER_TYPE(RuleBasedNumberFormat, m); REGISTER_TYPE(ChoiceFormat, m); INSTALL_STATIC_INT(DecimalFormatSymbols, kDecimalSeparatorSymbol); INSTALL_STATIC_INT(DecimalFormatSymbols, kGroupingSeparatorSymbol); INSTALL_STATIC_INT(DecimalFormatSymbols, kPatternSeparatorSymbol); INSTALL_STATIC_INT(DecimalFormatSymbols, kPercentSymbol); INSTALL_STATIC_INT(DecimalFormatSymbols, kZeroDigitSymbol); INSTALL_STATIC_INT(DecimalFormatSymbols, kDigitSymbol); INSTALL_STATIC_INT(DecimalFormatSymbols, kMinusSignSymbol); INSTALL_STATIC_INT(DecimalFormatSymbols, kPlusSignSymbol); INSTALL_STATIC_INT(DecimalFormatSymbols, kCurrencySymbol); INSTALL_STATIC_INT(DecimalFormatSymbols, kIntlCurrencySymbol); INSTALL_STATIC_INT(DecimalFormatSymbols, kMonetarySeparatorSymbol); INSTALL_STATIC_INT(DecimalFormatSymbols, kExponentialSymbol); INSTALL_STATIC_INT(DecimalFormatSymbols, kPerMillSymbol); INSTALL_STATIC_INT(DecimalFormatSymbols, kPadEscapeSymbol); INSTALL_STATIC_INT(DecimalFormatSymbols, kInfinitySymbol); INSTALL_STATIC_INT(DecimalFormatSymbols, kNaNSymbol); INSTALL_STATIC_INT(DecimalFormatSymbols, kSignificantDigitSymbol); #if U_ICU_VERSION_HEX >= 0x04020000 && U_ICU_VERSION_HEX < 0x04080000 INSTALL_STATIC_INT(DecimalFormatSymbols, kCurrencyMatch); INSTALL_STATIC_INT(DecimalFormatSymbols, kSurroundingMatch); INSTALL_STATIC_INT(DecimalFormatSymbols, kInsert); INSTALL_STATIC_INT(DecimalFormatSymbols, kCurrencySpacingCount); #endif #if U_HAVE_RBNF INSTALL_CONSTANTS_TYPE(URBNFRuleSetTag, m); INSTALL_ENUM(URBNFRuleSetTag, "SPELLOUT", URBNF_SPELLOUT); INSTALL_ENUM(URBNFRuleSetTag, "ORDINAL", URBNF_ORDINAL); INSTALL_ENUM(URBNFRuleSetTag, "DURATION", URBNF_DURATION); INSTALL_ENUM(URBNFRuleSetTag, "NUMBERING_SYSTEM", URBNF_NUMBERING_SYSTEM); #endif #if U_ICU_VERSION_HEX >= 0x04080000 INSTALL_CONSTANTS_TYPE(UCurrencySpacing, m); INSTALL_ENUM(UCurrencySpacing, "MATCH", UNUM_CURRENCY_MATCH); INSTALL_ENUM(UCurrencySpacing, "SURROUNDING_MATCH", UNUM_CURRENCY_SURROUNDING_MATCH); INSTALL_ENUM(UCurrencySpacing, "INSERT", UNUM_CURRENCY_INSERT); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(51, 0, 0) INSTALL_CONSTANTS_TYPE(UNumberCompactStyle, m); INSTALL_ENUM(UNumberCompactStyle, "SHORT", UNUM_SHORT); INSTALL_ENUM(UNumberCompactStyle, "LONG", UNUM_LONG); #endif INSTALL_STATIC_INT(NumberFormat, kIntegerField); INSTALL_STATIC_INT(NumberFormat, kFractionField); INSTALL_STATIC_INT(NumberFormat, INTEGER_FIELD); INSTALL_STATIC_INT(NumberFormat, FRACTION_FIELD); INSTALL_STATIC_INT(DecimalFormat, kRoundCeiling); INSTALL_STATIC_INT(DecimalFormat, kRoundFloor); INSTALL_STATIC_INT(DecimalFormat, kRoundDown); INSTALL_STATIC_INT(DecimalFormat, kRoundUp); INSTALL_STATIC_INT(DecimalFormat, kRoundHalfEven); INSTALL_STATIC_INT(DecimalFormat, kRoundHalfDown); INSTALL_STATIC_INT(DecimalFormat, kRoundHalfUp); INSTALL_STATIC_INT(DecimalFormat, kPadBeforePrefix); INSTALL_STATIC_INT(DecimalFormat, kPadAfterPrefix); INSTALL_STATIC_INT(DecimalFormat, kPadBeforeSuffix); INSTALL_STATIC_INT(DecimalFormat, kPadAfterSuffix); } PyICU-1.9.5/numberformat.h0000644000076500000000000000320512520066206015533 0ustar vajdawheel00000000000000/* ==================================================================== * Copyright (c) 2004-2010 Open Source Applications Foundation. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. * ==================================================================== */ #ifndef _numberformat_h #define _numberformat_h extern PyTypeObject NumberFormatType_; PyObject *wrap_NumberFormat(NumberFormat *, int); PyObject *wrap_DecimalFormat(DecimalFormat *, int); PyObject *wrap_RuleBasedNumberFormat(RuleBasedNumberFormat *, int); PyObject *wrap_ChoiceFormat(ChoiceFormat *, int); void _init_numberformat(PyObject *m); #endif /* _numberformat_h */ PyICU-1.9.5/PKG-INFO0000644000076500000000000002506713011413477013772 0ustar vajdawheel00000000000000Metadata-Version: 1.1 Name: PyICU Version: 1.9.5 Summary: Python extension wrapping the ICU C++ API Home-page: https://github.com/ovalhub/pyicu Author: Andi Vajda Author-email: github@ovaltofu.org License: UNKNOWN Description: --------------------- README file for PyICU --------------------- Welcome ------- Welcome to PyICU, a Python extension wrapping IBM's International Components for Unicode C++ library (ICU). The PyICU source code is hosted on GitHub at https://github.com/ovalhub/pyicu. The ICU homepage is http://site.icu-project.org/ Building PyICU -------------- Before building PyICU the ICU libraries must be built and installed. Refer to each system's instructions for more information. PyICU is built with distutils or setuptools: - verify that the ``INCLUDES``, ``LFLAGS``, ``CFLAGS`` and ``LIBRARIES`` dictionaries in ``setup.py`` contain correct values for your platform - ``python setup.py build`` - ``sudo python setup.py install`` Running PyICU ------------- - Mac OS X Make sure that ``DYLD_LIBRARY_PATH`` contains paths to the directory(ies) containing the ICU libs. - Linux & Solaris Make sure that ``LD_LIBRARY_PATH`` contains paths to the directory(ies) containing the ICU libs or that you added the corresponding ``-rpath`` argument to ``LFLAGS``. - Windows Make sure that ``PATH`` contains paths to the directory(ies) containing the ICU DLLs. What's available ---------------- See the ``CHANGES`` file for an up to date log of changes and additions. API Documentation ----------------- There is no API documentation for PyICU. The API for ICU is documented at http://icu-project.org/apiref/icu4c/ and the following patterns can be used to translate from the C++ APIs to the corresponding Python APIs. - strings The ICU string type, ``UnicodeString``, is a type pointing at a mutable array of ``UChar`` Unicode 16-bit wide characters. The Python unicode type is an immutable string of 16-bit or 32-bit wide Unicode characters. Because of these differences, ``UnicodeString`` and Python's ``unicode`` type are not merged into the same type when crossing the C++ boundary. ICU APIs taking ``UnicodeString`` arguments have been overloaded to also accept Python str or unicode type arguments. In the case of ``str`` objects, ``utf-8`` encoding is assumed when converting them to ``UnicodeString`` objects. To convert a Python ``str`` encoded in an encoding other than ``utf-8`` to an ICU ``UnicodeString`` use the ``UnicodeString(str, encodingName)`` constructor. ICU's C++ APIs accept and return ``UnicodeString`` arguments in several ways: by value, by pointer or by reference. When an ICU C++ API is documented to accept a ``UnicodeString`` reference parameter, it is safe to assume that there are several corresponding PyICU python APIs making it accessible in simpler ways: For example, the ``'UnicodeString &Locale::getDisplayName(UnicodeString &)'`` API, documented at http://icu-project.org/apiref/icu4c/classLocale.html can be invoked from Python in several ways: 1. The ICU way >>> from icu import UnicodeString, Locale >>> locale = Locale('pt_BR') >>> string = UnicodeString() >>> name = locale.getDisplayName(string) >>> name >>> name is string True <-- string arg was returned, modified in place 2. The Python way >>> from icu import Locale >>> locale = Locale('pt_BR') >>> name = locale.getDisplayName() >>> name u'Portuguese (Brazil)' A ``UnicodeString`` object was allocated and converted to a Python ``unicode`` object. A UnicodeString can be coerced to a Python unicode string with Python's ``unicode()`` constructor. The usual ``len()``, ``str()``, comparison, ``[]`` and ``[:]`` operators are all available, with the additional twists that slicing is not read-only and that ``+=`` is also available since a UnicodeString is mutable. For example: >>> name = locale.getDisplayName() u'Portuguese (Brazil)' >>> name = UnicodeString(name) >>> name >>> unicode(name) u'Portuguese (Brazil)' >>> len(name) 19 >>> str(name) <-- works when chars fit with default encoding 'Portuguese (Brazil)' >>> name[3] u't' >>> name[12:18] >>> name[12:18] = 'the country of Brasil' >>> name >>> name += ' oh joy' >>> name - error reporting The C++ ICU library does not use C++ exceptions to report errors. ICU C++ APIs return errors via a ``UErrorCode`` reference argument. All such APIs are wrapped by Python APIs that omit this argument and throw an ``ICUError`` Python exception instead. The same is true for ICU APIs taking both a ``ParseError`` and a ``UErrorCode``, they are both to be omitted. For example, the ``'UnicodeString &DateFormat::format(const Formattable &, UnicodeString &, UErrorCode &)'`` API, documented at http://icu-project.org/apiref/icu4c/classDateFormat.html is invoked from Python with: >>> from icu import DateFormat, Formattable >>> df = DateFormat.createInstance() >>> df >>> f = Formattable(940284258.0, Formattable.kIsDate) >>> df.format(f) u'10/18/99 3:04 PM' Of course, the simpler ``'UnicodeString &DateFormat::format(UDate, UnicodeString &)'`` documented here: http://icu-project.org/apiref/icu4c/classDateFormat.html can be used too: >>> from icu import DateFormat >>> df = DateFormat.createInstance() >>> df >>> df.format(940284258.0) u'10/18/99 3:04 PM' - dates ICU uses a double floating point type called ``UDate`` that represents the number of milliseconds elapsed since 1970-jan-01 UTC for dates. In Python, the value returned by the ``time`` module's ``time()`` function is the number of seconds since 1970-jan-01 UTC. Because of this difference, floating point values are multiplied by 1000 when passed to APIs taking ``UDate`` and divided by 1000 when returned as ``UDate``. Python's ``datetime`` objects, with or without timezone information, can also be used with APIs taking ``UDate`` arguments. The ``datetime`` objects get converted to ``UDate`` when crossing into the C++ layer. - arrays Many ICU API take array arguments. A list of elements of the array element types is to be passed from Python. - StringEnumeration An ICU ``StringEnumeration`` has three ``next`` methods: ``next()`` which returns a ``str`` objects, ``unext()`` which returns ``unicode`` objects and ``snext()`` which returns ``UnicodeString`` objects. Any of these methods can be used as an iterator, using the Python built-in ``iter`` function. For example, let ``e`` be a ``StringEnumeration`` instance:: [s for s in e] is a list of 'str' objects [s for s in iter(e.unext, None)] is a list of 'unicode' objects [s for s in iter(e.snext, None)] is a list of 'UnicodeString' objects - timezones The ICU ``TimeZone`` type may be wrapped with an ``ICUtzinfo`` type for usage with Python's ``datetime`` type. For example:: tz = ICUtzinfo(TimeZone.createTimeZone('US/Mountain')) datetime.now(tz) or, even simpler:: tz = ICUtzinfo.getInstance('Pacific/Fiji') datetime.now(tz) To get the default time zone use:: defaultTZ = ICUtzinfo.getDefault() To get the time zone's id, use the ``tzid`` attribute or coerce the time zone to a string:: ICUtzinfo.getInstance('Pacific/Fiji').tzid -> 'Pacific/Fiji' str(ICUtzinfo.getInstance('Pacific/Fiji')) -> 'Pacific/Fiji' Platform: UNKNOWN Classifier: Development Status :: 5 - Production/Stable Classifier: Environment :: Console Classifier: Intended Audience :: Developers Classifier: License :: OSI Approved Classifier: Operating System :: OS Independent Classifier: Programming Language :: C++ Classifier: Programming Language :: Python Classifier: Programming Language :: Python :: 2 Classifier: Programming Language :: Python :: 3 Classifier: Programming Language :: Python :: Implementation :: CPython Classifier: Programming Language :: Python :: Implementation :: PyPy Classifier: Topic :: Software Development :: Localization Classifier: Topic :: Software Development :: Internationalization PyICU-1.9.5/PyICU.egg-info/0000755000076500000000000000000013011413477015306 5ustar vajdawheel00000000000000PyICU-1.9.5/PyICU.egg-info/dependency_links.txt0000644000076500000000000000000113011413473021350 0ustar vajdawheel00000000000000 PyICU-1.9.5/PyICU.egg-info/PKG-INFO0000644000076500000000000002506713011413473016411 0ustar vajdawheel00000000000000Metadata-Version: 1.1 Name: PyICU Version: 1.9.5 Summary: Python extension wrapping the ICU C++ API Home-page: https://github.com/ovalhub/pyicu Author: Andi Vajda Author-email: github@ovaltofu.org License: UNKNOWN Description: --------------------- README file for PyICU --------------------- Welcome ------- Welcome to PyICU, a Python extension wrapping IBM's International Components for Unicode C++ library (ICU). The PyICU source code is hosted on GitHub at https://github.com/ovalhub/pyicu. The ICU homepage is http://site.icu-project.org/ Building PyICU -------------- Before building PyICU the ICU libraries must be built and installed. Refer to each system's instructions for more information. PyICU is built with distutils or setuptools: - verify that the ``INCLUDES``, ``LFLAGS``, ``CFLAGS`` and ``LIBRARIES`` dictionaries in ``setup.py`` contain correct values for your platform - ``python setup.py build`` - ``sudo python setup.py install`` Running PyICU ------------- - Mac OS X Make sure that ``DYLD_LIBRARY_PATH`` contains paths to the directory(ies) containing the ICU libs. - Linux & Solaris Make sure that ``LD_LIBRARY_PATH`` contains paths to the directory(ies) containing the ICU libs or that you added the corresponding ``-rpath`` argument to ``LFLAGS``. - Windows Make sure that ``PATH`` contains paths to the directory(ies) containing the ICU DLLs. What's available ---------------- See the ``CHANGES`` file for an up to date log of changes and additions. API Documentation ----------------- There is no API documentation for PyICU. The API for ICU is documented at http://icu-project.org/apiref/icu4c/ and the following patterns can be used to translate from the C++ APIs to the corresponding Python APIs. - strings The ICU string type, ``UnicodeString``, is a type pointing at a mutable array of ``UChar`` Unicode 16-bit wide characters. The Python unicode type is an immutable string of 16-bit or 32-bit wide Unicode characters. Because of these differences, ``UnicodeString`` and Python's ``unicode`` type are not merged into the same type when crossing the C++ boundary. ICU APIs taking ``UnicodeString`` arguments have been overloaded to also accept Python str or unicode type arguments. In the case of ``str`` objects, ``utf-8`` encoding is assumed when converting them to ``UnicodeString`` objects. To convert a Python ``str`` encoded in an encoding other than ``utf-8`` to an ICU ``UnicodeString`` use the ``UnicodeString(str, encodingName)`` constructor. ICU's C++ APIs accept and return ``UnicodeString`` arguments in several ways: by value, by pointer or by reference. When an ICU C++ API is documented to accept a ``UnicodeString`` reference parameter, it is safe to assume that there are several corresponding PyICU python APIs making it accessible in simpler ways: For example, the ``'UnicodeString &Locale::getDisplayName(UnicodeString &)'`` API, documented at http://icu-project.org/apiref/icu4c/classLocale.html can be invoked from Python in several ways: 1. The ICU way >>> from icu import UnicodeString, Locale >>> locale = Locale('pt_BR') >>> string = UnicodeString() >>> name = locale.getDisplayName(string) >>> name >>> name is string True <-- string arg was returned, modified in place 2. The Python way >>> from icu import Locale >>> locale = Locale('pt_BR') >>> name = locale.getDisplayName() >>> name u'Portuguese (Brazil)' A ``UnicodeString`` object was allocated and converted to a Python ``unicode`` object. A UnicodeString can be coerced to a Python unicode string with Python's ``unicode()`` constructor. The usual ``len()``, ``str()``, comparison, ``[]`` and ``[:]`` operators are all available, with the additional twists that slicing is not read-only and that ``+=`` is also available since a UnicodeString is mutable. For example: >>> name = locale.getDisplayName() u'Portuguese (Brazil)' >>> name = UnicodeString(name) >>> name >>> unicode(name) u'Portuguese (Brazil)' >>> len(name) 19 >>> str(name) <-- works when chars fit with default encoding 'Portuguese (Brazil)' >>> name[3] u't' >>> name[12:18] >>> name[12:18] = 'the country of Brasil' >>> name >>> name += ' oh joy' >>> name - error reporting The C++ ICU library does not use C++ exceptions to report errors. ICU C++ APIs return errors via a ``UErrorCode`` reference argument. All such APIs are wrapped by Python APIs that omit this argument and throw an ``ICUError`` Python exception instead. The same is true for ICU APIs taking both a ``ParseError`` and a ``UErrorCode``, they are both to be omitted. For example, the ``'UnicodeString &DateFormat::format(const Formattable &, UnicodeString &, UErrorCode &)'`` API, documented at http://icu-project.org/apiref/icu4c/classDateFormat.html is invoked from Python with: >>> from icu import DateFormat, Formattable >>> df = DateFormat.createInstance() >>> df >>> f = Formattable(940284258.0, Formattable.kIsDate) >>> df.format(f) u'10/18/99 3:04 PM' Of course, the simpler ``'UnicodeString &DateFormat::format(UDate, UnicodeString &)'`` documented here: http://icu-project.org/apiref/icu4c/classDateFormat.html can be used too: >>> from icu import DateFormat >>> df = DateFormat.createInstance() >>> df >>> df.format(940284258.0) u'10/18/99 3:04 PM' - dates ICU uses a double floating point type called ``UDate`` that represents the number of milliseconds elapsed since 1970-jan-01 UTC for dates. In Python, the value returned by the ``time`` module's ``time()`` function is the number of seconds since 1970-jan-01 UTC. Because of this difference, floating point values are multiplied by 1000 when passed to APIs taking ``UDate`` and divided by 1000 when returned as ``UDate``. Python's ``datetime`` objects, with or without timezone information, can also be used with APIs taking ``UDate`` arguments. The ``datetime`` objects get converted to ``UDate`` when crossing into the C++ layer. - arrays Many ICU API take array arguments. A list of elements of the array element types is to be passed from Python. - StringEnumeration An ICU ``StringEnumeration`` has three ``next`` methods: ``next()`` which returns a ``str`` objects, ``unext()`` which returns ``unicode`` objects and ``snext()`` which returns ``UnicodeString`` objects. Any of these methods can be used as an iterator, using the Python built-in ``iter`` function. For example, let ``e`` be a ``StringEnumeration`` instance:: [s for s in e] is a list of 'str' objects [s for s in iter(e.unext, None)] is a list of 'unicode' objects [s for s in iter(e.snext, None)] is a list of 'UnicodeString' objects - timezones The ICU ``TimeZone`` type may be wrapped with an ``ICUtzinfo`` type for usage with Python's ``datetime`` type. For example:: tz = ICUtzinfo(TimeZone.createTimeZone('US/Mountain')) datetime.now(tz) or, even simpler:: tz = ICUtzinfo.getInstance('Pacific/Fiji') datetime.now(tz) To get the default time zone use:: defaultTZ = ICUtzinfo.getDefault() To get the time zone's id, use the ``tzid`` attribute or coerce the time zone to a string:: ICUtzinfo.getInstance('Pacific/Fiji').tzid -> 'Pacific/Fiji' str(ICUtzinfo.getInstance('Pacific/Fiji')) -> 'Pacific/Fiji' Platform: UNKNOWN Classifier: Development Status :: 5 - Production/Stable Classifier: Environment :: Console Classifier: Intended Audience :: Developers Classifier: License :: OSI Approved Classifier: Operating System :: OS Independent Classifier: Programming Language :: C++ Classifier: Programming Language :: Python Classifier: Programming Language :: Python :: 2 Classifier: Programming Language :: Python :: 3 Classifier: Programming Language :: Python :: Implementation :: CPython Classifier: Programming Language :: Python :: Implementation :: PyPy Classifier: Topic :: Software Development :: Localization Classifier: Topic :: Software Development :: Internationalization PyICU-1.9.5/PyICU.egg-info/SOURCES.txt0000644000076500000000000000222213011413473017164 0ustar vajdawheel00000000000000CHANGES CREDITS LICENSE MANIFEST.in PyICU.py README.md _icu.cpp bases.cpp bases.h calendar.cpp calendar.h char.cpp char.h charset.cpp charset.h collator.cpp collator.h common.cpp common.h dateformat.cpp dateformat.h docs.py errors.cpp errors.h format.cpp format.h icu.py idna.cpp idna.h iterators.cpp iterators.h layoutengine.cpp layoutengine.h locale.cpp locale.h macros.h normalizer.cpp normalizer.h numberformat.cpp numberformat.h regex.cpp regex.h script.cpp script.h search.cpp search.h setup.cfg setup.py shape.cpp shape.h spoof.cpp spoof.h transliterator.cpp transliterator.h tzinfo.cpp tzinfo.h unicodeset.cpp unicodeset.h PyICU.egg-info/PKG-INFO PyICU.egg-info/SOURCES.txt PyICU.egg-info/dependency_links.txt PyICU.egg-info/top_level.txt samples/break.py samples/strsrch.py test/__init__.py test/lohit_hi.ttf test/noms.txt test/test_BreakIterator.py test/test_Charset.py test/test_Collator.py test/test_DateTimeParserGenerator.py test/test_LayoutEngine.py test/test_ListFormatter.py test/test_LocaleData.py test/test_MessageFormat.py test/test_Normalizer.py test/test_Script.py test/test_Spoof.py test/test_Transliterator.py test/test_UCS4.py test/test_UDate.pyPyICU-1.9.5/PyICU.egg-info/top_level.txt0000644000076500000000000000002413011413473020030 0ustar vajdawheel00000000000000PyICU _icu docs icu PyICU-1.9.5/PyICU.py0000644000076500000000000000266712656222370014205 0ustar vajdawheel00000000000000 # ==================================================================== # Copyright (c) 2004-2010 Open Source Applications Foundation. # # Permission is hereby granted, free of charge, to any person obtaining a # copy of this software and associated documentation files (the "Software"), # to deal in the Software without restriction, including without limitation # the rights to use, copy, modify, merge, publish, distribute, sublicense, # and/or sell copies of the Software, and to permit persons to whom the # Software is furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included # in all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS # OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING # FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER # DEALINGS IN THE SOFTWARE. # ==================================================================== import warnings as _warnings _warnings.warn("Module 'PyICU' is deprecated, import 'icu' instead", category=DeprecationWarning, stacklevel=2) from icu import * PyICU-1.9.5/README.md0000644000076500000000000001762313007205050014142 0ustar vajdawheel00000000000000 --------------------- README file for PyICU --------------------- Welcome ------- Welcome to PyICU, a Python extension wrapping IBM's International Components for Unicode C++ library (ICU). The PyICU source code is hosted on GitHub at https://github.com/ovalhub/pyicu. The ICU homepage is http://site.icu-project.org/ Building PyICU -------------- Before building PyICU the ICU libraries must be built and installed. Refer to each system's instructions for more information. PyICU is built with distutils or setuptools: - verify that the ``INCLUDES``, ``LFLAGS``, ``CFLAGS`` and ``LIBRARIES`` dictionaries in ``setup.py`` contain correct values for your platform - ``python setup.py build`` - ``sudo python setup.py install`` Running PyICU ------------- - Mac OS X Make sure that ``DYLD_LIBRARY_PATH`` contains paths to the directory(ies) containing the ICU libs. - Linux & Solaris Make sure that ``LD_LIBRARY_PATH`` contains paths to the directory(ies) containing the ICU libs or that you added the corresponding ``-rpath`` argument to ``LFLAGS``. - Windows Make sure that ``PATH`` contains paths to the directory(ies) containing the ICU DLLs. What's available ---------------- See the ``CHANGES`` file for an up to date log of changes and additions. API Documentation ----------------- There is no API documentation for PyICU. The API for ICU is documented at http://icu-project.org/apiref/icu4c/ and the following patterns can be used to translate from the C++ APIs to the corresponding Python APIs. - strings The ICU string type, ``UnicodeString``, is a type pointing at a mutable array of ``UChar`` Unicode 16-bit wide characters. The Python unicode type is an immutable string of 16-bit or 32-bit wide Unicode characters. Because of these differences, ``UnicodeString`` and Python's ``unicode`` type are not merged into the same type when crossing the C++ boundary. ICU APIs taking ``UnicodeString`` arguments have been overloaded to also accept Python str or unicode type arguments. In the case of ``str`` objects, ``utf-8`` encoding is assumed when converting them to ``UnicodeString`` objects. To convert a Python ``str`` encoded in an encoding other than ``utf-8`` to an ICU ``UnicodeString`` use the ``UnicodeString(str, encodingName)`` constructor. ICU's C++ APIs accept and return ``UnicodeString`` arguments in several ways: by value, by pointer or by reference. When an ICU C++ API is documented to accept a ``UnicodeString`` reference parameter, it is safe to assume that there are several corresponding PyICU python APIs making it accessible in simpler ways: For example, the ``'UnicodeString &Locale::getDisplayName(UnicodeString &)'`` API, documented at http://icu-project.org/apiref/icu4c/classLocale.html can be invoked from Python in several ways: 1. The ICU way >>> from icu import UnicodeString, Locale >>> locale = Locale('pt_BR') >>> string = UnicodeString() >>> name = locale.getDisplayName(string) >>> name >>> name is string True <-- string arg was returned, modified in place 2. The Python way >>> from icu import Locale >>> locale = Locale('pt_BR') >>> name = locale.getDisplayName() >>> name u'Portuguese (Brazil)' A ``UnicodeString`` object was allocated and converted to a Python ``unicode`` object. A UnicodeString can be coerced to a Python unicode string with Python's ``unicode()`` constructor. The usual ``len()``, ``str()``, comparison, ``[]`` and ``[:]`` operators are all available, with the additional twists that slicing is not read-only and that ``+=`` is also available since a UnicodeString is mutable. For example: >>> name = locale.getDisplayName() u'Portuguese (Brazil)' >>> name = UnicodeString(name) >>> name >>> unicode(name) u'Portuguese (Brazil)' >>> len(name) 19 >>> str(name) <-- works when chars fit with default encoding 'Portuguese (Brazil)' >>> name[3] u't' >>> name[12:18] >>> name[12:18] = 'the country of Brasil' >>> name >>> name += ' oh joy' >>> name - error reporting The C++ ICU library does not use C++ exceptions to report errors. ICU C++ APIs return errors via a ``UErrorCode`` reference argument. All such APIs are wrapped by Python APIs that omit this argument and throw an ``ICUError`` Python exception instead. The same is true for ICU APIs taking both a ``ParseError`` and a ``UErrorCode``, they are both to be omitted. For example, the ``'UnicodeString &DateFormat::format(const Formattable &, UnicodeString &, UErrorCode &)'`` API, documented at http://icu-project.org/apiref/icu4c/classDateFormat.html is invoked from Python with: >>> from icu import DateFormat, Formattable >>> df = DateFormat.createInstance() >>> df >>> f = Formattable(940284258.0, Formattable.kIsDate) >>> df.format(f) u'10/18/99 3:04 PM' Of course, the simpler ``'UnicodeString &DateFormat::format(UDate, UnicodeString &)'`` documented here: http://icu-project.org/apiref/icu4c/classDateFormat.html can be used too: >>> from icu import DateFormat >>> df = DateFormat.createInstance() >>> df >>> df.format(940284258.0) u'10/18/99 3:04 PM' - dates ICU uses a double floating point type called ``UDate`` that represents the number of milliseconds elapsed since 1970-jan-01 UTC for dates. In Python, the value returned by the ``time`` module's ``time()`` function is the number of seconds since 1970-jan-01 UTC. Because of this difference, floating point values are multiplied by 1000 when passed to APIs taking ``UDate`` and divided by 1000 when returned as ``UDate``. Python's ``datetime`` objects, with or without timezone information, can also be used with APIs taking ``UDate`` arguments. The ``datetime`` objects get converted to ``UDate`` when crossing into the C++ layer. - arrays Many ICU API take array arguments. A list of elements of the array element types is to be passed from Python. - StringEnumeration An ICU ``StringEnumeration`` has three ``next`` methods: ``next()`` which returns a ``str`` objects, ``unext()`` which returns ``unicode`` objects and ``snext()`` which returns ``UnicodeString`` objects. Any of these methods can be used as an iterator, using the Python built-in ``iter`` function. For example, let ``e`` be a ``StringEnumeration`` instance:: [s for s in e] is a list of 'str' objects [s for s in iter(e.unext, None)] is a list of 'unicode' objects [s for s in iter(e.snext, None)] is a list of 'UnicodeString' objects - timezones The ICU ``TimeZone`` type may be wrapped with an ``ICUtzinfo`` type for usage with Python's ``datetime`` type. For example:: tz = ICUtzinfo(TimeZone.createTimeZone('US/Mountain')) datetime.now(tz) or, even simpler:: tz = ICUtzinfo.getInstance('Pacific/Fiji') datetime.now(tz) To get the default time zone use:: defaultTZ = ICUtzinfo.getDefault() To get the time zone's id, use the ``tzid`` attribute or coerce the time zone to a string:: ICUtzinfo.getInstance('Pacific/Fiji').tzid -> 'Pacific/Fiji' str(ICUtzinfo.getInstance('Pacific/Fiji')) -> 'Pacific/Fiji' PyICU-1.9.5/regex.cpp0000644000076500000000000007227212520066516014515 0ustar vajdawheel00000000000000/* ==================================================================== * Copyright (c) 2010-2011 Open Source Applications Foundation. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. * ==================================================================== */ #include "common.h" #include "structmember.h" #include "bases.h" #include "regex.h" #include "macros.h" DECLARE_CONSTANTS_TYPE(URegexpFlag); /* RegexPattern */ class t_regexpattern : public _wrapper { public: RegexPattern *object; PyObject *re; // the wrapped original regex UnicodeString }; static int t_regexpattern_init(t_regexpattern *self, PyObject *args, PyObject *kwds); static PyObject *t_regexpattern_matcher(t_regexpattern *self, PyObject *args); static PyObject *t_regexpattern_pattern(t_regexpattern *self); static PyObject *t_regexpattern_flags(t_regexpattern *self); static PyObject *t_regexpattern_split(t_regexpattern *self, PyObject *args); static PyObject *t_regexpattern_compile(PyTypeObject *type, PyObject *args); static PyObject *t_regexpattern_matches(PyTypeObject *type, PyObject *args); static PyObject *wrap_RegexPattern(RegexPattern *pattern, PyObject *re); static PyObject *wrap_RegexMatcher(RegexMatcher *matcher, PyObject *pattern, PyObject *input); static PyMethodDef t_regexpattern_methods[] = { DECLARE_METHOD(t_regexpattern, matcher, METH_VARARGS), DECLARE_METHOD(t_regexpattern, pattern, METH_NOARGS), DECLARE_METHOD(t_regexpattern, flags, METH_NOARGS), DECLARE_METHOD(t_regexpattern, split, METH_VARARGS), DECLARE_METHOD(t_regexpattern, compile, METH_VARARGS | METH_CLASS), DECLARE_METHOD(t_regexpattern, matches, METH_VARARGS | METH_CLASS), { NULL, NULL, 0, NULL } }; static void t_regexpattern_dealloc(t_regexpattern *self) { if (self->flags & T_OWNED) delete self->object; self->object = NULL; Py_CLEAR(self->re); } DECLARE_TYPE(RegexPattern, t_regexpattern, UObject, RegexPattern, t_regexpattern_init, t_regexpattern_dealloc); /* RegexMatcher */ class t_regexmatcher : public _wrapper { public: RegexMatcher *object; PyObject *re; PyObject *input; PyObject *pattern; #if U_ICU_VERSION_HEX >= 0x04000000 PyObject *callable; #endif }; static int t_regexmatcher_init(t_regexmatcher *self, PyObject *args, PyObject *kwds); static PyObject *t_regexmatcher_matches(t_regexmatcher *self, PyObject *args); static PyObject *t_regexmatcher_lookingAt(t_regexmatcher *self, PyObject *args); static PyObject *t_regexmatcher_find(t_regexmatcher *self, PyObject *args); static PyObject *t_regexmatcher_pattern(t_regexmatcher *self); static PyObject *t_regexmatcher_group(t_regexmatcher *self, PyObject *args); static PyObject *t_regexmatcher_groupCount(t_regexmatcher *self); static PyObject *t_regexmatcher_start(t_regexmatcher *self, PyObject *args); static PyObject *t_regexmatcher_end(t_regexmatcher *self, PyObject *args); static PyObject *t_regexmatcher_reset(t_regexmatcher *self, PyObject *args); static PyObject *t_regexmatcher_input(t_regexmatcher *self); #if U_ICU_VERSION_HEX >= 0x04000000 static PyObject *t_regexmatcher_region(t_regexmatcher *self, PyObject *args); static PyObject *t_regexmatcher_regionStart(t_regexmatcher *self); static PyObject *t_regexmatcher_regionEnd(t_regexmatcher *self); static PyObject *t_regexmatcher_hasTransparentBounds(t_regexmatcher *self); static PyObject *t_regexmatcher_useTransparentBounds(t_regexmatcher *self, PyObject *arg); static PyObject *t_regexmatcher_hasAnchoringBounds(t_regexmatcher *self); static PyObject *t_regexmatcher_useAnchoringBounds(t_regexmatcher *self, PyObject *arg); static PyObject *t_regexmatcher_hitEnd(t_regexmatcher *self); static PyObject *t_regexmatcher_requireEnd(t_regexmatcher *self); #endif static PyObject *t_regexmatcher_replaceAll(t_regexmatcher *self, PyObject *arg); static PyObject *t_regexmatcher_replaceFirst(t_regexmatcher *self, PyObject *arg); static PyObject *t_regexmatcher_appendReplacement(t_regexmatcher *self, PyObject *args); static PyObject *t_regexmatcher_appendTail(t_regexmatcher *self, PyObject *arg); static PyObject *t_regexmatcher_split(t_regexmatcher *self, PyObject *args); #if U_ICU_VERSION_HEX >= 0x04000000 static PyObject *t_regexmatcher_setTimeLimit(t_regexmatcher *self, PyObject *arg); static PyObject *t_regexmatcher_getTimeLimit(t_regexmatcher *self); static PyObject *t_regexmatcher_setStackLimit(t_regexmatcher *self, PyObject *arg); static PyObject *t_regexmatcher_getStackLimit(t_regexmatcher *self); static PyObject *t_regexmatcher_setMatchCallback(t_regexmatcher *self, PyObject *arg); static PyObject *t_regexmatcher_getMatchCallback(t_regexmatcher *self); #endif static PyMethodDef t_regexmatcher_methods[] = { DECLARE_METHOD(t_regexmatcher, matches, METH_VARARGS), DECLARE_METHOD(t_regexmatcher, lookingAt, METH_VARARGS), DECLARE_METHOD(t_regexmatcher, find, METH_VARARGS), DECLARE_METHOD(t_regexmatcher, pattern, METH_NOARGS), DECLARE_METHOD(t_regexmatcher, group, METH_VARARGS), DECLARE_METHOD(t_regexmatcher, groupCount, METH_NOARGS), DECLARE_METHOD(t_regexmatcher, start, METH_VARARGS), DECLARE_METHOD(t_regexmatcher, end, METH_VARARGS), DECLARE_METHOD(t_regexmatcher, reset, METH_VARARGS), DECLARE_METHOD(t_regexmatcher, input, METH_NOARGS), DECLARE_METHOD(t_regexmatcher, replaceAll, METH_O), DECLARE_METHOD(t_regexmatcher, replaceFirst, METH_O), DECLARE_METHOD(t_regexmatcher, appendReplacement, METH_VARARGS), DECLARE_METHOD(t_regexmatcher, appendTail, METH_O), DECLARE_METHOD(t_regexmatcher, split, METH_VARARGS), #if U_ICU_VERSION_HEX >= 0x04000000 DECLARE_METHOD(t_regexmatcher, region, METH_VARARGS), DECLARE_METHOD(t_regexmatcher, regionStart, METH_NOARGS), DECLARE_METHOD(t_regexmatcher, regionEnd, METH_NOARGS), DECLARE_METHOD(t_regexmatcher, hasTransparentBounds, METH_NOARGS), DECLARE_METHOD(t_regexmatcher, useTransparentBounds, METH_O), DECLARE_METHOD(t_regexmatcher, hasAnchoringBounds, METH_NOARGS), DECLARE_METHOD(t_regexmatcher, useAnchoringBounds, METH_O), DECLARE_METHOD(t_regexmatcher, hitEnd, METH_NOARGS), DECLARE_METHOD(t_regexmatcher, requireEnd, METH_NOARGS), DECLARE_METHOD(t_regexmatcher, setTimeLimit, METH_O), DECLARE_METHOD(t_regexmatcher, getTimeLimit, METH_NOARGS), DECLARE_METHOD(t_regexmatcher, setStackLimit, METH_O), DECLARE_METHOD(t_regexmatcher, getStackLimit, METH_NOARGS), DECLARE_METHOD(t_regexmatcher, setMatchCallback, METH_O), DECLARE_METHOD(t_regexmatcher, getMatchCallback, METH_NOARGS), #endif { NULL, NULL, 0, NULL } }; static void t_regexmatcher_dealloc(t_regexmatcher *self) { if (self->flags & T_OWNED) delete self->object; self->object = NULL; Py_CLEAR(self->re); Py_CLEAR(self->input); Py_CLEAR(self->pattern); #if U_ICU_VERSION_HEX >= 0x04000000 Py_CLEAR(self->callable); #endif Py_TYPE(self)->tp_free((PyObject *) self); } DECLARE_TYPE(RegexMatcher, t_regexmatcher, UObject, RegexMatcher, t_regexmatcher_init, t_regexmatcher_dealloc); /* RegexPattern */ static PyObject *wrap_RegexPattern(RegexPattern *pattern, PyObject *re) { t_regexpattern *self = (t_regexpattern *) wrap_RegexPattern(pattern, T_OWNED); self->re = re; /* steals reference */ return (PyObject *) self; } static int t_regexpattern_init(t_regexpattern *self, PyObject *args, PyObject *kwds) { RegexPattern *pattern; switch (PyTuple_Size(args)) { case 0: self->object = new RegexPattern(); self->flags = T_OWNED; break; case 1: if (!parseArgs(args, "P", TYPE_CLASSID(RegexPattern), &pattern)) { self->object = new RegexPattern(*pattern); self->flags = T_OWNED; self->re = NULL; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; default: PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; } if (self->object) return 0; return -1; } static PyObject *t_regexpattern_matcher(t_regexpattern *self, PyObject *args) { UnicodeString *u; RegexMatcher *matcher; PyObject *input = NULL; switch (PyTuple_Size(args)) { case 0: STATUS_CALL(matcher = self->object->matcher(status)); return wrap_RegexMatcher(matcher, (PyObject *) self, input); case 1: if (!parseArgs(args, "W", &u, &input)) { UErrorCode status = U_ZERO_ERROR; matcher = self->object->matcher(*u, status); if (U_FAILURE(status)) { Py_XDECREF(input); return ICUException(status).reportError(); } return wrap_RegexMatcher(matcher, (PyObject *) self, input); } break; } return PyErr_SetArgsError((PyObject *) self, "matcher", args); } static PyObject *t_regexpattern_pattern(t_regexpattern *self) { UnicodeString u = self->object->pattern(); return PyUnicode_FromUnicodeString(&u); } static PyObject *t_regexpattern_flags(t_regexpattern *self) { uint32_t flags = self->object->flags(); return PyInt_FromLong(flags); } static PyObject *t_regexpattern_split(t_regexpattern *self, PyObject *args) { UnicodeString *u, _u; int capacity, count; if (!parseArgs(args, "Si", &u, &_u, &capacity)) { if (capacity < 32) { UnicodeString array[31]; PyObject *tuple; STATUS_CALL(count = self->object->split(*u, array, capacity, status)); tuple = PyTuple_New(count); for (int i = 0; i < count; i++) PyTuple_SET_ITEM(tuple, i, PyUnicode_FromUnicodeString(&array[i])); return tuple; } else { class finalizer { public: UnicodeString *array; finalizer(int size) { array = new UnicodeString[size]; } ~finalizer() { delete[] array; } }; finalizer finally(capacity); PyObject *tuple; if (!finally.array) return PyErr_NoMemory(); STATUS_CALL(count = self->object->split(*u, finally.array, capacity, status)); tuple = PyTuple_New(count); for (int i = 0; i < count; i++) PyTuple_SET_ITEM(tuple, i, PyUnicode_FromUnicodeString(&finally.array[i])); return tuple; } } return PyErr_SetArgsError((PyObject *) self, "split", args); } static PyObject *t_regexpattern_compile(PyTypeObject *type, PyObject *args) { UnicodeString *u; uint32_t flags; RegexPattern *pattern; PyObject *re = NULL; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "W", &u, &re)) { UErrorCode status = U_ZERO_ERROR; UParseError parseError; pattern = RegexPattern::compile(*u, parseError, status); if (U_FAILURE(status)) { Py_XDECREF(re); return ICUException(parseError, status).reportError(); } return wrap_RegexPattern(pattern, re); } break; case 2: if (!parseArgs(args, "Wi", &u, &re, &flags)) { UErrorCode status = U_ZERO_ERROR; UParseError parseError; pattern = RegexPattern::compile(*u, flags, parseError, status); if (U_FAILURE(status)) { Py_XDECREF(re); return ICUException(parseError, status).reportError(); } return wrap_RegexPattern(pattern, re); } break; } return PyErr_SetArgsError(type, "compile", args); } static PyObject *t_regexpattern_matches(PyTypeObject *type, PyObject *args) { UnicodeString *u0, _u0; UnicodeString *u1, _u1; UBool b; switch (PyTuple_Size(args)) { case 2: if (!parseArgs(args, "SS", &u0, &_u0, &u1, &_u1)) { STATUS_PARSER_CALL(b = RegexPattern::matches(*u0, *u1, parseError, status)); Py_RETURN_BOOL(b); } break; } return PyErr_SetArgsError(type, "matches", args); } static PyObject *t_regexpattern_str(t_regexpattern *self) { UnicodeString u = self->object->pattern(); return PyUnicode_FromUnicodeString(&u); } static PyObject *t_regexpattern_richcmp(t_regexpattern *self, PyObject *arg, int op) { RegexPattern *pattern; int b = 0; if (!parseArg(arg, "P", TYPE_CLASSID(RegexPattern), &pattern)) { switch (op) { case Py_EQ: case Py_NE: b = *self->object == *pattern; if (op == Py_EQ) Py_RETURN_BOOL(b); Py_RETURN_BOOL(!b); case Py_LT: case Py_LE: case Py_GT: case Py_GE: PyErr_SetNone(PyExc_NotImplementedError); return NULL; } } return PyErr_SetArgsError((PyObject *) self, "__richcmp__", arg); } /* RegexMatcher */ static int t_regexmatcher_init(t_regexmatcher *self, PyObject *args, PyObject *kwds) { RegexMatcher *matcher; UnicodeString *u0, *u1; uint32_t flags; switch (PyTuple_Size(args)) { case 2: if (!parseArgs(args, "Wi", &u0, &self->re, &flags)) { INT_STATUS_CALL(matcher = new RegexMatcher(*u0, flags, status)); self->object = matcher; self->pattern = NULL; self->input = NULL; self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; case 3: if (!parseArgs(args, "WWi", &u0, &self->re, &u1, &self->input, &flags)) { INT_STATUS_CALL(matcher = new RegexMatcher(*u0, *u1, flags, status)); self->object = matcher; self->pattern = NULL; self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; default: PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; } if (self->object) return 0; return -1; } static PyObject *wrap_RegexMatcher(RegexMatcher *matcher, PyObject *pattern, PyObject *input) { t_regexmatcher *self = (t_regexmatcher *) wrap_RegexMatcher(matcher, T_OWNED); Py_INCREF(pattern); self->pattern = pattern; self->input = input; /* steals reference */ self->re = NULL; return (PyObject *) self; } static PyObject *t_regexmatcher_matches(t_regexmatcher *self, PyObject *args) { int32_t startIndex; UBool b; switch (PyTuple_Size(args)) { case 0: STATUS_CALL(b = self->object->matches(status)); Py_RETURN_BOOL(b); case 1: if (!parseArgs(args, "i", &startIndex)) { STATUS_CALL(b = self->object->matches(startIndex, status)); Py_RETURN_BOOL(b); } } return PyErr_SetArgsError((PyObject *) self, "matches", args); } static PyObject *t_regexmatcher_lookingAt(t_regexmatcher *self, PyObject *args) { int32_t startIndex; UBool b; switch (PyTuple_Size(args)) { case 0: STATUS_CALL(b = self->object->lookingAt(status)); Py_RETURN_BOOL(b); case 1: if (!parseArgs(args, "i", &startIndex)) { STATUS_CALL(b = self->object->lookingAt(startIndex, status)); Py_RETURN_BOOL(b); } } return PyErr_SetArgsError((PyObject *) self, "matches", args); } static PyObject *t_regexmatcher_find(t_regexmatcher *self, PyObject *args) { int32_t startIndex; UBool b; switch (PyTuple_Size(args)) { case 0: b = self->object->find(); Py_RETURN_BOOL(b); case 1: if (!parseArgs(args, "i", &startIndex)) { STATUS_CALL(b = self->object->find(startIndex, status)); Py_RETURN_BOOL(b); } } return PyErr_SetArgsError((PyObject *) self, "matches", args); } static PyObject *t_regexmatcher_pattern(t_regexmatcher *self) { const RegexPattern pattern = self->object->pattern(); return wrap_RegexPattern(pattern.clone(), T_OWNED); } static PyObject *t_regexmatcher_group(t_regexmatcher *self, PyObject *args) { UnicodeString u; int32_t groupNum; switch (PyTuple_Size(args)) { case 0: STATUS_CALL(u = self->object->group(status)); return PyUnicode_FromUnicodeString(&u); case 1: if (!parseArgs(args, "i", &groupNum)) { STATUS_CALL(u = self->object->group(groupNum, status)); return PyUnicode_FromUnicodeString(&u); } break; } return PyErr_SetArgsError((PyObject *) self, "group", args); } static PyObject *t_regexmatcher_groupCount(t_regexmatcher *self) { int32_t count = self->object->groupCount(); return PyInt_FromLong(count); } static PyObject *t_regexmatcher_start(t_regexmatcher *self, PyObject *args) { int32_t index, groupNum; switch (PyTuple_Size(args)) { case 0: STATUS_CALL(index = self->object->start(status)); return PyInt_FromLong(index); case 1: if (!parseArgs(args, "i", &groupNum)) { STATUS_CALL(index = self->object->start(groupNum, status)); return PyInt_FromLong(index); } break; } return PyErr_SetArgsError((PyObject *) self, "start", args); } static PyObject *t_regexmatcher_end(t_regexmatcher *self, PyObject *args) { int32_t index, groupNum; switch (PyTuple_Size(args)) { case 0: STATUS_CALL(index = self->object->end(status)); return PyInt_FromLong(index); case 1: if (!parseArgs(args, "i", &groupNum)) { STATUS_CALL(index = self->object->end(groupNum, status)); return PyInt_FromLong(index); } break; } return PyErr_SetArgsError((PyObject *) self, "end", args); } static PyObject *t_regexmatcher_reset(t_regexmatcher *self, PyObject *args) { int32_t index; UnicodeString *u, _u; switch (PyTuple_Size(args)) { case 0: self->object->reset(); Py_RETURN_SELF(); case 1: if (!parseArgs(args, "i", &index)) { STATUS_CALL(self->object->reset(index, status)); Py_RETURN_SELF(); } if (!parseArgs(args, "S", &u, &_u)) { self->object->reset(*u); Py_RETURN_SELF(); } break; } return PyErr_SetArgsError((PyObject *) self, "reset", args); } static PyObject *t_regexmatcher_input(t_regexmatcher *self) { UnicodeString u = self->object->input(); return PyUnicode_FromUnicodeString(&u); } #if U_ICU_VERSION_HEX >= 0x04000000 static PyObject *t_regexmatcher_region(t_regexmatcher *self, PyObject *args) { int32_t start, end; if (!parseArgs(args, "ii", &start, &end)) { STATUS_CALL(self->object->region(start, end, status)); Py_RETURN_SELF(); } return PyErr_SetArgsError((PyObject *) self, "region", args); } static PyObject *t_regexmatcher_regionStart(t_regexmatcher *self) { int32_t index = self->object->regionStart(); return PyInt_FromLong(index); } static PyObject *t_regexmatcher_regionEnd(t_regexmatcher *self) { int32_t index = self->object->regionEnd(); return PyInt_FromLong(index); } static PyObject *t_regexmatcher_hasTransparentBounds(t_regexmatcher *self) { UBool b = self->object->hasTransparentBounds(); Py_RETURN_BOOL(b); } static PyObject *t_regexmatcher_useTransparentBounds(t_regexmatcher *self, PyObject *arg) { UBool b; if (!parseArg(arg, "B", &b)) { self->object->useTransparentBounds(b); Py_RETURN_SELF(); } return PyErr_SetArgsError((PyObject *) self, "useTransparentBounds", arg); } static PyObject *t_regexmatcher_hasAnchoringBounds(t_regexmatcher *self) { UBool b = self->object->hasAnchoringBounds(); Py_RETURN_BOOL(b); } static PyObject *t_regexmatcher_useAnchoringBounds(t_regexmatcher *self, PyObject *arg) { UBool b; if (!parseArg(arg, "B", &b)) { self->object->useAnchoringBounds(b); Py_RETURN_SELF(); } return PyErr_SetArgsError((PyObject *) self, "useAnchoringBounds", arg); } static PyObject *t_regexmatcher_hitEnd(t_regexmatcher *self) { UBool b = self->object->hitEnd(); Py_RETURN_BOOL(b); } static PyObject *t_regexmatcher_requireEnd(t_regexmatcher *self) { UBool b = self->object->requireEnd(); Py_RETURN_BOOL(b); } #endif static PyObject *t_regexmatcher_replaceAll(t_regexmatcher *self, PyObject *arg) { UnicodeString *u, _u, result; if (!parseArg(arg, "S", &u, &_u)) { STATUS_CALL(result = self->object->replaceAll(*u, status)); return PyUnicode_FromUnicodeString(&result); } return PyErr_SetArgsError((PyObject *) self, "replaceAll", arg); } static PyObject *t_regexmatcher_replaceFirst(t_regexmatcher *self, PyObject *arg) { UnicodeString *u, _u, result; if (!parseArg(arg, "S", &u, &_u)) { STATUS_CALL(result = self->object->replaceFirst(*u, status)); return PyUnicode_FromUnicodeString(&result); } return PyErr_SetArgsError((PyObject *) self, "replaceFirst", arg); } static PyObject *t_regexmatcher_appendReplacement(t_regexmatcher *self, PyObject *args) { UnicodeString *u0, _u0; UnicodeString *u1, _u1; if (!parseArgs(args, "SS", &u0, &_u0, &u1, &_u1)) { STATUS_CALL(self->object->appendReplacement(*u0, *u1, status)); Py_RETURN_SELF(); } return PyErr_SetArgsError((PyObject *) self, "appendReplacement", args); } static PyObject *t_regexmatcher_appendTail(t_regexmatcher *self, PyObject *arg) { UnicodeString *u, _u, result; if (!parseArg(arg, "S", &u, &_u)) { result = self->object->appendTail(*u); return PyUnicode_FromUnicodeString(&result); } return PyErr_SetArgsError((PyObject *) self, "appendTail", arg); } static PyObject *t_regexmatcher_split(t_regexmatcher *self, PyObject *args) { UnicodeString *u, _u; int capacity, count; if (!parseArgs(args, "Si", &u, &_u, &capacity)) { if (capacity < 32) { UnicodeString array[31]; PyObject *tuple; STATUS_CALL(count = self->object->split(*u, array, capacity, status)); tuple = PyTuple_New(count); for (int i = 0; i < count; i++) PyTuple_SET_ITEM(tuple, i, PyUnicode_FromUnicodeString(&array[i])); return tuple; } else { class finalizer { public: UnicodeString *array; finalizer(int size) { array = new UnicodeString[size]; } ~finalizer() { delete[] array; } }; finalizer finally(capacity); PyObject *tuple; if (!finally.array) return PyErr_NoMemory(); STATUS_CALL(count = self->object->split(*u, finally.array, capacity, status)); tuple = PyTuple_New(count); for (int i = 0; i < count; i++) PyTuple_SET_ITEM(tuple, i, PyUnicode_FromUnicodeString(&finally.array[i])); return tuple; } } return PyErr_SetArgsError((PyObject *) self, "split", args); } #if U_ICU_VERSION_HEX >= 0x04000000 static PyObject *t_regexmatcher_setTimeLimit(t_regexmatcher *self, PyObject *arg) { int32_t limit; if (!parseArg(arg, "i", &limit)) { STATUS_CALL(self->object->setTimeLimit(limit, status)); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setTimeLimit", arg); } static PyObject *t_regexmatcher_getTimeLimit(t_regexmatcher *self) { int32_t limit = self->object->getTimeLimit(); return PyInt_FromLong(limit); } static PyObject *t_regexmatcher_setStackLimit(t_regexmatcher *self, PyObject *arg) { int32_t limit; if (!parseArg(arg, "i", &limit)) { STATUS_CALL(self->object->setStackLimit(limit, status)); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setStackLimit", arg); } static PyObject *t_regexmatcher_getStackLimit(t_regexmatcher *self) { int32_t limit = self->object->getStackLimit(); return PyInt_FromLong(limit); } static UBool t_regexmatcher_matchCallback(const void *context, int32_t steps) { t_regexmatcher *self = (t_regexmatcher *) context; PyObject *n = PyInt_FromLong(steps); PyObject *args = PyTuple_Pack(1, n); PyObject *result = PyObject_Call(self->callable, args, NULL); int b; Py_DECREF(args); Py_DECREF(n); if (!result) return 0; b = PyObject_IsTrue(result); Py_DECREF(result); if (b == -1) return 0; return b; } static PyObject *t_regexmatcher_setMatchCallback(t_regexmatcher *self, PyObject *arg) { if (PyCallable_Check(arg)) { Py_INCREF(arg); Py_XDECREF(self->callable); self->callable = arg; STATUS_CALL(self->object->setMatchCallback(t_regexmatcher_matchCallback, self, status)); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setMatchCallback", arg); } static PyObject *t_regexmatcher_getMatchCallback(t_regexmatcher *self) { if (self->callable) { Py_INCREF(self->callable); return self->callable; } Py_RETURN_NONE; } #endif static PyObject *t_regexmatcher_str(t_regexmatcher *self) { UnicodeString u = self->object->pattern().pattern(); return PyUnicode_FromUnicodeString(&u); } #if U_ICU_VERSION_HEX >= 0x04000000 static int t_regexmatcher_traverse(t_regexmatcher *self, visitproc visit, void *arg) { Py_VISIT(self->callable); return 0; } static int t_regexmatcher_clear(t_regexmatcher *self) { Py_CLEAR(self->callable); return 0; } #endif void _init_regex(PyObject *m) { RegexPatternType_.tp_str = (reprfunc) t_regexpattern_str; RegexPatternType_.tp_richcompare = (richcmpfunc) t_regexpattern_richcmp; #if U_ICU_VERSION_HEX >= 0x04000000 RegexMatcherType_.tp_traverse = (traverseproc) t_regexmatcher_traverse; RegexMatcherType_.tp_clear = (inquiry) t_regexmatcher_clear; RegexMatcherType_.tp_flags |= Py_TPFLAGS_HAVE_GC; #endif RegexMatcherType_.tp_str = (reprfunc) t_regexmatcher_str; INSTALL_CONSTANTS_TYPE(URegexpFlag, m); REGISTER_TYPE(RegexPattern, m); REGISTER_TYPE(RegexMatcher, m); INSTALL_ENUM(URegexpFlag, "CANON_EQ", UREGEX_CANON_EQ); INSTALL_ENUM(URegexpFlag, "CASE_INSENSITIVE", UREGEX_CASE_INSENSITIVE); INSTALL_ENUM(URegexpFlag, "COMMENTS", UREGEX_COMMENTS); INSTALL_ENUM(URegexpFlag, "DOTALL", UREGEX_DOTALL); INSTALL_ENUM(URegexpFlag, "MULTILINE", UREGEX_MULTILINE); INSTALL_ENUM(URegexpFlag, "UWORD", UREGEX_UWORD); #if U_ICU_VERSION_HEX >= 0x04000000 INSTALL_ENUM(URegexpFlag, "LITERAL", UREGEX_LITERAL); INSTALL_ENUM(URegexpFlag, "UNIX_LINES", UREGEX_UNIX_LINES); INSTALL_ENUM(URegexpFlag, "ERROR_ON_UNKNOWN_ESCAPES", UREGEX_ERROR_ON_UNKNOWN_ESCAPES); #endif } PyICU-1.9.5/regex.h0000644000076500000000000000254311344037063014152 0ustar vajdawheel00000000000000/* ==================================================================== * Copyright (c) 2010-2010 Open Source Applications Foundation. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. * ==================================================================== */ #ifndef _regex_h #define _regex_h void _init_regex(PyObject *m); #endif /* _regex_h */ PyICU-1.9.5/samples/0000755000076500000000000000000013011413477014327 5ustar vajdawheel00000000000000PyICU-1.9.5/samples/break.py0000644000076500000000000000753311354706254016003 0ustar vajdawheel00000000000000# ==================================================================== # Copyright (c) 2004-2010 Open Source Applications Foundation. # # Permission is hereby granted, free of charge, to any person obtaining a # copy of this software and associated documentation files (the "Software"), # to deal in the Software without restriction, including without limitation # the rights to use, copy, modify, merge, publish, distribute, sublicense, # and/or sell copies of the Software, and to permit persons to whom the # Software is furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included # in all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS # OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING # FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER # DEALINGS IN THE SOFTWARE. # ==================================================================== # from icu import UnicodeString, BreakIterator, Locale def printTextRange(iterator, start, end): s = iterator.getText().getText() print "%2d %2d %s|%s|%s" %(start, end, s[:start], s[start:end], s[end:]) #def printTextRange(iterator, start, end): # # u = iterator.getText().getText(UnicodeString()) # print "%2d %2d %s|%s|%s" %(start, end, # UnicodeString(u, 0, start), # UnicodeString(u, start, end-start), # UnicodeString(u, end)) def printEachForward(boundary): start = boundary.first() for end in boundary: printTextRange(boundary, start, end) start = end # Print each element in reverse order: def printEachBackward(boundary): end = boundary.last() while True: start = boundary.previous() if start == BreakIterator.DONE: break printTextRange(boundary, start, end) end = start # Print the first element def printFirst(boundary): start = boundary.first() end = boundary.next() printTextRange(boundary, start, end) # Print the last element def printLast(boundary): end = boundary.last() start = boundary.previous() if start != BreakIterator.DONE: printTextRange(boundary, start, end) # Print the element at a specified position def printAt(boundary, pos): end = boundary.following(pos) start = boundary.previous() printTextRange(boundary, start, end) def main(): print "ICU Break Iterator Sample Program" print "C++ Break Iteration in Python" stringToExamine = u"Aaa bbb ccc. Ddd eee fff." print "Examining: ", stringToExamine # print each sentence in forward and reverse order boundary = BreakIterator.createSentenceInstance(Locale.getUS()) boundary.setText(stringToExamine) print print "Sentence Boundaries... " print "----- forward: -----------" printEachForward(boundary) print "----- backward: ----------" printEachBackward(boundary) # print each word in order print print "Word Boundaries..." boundary = BreakIterator.createWordInstance(Locale.getUS()) boundary.setText(stringToExamine) print "----- forward: -----------" printEachForward(boundary) # print first element print "----- first: -------------" printFirst(boundary) # print last element print "----- last: --------------" printLast(boundary) # print word at charpos 10 print "----- at pos 10: ---------" printAt(boundary, 10) print print "End C++ Break Iteration in Python" if __name__ == "__main__": main() PyICU-1.9.5/samples/strsrch.py0000644000076500000000000001500111362445316016372 0ustar vajdawheel00000000000000# ==================================================================== # Copyright (c) 2004-2010 Open Source Applications Foundation. # # Permission is hereby granted, free of charge, to any person obtaining a # copy of this software and associated documentation files (the "Software"), # to deal in the Software without restriction, including without limitation # the rights to use, copy, modify, merge, publish, distribute, sublicense, # and/or sell copies of the Software, and to permit persons to whom the # Software is furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included # in all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS # OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING # FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER # DEALINGS IN THE SOFTWARE. # ==================================================================== # from icu import * def processCollator(options): if options.rules is not None: rules = unicode(options.rules, 'unicode-escape') collator = RuleBasedCollator(rules, Collator.TERTIARY, UCollAttributeValue.OFF) else: collator = Collator.createInstance(Locale(options.locale)) if options.norm: collator.setAttribute(UCollAttribute.NORMALIZATION_MODE, UCollAttributeValue.ON) if options.french: collator.setAttribute(UCollAttribute.FRENCH_COLLATION, UCollAttributeValue.ON) if options.lower: collator.setAttribute(UCollAttribute.CASE_FIRST, UCollAttributeValue.LOWER_FIRST) if options.upper: collator.setAttribute(UCollAttribute.CASE_FIRST, UCollAttributeValue.UPPER_FIRST) if options.case: collator.setAttribute(UCollAttribute.CASE_LEVEL, UCollAttributeValue.ON) if options.shifted: collator.setAttribute(UCollAttribute.ALTERNATE_HANDLING, UCollAttributeValue.SHIFTED) if options.level == 1: collator.setAttribute(UCollAttribute.STRENGTH, UCollAttributeValue.PRIMARY) elif options.level == 2: collator.setAttribute(UCollAttribute.STRENGTH, UCollAttributeValue.SECONDARY) elif options.level == 3: collator.setAttribute(UCollAttribute.STRENGTH, UCollAttributeValue.TERTIARY) elif options.level == 4: collator.setAttribute(UCollAttribute.STRENGTH, UCollAttributeValue.QUATERNARY) elif options.level == 5: collator.setAttribute(UCollAttribute.STRENGTH, UCollAttributeValue.IDENTICAL) else: raise ValueError, "--level must be between 1 and 5" return collator def processStringSearch(options, collator): source = unicode(options.source, "unicode-escape") pattern = unicode(options.pattern, "unicode-escape") search = StringSearch(pattern, source, collator) if options.overlap: search.setAttribute(USearchAttribute.OVERLAP, USearchAttributeValue.ON) if options.canonical: search.setAttribute(USearchAttribute.CANONICAL_MATCH, USearchAttributeValue.ON) return search def findPattern(search): found = False for offset in search: print "Pattern found at offset", offset, "size", search.getMatchedLength() found = True if not found: print "Pattern not found in source" if __name__ == "__main__": from optparse import OptionParser parser = OptionParser(usage=''' strsrch [options*] --source source_string --pattern pattern_string Example: python strsrch.py --rules \\u0026b\\u003ca --source a\\u0020b\\u0020bc --pattern b The format \\uXXXX is supported for the rules and comparison strings''') parser.add_option('-l', "--locale", dest='locale', default='en_US', help="ICU locale to use. Default is en_US") parser.add_option('-r', "--rules", dest='rules', default=None, help="Collation rules file (overrides locale)") parser.add_option('-f', "--french", dest='french', default=False, action="store_true", help="French accent ordering") parser.add_option('-n', "--norm", dest='norm', default=False, action="store_true", help="Normalizing mode on") parser.add_option('-s', "--shifted", dest='shifted', default=False, action="store_true", help="Shifted mode") parser.add_option('-L', "--lower", dest='lower', default=False, action="store_true", help="Lower case first") parser.add_option('-U', "--upper", dest='upper', default=False, action="store_true", help="Upper case first") parser.add_option('-C', "--case", dest='case', default=False, action="store_true", help="Enable separate case level") parser.add_option('-S', "--sort", dest='level', default='1', help="Sort level, 1 to 5, for Primary, Secondary, Tertiary, Quaternary, Identical") parser.add_option('-u', "--source", dest='source', default="International Components for Unicode", help="Source string") parser.add_option('-p', "--pattern", dest='pattern', default="Unicode", help="Pattern string to look for in source") parser.add_option('-o', "--overlap", dest='overlap', default=False, action="store_true", help="Enable searching to be done on overlapping patterns") parser.add_option('-c', "--canonical", dest='canonical', default=False, action="store_true", help="Enable searching to be done matching canonical equivalent patterns") options, args = parser.parse_args() options.level = int(options.level) collator = processCollator(options) search = processStringSearch(options, collator) print "Finding pattern", options.pattern, "in source", options.source findPattern(search) del search del collator PyICU-1.9.5/script.cpp0000644000076500000000000005023613010720526014674 0ustar vajdawheel00000000000000/* ==================================================================== * Copyright (c) 2004-2013 Open Source Applications Foundation. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. * ==================================================================== */ #include #include #include "common.h" #include "structmember.h" #include "bases.h" #include "script.h" #include "macros.h" DECLARE_CONSTANTS_TYPE(UScriptCode); #if U_ICU_VERSION_HEX >= VERSION_HEX(51, 0, 0) DECLARE_CONSTANTS_TYPE(UScriptUsage); #endif /* Script */ struct UNone; typedef struct UNone UNone; class t_script : public _wrapper { public: UNone *object; UScriptCode code; }; static int t_script_init(t_script *self, PyObject *args, PyObject *kwds); static PyObject *t_script_getName(t_script *self); static PyObject *t_script_getShortName(t_script *self); static PyObject *t_script_getScriptCode(t_script *self); static PyObject *t_script_getCode(PyTypeObject *type, PyObject *arg); static PyObject *t_script_getScript(PyTypeObject *type, PyObject *arg); #if U_ICU_VERSION_HEX >= VERSION_HEX(49, 0, 0) static PyObject *t_script_hasScript(PyTypeObject *type, PyObject *args); static PyObject *t_script_getScriptExtensions(PyTypeObject *type, PyObject *arg); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(51, 0, 0) static PyObject *t_script_isRightToLeft(t_script *self); static PyObject *t_script_isCased(t_script *self); static PyObject *t_script_breaksBetweenLetters(t_script *self); static PyObject *t_script_getSampleString(t_script *self); static PyObject *t_script_getUsage(t_script *self); #endif static PyMethodDef t_script_methods[] = { DECLARE_METHOD(t_script, getName, METH_NOARGS), DECLARE_METHOD(t_script, getShortName, METH_NOARGS), DECLARE_METHOD(t_script, getScriptCode, METH_NOARGS), DECLARE_METHOD(t_script, getCode, METH_O | METH_CLASS), DECLARE_METHOD(t_script, getScript, METH_O | METH_CLASS), #if U_ICU_VERSION_HEX >= VERSION_HEX(49, 0, 0) DECLARE_METHOD(t_script, hasScript, METH_VARARGS | METH_CLASS), DECLARE_METHOD(t_script, getScriptExtensions, METH_O | METH_CLASS), #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(51, 0, 0) DECLARE_METHOD(t_script, isRightToLeft, METH_NOARGS), DECLARE_METHOD(t_script, isCased, METH_NOARGS), DECLARE_METHOD(t_script, breaksBetweenLetters, METH_NOARGS), DECLARE_METHOD(t_script, getSampleString, METH_NOARGS), DECLARE_METHOD(t_script, getUsage, METH_NOARGS), #endif { NULL, NULL, 0, NULL } }; static void t_script_dealloc(t_script *self) { Py_TYPE(self)->tp_free((PyObject *) self); } DECLARE_STRUCT(Script, t_script, UNone, t_script_init, t_script_dealloc); /* Script */ static int t_script_init(t_script *self, PyObject *args, PyObject *kwds) { UScriptCode code; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "i", &code)) { if (uscript_getName(code) == NULL) { PyErr_Format(PyExc_ValueError, "Invalid script code: %d", code); return -1; } self->object = NULL; /* there is no ICU struct for this */ self->code = code; self->flags = T_OWNED; return 0; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; default: PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; } } static PyObject *t_script_getName(t_script *self) { return PyString_FromString(uscript_getName(self->code)); } static PyObject *t_script_getShortName(t_script *self) { return PyString_FromString(uscript_getShortName(self->code)); } static PyObject *t_script_getScriptCode(t_script *self) { return PyInt_FromLong(self->code); } static PyObject *t_script_getCode(PyTypeObject *type, PyObject *arg) { charsArg name; if (!parseArg(arg, "n", &name)) { UScriptCode codes[256]; int count; STATUS_CALL(count = uscript_getCode( name, codes, sizeof(codes) / sizeof(UScriptCode), &status)); PyObject *tuple = PyTuple_New(count); for (int i = 0; i < count; ++i) PyTuple_SET_ITEM(tuple, i, PyInt_FromLong(codes[i])); return tuple; } return PyErr_SetArgsError((PyObject *) type, "getCode", arg); } static PyObject *t_script_getScript(PyTypeObject *type, PyObject *arg) { UnicodeString *u, _u; int cp; if (!parseArg(arg, "S", &u, &_u)) { UScriptCode code; if (u->countChar32() != 1) { PyObject *tuple = Py_BuildValue( "(sO)", "string must contain only one codepoint", arg); PyErr_SetObject(PyExc_ValueError, tuple); Py_DECREF(tuple); return NULL; } STATUS_CALL(code = uscript_getScript(u->char32At(0), &status)); return PyObject_CallFunction((PyObject *) type, (char *) "i", code); } if (!parseArg(arg, "i", &cp)) { UScriptCode code; STATUS_CALL(code = uscript_getScript((UChar32) cp, &status)); return PyObject_CallFunction((PyObject *) type, (char *) "i", code); } return PyErr_SetArgsError((PyObject *) type, "getScript", arg); } #if U_ICU_VERSION_HEX >= VERSION_HEX(49, 0, 0) static PyObject *t_script_hasScript(PyTypeObject *type, PyObject *args) { UnicodeString *u, _u; UScriptCode code; int cp; switch (PyTuple_Size(args)) { case 2: if (!parseArgs(args, "Si", &u, &_u, &code)) { if (u->countChar32() != 1) { PyObject *tuple = Py_BuildValue( "(sO)", "string must contain only one codepoint", PyTuple_GET_ITEM(args, 0)); PyErr_SetObject(PyExc_ValueError, tuple); Py_DECREF(tuple); return NULL; } if (uscript_hasScript(u->char32At(0), code)) Py_RETURN_TRUE; Py_RETURN_FALSE; } if (!parseArgs(args, "ii", &cp, &code)) { if (uscript_hasScript((UChar32) cp, code)) Py_RETURN_TRUE; Py_RETURN_FALSE; } break; } return PyErr_SetArgsError((PyObject *) type, "hasScript", args); } static PyObject *t_script_getScriptExtensions(PyTypeObject *type, PyObject *arg) { UnicodeString *u, _u; int cp; if (!parseArg(arg, "S", &u, &_u)) { if (u->countChar32() != 1) { PyObject *tuple = Py_BuildValue( "(sO)", "string must contain only one codepoint", arg); PyErr_SetObject(PyExc_ValueError, tuple); Py_DECREF(tuple); return NULL; } UScriptCode codes[256]; int count; STATUS_CALL(count = uscript_getScriptExtensions( u->char32At(0), codes, sizeof(codes) / sizeof(UScriptCode), &status)); PyObject *tuple = PyTuple_New(count); for (int i = 0; i < count; ++i) PyTuple_SET_ITEM(tuple, i, PyInt_FromLong(codes[i])); return tuple; } if (!parseArg(arg, "i", &cp)) { UScriptCode codes[256]; int count; STATUS_CALL(count = uscript_getScriptExtensions( (UChar32) cp, codes, sizeof(codes) / sizeof(UScriptCode), &status)); PyObject *tuple = PyTuple_New(count); for (int i = 0; i < count; ++i) PyTuple_SET_ITEM(tuple, i, PyInt_FromLong(codes[i])); return tuple; } return PyErr_SetArgsError((PyObject *) type, "getScriptExtensions", arg); } #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(51, 0, 0) static PyObject *t_script_isRightToLeft(t_script *self) { if (uscript_isRightToLeft(self->code)) Py_RETURN_TRUE; Py_RETURN_FALSE; } static PyObject *t_script_isCased(t_script *self) { if (uscript_isCased(self->code)) Py_RETURN_TRUE; Py_RETURN_FALSE; } static PyObject *t_script_breaksBetweenLetters(t_script *self) { if (uscript_breaksBetweenLetters(self->code)) Py_RETURN_TRUE; Py_RETURN_FALSE; } static PyObject *t_script_getSampleString(t_script *self) { UChar dest[32]; int32_t count; STATUS_CALL(count = uscript_getSampleString(self->code, dest, sizeof(dest), &status)); return PyUnicode_FromUnicodeString(dest, count); } static PyObject *t_script_getUsage(t_script *self) { return PyInt_FromLong(uscript_getUsage(self->code)); } #endif void _init_script(PyObject *m) { INSTALL_CONSTANTS_TYPE(UScriptCode, m); #if U_ICU_VERSION_HEX >= VERSION_HEX(51, 0, 0) INSTALL_CONSTANTS_TYPE(UScriptUsage, m); #endif INSTALL_STRUCT(Script, m); INSTALL_ENUM(UScriptCode, "COMMON", USCRIPT_COMMON); INSTALL_ENUM(UScriptCode, "INHERITED", USCRIPT_INHERITED); INSTALL_ENUM(UScriptCode, "ARABIC", USCRIPT_ARABIC); INSTALL_ENUM(UScriptCode, "ARMENIAN", USCRIPT_ARMENIAN); INSTALL_ENUM(UScriptCode, "BENGALI", USCRIPT_BENGALI); INSTALL_ENUM(UScriptCode, "BOPOMOFO", USCRIPT_BOPOMOFO); INSTALL_ENUM(UScriptCode, "CHEROKEE", USCRIPT_CHEROKEE); INSTALL_ENUM(UScriptCode, "COPTIC", USCRIPT_COPTIC); INSTALL_ENUM(UScriptCode, "CYRILLIC", USCRIPT_CYRILLIC); INSTALL_ENUM(UScriptCode, "DESERET", USCRIPT_DESERET); INSTALL_ENUM(UScriptCode, "DEVANAGARI", USCRIPT_DEVANAGARI); INSTALL_ENUM(UScriptCode, "ETHIOPIC", USCRIPT_ETHIOPIC); INSTALL_ENUM(UScriptCode, "GEORGIAN", USCRIPT_GEORGIAN); INSTALL_ENUM(UScriptCode, "GOTHIC", USCRIPT_GOTHIC); INSTALL_ENUM(UScriptCode, "GREEK", USCRIPT_GREEK); INSTALL_ENUM(UScriptCode, "GUJARATI", USCRIPT_GUJARATI); INSTALL_ENUM(UScriptCode, "GURMUKHI", USCRIPT_GURMUKHI); INSTALL_ENUM(UScriptCode, "HAN", USCRIPT_HAN); INSTALL_ENUM(UScriptCode, "HANGUL", USCRIPT_HANGUL); INSTALL_ENUM(UScriptCode, "HEBREW", USCRIPT_HEBREW); INSTALL_ENUM(UScriptCode, "HIRAGANA", USCRIPT_HIRAGANA); INSTALL_ENUM(UScriptCode, "KANNADA", USCRIPT_KANNADA); INSTALL_ENUM(UScriptCode, "KATAKANA", USCRIPT_KATAKANA); INSTALL_ENUM(UScriptCode, "KHMER", USCRIPT_KHMER); INSTALL_ENUM(UScriptCode, "LAO", USCRIPT_LAO); INSTALL_ENUM(UScriptCode, "LATIN", USCRIPT_LATIN); INSTALL_ENUM(UScriptCode, "MALAYALAM", USCRIPT_MALAYALAM); INSTALL_ENUM(UScriptCode, "MONGOLIAN", USCRIPT_MONGOLIAN); INSTALL_ENUM(UScriptCode, "MYANMAR", USCRIPT_MYANMAR); INSTALL_ENUM(UScriptCode, "OGHAM", USCRIPT_OGHAM); INSTALL_ENUM(UScriptCode, "OLD_ITALIC", USCRIPT_OLD_ITALIC); INSTALL_ENUM(UScriptCode, "ORIYA", USCRIPT_ORIYA); INSTALL_ENUM(UScriptCode, "RUNIC", USCRIPT_RUNIC); INSTALL_ENUM(UScriptCode, "SINHALA", USCRIPT_SINHALA); INSTALL_ENUM(UScriptCode, "SYRIAC", USCRIPT_SYRIAC); INSTALL_ENUM(UScriptCode, "TAMIL", USCRIPT_TAMIL); INSTALL_ENUM(UScriptCode, "TELUGU", USCRIPT_TELUGU); INSTALL_ENUM(UScriptCode, "THAANA", USCRIPT_THAANA); INSTALL_ENUM(UScriptCode, "THAI", USCRIPT_THAI); INSTALL_ENUM(UScriptCode, "TIBETAN", USCRIPT_TIBETAN); INSTALL_ENUM(UScriptCode, "CANADIAN_ABORIGINAL", USCRIPT_CANADIAN_ABORIGINAL); INSTALL_ENUM(UScriptCode, "UCAS", USCRIPT_UCAS); INSTALL_ENUM(UScriptCode, "YI", USCRIPT_YI); INSTALL_ENUM(UScriptCode, "TAGALOG", USCRIPT_TAGALOG); INSTALL_ENUM(UScriptCode, "HANUNOO", USCRIPT_HANUNOO); INSTALL_ENUM(UScriptCode, "BUHID", USCRIPT_BUHID); INSTALL_ENUM(UScriptCode, "TAGBANWA", USCRIPT_TAGBANWA); INSTALL_ENUM(UScriptCode, "BRAILLE", USCRIPT_BRAILLE); INSTALL_ENUM(UScriptCode, "CYPRIOT", USCRIPT_CYPRIOT); INSTALL_ENUM(UScriptCode, "LIMBU", USCRIPT_LIMBU); INSTALL_ENUM(UScriptCode, "LINEAR_B", USCRIPT_LINEAR_B); INSTALL_ENUM(UScriptCode, "OSMANYA", USCRIPT_OSMANYA); INSTALL_ENUM(UScriptCode, "SHAVIAN", USCRIPT_SHAVIAN); INSTALL_ENUM(UScriptCode, "TAI_LE", USCRIPT_TAI_LE); INSTALL_ENUM(UScriptCode, "UGARITIC", USCRIPT_UGARITIC); INSTALL_ENUM(UScriptCode, "KATAKANA_OR_HIRAGANA", USCRIPT_KATAKANA_OR_HIRAGANA); INSTALL_ENUM(UScriptCode, "BUGINESE", USCRIPT_BUGINESE); INSTALL_ENUM(UScriptCode, "GLAGOLITIC", USCRIPT_GLAGOLITIC); INSTALL_ENUM(UScriptCode, "KHAROSHTHI", USCRIPT_KHAROSHTHI); INSTALL_ENUM(UScriptCode, "SYLOTI_NAGRI", USCRIPT_SYLOTI_NAGRI); INSTALL_ENUM(UScriptCode, "NEW_TAI_LUE", USCRIPT_NEW_TAI_LUE); INSTALL_ENUM(UScriptCode, "TIFINAGH", USCRIPT_TIFINAGH); INSTALL_ENUM(UScriptCode, "OLD_PERSIAN", USCRIPT_OLD_PERSIAN); INSTALL_ENUM(UScriptCode, "BALINESE", USCRIPT_BALINESE); INSTALL_ENUM(UScriptCode, "BATAK", USCRIPT_BATAK); INSTALL_ENUM(UScriptCode, "BLISSYMBOLS", USCRIPT_BLISSYMBOLS); INSTALL_ENUM(UScriptCode, "BRAHMI", USCRIPT_BRAHMI); INSTALL_ENUM(UScriptCode, "CHAM", USCRIPT_CHAM); INSTALL_ENUM(UScriptCode, "CIRTH", USCRIPT_CIRTH); INSTALL_ENUM(UScriptCode, "OLD_CHURCH_SLAVONIC_CYRILLIC", USCRIPT_OLD_CHURCH_SLAVONIC_CYRILLIC); INSTALL_ENUM(UScriptCode, "DEMOTIC_EGYPTIAN", USCRIPT_DEMOTIC_EGYPTIAN); INSTALL_ENUM(UScriptCode, "HIERATIC_EGYPTIAN", USCRIPT_HIERATIC_EGYPTIAN); INSTALL_ENUM(UScriptCode, "EGYPTIAN_HIEROGLYPHS", USCRIPT_EGYPTIAN_HIEROGLYPHS); INSTALL_ENUM(UScriptCode, "KHUTSURI", USCRIPT_KHUTSURI); INSTALL_ENUM(UScriptCode, "SIMPLIFIED_HAN", USCRIPT_SIMPLIFIED_HAN); INSTALL_ENUM(UScriptCode, "TRADITIONAL_HAN", USCRIPT_TRADITIONAL_HAN); INSTALL_ENUM(UScriptCode, "PAHAWH_HMONG", USCRIPT_PAHAWH_HMONG); INSTALL_ENUM(UScriptCode, "OLD_HUNGARIAN", USCRIPT_OLD_HUNGARIAN); INSTALL_ENUM(UScriptCode, "HARAPPAN_INDUS", USCRIPT_HARAPPAN_INDUS); INSTALL_ENUM(UScriptCode, "JAVANESE", USCRIPT_JAVANESE); INSTALL_ENUM(UScriptCode, "KAYAH_LI", USCRIPT_KAYAH_LI); INSTALL_ENUM(UScriptCode, "LATIN_FRAKTUR", USCRIPT_LATIN_FRAKTUR); INSTALL_ENUM(UScriptCode, "LATIN_GAELIC", USCRIPT_LATIN_GAELIC); INSTALL_ENUM(UScriptCode, "LEPCHA", USCRIPT_LEPCHA); INSTALL_ENUM(UScriptCode, "LINEAR_A", USCRIPT_LINEAR_A); INSTALL_ENUM(UScriptCode, "MANDAEAN", USCRIPT_MANDAEAN); INSTALL_ENUM(UScriptCode, "MEROITIC", USCRIPT_MEROITIC); INSTALL_ENUM(UScriptCode, "ORKHON", USCRIPT_ORKHON); INSTALL_ENUM(UScriptCode, "OLD_PERMIC", USCRIPT_OLD_PERMIC); INSTALL_ENUM(UScriptCode, "PHAGS_PA", USCRIPT_PHAGS_PA); INSTALL_ENUM(UScriptCode, "PHOENICIAN", USCRIPT_PHOENICIAN); INSTALL_ENUM(UScriptCode, "PHONETIC_POLLARD", USCRIPT_PHONETIC_POLLARD); INSTALL_ENUM(UScriptCode, "RONGORONGO", USCRIPT_RONGORONGO); INSTALL_ENUM(UScriptCode, "SARATI", USCRIPT_SARATI); INSTALL_ENUM(UScriptCode, "ESTRANGELO_SYRIAC", USCRIPT_ESTRANGELO_SYRIAC); INSTALL_ENUM(UScriptCode, "WESTERN_SYRIAC", USCRIPT_WESTERN_SYRIAC); INSTALL_ENUM(UScriptCode, "EASTERN_SYRIAC", USCRIPT_EASTERN_SYRIAC); INSTALL_ENUM(UScriptCode, "TENGWAR", USCRIPT_TENGWAR); INSTALL_ENUM(UScriptCode, "VAI", USCRIPT_VAI); INSTALL_ENUM(UScriptCode, "VISIBLE_SPEECH", USCRIPT_VISIBLE_SPEECH); INSTALL_ENUM(UScriptCode, "CUNEIFORM", USCRIPT_CUNEIFORM); INSTALL_ENUM(UScriptCode, "UNWRITTEN_LANGUAGES", USCRIPT_UNWRITTEN_LANGUAGES); INSTALL_ENUM(UScriptCode, "UNKNOWN", USCRIPT_UNKNOWN); INSTALL_ENUM(UScriptCode, "CARIAN", USCRIPT_CARIAN); INSTALL_ENUM(UScriptCode, "JAPANESE", USCRIPT_JAPANESE); INSTALL_ENUM(UScriptCode, "LANNA", USCRIPT_LANNA); INSTALL_ENUM(UScriptCode, "LYCIAN", USCRIPT_LYCIAN); INSTALL_ENUM(UScriptCode, "LYDIAN", USCRIPT_LYDIAN); INSTALL_ENUM(UScriptCode, "OL_CHIKI", USCRIPT_OL_CHIKI); INSTALL_ENUM(UScriptCode, "REJANG", USCRIPT_REJANG); INSTALL_ENUM(UScriptCode, "SAURASHTRA", USCRIPT_SAURASHTRA); INSTALL_ENUM(UScriptCode, "SIGN_WRITING", USCRIPT_SIGN_WRITING); INSTALL_ENUM(UScriptCode, "SUNDANESE", USCRIPT_SUNDANESE); INSTALL_ENUM(UScriptCode, "MOON", USCRIPT_MOON); INSTALL_ENUM(UScriptCode, "MEITEI_MAYEK", USCRIPT_MEITEI_MAYEK); #if U_ICU_VERSION_HEX >= 0x04000000 INSTALL_ENUM(UScriptCode, "IMPERIAL_ARAMAIC", USCRIPT_IMPERIAL_ARAMAIC); INSTALL_ENUM(UScriptCode, "AVESTAN", USCRIPT_AVESTAN); INSTALL_ENUM(UScriptCode, "CHAKMA", USCRIPT_CHAKMA); INSTALL_ENUM(UScriptCode, "KOREAN", USCRIPT_KOREAN); INSTALL_ENUM(UScriptCode, "KAITHI", USCRIPT_KAITHI); INSTALL_ENUM(UScriptCode, "MANICHAEAN", USCRIPT_MANICHAEAN); INSTALL_ENUM(UScriptCode, "INSCRIPTIONAL_PAHLAVI", USCRIPT_INSCRIPTIONAL_PAHLAVI); INSTALL_ENUM(UScriptCode, "PSALTER_PAHLAVI", USCRIPT_PSALTER_PAHLAVI); INSTALL_ENUM(UScriptCode, "BOOK_PAHLAVI", USCRIPT_BOOK_PAHLAVI); INSTALL_ENUM(UScriptCode, "INSCRIPTIONAL_PARTHIAN", USCRIPT_INSCRIPTIONAL_PARTHIAN); INSTALL_ENUM(UScriptCode, "SAMARITAN", USCRIPT_SAMARITAN); INSTALL_ENUM(UScriptCode, "TAI_VIET", USCRIPT_TAI_VIET); INSTALL_ENUM(UScriptCode, "MATHEMATICAL_NOTATION", USCRIPT_MATHEMATICAL_NOTATION); INSTALL_ENUM(UScriptCode, "SYMBOLS", USCRIPT_SYMBOLS); #endif #if U_ICU_VERSION_HEX >= 0x04040000 INSTALL_ENUM(UScriptCode, "BAMUM", USCRIPT_BAMUM); INSTALL_ENUM(UScriptCode, "LISU", USCRIPT_LISU); INSTALL_ENUM(UScriptCode, "NAKHI_GEBA", USCRIPT_NAKHI_GEBA); INSTALL_ENUM(UScriptCode, "OLD_SOUTH_ARABIAN", USCRIPT_OLD_SOUTH_ARABIAN); #endif #if U_ICU_VERSION_HEX >= 0x04060000 INSTALL_ENUM(UScriptCode, "BASSA_VAH", USCRIPT_BASSA_VAH); INSTALL_ENUM(UScriptCode, "DUPLOYAN_SHORTAND", USCRIPT_DUPLOYAN_SHORTAND); INSTALL_ENUM(UScriptCode, "ELBASAN", USCRIPT_ELBASAN); INSTALL_ENUM(UScriptCode, "GRANTHA", USCRIPT_GRANTHA); INSTALL_ENUM(UScriptCode, "KPELLE", USCRIPT_KPELLE); INSTALL_ENUM(UScriptCode, "LOMA", USCRIPT_LOMA); INSTALL_ENUM(UScriptCode, "MANDAIC", USCRIPT_MANDAIC); INSTALL_ENUM(UScriptCode, "MENDE", USCRIPT_MENDE); INSTALL_ENUM(UScriptCode, "MEROITIC_CURSIVE", USCRIPT_MEROITIC_CURSIVE); INSTALL_ENUM(UScriptCode, "MEROITIC_HIEROGLYPHS", USCRIPT_MEROITIC_HIEROGLYPHS); INSTALL_ENUM(UScriptCode, "OLD_NORTH_ARABIAN", USCRIPT_OLD_NORTH_ARABIAN); INSTALL_ENUM(UScriptCode, "NABATAEAN", USCRIPT_NABATAEAN); INSTALL_ENUM(UScriptCode, "PALMYRENE", USCRIPT_PALMYRENE); INSTALL_ENUM(UScriptCode, "SINDHI", USCRIPT_SINDHI); INSTALL_ENUM(UScriptCode, "WARANG_CITI", USCRIPT_WARANG_CITI); #endif #if U_ICU_VERSION_HEX >= 0x04080000 INSTALL_ENUM(UScriptCode, "AFAKA", USCRIPT_AFAKA); INSTALL_ENUM(UScriptCode, "JURCHEN", USCRIPT_JURCHEN); INSTALL_ENUM(UScriptCode, "MRO", USCRIPT_MRO); INSTALL_ENUM(UScriptCode, "NUSHU", USCRIPT_NUSHU); INSTALL_ENUM(UScriptCode, "SHARADA", USCRIPT_SHARADA); INSTALL_ENUM(UScriptCode, "SORA_SOMPENG", USCRIPT_SORA_SOMPENG); INSTALL_ENUM(UScriptCode, "TAKRI", USCRIPT_TAKRI); INSTALL_ENUM(UScriptCode, "TANGUT", USCRIPT_TANGUT); INSTALL_ENUM(UScriptCode, "WOLEAI", USCRIPT_WOLEAI); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(49, 0, 0) INSTALL_ENUM(UScriptCode, "ANATOLIAN_HIEROGLYPHS", USCRIPT_ANATOLIAN_HIEROGLYPHS); INSTALL_ENUM(UScriptCode, "KHOJKI", USCRIPT_KHOJKI); INSTALL_ENUM(UScriptCode, "TIRHUTA", USCRIPT_TIRHUTA); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(51, 0, 0) INSTALL_ENUM(UScriptUsage, "NOT_ENCODED", USCRIPT_USAGE_NOT_ENCODED); INSTALL_ENUM(UScriptUsage, "UNKNOWN", USCRIPT_USAGE_UNKNOWN); INSTALL_ENUM(UScriptUsage, "EXCLUDED", USCRIPT_USAGE_EXCLUDED); INSTALL_ENUM(UScriptUsage, "LIMITED_USE", USCRIPT_USAGE_LIMITED_USE); INSTALL_ENUM(UScriptUsage, "ASPIRATIONAL", USCRIPT_USAGE_ASPIRATIONAL); INSTALL_ENUM(UScriptUsage, "RECOMMENDED", USCRIPT_USAGE_RECOMMENDED); #endif } PyICU-1.9.5/script.h0000644000076500000000000000254712115721545014352 0ustar vajdawheel00000000000000/* ==================================================================== * Copyright (c) 2004-2013 Open Source Applications Foundation. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. * ==================================================================== */ #ifndef _script_h #define _script_h void _init_script(PyObject *m); #endif /* _script_h */ PyICU-1.9.5/search.cpp0000644000076500000000000004744412520066546014656 0ustar vajdawheel00000000000000/* ==================================================================== * Copyright (c) 2004-2010 Open Source Applications Foundation. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. * ==================================================================== */ #include "common.h" #include "structmember.h" #include "bases.h" #include "locale.h" #include "collator.h" #include "iterators.h" #include "search.h" #include "macros.h" DECLARE_CONSTANTS_TYPE(USearchAttribute); DECLARE_CONSTANTS_TYPE(USearchAttributeValue); /* SearchIterator */ class t_searchiterator : public _wrapper { public: SearchIterator *object; PyObject *text; PyObject *iterator; }; static PyObject *t_searchiterator_getOffset(t_searchiterator *self); static PyObject *t_searchiterator_setOffset(t_searchiterator *self, PyObject *arg); static PyObject *t_searchiterator_getAttribute(t_searchiterator *self, PyObject *arg); static PyObject *t_searchiterator_setAttribute(t_searchiterator *self, PyObject *args); static PyObject *t_searchiterator_getMatchedStart(t_searchiterator *self); static PyObject *t_searchiterator_getMatchedLength(t_searchiterator *self); static PyObject *t_searchiterator_getMatchedText(t_searchiterator *self, PyObject *args); static PyObject *t_searchiterator_getBreakIterator(t_searchiterator *self); static PyObject *t_searchiterator_setBreakIterator(t_searchiterator *self, PyObject *arg); static PyObject *t_searchiterator_getText(t_searchiterator *self, PyObject *args); static PyObject *t_searchiterator_setText(t_searchiterator *self, PyObject *arg); static PyObject *t_searchiterator_first(t_searchiterator *self); static PyObject *t_searchiterator_last(t_searchiterator *self); static PyObject *t_searchiterator_nextMatch(t_searchiterator *self); static PyObject *t_searchiterator_following(t_searchiterator *self, PyObject *arg); static PyObject *t_searchiterator_preceding(t_searchiterator *self, PyObject *arg); static PyObject *t_searchiterator_reset(t_searchiterator *self); static PyMethodDef t_searchiterator_methods[] = { DECLARE_METHOD(t_searchiterator, getOffset, METH_NOARGS), DECLARE_METHOD(t_searchiterator, setOffset, METH_O), DECLARE_METHOD(t_searchiterator, getAttribute, METH_O), DECLARE_METHOD(t_searchiterator, setAttribute, METH_VARARGS), DECLARE_METHOD(t_searchiterator, getMatchedStart, METH_NOARGS), DECLARE_METHOD(t_searchiterator, getMatchedLength, METH_NOARGS), DECLARE_METHOD(t_searchiterator, getMatchedText, METH_VARARGS), DECLARE_METHOD(t_searchiterator, getBreakIterator, METH_NOARGS), DECLARE_METHOD(t_searchiterator, setBreakIterator, METH_O), DECLARE_METHOD(t_searchiterator, getText, METH_VARARGS), DECLARE_METHOD(t_searchiterator, setText, METH_O), DECLARE_METHOD(t_searchiterator, first, METH_NOARGS), DECLARE_METHOD(t_searchiterator, last, METH_NOARGS), DECLARE_METHOD(t_searchiterator, nextMatch, METH_NOARGS), DECLARE_METHOD(t_searchiterator, following, METH_O), DECLARE_METHOD(t_searchiterator, preceding, METH_O), DECLARE_METHOD(t_searchiterator, reset, METH_NOARGS), { NULL, NULL, 0, NULL } }; static void t_searchiterator_dealloc(t_searchiterator *self) { if (self->flags & T_OWNED) delete self->object; self->object = NULL; Py_CLEAR(self->text); Py_CLEAR(self->iterator); Py_TYPE(self)->tp_free((PyObject *) self); } DECLARE_TYPE(SearchIterator, t_searchiterator, UObject, SearchIterator, abstract_init, t_searchiterator_dealloc); /* StringSearch */ class t_stringsearch : public _wrapper { public: StringSearch *object; PyObject *text; PyObject *iterator; PyObject *collator; }; static int t_stringsearch_init(t_stringsearch *self, PyObject *args, PyObject *kwds); static PyObject *t_stringsearch_getCollator(t_stringsearch *self); static PyObject *t_stringsearch_setCollator(t_stringsearch *self, PyObject *arg); static PyObject *t_stringsearch_getPattern(t_stringsearch *self, PyObject *args); static PyObject *t_stringsearch_setPattern(t_stringsearch *self, PyObject *arg); static PyMethodDef t_stringsearch_methods[] = { DECLARE_METHOD(t_stringsearch, getCollator, METH_NOARGS), DECLARE_METHOD(t_stringsearch, setCollator, METH_O), DECLARE_METHOD(t_stringsearch, getPattern, METH_NOARGS), DECLARE_METHOD(t_stringsearch, setPattern, METH_VARARGS), { NULL, NULL, 0, NULL } }; static void t_stringsearch_dealloc(t_stringsearch *self) { if (self->flags & T_OWNED) delete self->object; self->object = NULL; Py_CLEAR(self->text); Py_CLEAR(self->iterator); Py_CLEAR(self->collator); Py_TYPE(self)->tp_free((PyObject *) self); } DECLARE_TYPE(StringSearch, t_stringsearch, SearchIterator, StringSearch, t_stringsearch_init, t_stringsearch_dealloc); /* SearchIterator */ static PyObject *t_searchiterator_getOffset(t_searchiterator *self) { int32_t offset = self->object->getOffset(); return PyInt_FromLong(offset); } static PyObject *t_searchiterator_setOffset(t_searchiterator *self, PyObject *arg) { int32_t offset; if (!parseArg(arg, "i", &offset)) { STATUS_CALL(self->object->setOffset(offset, status)); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setOffset", arg); } static PyObject *t_searchiterator_getAttribute(t_searchiterator *self, PyObject *arg) { USearchAttribute attribute; if (!parseArg(arg, "i", &attribute)) { USearchAttributeValue value = self->object->getAttribute(attribute); return PyInt_FromLong(value); } return PyErr_SetArgsError((PyObject *) self, "getAttribute", arg); } static PyObject *t_searchiterator_setAttribute(t_searchiterator *self, PyObject *args) { USearchAttribute attribute; USearchAttributeValue value; if (!parseArgs(args, "ii", &attribute, &value)) { STATUS_CALL(self->object->setAttribute(attribute, value, status)); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setAttribute", args); } static PyObject *t_searchiterator_getMatchedStart(t_searchiterator *self) { int32_t start = self->object->getMatchedStart(); return PyInt_FromLong(start); } static PyObject *t_searchiterator_getMatchedLength(t_searchiterator *self) { int32_t length = self->object->getMatchedLength(); return PyInt_FromLong(length); } static PyObject *t_searchiterator_getMatchedText(t_searchiterator *self, PyObject *args) { UnicodeString *u, _u; switch (PyTuple_Size(args)) { case 0: self->object->getMatchedText(_u); return PyUnicode_FromUnicodeString(&_u); case 1: if (!parseArgs(args, "U", &u)) { self->object->getMatchedText(*u); Py_RETURN_ARG(args, 0); } break; } return PyErr_SetArgsError((PyObject *) self, "getMatchedText", args); } static PyObject *t_searchiterator_getBreakIterator(t_searchiterator *self) { if (self->iterator) { Py_INCREF(self->iterator); return self->iterator; } Py_RETURN_NONE; } static PyObject *t_searchiterator_setBreakIterator(t_searchiterator *self, PyObject *arg) { BreakIterator *iterator; if (arg == Py_None) { STATUS_CALL(self->object->setBreakIterator(NULL, status)); Py_XDECREF(self->iterator); self->iterator = NULL; Py_RETURN_NONE; } if (!parseArg(arg, "p", TYPE_ID(BreakIterator), &iterator, &self->iterator)) { /* ref'd */ STATUS_CALL(self->object->setBreakIterator(iterator, status)); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setBreakIterator", arg); } static PyObject *t_searchiterator_getText(t_searchiterator *self, PyObject *args) { switch (PyTuple_Size(args)) { case 0: { UnicodeString u = self->object->getText(); return PyUnicode_FromUnicodeString(&u); } case 1: { UnicodeString *u; if (!parseArgs(args, "U", &u)) { u->setTo(self->object->getText()); Py_RETURN_ARG(args, 0); } break; } } return PyErr_SetArgsError((PyObject *) self, "getText", args); } static PyObject *t_searchiterator_setText(t_searchiterator *self, PyObject *arg) { UnicodeString *u; CharacterIterator *chars; if (!parseArg(arg, "W", &u, &self->text)) { STATUS_CALL(self->object->setText(*u, status)); /* ref'd */ Py_RETURN_NONE; } else if (!parseArg(arg, "P", TYPE_ID(CharacterIterator), &chars)) { STATUS_CALL(self->object->setText(*chars, status)); /* copied */ Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setText", arg); } static PyObject *t_searchiterator_first(t_searchiterator *self) { int32_t first; STATUS_CALL(first = self->object->first(status)); return PyInt_FromLong(first); } static PyObject *t_searchiterator_last(t_searchiterator *self) { int32_t last; STATUS_CALL(last = self->object->last(status)); return PyInt_FromLong(last); } static PyObject *t_searchiterator_nextMatch(t_searchiterator *self) { int32_t next; STATUS_CALL(next = self->object->next(status)); return PyInt_FromLong(next); } static PyObject *t_searchiterator_following(t_searchiterator *self, PyObject *arg) { int32_t position, following; if (!parseArg(arg, "i", &position)) { STATUS_CALL(following = self->object->following(position, status)); return PyInt_FromLong(following); } return PyErr_SetArgsError((PyObject *) self, "following", arg); } static PyObject *t_searchiterator_preceding(t_searchiterator *self, PyObject *arg) { int32_t position, preceding; if (!parseArg(arg, "i", &position)) { STATUS_CALL(preceding = self->object->preceding(position, status)); return PyInt_FromLong(preceding); } return PyErr_SetArgsError((PyObject *) self, "preceding", arg); } static PyObject *t_searchiterator_reset(t_searchiterator *self) { self->object->reset(); Py_RETURN_NONE; } static PyObject *t_searchiterator_iter(t_searchiterator *self) { Py_RETURN_SELF(); } static PyObject *t_searchiterator_iter_next(t_searchiterator *self) { int32_t offset; STATUS_CALL(offset = self->object->next(status)); if (offset == USEARCH_DONE) { PyErr_SetNone(PyExc_StopIteration); return NULL; } return PyInt_FromLong(offset); } /* StringSearch */ static int t_stringsearch_init(t_stringsearch *self, PyObject *args, PyObject *kwds) { UnicodeString *u0, _u0; UnicodeString *u1; Locale *locale; BreakIterator *iterator; RuleBasedCollator *collator; CharacterIterator *chars; switch (PyTuple_Size(args)) { case 3: if (!parseArgs(args, "SWP", TYPE_CLASSID(Locale), &u0, &_u0, &u1, &self->text, &locale)) { INT_STATUS_CALL(self->object = new StringSearch(*u0, *u1, *locale, NULL, status)); self->flags = T_OWNED; break; } if (!parseArgs(args, "SWp", TYPE_CLASSID(RuleBasedCollator), &u0, &_u0, &u1, &self->text, &collator, &self->collator)) { INT_STATUS_CALL(self->object = new StringSearch(*u0, *u1, collator, NULL, status)); self->flags = T_OWNED; break; } if (!parseArgs(args, "SpP", TYPE_ID(CharacterIterator), TYPE_CLASSID(Locale), &u0, &_u0, &chars, &self->text, &locale)) { INT_STATUS_CALL(self->object = new StringSearch(*u0, *chars, *locale, NULL, status)); self->flags = T_OWNED; break; } if (!parseArgs(args, "Spp", TYPE_ID(CharacterIterator), TYPE_CLASSID(RuleBasedCollator), &u0, &_u0, &chars, &self->text, &collator, &self->collator)) { INT_STATUS_CALL(self->object = new StringSearch(*u0, *chars, collator, NULL, status)); self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; case 4: if (!parseArgs(args, "SWPp", TYPE_CLASSID(Locale), TYPE_ID(BreakIterator), &u0, &_u0, &u1, &self->text, &locale, &iterator, &self->iterator)) { INT_STATUS_CALL(self->object = new StringSearch(*u0, *u1, *locale, iterator, status)); self->flags = T_OWNED; break; } if (!parseArgs(args, "SWpp", TYPE_CLASSID(RuleBasedCollator), TYPE_ID(BreakIterator), &u0, &_u0, &u1, &self->text, &collator, &self->collator, &iterator, &self->iterator)) { INT_STATUS_CALL(self->object = new StringSearch(*u0, *u1, collator, NULL, status)); self->flags = T_OWNED; break; } if (!parseArgs(args, "SpPp", TYPE_ID(CharacterIterator), TYPE_CLASSID(Locale), TYPE_ID(BreakIterator), &u0, &_u0, &chars, &self->text, &locale, &iterator, &self->iterator)) { INT_STATUS_CALL(self->object = new StringSearch(*u0, *chars, *locale, iterator, status)); self->flags = T_OWNED; break; } if (!parseArgs(args, "Sppp", TYPE_ID(CharacterIterator), TYPE_CLASSID(RuleBasedCollator), TYPE_ID(BreakIterator), &u0, &_u0, &chars, &self->text, &collator, &self->collator, &iterator, &self->iterator)) { INT_STATUS_CALL(self->object = new StringSearch(*u0, *chars, collator, iterator, status)); self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; default: PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; } if (self->object) return 0; return -1; } static PyObject *t_stringsearch_getCollator(t_stringsearch *self) { if (self->collator) { Py_INCREF(self->collator); return self->collator; } return wrap_RuleBasedCollator(self->object->getCollator(), 0); } static PyObject *t_stringsearch_setCollator(t_stringsearch *self, PyObject *arg) { RuleBasedCollator *collator; if (!parseArg(arg, "p", TYPE_CLASSID(RuleBasedCollator), &collator, &self->collator)) { STATUS_CALL(self->object->setCollator(collator, status)); /* ref'd */ Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setCollator", arg); } static PyObject *t_stringsearch_getPattern(t_stringsearch *self, PyObject *args) { switch (PyTuple_Size(args)) { case 0: { UnicodeString u = self->object->getPattern(); return PyUnicode_FromUnicodeString(&u); } case 1: { UnicodeString *u; if (!parseArgs(args, "U", &u)) { *u = self->object->getPattern(); Py_RETURN_ARG(args, 0); } break; } } return PyErr_SetArgsError((PyObject *) self, "getPattern", args); } static PyObject *t_stringsearch_setPattern(t_stringsearch *self, PyObject *arg) { UnicodeString *u, _u; if (!parseArg(arg, "S", &u, &_u)) { STATUS_CALL(self->object->setPattern(*u, status)); /* copied */ Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setPattern", arg); } static PyObject *t_stringsearch_str(t_stringsearch *self) { UnicodeString u = self->object->getPattern(); return PyUnicode_FromUnicodeString(&u); } DEFINE_RICHCMP(StringSearch, t_stringsearch); void _init_search(PyObject *m) { SearchIteratorType_.tp_iter = (getiterfunc) t_searchiterator_iter; SearchIteratorType_.tp_iternext = (iternextfunc) t_searchiterator_iter_next; StringSearchType_.tp_str = (reprfunc) t_stringsearch_str; StringSearchType_.tp_richcompare = (richcmpfunc) t_stringsearch_richcmp; INSTALL_CONSTANTS_TYPE(USearchAttribute, m); INSTALL_CONSTANTS_TYPE(USearchAttributeValue, m); INSTALL_TYPE(SearchIterator, m); REGISTER_TYPE(StringSearch, m); INSTALL_ENUM(USearchAttribute, "OVERLAP", USEARCH_OVERLAP); INSTALL_ENUM(USearchAttribute, "CANONICAL_MATCH", USEARCH_CANONICAL_MATCH); #if U_ICU_VERSION_HEX >= 0x04040000 INSTALL_ENUM(USearchAttribute, "ELEMENT_COMPARISON", USEARCH_ELEMENT_COMPARISON); #endif INSTALL_ENUM(USearchAttributeValue, "DEFAULT", USEARCH_DEFAULT); INSTALL_ENUM(USearchAttributeValue, "OFF", USEARCH_OFF); INSTALL_ENUM(USearchAttributeValue, "ON", USEARCH_ON); #if U_ICU_VERSION_HEX >= 0x04040000 INSTALL_ENUM(USearchAttributeValue, "STANDARD_ELEMENT_COMPARISON", USEARCH_STANDARD_ELEMENT_COMPARISON); INSTALL_ENUM(USearchAttributeValue, "PATTERN_BASE_WEIGHT_IS_WILDCARD", USEARCH_PATTERN_BASE_WEIGHT_IS_WILDCARD); INSTALL_ENUM(USearchAttributeValue, "ANY_BASE_WEIGHT_IS_WILDCARD", USEARCH_ANY_BASE_WEIGHT_IS_WILDCARD); #endif INSTALL_ENUM(SearchIterator, "DONE", USEARCH_DONE); } PyICU-1.9.5/search.h0000644000076500000000000000255011353503672014307 0ustar vajdawheel00000000000000/* ==================================================================== * Copyright (c) 2004-2010 Open Source Applications Foundation. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. * ==================================================================== */ #ifndef _search_h #define _search_h void _init_search(PyObject *m); #endif /* _search_h */ PyICU-1.9.5/setup.cfg0000644000076500000000000000007313011413477014504 0ustar vajdawheel00000000000000[egg_info] tag_build = tag_date = 0 tag_svn_revision = 0 PyICU-1.9.5/setup.py0000644000076500000000000001040113011412421014355 0ustar vajdawheel00000000000000 import os, sys, subprocess try: from setuptools import setup, Extension except ImportError: from distutils.core import setup, Extension VERSION = '1.9.5' ICU_VERSION = subprocess.check_output(('icu-config', '--version')).strip() INCLUDES = { 'darwin': ['/usr/local/include'], 'linux': [], 'freebsd': ['/usr/local/include'], 'win32': ['c:/icu/include'], 'sunos5': [], } CFLAGS = { 'darwin': ['-DPYICU_VER="%s"' %(VERSION)], 'linux': ['-DPYICU_VER="%s"' %(VERSION)], 'freebsd': ['-DPYICU_VER="%s"' %(VERSION)], 'win32': ['/Zc:wchar_t', '/EHsc', '/DPYICU_VER=\\"%s\\"' %(VERSION)], 'sunos5': ['-DPYICU_VER="%s"' %(VERSION)], } # added to CFLAGS when setup is invoked with --debug DEBUG_CFLAGS = { 'darwin': ['-O0', '-g', '-DDEBUG'], 'linux': ['-O0', '-g', '-DDEBUG'], 'freebsd': ['-O0', '-g', '-DDEBUG'], 'win32': ['/Od', '/DDEBUG'], 'sunos5': ['-DDEBUG'], } LFLAGS = { 'darwin': ['-L/usr/local/lib'], 'linux': [], 'freebsd': ['-L/usr/local/lib'], 'win32': ['/LIBPATH:c:/icu/lib'], 'sunos5': [], } LIBRARIES = { 'darwin': ['icui18n', 'icuuc', 'icudata'], 'linux': ['icui18n', 'icuuc', 'icudata'], 'freebsd': ['icui18n', 'icuuc', 'icudata'], 'win32': ['icuin', 'icuuc', 'icudt'], 'sunos5': ['icui18n', 'icuuc', 'icudata'], } platform = sys.platform if platform.startswith(('linux', 'gnu')): platform = 'linux' elif platform.startswith('freebsd'): platform = 'freebsd' if 'PYICU_INCLUDES' in os.environ: _includes = os.environ['PYICU_INCLUDES'].split(os.pathsep) else: _includes = INCLUDES[platform] if 'PYICU_CFLAGS' in os.environ: _cflags = os.environ['PYICU_CFLAGS'].split(os.pathsep) else: _cflags = CFLAGS[platform] if '--debug' in sys.argv: if 'PYICU_DEBUG_CFLAGS' in os.environ: _cflags += os.environ['PYICU_DEBUG_CFLAGS'].split(os.pathsep) else: _cflags += DEBUG_CFLAGS[platform] if 'PYICU_LFLAGS' in os.environ: _lflags = os.environ['PYICU_LFLAGS'].split(os.pathsep) else: _lflags = LFLAGS[platform] if 'PYICU_LIBRARIES' in os.environ: _libraries = os.environ['PYICU_LIBRARIES'].split(os.pathsep) elif ((sys.version_info >= (3,) and str(ICU_VERSION, 'ascii') < '58') or (sys.version_info < (3,) and ICU_VERSION < '58')): _libraries = LIBRARIES[platform][:] + ['icule'] else: _libraries = LIBRARIES[platform] if sys.version_info < (2, 4): def sorted(iterable, *args, **kwargs): iterable = list(iterable) iterable.sort(*args, **kwargs) return iterable setup(name="PyICU", description='Python extension wrapping the ICU C++ API', long_description=open('README.md').read(), version=VERSION, test_suite="test", url='https://github.com/ovalhub/pyicu', author='Andi Vajda', author_email='github@ovaltofu.org', classifiers=[ 'Development Status :: 5 - Production/Stable', 'Environment :: Console', 'Intended Audience :: Developers', 'License :: OSI Approved', 'Operating System :: OS Independent', 'Programming Language :: C++', 'Programming Language :: Python', 'Programming Language :: Python :: 2', 'Programming Language :: Python :: 3', 'Programming Language :: Python :: Implementation :: CPython', 'Programming Language :: Python :: Implementation :: PyPy', 'Topic :: Software Development :: Localization', 'Topic :: Software Development :: Internationalization'], ext_modules=[Extension('_icu', [filename for filename in sorted(os.listdir(os.curdir)) if filename.endswith('.cpp')], include_dirs=_includes, extra_compile_args=_cflags, extra_link_args=_lflags, libraries=_libraries)], py_modules=['icu', 'PyICU', 'docs']) if sys.version_info >= (3,): path = os.path.join('test', '2to3.note') if not os.path.exists(path): from lib2to3.main import main main("lib2to3.fixes", ['-w', '-n', '--no-diffs', 'test']) output = open(path, 'w') output.write('tests auto-converted by 2to3 during setup\n') output.close() PyICU-1.9.5/shape.cpp0000644000076500000000000001662012656222100014467 0ustar vajdawheel00000000000000/* ==================================================================== * Copyright (c) 2004-2015 Open Source Applications Foundation. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. * ==================================================================== */ #include #include #include "common.h" #include "structmember.h" #include "bases.h" #include "shape.h" #include "macros.h" /* Shape */ struct UNone; typedef struct UNone UNone; class t_shape : public _wrapper { public: UNone *object; }; static int t_shape_init(t_shape *self, PyObject *args, PyObject *kwds); static PyObject *t_shape_shapeArabic(PyTypeObject *type, PyObject *args); static PyMethodDef t_shape_methods[] = { DECLARE_METHOD(t_shape, shapeArabic, METH_VARARGS | METH_CLASS), { NULL, NULL, 0, NULL } }; static void t_shape_dealloc(t_shape *self) { Py_TYPE(self)->tp_free((PyObject *) self); } DECLARE_STRUCT(Shape, t_shape, UNone, t_shape_init, t_shape_dealloc); /* Shape */ static int t_shape_init(t_shape *self, PyObject *args, PyObject *kwds) { switch (PyTuple_Size(args)) { case 0: self->object = NULL; /* there is no ICU struct for this */ self->flags = T_OWNED; return 0; default: PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; } } static PyObject *t_shape_shapeArabic(PyTypeObject *type, PyObject *args) { UnicodeString *u, _u; uint32_t options = 0; switch (PyTuple_Size(args)) { case 2: if (!parseArgs(args, "Si", &u, &_u, &options)) { const size_t len = u->length(); const size_t capacity = len * 4 + 32; UErrorCode status = U_ZERO_ERROR; UChar *dest = new UChar[capacity]; PyObject *result; size_t size; if (!dest) { PyErr_SetNone(PyExc_MemoryError); return NULL; } size = u_shapeArabic(u->getBuffer(), len, dest, capacity, options, &status); if (U_FAILURE(status)) { delete[] dest; return ICUException(status).reportError(); } result = PyUnicode_FromUnicodeString(dest, size); delete[] dest; return result; } break; } return PyErr_SetArgsError((PyObject *) type, "shapeArabic", args); } void _init_shape(PyObject *m) { INSTALL_STRUCT(Shape, m); INSTALL_ENUM(Shape, "LENGTH_GROW_SHRINK", U_SHAPE_LENGTH_GROW_SHRINK); INSTALL_ENUM(Shape, "LAMALEF_RESIZE", U_SHAPE_LAMALEF_RESIZE); INSTALL_ENUM(Shape, "LENGTH_FIXED_SPACES_NEAR", U_SHAPE_LENGTH_FIXED_SPACES_NEAR); INSTALL_ENUM(Shape, "LAMALEF_NEAR", U_SHAPE_LAMALEF_NEAR); INSTALL_ENUM(Shape, "LENGTH_FIXED_SPACES_AT_END", U_SHAPE_LENGTH_FIXED_SPACES_AT_END); INSTALL_ENUM(Shape, "LAMALEF_END", U_SHAPE_LAMALEF_END); INSTALL_ENUM(Shape, "LENGTH_FIXED_SPACES_AT_BEGINNING", U_SHAPE_LENGTH_FIXED_SPACES_AT_BEGINNING); INSTALL_ENUM(Shape, "TEXT_DIRECTION_LOGICAL", U_SHAPE_TEXT_DIRECTION_LOGICAL); INSTALL_ENUM(Shape, "TEXT_DIRECTION_MASK", U_SHAPE_TEXT_DIRECTION_MASK); INSTALL_ENUM(Shape, "TEXT_DIRECTION_VISUAL_LTR", U_SHAPE_TEXT_DIRECTION_VISUAL_LTR); #if U_ICU_VERSION_HEX >= 0x04020000 INSTALL_ENUM(Shape, "LAMALEF_BEGIN", U_SHAPE_LAMALEF_BEGIN); INSTALL_ENUM(Shape, "LAMALEF_AUTO", U_SHAPE_LAMALEF_AUTO); INSTALL_ENUM(Shape, "LENGTH_MASK", U_SHAPE_LENGTH_MASK); INSTALL_ENUM(Shape, "LAMALEF_MASK", U_SHAPE_LAMALEF_MASK); INSTALL_ENUM(Shape, "LAMALEF_NEAR", U_SHAPE_LAMALEF_NEAR); INSTALL_ENUM(Shape, "LAMALEF_RESIZE", U_SHAPE_LAMALEF_RESIZE); INSTALL_ENUM(Shape, "TEXT_DIRECTION_VISUAL_RTL", U_SHAPE_TEXT_DIRECTION_VISUAL_RTL); #endif INSTALL_ENUM(Shape, "LETTERS_NOOP", U_SHAPE_LETTERS_NOOP); INSTALL_ENUM(Shape, "LETTERS_SHAPE", U_SHAPE_LETTERS_SHAPE); INSTALL_ENUM(Shape, "LETTERS_UNSHAPE", U_SHAPE_LETTERS_UNSHAPE); INSTALL_ENUM(Shape, "LETTERS_SHAPE_TASHKEEL_ISOLATED", U_SHAPE_LETTERS_SHAPE_TASHKEEL_ISOLATED); INSTALL_ENUM(Shape, "LETTERS_MASK", U_SHAPE_LETTERS_MASK); INSTALL_ENUM(Shape, "DIGITS_NOOP", U_SHAPE_DIGITS_NOOP); INSTALL_ENUM(Shape, "DIGITS_EN2AN", U_SHAPE_DIGITS_EN2AN); INSTALL_ENUM(Shape, "DIGITS_AN2EN", U_SHAPE_DIGITS_AN2EN); INSTALL_ENUM(Shape, "DIGITS_ALEN2AN_INIT_LR", U_SHAPE_DIGITS_ALEN2AN_INIT_LR); INSTALL_ENUM(Shape, "DIGITS_ALEN2AN_INIT_AL", U_SHAPE_DIGITS_ALEN2AN_INIT_AL); INSTALL_ENUM(Shape, "DIGITS_RESERVED", U_SHAPE_DIGITS_RESERVED); INSTALL_ENUM(Shape, "DIGITS_MASK", U_SHAPE_DIGITS_MASK); INSTALL_ENUM(Shape, "DIGIT_TYPE_AN", U_SHAPE_DIGIT_TYPE_AN); INSTALL_ENUM(Shape, "DIGIT_TYPE_AN_EXTENDED", U_SHAPE_DIGIT_TYPE_AN_EXTENDED); INSTALL_ENUM(Shape, "DIGIT_TYPE_RESERVED", U_SHAPE_DIGIT_TYPE_RESERVED); INSTALL_ENUM(Shape, "DIGIT_TYPE_MASK", U_SHAPE_DIGIT_TYPE_MASK); INSTALL_ENUM(Shape, "AGGREGATE_TASHKEEL", U_SHAPE_AGGREGATE_TASHKEEL); INSTALL_ENUM(Shape, "AGGREGATE_TASHKEEL_NOOP", U_SHAPE_AGGREGATE_TASHKEEL_NOOP); INSTALL_ENUM(Shape, "AGGREGATE_TASHKEEL_MASK", U_SHAPE_AGGREGATE_TASHKEEL_MASK); INSTALL_ENUM(Shape, "PRESERVE_PRESENTATION", U_SHAPE_PRESERVE_PRESENTATION); INSTALL_ENUM(Shape, "PRESERVE_PRESENTATION_NOOP", U_SHAPE_PRESERVE_PRESENTATION_NOOP); INSTALL_ENUM(Shape, "PRESERVE_PRESENTATION_MASK", U_SHAPE_PRESERVE_PRESENTATION_MASK); INSTALL_ENUM(Shape, "SEEN_TWOCELL_NEAR", U_SHAPE_SEEN_TWOCELL_NEAR); #if U_ICU_VERSION_HEX >= 0x04020000 INSTALL_ENUM(Shape, "SEEN_MASK", U_SHAPE_SEEN_MASK); INSTALL_ENUM(Shape, "YEHHAMZA_TWOCELL_NEAR", U_SHAPE_YEHHAMZA_TWOCELL_NEAR); INSTALL_ENUM(Shape, "YEHHAMZA_MASK", U_SHAPE_YEHHAMZA_MASK); INSTALL_ENUM(Shape, "TASHKEEL_BEGIN", U_SHAPE_TASHKEEL_BEGIN); INSTALL_ENUM(Shape, "TASHKEEL_END", U_SHAPE_TASHKEEL_END); INSTALL_ENUM(Shape, "TASHKEEL_RESIZE", U_SHAPE_TASHKEEL_RESIZE); INSTALL_ENUM(Shape, "TASHKEEL_REPLACE_BY_TATWEEL", U_SHAPE_TASHKEEL_REPLACE_BY_TATWEEL); INSTALL_ENUM(Shape, "TASHKEEL_MASK", U_SHAPE_TASHKEEL_MASK); INSTALL_ENUM(Shape, "SPACES_RELATIVE_TO_TEXT_BEGIN_END", U_SHAPE_SPACES_RELATIVE_TO_TEXT_BEGIN_END); INSTALL_ENUM(Shape, "SPACES_RELATIVE_TO_TEXT_MASK", U_SHAPE_SPACES_RELATIVE_TO_TEXT_MASK); #endif #if U_ICU_VERSION_HEX >= 0x04080000 INSTALL_ENUM(Shape, "TAIL_NEW_UNICODE", U_SHAPE_TAIL_NEW_UNICODE); INSTALL_ENUM(Shape, "TAIL_TYPE_MASK", U_SHAPE_TAIL_TYPE_MASK); #endif } PyICU-1.9.5/shape.h0000644000076500000000000000254312517773021014144 0ustar vajdawheel00000000000000/* ==================================================================== * Copyright (c) 2004-2015 Open Source Applications Foundation. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. * ==================================================================== */ #ifndef _shape_h #define _shape_h void _init_shape(PyObject *m); #endif /* _shape_h */ PyICU-1.9.5/spoof.cpp0000644000076500000000000003112212520066666014524 0ustar vajdawheel00000000000000/* ==================================================================== * Copyright (c) 2014-2014 Open Source Applications Foundation. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. * ==================================================================== */ #include "common.h" #include "structmember.h" #include "bases.h" #include "unicodeset.h" #include "spoof.h" #include "macros.h" #if U_ICU_VERSION_HEX >= 0x04020000 DECLARE_CONSTANTS_TYPE(USpoofChecks); #if U_ICU_VERSION_HEX >= VERSION_HEX(51, 0, 0) DECLARE_CONSTANTS_TYPE(URestrictionLevel); #endif /* SpoofChecker */ class t_spoofchecker : public _wrapper { public: USpoofChecker *object; }; static int t_spoofchecker_init(t_spoofchecker *self, PyObject *args, PyObject *kwds); static PyObject *t_spoofchecker_setChecks(t_spoofchecker *self, PyObject *arg); static PyObject *t_spoofchecker_getChecks(t_spoofchecker *self); static PyObject *t_spoofchecker_setAllowedLocales(t_spoofchecker *self, PyObject *arg); static PyObject *t_spoofchecker_getAllowedLocales(t_spoofchecker *self); static PyObject *t_spoofchecker_setAllowedUnicodeSet(t_spoofchecker *self, PyObject *arg); static PyObject *t_spoofchecker_getAllowedUnicodeSet(t_spoofchecker *self); static PyObject *t_spoofchecker_check(t_spoofchecker *self, PyObject *arg); static PyObject *t_spoofchecker_areConfusable(t_spoofchecker *self, PyObject *args); static PyObject *t_spoofchecker_getSkeleton(t_spoofchecker *self, PyObject *args); #if U_ICU_VERSION_HEX >= VERSION_HEX(51, 0, 0) static PyObject *t_spoofchecker_setRestrictionLevel(t_spoofchecker *self, PyObject *arg); static PyObject *t_spoofchecker_getRestrictionLevel(t_spoofchecker *self); static PyObject *t_spoofchecker_getInclusionUnicodeSet(PyTypeObject *type); static PyObject *t_spoofchecker_getRecommendedUnicodeSet(PyTypeObject *type); #endif static PyMethodDef t_spoofchecker_methods[] = { DECLARE_METHOD(t_spoofchecker, setChecks, METH_O), DECLARE_METHOD(t_spoofchecker, getChecks, METH_NOARGS), DECLARE_METHOD(t_spoofchecker, setAllowedLocales, METH_O), DECLARE_METHOD(t_spoofchecker, getAllowedLocales, METH_NOARGS), DECLARE_METHOD(t_spoofchecker, setAllowedUnicodeSet, METH_O), DECLARE_METHOD(t_spoofchecker, getAllowedUnicodeSet, METH_NOARGS), DECLARE_METHOD(t_spoofchecker, check, METH_O), DECLARE_METHOD(t_spoofchecker, areConfusable, METH_VARARGS), DECLARE_METHOD(t_spoofchecker, getSkeleton, METH_VARARGS), #if U_ICU_VERSION_HEX >= VERSION_HEX(51, 0, 0) DECLARE_METHOD(t_spoofchecker, setRestrictionLevel, METH_O), DECLARE_METHOD(t_spoofchecker, getRestrictionLevel, METH_NOARGS), DECLARE_METHOD(t_spoofchecker, getInclusionUnicodeSet, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_spoofchecker, getRecommendedUnicodeSet, METH_NOARGS | METH_CLASS), #endif { NULL, NULL, 0, NULL } }; static void t_spoofchecker_dealloc(t_spoofchecker *self) { if (self->object != NULL) { uspoof_close(self->object); self->object = NULL; } Py_TYPE(self)->tp_free((PyObject *) self); } DECLARE_STRUCT(SpoofChecker, t_spoofchecker, USpoofChecker, t_spoofchecker_init, t_spoofchecker_dealloc); /* SpoofChecker */ static int t_spoofchecker_init(t_spoofchecker *self, PyObject *args, PyObject *kwds) { USpoofChecker *usc = NULL; t_spoofchecker *sc = NULL; switch (PyTuple_Size(args)) { case 0: INT_STATUS_CALL(usc = uspoof_open(&status)); self->object = usc; self->flags = T_OWNED; break; case 1: if (!parseArgs(args, "O", &SpoofCheckerType_, &sc)) { INT_STATUS_CALL(usc = uspoof_clone(sc->object, &status)); self->object = usc; self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; default: PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; } if (self->object != NULL) return 0; return -1; } static PyObject *t_spoofchecker_setChecks(t_spoofchecker *self, PyObject *arg) { int32_t checks = PyInt_AsLong(arg); if (PyErr_Occurred()) return NULL; STATUS_CALL(uspoof_setChecks(self->object, (uint32_t) checks, &status)); Py_RETURN_NONE; } static PyObject *t_spoofchecker_getChecks(t_spoofchecker *self) { uint32_t checks; STATUS_CALL(checks = uspoof_getChecks(self->object, &status)); return PyInt_FromLong((int32_t) checks); } static PyObject *t_spoofchecker_setAllowedLocales(t_spoofchecker *self, PyObject *arg) { char *localesList; if (!parseArg(arg, "c", &localesList)) { STATUS_CALL(uspoof_setAllowedLocales(self->object, localesList, &status)); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setAllowedLocales", arg); } static PyObject *t_spoofchecker_getAllowedLocales(t_spoofchecker *self) { const char *localesList; STATUS_CALL(localesList = uspoof_getAllowedLocales(self->object, &status)); return PyString_FromString(localesList); } static PyObject *t_spoofchecker_setAllowedUnicodeSet(t_spoofchecker *self, PyObject *arg) { const UnicodeSet *set; if (!parseArg(arg, "P", TYPE_CLASSID(UnicodeSet), &set)) { STATUS_CALL(uspoof_setAllowedUnicodeSet(self->object, set, &status)); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setAllowedUnicodeSet", arg); } static PyObject *t_spoofchecker_getAllowedUnicodeSet(t_spoofchecker *self) { const UnicodeSet *set; STATUS_CALL(set = uspoof_getAllowedUnicodeSet(self->object, &status)); return wrap_UnicodeSet(new UnicodeSet(*set), T_OWNED); } static PyObject *t_spoofchecker_check(t_spoofchecker *self, PyObject *arg) { UnicodeString *u, _u; int32_t checks; if (!parseArg(arg, "S", &u, &_u)) { STATUS_CALL(checks = uspoof_check(self->object, u->getBuffer(), u->length(), NULL, &status)); return PyInt_FromLong(checks); } return PyErr_SetArgsError((PyObject *) self, "check", arg); } static PyObject *t_spoofchecker_areConfusable(t_spoofchecker *self, PyObject *args) { UnicodeString *u0, _u0; UnicodeString *u1, _u1; int32_t checks; switch (PyTuple_Size(args)) { case 2: if (!parseArgs(args, "SS", &u0, &_u0, &u1, &_u1)) { STATUS_CALL(checks = uspoof_areConfusable( self->object, u0->getBuffer(), u0->length(), u1->getBuffer(), u1->length(), &status)); return PyInt_FromLong(checks); } } return PyErr_SetArgsError((PyObject *) self, "areConfusable", args); } static PyObject *t_spoofchecker_getSkeleton(t_spoofchecker *self, PyObject *args) { UnicodeString *u, _u; int32_t type; switch (PyTuple_Size(args)) { case 2: if (!parseArgs(args, "iS", &type, &u, &_u)) { class Buffer { public: explicit Buffer(int32_t len) : size(len), buffer(u.getBuffer(len)) {} ~Buffer() { u.releaseBuffer(0); } UnicodeString u; int32_t size; UChar *buffer; }; const int32_t len = u->length(); Buffer dest(len + 32); UErrorCode status = U_ZERO_ERROR; int32_t size = uspoof_getSkeleton(self->object, type, u->getBuffer(), len, dest.buffer, dest.size, &status); switch (status) { case 0: return PyUnicode_FromUnicodeString(dest.buffer, size); case U_BUFFER_OVERFLOW_ERROR: { Buffer dest(size); STATUS_CALL(size = uspoof_getSkeleton( self->object, type, u->getBuffer(), len, dest.buffer, dest.size, &status)); return PyUnicode_FromUnicodeString(dest.buffer, size); } default: return ICUException(status).reportError(); } } } return PyErr_SetArgsError((PyObject *) self, "getSkeleton", args); } #if U_ICU_VERSION_HEX >= VERSION_HEX(51, 0, 0) static PyObject *t_spoofchecker_setRestrictionLevel(t_spoofchecker *self, PyObject *arg) { int32_t level = PyInt_AsLong(arg); if (PyErr_Occurred()) return NULL; uspoof_setRestrictionLevel(self->object, (URestrictionLevel) level); Py_RETURN_NONE; } static PyObject *t_spoofchecker_getRestrictionLevel(t_spoofchecker *self) { URestrictionLevel level = uspoof_getRestrictionLevel(self->object); return PyInt_FromLong((int32_t) level); } static PyObject *t_spoofchecker_getInclusionUnicodeSet(PyTypeObject *type) { const UnicodeSet *set; STATUS_CALL(set = uspoof_getInclusionUnicodeSet(&status)); if (!set->isFrozen()) const_cast(set)->freeze(); // documented to be frozen return wrap_UnicodeSet(const_cast(set), 0); // owned by icu } static PyObject *t_spoofchecker_getRecommendedUnicodeSet(PyTypeObject *type) { const UnicodeSet *set; STATUS_CALL(set = uspoof_getRecommendedUnicodeSet(&status)); if (!set->isFrozen()) const_cast(set)->freeze(); // documented to be frozen return wrap_UnicodeSet(const_cast(set), 0); // owned by icu } #endif /* 51 */ #endif /* 4.2 */ void _init_spoof(PyObject *m) { #if U_ICU_VERSION_HEX >= 0x04020000 INSTALL_CONSTANTS_TYPE(USpoofChecks, m); #if U_ICU_VERSION_HEX >= VERSION_HEX(51, 0, 0) INSTALL_CONSTANTS_TYPE(URestrictionLevel, m); #endif INSTALL_STRUCT(SpoofChecker, m); INSTALL_ENUM(USpoofChecks, "SINGLE_SCRIPT_CONFUSABLE", USPOOF_SINGLE_SCRIPT_CONFUSABLE); INSTALL_ENUM(USpoofChecks, "MIXED_SCRIPT_CONFUSABLE", USPOOF_MIXED_SCRIPT_CONFUSABLE); INSTALL_ENUM(USpoofChecks, "WHOLE_SCRIPT_CONFUSABLE", USPOOF_WHOLE_SCRIPT_CONFUSABLE); INSTALL_ENUM(USpoofChecks, "ANY_CASE", USPOOF_ANY_CASE); INSTALL_ENUM(USpoofChecks, "INVISIBLE", USPOOF_INVISIBLE); INSTALL_ENUM(USpoofChecks, "CHAR_LIMIT", USPOOF_CHAR_LIMIT); #if U_ICU_VERSION_HEX >= 0x04060000 INSTALL_ENUM(USpoofChecks, "ALL_CHECKS", USPOOF_ALL_CHECKS); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(51, 0, 0) INSTALL_ENUM(USpoofChecks, "RESTRICTION_LEVEL", USPOOF_RESTRICTION_LEVEL); INSTALL_ENUM(USpoofChecks, "MIXED_NUMBERS", USPOOF_MIXED_NUMBERS); INSTALL_ENUM(USpoofChecks, "AUX_INFO", USPOOF_AUX_INFO); #else INSTALL_ENUM(USpoofChecks, "SINGLE_SCRIPT", USPOOF_SINGLE_SCRIPT); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(51, 0, 0) INSTALL_ENUM(URestrictionLevel, "ASCII", USPOOF_ASCII); INSTALL_ENUM(URestrictionLevel, "HIGHLY_RESTRICTIVE", USPOOF_HIGHLY_RESTRICTIVE); INSTALL_ENUM(URestrictionLevel, "MODERATELY_RESTRICTIVE", USPOOF_MODERATELY_RESTRICTIVE); INSTALL_ENUM(URestrictionLevel, "MINIMALLY_RESTRICTIVE", USPOOF_MINIMALLY_RESTRICTIVE); INSTALL_ENUM(URestrictionLevel, "UNRESTRICTIVE", USPOOF_UNRESTRICTIVE); #endif /* 51 */ #if U_ICU_VERSION_HEX >= VERSION_HEX(53, 0, 0) INSTALL_ENUM(URestrictionLevel, "SINGLE_SCRIPT_RESTRICTIVE", USPOOF_SINGLE_SCRIPT_RESTRICTIVE); INSTALL_ENUM(URestrictionLevel, "RESTRICTION_LEVEL_MASK", USPOOF_RESTRICTION_LEVEL_MASK); #endif #endif /* 4.2 */ } PyICU-1.9.5/spoof.h0000644000076500000000000000262012523473545014173 0ustar vajdawheel00000000000000/* ==================================================================== * Copyright (c) 2014-2014 Open Source Applications Foundation. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. * ==================================================================== */ #ifndef _spoof_h #define _spoof_h PyObject *wrap_Spoof(NumberFormat *, int); void _init_spoof(PyObject *m); #endif /* _spoof_h */ PyICU-1.9.5/test/0000755000076500000000000000000013011413477013642 5ustar vajdawheel00000000000000PyICU-1.9.5/test/__init__.py0000644000076500000000000000146213011412542015746 0ustar vajdawheel00000000000000# test package import sys if __name__ == "__main__": if sys.version_info >= (2, 7): import os, unittest def load_tests(loader, standard_tests, pattern): if pattern is None: pattern = 'test*.py' this_dir = os.path.dirname(__file__) package_tests = loader.discover(start_dir=this_dir, pattern=pattern) standard_tests.addTests(package_tests) return standard_tests unittest.main() else: print >>sys.stderr, 'Unit test discovery requires Python 2.7 or later' try: from pkg_resources import require with_setuptools = require('setuptools')[0].parsed_version print >>sys.stderr, "Use: 'python setup.py test' instead" except ImportError: pass PyICU-1.9.5/test/lohit_hi.ttf0000644000076500000000000023711411634256064016176 0ustar vajdawheel00000000000000FFTMNOj§>0GDEF N cd˜GPOS‡K?4< òGSUB\ƒÌü@OS/2úµùã˜Vcmapvç<tÒcvt +|Bv ¸$fpgm§Ù^“ Hdglyfær˜  íTheadï…þ;6hheaÃÌT$hmtxá:Зð„locaf“ â ÜÄmaxpóHx name^Dúô µpost6å8¬µprepS0_ ¬ ff’ «_<õÆÍ*nÆÍ*nýƒýý4ÿÿýý 3ýƒü:4aaœ <@Dor¤b ¤bšCM€€ @ACE @ %Ìçþ“ÿ)…<SdÌd¦dÈdudùddædÒd¨fhdgd´dd dyA{ÁyO{D{L{D{D{5{5{Ldnd•dd•d™ddˆd]dˆdŸddäd dædÑdíd™d@dþ§ÿOSd÷ÿóþÿówÿó™ÿó`ÿó¿ÿóêÿóêÿóæÿóëÿóíÿó9ÿóÿó|ÿóÍÿó}ÿóÅÿóØÿóÛÿóáÿó5ÿóDÿówÿóCÿóÿó`ÿó­(ÿëˆ$IÿóIÿóÿóÿóÿó‘CÿóTÿó´ÿóºÿó×ÿóßÿóÝÿóÿó¤ÿóÅÿóÿóý½º ÿó ÿó ÿ$þþÛþ²þ·þºþþaþ" ÿ8 ÿ ÿn ÿ8ÿ0ÑÿTýƒÿGÿNñÿóDÿóÿóÝÿóxÿó<ÿóýÿóTÿórÿóÄÿóþŒþŒnÈCÈ™d™™™q˜ˆ˜g™d™x™W™d˜t!d´(ÿòØÿówhÍÿóÿñ™3`d‚dd<dd´d–d ÿóþaþaþnþ"þ/þ6ÿ7ÿþ!þ˜Å ÿóçÿó‘-ÇÿóHÿóÿóýÿóÞÿóÓÿóÞÿóÅÿóLÿó ÿóËÿó5ÿóAÿówÿóCÿóÆÿóxÿó$%ÿóê%ŠÿóŠÿó`ÿóLÿónÿóÒÿóœÿó ÿó ÿóÿó‘ÿóÿóZÿó¼pÿó ÿó5ÿóHÿó¡ÿóÿóWÿóLÿón sÿóKÿó#0ßÿó ÿó ÿó ÿó ÿó ÿó ÿó ÿó ÿ$ ÿ$ ÿ$ þI þI þI þIþ-þ’þþâþqÿÿó­ÿóÿó4ÿóÿóÕÿóáÿóÿó#ÿó@ÿóÿó%ÿó“Eÿó)ÿóÿó(ÿóq  ÿó-ÿóøÿóüÿó ÿóÃÿóÈÿó¨ÿó¤ÿóÄÿóÃÿóˆÿóœÿóÿóÐÿóÐ+ÿóCÿó·ÿó+ÿóXÿóÆÿó„ÿótÿóÆÿóTÿó²ÿóÿó™ÿó-ÿóÜÿó?ÿó%ÿóiÿóÉÿóËÿó/ÿó—ÿó9ÿóYÿóÿóàÿóq s p +ÿóXÿóÐÿólÿóäÿóÿó‡ÿó@ÿóœÿóúÿó(ÿóÿóøÿó#ÿóþQ„ÿó}ÿó´/)QÿóÛÿóÀÿó ÿn ÿ` ÿt ÿF ÿ? ÿ?áÿóÿóWÿó)ÿó‘-ÇÿóÌ°(  @`~¢×÷ 9 M T r     &"%Ìÿÿ [{¢×÷  < P X {    &"%ÌÿÿÿöÿãÿÉÿ¯ÿŒÿXÿ9÷0÷.÷,÷)÷!à•ààà‹àƒÞ˜Úß  !"#$%&'()*+,-.©£¤§¨¥¦0@,vE °%E#ah#h`D-,E °%E#ah#h`D-, ¸ÿÀ8±@68-, °@8°6¸ÿÀ8-,°Fv Gh#Fah X °%#8°%°6e8Y-@E¸ÿ…v2¼ÿÎd+ó‘ÿÿövÿ´!*ÿö£ÿ[ì[ïKÿœÜ™ÿy"ÿõm@äEsSÿÐÆÿ8bÿŸihÿ;ÿLÿnîÿ fÿˆ2È\ÿ¢¤FÛé:·qšPÿ¡ ÿÝÿìÿûþ7ÿñÿçÿºêÿ3#ÿB5äùÿÉÿ.þþ}© ÿ’ÿ¿ÿƒûÿÒl³{-–ÿتUZÿGÿL}ÿt¯›_Ën‘¾(ÐÁÚÿÿÿÓÿþ÷ÿ°ÿ¦ÿ—ÿ~ÿÿ`ÿÄÿ«ÿµÿ÷NNNN|°þfÐ>dšÐjœÂè 4v ê>r¢ö$†Ø2Zˆ°örœÄî  D p ´ Ú h Î  N Š ° ô b Ö R °<Žú|ödÎx $®„¾~Ä6züVšä<–Öv¾*d¬è@”ê&r²RÀ0xÞ hÄè 8 ` ª ô!:!€!À""R"‚"¨"Ô#2#r#¦#à$$¦$Ì$ò%%&%–&&d&¶''t'Ø(0(ž)*)¨*0*T*†*Ê++`+Â,&,€,â-6-v-Ð..".’.À.ø/ /h/°/ä00N0‚0¨0Ð11:1x1ž2’2À2ì3(3j3œ3æ484t4¶4Ú5 5h5Ò66˜7 7f7Ô8 8\8Ð99„9Ê:D: :ê;:;˜;ú<8>H>˜>ì?B?z?À@ @\@ªAAˆAÒB&BdB¨BôC\CØDDbD¾EEVE’FF€FÒG4GžGèH8HœII`I¾J$JnJÀK"KŠKØLLbLªLîM>MzMØN>N¸NøODOÈPPbP¦QQ\QºRRLRœRüS\SøTTTêUdU¾VlW"W®XXXàY²ZZ¦[[x[è\L\¾].]–^^Œ__¦`*`ºaDa¼bLb°cDc°d2d´eedeÚf>fŠfügŠhh~hòitiêj@jœkkxkìldlâm\mÂn(nŒnâoFo¸oîpJp”pøqfqªrr¤ràs*szsÄttbtÆuu^uªv2vª…¤¤ oA$  FFv/7v?<ý:Í:>;™¬B¬¸ÍDÎCÂ==Í@¶¶¶¶@ÍÍÍdÿ›eG")16A 2+FFv/7v/4&'d=YFWutXAYw@S=b‚ƒaA_}HaaHA>PP>á53#'#"&573267'>54&#"d\P/0_B@\H>‘ 9uPP!i;UxBX>,Sª@JN(&080!)<®:x.;f'9S^B4e$½ 94Tš^06nM 9R3,Ô&Y)“O1M'+=8'd˜¼k0A FFv/7v?.'&'&67>7#"&4677'.''6>7&% • 1>(HY9- \E(>×#( š 2?(H]=- ZK(?«!$X@FR . G9 Ñ 1 9F 4#%,SE@X› / F9 Ó 3 9G d“ 0A FFv/7v?54&#"#54632!!O†lET\=@[Q‹a^ŒeQ²~þ$e¨>(\;6EY@,,_…pVL.fVQDÿñ7Ê)5A'&% FFv/7v?QB30=N32#"&5DHeDHiiH/UPHwþËC,j˜™icŽÝ=O^EFb'#nG¸‘hg€]Dÿñ7Ê'5A FFv/7v?32#"&532654&#"D’|W~IS9Zd\8e•”fkŽ^[@EddEAZ XØtT5H¦p-1‚aeŽ¨q-@Z]DBZ`C5FÀ +A !FFv/7v?<3<;449:3Lÿñ/Ê'5A  FFv/7v?54&#"'>32#é]] piJ.])(0r:f‹rCWW¦Ïw@9S.)504yULŽ* dÿÀ°Ó4ABA *&%$)FFv/7v?B#7MÊšÛÛš+A 43FFv/7v?323267#"&'.#"ˆ$!I##98$B%V08980- *#'dÿƒŠ$$/6A <;FFv/7v/=FFv/7v?54&#"'>3232675#5!###"&'#ÙIqC L0SuCN7¤P–810|A);C.!<\. 'T%/#m?=U 3N,x,rB!- aE&eO7HqP9Sý …xfq=,6J<I*&71,.38Y@">ð<<ý¢, &Heš?2A 21.-FFv/7v/54&#"'>3232675#5!###"&'#5P–810|A);C.!<\. 'T%/#m?=U 3N,x,rB!- aE/…xfq=,6J<I*&71,.38Y@">ð<<ý¢, &He šC9A6521.-FFv/7v/54&#"'>3232675#5!#####"&'#6P–8/2}@*:B/!<]7& N%."g8B] -X( "x=qCÎC!. aF/…x(lwG1/B<M,$31,.38U>$B ð<<ý¢^ý¢, &Heÿóÿ`š6&A8FFv/7v/32#ŸGl"B]&'J32'>54&#"#"&'732654&+'32654&'! ´þH(! (Y4He<5,*0>,2R gBjÅ2<-¤T1FF1x…,="þ]^<<7-E (7B]BCt%1\7);nT?Sí½«×N71G;;)8ÿóÿónšG6A$#"87FFv/7v/3Í>jþD{þ„$ **:>J4*B <"#?9!$ Cþï'I4N/(8b'ík<<ð '(9s04J8,"#,e0þÎý~5xI# /&*ÿóÿ$ÌšC6A'&%CFFv/7v/75!5!#3267#"&5467>54&#"'>7.#"ú]qaE$G:#þ*ÙÁ-54&/.5#5!#'>=#"&'332673#p6! ÷JL/'(Ü é,#xJq C L00L B qI/  ã'%<<È4M /8%Áý,Û)2ofN6HH6Nfÿóÿ÷Ø&56A&G+*5FFv/7v?54&/.5#5!#'>=#"&'332#4&#p6! ÷JL/'(Ü é,#“IqC L0SuCN7/  ã'%<<Ï1I /8%Áý,Û)2£eO7HqP9Sÿóÿóš&+A GFFv/7v/=#'>54&/.5# P+$(âé,$5! öI^<<Ã6Q /8%Áý.Û)2/  ã;!ÿóÿù±*2A G+FFv/7v/=#'>54&/.5# mÈ<ÖOJ-)( ðÜ,$5$Û H^<â5þé<Á,Q55¿þö.Î)2/ Î8  ¤CRHAONHG6521.-FFv/7v/54&#"'>3232675#5!#####"&'#"&'332673#6P–8/2}@*:B/!<]7&#M#."g8B] -U$ &x=qCÎC%* aFHqC L00L CqH/…x(lwG1/B<I*$2-).38Y@"> ð<<ý¢^ý¢, #Ji»iQ6HH6Qi ÚCR8A6521.-HG5FFv/7v?54&#"'>3232675#5!#####"&'#"&'332#4&#6P–8/2}@*:B/!<]7& N%.%f6B] 2U "x=qCÎC!. aF±IqC L0SuCN7/…x(lwG1/B<M,$31,.6;Y@$Bð<<ý¢^ý¢, &He÷eO7HqP9S çG54&#"'>3232675#5!73#####"&'#6P–8/2}@*:B/!<]7& N%.%f6B] 2Q*x„ñ.wqCÎC!. aF/…x(lw?,4J<M,$31,.6;Y@$Bð<%(þ³<ý¢^ý¢, &He çJ54&#"'>3232675#5!%773#####"&'#6P–8/2}@*:B/!<]?,D5%`.He 2U "xkþì(%ŒCntqCÎC!. aF/…x(lw?,4J<I*&7-*(6;]B">ð<´;é(þ³<ý¢^ý¢, &Heÿóûš6)A FFv/7v/32'>54&#"#5#"&54632.#"3267! þ J,@YB<<8@3$.OBE(HeuR# 6O?,&Hþš^<<´%+iK@}2('j6/BF8þÇÈ eHPqCJ4,?/(9ÿóGš@2A FFv/7v/GõÂ+22$“ýÞUK5T;:2 ,$3;;)*:ÿó Ûš.;.A HFFv/7v/54&#"6]…'"19hà¦1@é+U'./;/þÀG1I5,?^BÕ&*."+'"!mN0QH'!6 <54&#"#"&546;5!5!###"&'267##"326323>,I4K99L I$o;)§þ»õqB,$XO"9" ,»é <I"7!/3/!" G-})$3]<<ý¢ Kb%/a   K ÿóïš/)A %$! FFv/7v/3232675!5!###"&'#Ú4j).S*4K?, <. R-ÿóRš"0A "! FFv/7v/†O9R)&5,1yU³kMm<<ÁG1Q‹U>%M (%a4X}ÿó „š.0A .-HFFv/7v/58©X6O M3z2$´þ)‘w÷ PM);vR Ÿ†"wR:€4$2k<<­ U>,Vyÿó Qš!..A HFFv/7v/54&#" ^Šþý$3‹QK46O}Xk³Y@Áþn˜#-&#^<<È>,NŽ<"4KO6Eb´kHe…ýò7&&" 7ÿó«š)A FFv/7v/$2´7' aE<<ý¢^þèEaB;)þè);ÿónš.A   FFv/7v/;#"3267#5!##5#Ki5ÿóš#-)A FFv/7v/32'>54&#"##"&52675#37D!þ‘J(Ea-*;&):)#I CE'Ea¦'Fé;)ué<<» #mMUK‰=/Yã‚!0:."™ÿóÿùÇš 1A M FFv/7v/<K+*þÉÔZS9*vI(ð5555Yã‚/:E3$™<<™>UK‰=//55/ÿóÿùäš&.A MFFv/7v/7.#".54632>35! ñqB:d< @#7NycuuS1XP,ýÂ^<<ý¢gS 4 "N775!267.#"32654&#"3 ùÆ=OaF)TP&KiiK.P<"þí??!/BB/+*::*$DC^<< qLVyH==HuTVwA61@þ.I9RN=CPÿóÿìëš,9>)A >:PFFv/7v/75!5!##"&'#5267.#"32654&#"3'7àKiiK.P8þøÅ=OaF)TP&??!/BB/+*::*$DC™5555I{VRsA6*< …<<…lEVyH==HCI9RN=CP™5665ÿó-š")A FFv/7v/,Œéé^<<ý¢ðeHéþ¬â¦,?xÜÜÿóÿùÓš.A MFFv/7v/32'>54&#"3"&5467.546;5! *kþï (!3Ki5B/He¬yË'""';)Ïþƒ^<<  2 U>"9. ".B/=U#=Užy<ý¢^þþï(7AVUFFv/7v?32#ÈHM/I…5:R+ 8.P/9SzUþïE@<=A:)".. #U>EaþÛÿ¦/9A XWFFv/7v?323267>32#"&5332654&#"#"&'#"&'732654&#"'>5%"&'332673#'53#†=+ H3%c3Fd = 9K-Fa]CEa;?,'6:*>H-! ]BS 2<,~?&7+ (?Y4X„ B[65\CƒX"JJË*:5/*:DbF<$"'yVUyeH,>R9:R*&  &Gfƒm!^p>,/C/F,“eO32'>54&#"#5#"&54632.#"3267!'7  þ¢J.@YF?/5<2$0NC?PquS#7NJ4@þ•Ù6655^<<´#&eH=}5.-f.,?C5þÇÎ "eHMm<G1/B5/2ý•5555ÿóÿóRšCH:AHD FFv/7v/=VbE!!);/!= þ’?, *—PþÇ<<<<^<<ý¢…@Eug0j;!+2* ýåMECU>=UC.!"0ý“=UuŽP5555ÿóÿóš1A FFv/7v/,Vy£‰!zR:€4$2ký.//.ÿóÿ{Jš!.3)A 3/FFv/7v/54&#"'7 W„é/B~^K46O}Xh°iK¦þp—!(&' I<<<<^<<ÁC.Sz< 4JN7Ea«fHe…þ2**1é.//.ÿóÿù š#-21A 2.MFFv/7v/32'>54&#"##"&=#2675#3'7 þF$He.)<')>,#EBF"@YHá$FÜ3$(5555^<<±mM32! þrq"" ..<>,0!#AHe/(…Cþï'P1N/(8b'=#jþD^<<ð51 V:"*:<]C(D(<þÎý~5xI # /&*kÿóþèÒšQ6A0/.]RFFv/7v/75!5!#;#"3267#"&5467.5467>54&#"'>7.#"ú]qaE(J8þ*ßÇ?MeO*//**!B N+9S!!?-3DC/(JB 9):ZL(‘QPq*%*“<<“wLNy5,"5C/, -*<U:>UeO/$K4At 5þŒþ'T;OA _ ^FFv/7v?323267#"&467>54&#"'>7.#"ÙGTJ466 4K=2'(/72H:.!++!< +  **A7þÎk:;R^C4Q ,% ,F^G8%-?K9#4$-Q-þŒýýY!K;A)('` IFFv/7v?32;#"3267#"&5467.5467>54&#"'>7.#"ÙGTJ4 828PI9 1;#*<-!&10#60  +*B7þÎk:#HeeHUfCx/BB/,>>,!£iJKim[ýì°G14KK41GqÿÑ)Â"0A "JcF Fv/7v?54&#"'>32ß­*:&8ETY@-\+(3q8Z‚cQ 6/é."uGEa%$5).‰`XÜ(ˆÿn´10A 2d#"!F Fv/7v?54&+'32654&#"'>32‹>2F"4:>N]CI!x1FJ4G(!&\2Mm/(4>jQ 76’UA;).( O27O;?,);/ "aE)LV2Em8D .g2®&3/A K&%FFv/7v?54&'7#52654&'3PHf@8Ra6\KJU<YN8@iJ.C>30;?,aE4` 't:">!-2`+]%0"B#6s, `4Ea54&/#"&54673267.54632Ò!  /7X}<V=,/!'< 5/W6*6$™[>p-(c6C] 9*,>>,=È$6#HxÿZ" 20A 2g[FFv/7v?54&#"3Tj“ I mN,QSuS9@Y‚mŸ3$!/Y@Γ!x'K Ty¬I<[PqŒd¦Èð%@KiO6Hed6§/A NFFv/7v?54&#"'>3232675#5!###"&'#ONxI P23P IxOþæP–810|A);C.!<\. 'T%/#m?=U 3N,x,rB!- aE÷iQ6HH6Qiý8…xfq=,6J<I*&71,.38Y@">ð<<ý¢, &HeÿòÿÄš5!!5!####"&546;26=#°þP qB§ l / „<<<š<<ý¢^þº} ™ÿóÿÃæš#5!!%"&'732654&'!5!5!####uý‹7Hœ:<3|3!/;6ýÁóqC U==<<Á Ž«3$9y7Œ<<ý¢%U,@YhŽ#76'&'&'676Bx&U•Y?4BMqA4ÿÿB-Xs E+!'#ŠeE5ÿóÿÄÛš35!!5!##"32632#"&'732654&#"#"&546;5!†ýz#èÉâKQ);vR`ÌP6I®O6O Q)}:*Ÿþ$<<<š<<§ U!?,X}¡‹(’U=!ˆ,$2kÿñÿÄ'š#.5!!4632.#"7!5!##5#"&5267'3Åþ;6uR,!) Âþ4qB L'Mmº(´ G1<<<|Or 6 ’,<<ý¢Õ #fHk ’ !,?þº5çJA65FFv/7v?32.#"#œþý.“V;0&'632.#"#`CC<ö.†W:/&'65<êIIP%(´7G 5 6'#Bþ"šÿôç +A 5FFv/7v?/<10º +%77#753#Àþâ!,“CxWPddšŒ<Â(þ³¦]]þ/š7ç?A    5FFv/7v?/<?ý?ý10º+%77>32.#"#¬þÛ"2§C<N0$$ .C Wš…CÂ(Œ(.< :*Bþ6š7ç?A 5FFv/7v?/<?ý?ý10º+53#%77>32.#"#4IIxþâ2§C<N0$$ .C WãIIIŒ<Â(Œ(.< :*Bÿ7š ±3A +FFv/7v/54&#" ¸+1I47O"¾5x,qCþÇ.ý´È,ç'#* "wJ'4JJ4#BO(â<<ý¢,ð5»I…2©.''0 ÿóÿË(š'161A 62pFFv/7v/32'>54&#"#5'%5#"&=#2675#3'7 5þ‘J(Ea-*;&):)#I CþÕFE#EaXþ'Fé;)6655^<<» #mM54&"©öqC3'X..9SS9#@ ­“0**.ÿóÿÑÔš?3A JFFv/7v/32#.'"&54632>54&#"#"&5463!5! áqBþ} K! +qP B0.+L4J"1F`  *u:)ƒýÒ^<<ý¢¾ U?,C]'/ /#2$#'"A)€.$2]ÿócš0)A FFv/7v/32.#"#5#"&54632.#"3267! c»K)  2O B>MmqP$"4KG1@þš^<<´#&I K:þÎÈeHMm<J4,?3+2ÿó«š!<.A FFv/7v/UY@6($2."(ML)^<<´6Op†MEOFdy>Bw0Nm ,8\^<<-$2FFv/7v/54&#"6]…'"19hàý×G1I5,?^B+U'./R9>UéÕ&*."+'"!mN0QH'!6 <<4'6CJ42F" .d0=US9uØ»N**.!*JÿóIgš0A OFFv/7v/þ±gý™IÉ¥°3$7u6<"U/C]<<ÿóÿÑ;šG.A GJF FFv/7v/54&#"#"&546;5!5!##"326323267#"&'#YV"Ji"#@DVI%t7&§þ»;´é =I%2 (*  q.:)(/ 03$'"G%!ƒ*!/d<<  K!   C  +h %/ÿóx=š',0A '&s*)FFv/7v/323267#"&'#5!!â2p3"-])2FB/0!B!@a $ 13 gFïæþx82/-0N71G 5VC <  Idæ<<ÿóÿ Cš#&A!t FFv/7v/…/.³(Ÿ!ÿóÿ Oš")&A't FFv/7v/†O9R5 yU/Jï(Ç/³kMm<<ÁG1Q‹U> 8(M-X}x5!³(Ÿÿóÿ„š.5&A3uFFv/7v/,Vyx6!´( ÿóÿQš!.5&A3XFFv/7v/54&#"'7' ^Šþý$3‹QK46O}Xk³Y@Áþn˜#-&#qIð(È/^<<È>,NŽ<"4KO6Eb´kHe…ýò7&&" 7È5"´( ÿó¦Óš .A vFFv/7v/;#"3267#53#Ki 6BO64KG1"&:0) C!P@YG13}@@}3I™™kU=$=b97N>,*:<'0Q 5B/$3TLV@Eó<<ÿó饚0A xF Fv/7v/32.#"##"&=#2675#3 g»B%&B"B?!HeEò@â>,^<<Á"' C 5/þº  bEéþ¬.)ýé,?ÿó‰š!&0A z$#F Fv/7v/T01a!(^-N†Ea" …^<<? ?[9ED:]04…kB/? ÿó¼±=A +FFv/7v/3"'>7.#"5!!&r‹uS)W& S-Dp< ?!7Nu`þÍ7ýÉ)›TMm)' #C`M&3 F1C}#5^<<ÿóI¬š%276AO54FFv/7v/32#"&'#5267.#"3!2654&#"35!!ÚHeeH0TP-EaaE/UR,BC ,>>,,);;))D D)ýí¬ýTIyVUyE99EuSX}I<NÒ<<ÿóÿå«š%27<)A <8L54FFv/7v/32#"&'#5267.#"3!2654&#"35!!'7ÙHeeH1TP.EaaE/UQ,BB,>>,,);;)*D D*ýî«ýUy6655IyVRuA69EuSX}I<UY@7NN=@SÙ<<ý‡6556ÿó’uš0A |FFv/7v/32.#"#5#"&54632.#"3267!'7 c»@$*))D B E HeiJ3 ).C?,"HþšÓ<<<<^<<´#& CK:þÎÎ "eHMm 6 J4/B5/2ý•5555ÿóÿó¼š!<A6AA=FFv/7v/ 7OÌ<<ý›/55/ÿógš',0A ,(FFv/7v/32.#"##"&=#2675#3'7 g»B &&B"B?!HeEò@â>,!6655^<<Á"' < 5/þº  bEéþ¬.)ýé,?þö/../ ýß®"0A ~ KFFv/7v?7.54632'>54&#"ßï2_0">V(.N79S'"³ï "*''#ýŒ)?/$8H&4KK4CkIÎ5""46ÿó5åš)A F Fv/7v/7>35!!¥!@l"*3(E0<ŽGþÀ²Žþr56º@E % 5 - aT/Õ)<<ÿó½š)A F Fv/7v/´;GL6A;KJF Fv/7v/4&#"753#p( MmA7&*U=:R*&3/\)-\+0X%4=F2&" .Œ$,+!/("Î 0$eH4XB"9RR9&D BE".C'7'#((¾5<++5™<<ÿóÿßúš16.A 1Q043FFv/7v/54&#"#"&5463!!"326325!!,/E7A#.Oe T5k7&hþ˜ @T&7mT 435þÇúþ!/(!" L, j5$3< @6'?f "!<<ÿóã±!=A +FFv/7v/$$ '6C8£W=V rrBqêIIŒ< ,PqA<:Q; 6' ' `oO7, <ý¢^ÿóJ«=A FFv/7v/UkrBq^<4 Heu\lC.4<ý¢^ÿóyÌ!:A‚FFv/7v/Uk^^š<ý¢^<4 Heu\lC.4Õ]]ÿó»±/?A+/.FFv/7v/32.#"#.#"3rBqq}X2e,R3$&'6  <*ƒB>Ukš<ý¢^<4 He/,,5< 6' /\lC.4ÿó»±4?A+ 43 FFv/7v/32.#"#.#"3WIIþÁrBqq}X2e,R3$&'6  <*ƒB>UkãIII<ý¢^<4 He/,,5< 6' /\lC.4ÿ$¸!LA{FFv/7v/#=U›|<ý¢^öddÿ$9¸,=A{*)&%FFv/7v/32.#"3### q`2".IV=*X$O2$$ ,?rrBq^#@Y82-6< F2 Q<ý¢^ÿ$9¸,1=A{*)&%FFv/7v/32.#"3###753# q[4'6I]C'P"P3$$ *: rrBqâ]]^<`|3$ ?>#@Y5/+2< F2$6<ý¢^qddþI±=A+FFv/7v/'Ea™~<ý¢^þI±!AA+FFv/7v/'Ea™~<ý¢^ö]]þI2±,CA+*)&%FFv/7v/32.#"3### q$°l@YIZSš:[=$$ '6grBq^'EaC>8I< 6')D<ý¢^þI2±1CA+/.+*FFv/7v/32.#"3###ÕIIâq$°l@YIZSš:[=$$ '6grBqêIIŒ'EaC>8I< 6')D<ý¢^þ-þ¬p(!/A ƒUFFv/7v??<10º"+"&'732654&#"'>32#7''ÉW‹(!'yI7N3(H(,>mM éðÕÎþ¬40(&*'$(%*>,4Kxq/dk/þ’þ³Î!%A „IFFv/7v??10º+"&54632.#"3:37''x=UN7V³J.C™I*2$ !öéðÕÏþº:*.CaZ!OX#5 ]]/PV5þþ³ ÿÄ7A„…FFv/7v?32#ÁA—M!M†1@Y7&4/'L =UyUþ³E@/@E6'!/' #N79SþâþΦÿÄ9A †…FFv/7v?54&#"'>7.#".54632>75! È°3?RH(32'>54&#"#5'7.54632.#"3267! þ J,@YB<<8@3$.OBþâ(¢=QuR# 6O?,&Hþ†^<<´%+iK@}2('j6/BF8þÇÂÖ/rcAPqCJ4,?/(9ÿóÿ•BšC.A ˆFFv/7v/=VZ@/%$3/!=þ’G1˜_^<<ý¢…ð6d ZF%kE!+22$“þ22IS99S < /!!/ “=Ud~ÿóš)A FFv/7v/'40ýÄ^<<ý¢™¦5­º;6O™m‚&']0ŒÿóÿÑïš6M.A JFFv/7v/54&#"#"&546;5!267##"326323 üqC™!º%,OJ9/,I9R&99L J$n;)¦þµò,ºéAL# 3^<<ý¢kP.Wj La ! <3/!" @'})!/dþÔ   K ÿó)š)A FFv/7v/325! 6rBð!ñ-L%H('\1#^3þ~^<<ý¢öŸ5 -05 "82ýÿóÿË1š.0A #p FFv/7v/nö);N  *+ ,B+Ü.¦azaE´þr^<<­7&@n  '++ G%J/­.x}KB]kÿóNš.A FFv/7v/32'>54&#"#5'%5#"&52675#3MZ8þI(Eb.)<'):*"J BþÔFF"Fa§&Gé:*ué<<» #mM32'>54&''7"3"&5467.546;5! ChþÛ -:"Ki# 5Œ5gh¼„ â0&&*+ýþh^<<­ = R:*M/5§(™@>`‰<°{.I B*k þï§5B"&546;#"3267#>7.54632#53##''7>54&#"ÅEbiK<32'>54&#"#5#"&5467.54632.#"32675!267537>32>54&#" $þ˜M(9S83(&**%N BT1@Y,$$,eHB "0,>B/)Eþ†Ú3V 6.:K2$âJ* *-O^<<™"'K48 (([*5@##*&È™ ">,3 :#4J/&'éþ4/(C  -†  "".(]ÿó;š..A #FFv/7v/32'>54&#"##.5467#5!5! Hþ–; Mm" 6G1#<C %1UK"Yhw{þe^<<ÏiKDq'%c91Gþºn@+5o*/4ˆA(= <´ÿóÿ`š_&A:8FFv/7v/32'>54&#">32'>54&#"'>7.#".546325#"&54632.#"3267! þ¤C$B])&6 #7&/G 4 7NE9(-7'%G<(*:L9 RiaF(H&KiiK 5+/BB/0Mþ‹^<<… nM,T (?1G@1ýF21[5?"3+(  /!0 <R29S …fJIh <C.,?3+ ÿó š<G)A FFv/7v/32'>54&#"#5#"&5467.54632.#"32675!26753 þ¤Q,9SOC(8?*.TB&Z.1F8+.32#>32'>54&#"#5#"&54632.#"32675"&'732654&#"#"&546;5!"&54632# ÝËþá C $ 7OnM%D4KI<".6"D/<H*9RN7 8(!*.!(JM–;/,“X9S'- 1o;)Üþ1^<<“ 0 J49Sd7'&J5," …c:*.C/ " xMF(?G7'#[*$2Wéÿóÿ{Öškx&AEFFv/7v/32#5#"&54632.#"32675#"&'#"&'.'73265.'732654&#"#"&546;5!"&54632# ãÁþÛD(*7N*&<-,??,   . (N$." K,In<$@8¡Z6O'$6p:*âþ!™^<<“ 1F1&Dþï]0"#1/ $V 3K-<5 €\ ;)7 (CI:* Y,$2Wéÿóÿˆ¶šLY)A ‰FFv/7v/32#5#"&'#"&546;26=.'732654&#"#"&546;5!"&54632# ÃÁþÛL(',?$< %2 Y "3U(=”M6O'+7p?,âþAz^<<“ 0K4 9þèý´ E q:%(=B/!'U*$2Wéÿóÿn²š@[h6AdVUDFFv/7v/3"3"&54632# ¿¸þÛ Bj,>,$<?!4K )!Q7/5ŒI=Vc5k;)âþ<%? #!, '#  *"V^<<“ 0G1,EþÜB 7&-+=7(@F3$#U*$2WýR)'…/ÅÿóÿnÒš>HU)A dFFv/7v/54&#" ·—.=d5CL-HeeH*,*::*)M)@X})4 N10N&*8,þÍG1(0}þqjK49R I '+'"»S:2 4 þÀE$(@ ( <*!/C9!5ÿóš4)A ,+('FFv/7v/3235! ëqC,"<3235!ÝqC… mM<}05'a,/B$ö­ W97e%(Q.$2." *'?8S­ý×^<<ý¢J B]`SDN:)(x;6H1,/%+:*&5WÿóÿtQš.=6AŠ9FFv/7v/+5!#!"3267#"&546;5#"&546;5!#"32654&'7 ^þï*ta3V/( yUoœS9Î !™S9Îþd³å*uS9R ^<<“6B.Ž<%9SmN1FCcQ/BWþ #4K/!.ÿóÅš.A)A FFv/7v/32#3 ÒqCT1T„'O7>@ºC]}X.Z%/-sSuXUR0^<<ý¢¦ "€b#*U>Pq2+'6<”iVy…þB-)h…N7<<0:ÿóÿS9š<)A ‹FFv/7v/ˆ D%=UmM4JCfG2FWþ '1G/!/ `"1F2$) ÿóÔš4G)A FFv/7v/32#3 áqCP,T„j+?,C‹Jâ4J}XB]4/.8@…]t¤qP™þm”$P%ý©Q‘ZW´P"I¢N?Zf:R 7W(3­f4Kd.r?,Îþ ^<<“ 6!7&C] ;)@YVP/IP6' K4H+(HQ:* g+*Wÿóÿ+‚šKX.A *)(FFv/7v/,´þ‡.X ýùwVyaFJ,^<<ý¢­ "{`+".. L!C.X}¡Š"’Y@!{2'6kþO)'ak(R:3K-7ÿóÿnbš>KX3A -,+d FFv/7v/<ý?<10ºY+5!#!"3.54632!"3.54632#"&546;5#"&546;5!2654&#"32654&#"3 otþö*:qIK37Oþè$2uL K41GjWs²]BÕjh¢eHÇþH²&&''""""^<,4=yN/B(~Q6O<ýK#oÿóÀš4AT)A FFv/7v/54&#"%267!>32#3 ÍqC X.V~]$3O79h-þè):yUK46OqPy¬aEÕþL"-&#æ-X!ýÞ-h9SuaEN6^<<ý¢´')‚`'+?,`‰:4KO6Eb¬yFa…ýò7&&& 4V6.TqO64K,8ÿóÿå)š@8A('&L$FFv/7v/54&/.546;5! 6hð,>wd 3$!/ *<0d6 "(.#32#.'#"&'"&467.546;5!3>7.'267.'#"&'3 ´fþõ+yA 2$,+J']09W @YT>S9ÈýõÒ-=:) -* Œ1T$/!(6'^<<­'=p(6#,(‡\40')H6OlP  7Nkþ³1!.- )þÛ+%6 ,&7ÿóÿÑ;š9&A'JFFv/7v/2$# /6("I'He,$;JY@Çþl^<<­$2C @$+ "."45^PS9%? N./Bkÿóÿ•êšDW3A ˆ$ FFv/7v/32#.'#"&'"&54632.#"3>7.546;5!267.'#"&'3 ÷gþö*yA 1$++I"_39V Z>,-(  ]C )#AS9Èý² 2T$0"(7&^<<­'=p(6#+(‡\5#&H6aF,>( /B. q$7NkýŽ+%6 ,&7ÿóÿÑMš86A*)(JFFv/7v/7 @iþö".iK+'6(!,$< * ]01GA7GYU>ÇþlÚ BW +=<^<<­#=V "2$( 'T+ M8@6'%Eh@4Jký½I  . 0! Cÿóÿ°wšK3A &%$Ž4FFv/7v/Wþp“ ÿóØš2)A FFv/7v/3#"3 åqB>ŠCMm-7O6…þÅ'DŒ;´È&5( :2(^);G1^<<ý¢´=BY@. ?"/BWþMET“'<3$$2ÿóÿå=š4A0A &%$LFFv/7v/aE( 3#".&("CV14J/'ETeHºþdö,K$="'#^<< 7&9S  3$'#];;+37'7f;@YdýÃG8 " ÿó¤š6)A FFv/7v/75#"&=#2675#3 t¡1GS9'7#$3<%'7K4EaU=#8"O,EaQ÷*Pý;)^<<þpF1>U57'"2$ '!/5O64K  ’Y@ ö" ´ $2ÿóÿ`šKU.A :8=6FFv/7v/32'>54&#">32'>54&#"'>7.#".546325#"&=#2675#3 #þ˜I(Ea;;)#I &7OB6/-7')G<0'H7 RiS9$AE#EaMó'Gê;)^<<» #mM$L#!:1F)&é Fd[<: 3+( '!: <Z77Nº]Céþº&#ýé'6ÿóÿóîš,D.A FFv/7v/7.#".5467.54632>35!>35"'>7.#"2 ûqCDi5A!'78,!;J(!"']C-OfGý¹*`0Ge<?&'7,$:Z^<<ý¢âA6! /! 8 .Q1+A D'6O ]þ~$% 8,+#;  §&2?6ANFFv/7v/54&#" ­$+J47N$Ÿ!ÕqCU,*:j%~´/$S(]0:<"'!hV>"2FF2"><Ü<<ý¢™,1C.<5 /d/ð@8d(E(n *'')€§0<6A NFFv/7v/4&#" é™È!³*3O67O#  "ÕqB %!k'&,$x  ™I~5qH)2FF2!CW<<ý¢r  #S44""5 §7D;A)('NFFv/7v/7.#".5467''7.54632>35!>54&#"ªóqB:bC: ):bQcy5(q´(§$,J44K# Œ+I ^6þÀÈ "# ^<<ý¢2PB $'4b5$€E+@Cx5k=#/BB/=W)#')ð/. ~§4A6AN-,)(F Fv/7v/54&#"„iK6,/CC/.OÎÏ!­$,O64K ™/ãqCM-Kiq&"(!Ü4J5 &"*&qPq5]: ,>B/1<Á<<ý¢¦"'K4$( ÿóÿó9š%).A FFv/7v/;2#54&+#"&="3"&5467.546;5!Åk  þ.ëþàþÛ +$2é4KC"F21F:Rf ³&#')/!ðþw%qq9<<  7 G1éé#q2FF2qG1Jj<Žb'D E +dÿóÿ©zš>)A 0/fFFv/7v/32#5#"#"&546;54&#"3"&5467.546;5! ‡¹þè (!N6UzC5YºS9]…f |°'"&).!ðþu^<<  2 C.÷Œ i /G1Rv<šj'D E +dÿóÿÄòš0C1A "!…FFv/7v/32 ÿrBÁ  #!=U¸—×+%$,C.»þŠŠÁ“ý0& ,?^<<ý¢ (  5 B/Rv5”i(H9 $2Wþ~‚“ +6'5ÿóÿ·+š)C.A \FFv/7v/323 8qCI&Ei );7&Nmµ‹¡Ó.(&0>,Üþrø#K´þâ/'6B]1% ;&^<<ý¢x#&ZEG1?q5Q)L;!!/dþ1,  , F2-ÿóÿ”šI1A ;:FFv/7v/32#5"'7.#".54632>74&#"3"&5467.546;5! ¡Óþè (!#J&cŒB"2< %4DG114&fGdxyU l˜/(,1:)Üþu^<<  2 R:â´=..#/5L1.C'fUHe5…]32#5#"&54632.#"326754&#"3"&5467.546;5! [Œþè (!2UzC 5"1GG1  5R:He‰`t£&#')/!ðþs^<<  , U=ÜP?+,? 5 C$2Y@Pq<”i(M E +dÿó©š7)A FFv/7v/325!3#'#"&'&'7326=# ¶qBÏ(÷([*2((F-Y'þ;ðÁ5 %z$<"Ç..9&û^<<ý¢Œ< 045*&™´ B<!´+(**P(29#´ÿókš-20A 0/FFv/7v/32'>54&#"'#"&'7326=# ™þ©L):R1,C+3+4/3$Õ5þÀ5;"ÿ^<<Œ]C=l%(Y4);.Cþâ(¾!+2 ÿóš6&A,FFv/7v/32'>54&#".5467##"&'7326=! þ0…2He0-6')>,".(%+ d<( Ï6þÇ69'þÿ^<< yU?|5('g:9R2$4(F$"#-þè(ª/.6"­ÿóÿF1šD)A 65wFFv/7v/32#"3267#"&54632654&#"3"$5467.546;5! >XþÍ @.He2$);;) EbK4#?,RuÖ˜¶þÿ=4+22$ðþ]^<<“ 5O6$3'CN7,>&eHfI»„8d<&7PþQÿûÿ|é*A ‘xFFv/7v???10º+-&'.5467þkÎ: xq$@G))þV>:2 ,$3;;)*:ÿóÿß‹š .A QFFv/7v/;#"3267#5!##5'7î7.#".54632>75!5!##5m!é>aB @#7NXHuS1XN>ý¾õqBÈ5ƒÃiQ 4 "N7Bq32#>3"#"&54632#6H*9RN7 8(!*.!(JM–;/,“X9S'- 5x/!ýþ1ÛÉþá C $ 7OnM%DD/<M¦c:*.C/ " xMF(?G7'#n1"W<<“ 0 J49Sd6" …ÿnç 5A 5FFv/7v?/32.#"3### lÿ/’W:$ $ &76wrBq^</­4C< 6'#B<ý¢^ÿtç"5A5FFv/7v?/32.#"3###753# rñ/…X9$$ '60wrBq³CC^<%(´7G< 6'#B<ý¢^ŒIIÿFçKA  5FFv/7v?/32.#"3### dþè!2¦C<N0$$ /B,`rBq^<…CÈ%(Œ(.< :*~<ý¢^ÿ?@ç"7A5FFv/7v?/32.#"3###753# ]þï8­C<N0$$ .C,grBqâII^<Œ<È%(Œ(.< :*~<ý¢^…IIÿóÿßïš3.A 'Q%$! FFv/7v/3232675!5!##5'%5#"&'#Ú4j).S*4K?, <. R-$2´7' aE<<ý¢}ž5¦¤þèEaB;)þè);ÿóÿùeš#.A MFFv/7v/54&"©öqCPj3'X..9SS9#@ ­“0**.ÿóÿÑÔšC3A "J!FFv/7v/32#.'"&54632>54&#"#"&5463!5! áqB“­þ} K! +qP B0.+L4J"1F`  *u:)ƒýÒ^<<ý¢]I5Q$ U?,C]'/ /#2$#'"A)€.$2]®DŠ ç - g ­ Õ û ˆ  Ï  ó Z   •  ¹  ãCopyright (c) 2003, Automatic Control Equipments, Pune, INDIA. Copyright 2006 Modular Infotech Pvt Ltd. Copyright 2009 Red Hat, Inc. Licensed under the GNU General Public License, version 2 (see file COPYING) along with the following exception: As a special exception, if you create a document which uses this font, and embed this font or unaltered portions of this font into the document, this font does not by itself cause the resulting document to be covered by the GNU General Public License. This exception does not however invalidate any other reasons why the document might be covered by the GNU General Public License. If you modify this font, you may extend this exception to your version of the font, but you are not obligated to do so. If you do not wish to do so, delete this exception statement from your version.Copyright (c) 2003, Automatic Control Equipments, Pune, INDIA. Copyright 2006 Modular Infotech Pvt Ltd. Copyright 2009 Red Hat, Inc. Licensed under the GNU General Public License, version 2 (see file COPYING) along with the following exception: As a special exception, if you create a document which uses this font, and embed this font or unaltered portions of this font into the document, this font does not by itself cause the resulting document to be covered by the GNU General Public License. This exception does not however invalidate any other reasons why the document might be covered by the GNU General Public License. If you modify this font, you may extend this exception to your version of the font, but you are not obligated to do so. If you do not wish to do so, delete this exception statement from your version.Lohit HindiLohit HindiRegularRegularACE: Automatic Control Equipments Lohit HindiACE: Automatic Control Equipments Lohit HindiLohit HindiLohit HindiVersion 2.4.3Version 2.4.3Lohit-HindiLohit-Hindiþda  !"#>?@ABC^_`a„ð¸      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrs²³¶·´µ«ïtuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ      !"#$%&'()u0901u0902u0903uni0904u0905u0906u0907u0908u0909u090Au090Bu090Cu090Du090Eu090Fu0910u0911u0912u0913u0914u0915u0916u0917u0918u0919u091Au091Bu091Cu091Du091Eu091Fu0920u0921u0922u0923u0924u0925u0926u0927u0928u0929u092Au092Bu092Cu092Du092Eu092Fu0930u0931u0932u0933u0934u0935u0936u0937u0938u0939u093Cu093Du093Eu093Fu0940u0941u0942u0943u0944u0945u0946u0947u0948u0949u094Au094Bu094Cu094Du0950u0951u0952u0953u0954u0958u0959u095Au095Bu095Cu095Du095Eu095Fu0960u0961u0962u0963u0964u0965u0966u0967u0968u0969u096Au096Bu096Cu096Du096Eu096Fu0970uni0971uni0972uni097Buni097Cuni097Duni097Euni097F afii61664afii301uni25CCSignI_extended_1u0947_u0902.abvsu0947_u0930_u094D.rphf.abvs&u0947_u0930_u094D.rphf.abvs_u0902.abvsu0948_u0902.abvsu0948_u0930_u094D.rphf.abvs&u0948_u0930_u094D.rphf.abvs_u0902.abvsu0930_u094D.rphfu0930_u094D.rphf_u0902.abvsglyph172u0930_u094D.blwfu0936_u0930_u094D.blwf.vatuu095E_u0930_u094D.blwf.vatuu0924_u094D.half_u0924.presu0915_u094D_u0937.akhnu091C_u094D_u091E.akhnu0915_u094D.halfu0916_u094D.halfu0917_u094D.halfu0918_u094D.halfu0919_u094D.halfu091A_u094D.halfu091B_u094D.halfu091C_u094D.halfu091D_u094D.halfu091E_u094D.halfu091F_u094D.halfu0920_u094D.halfu0921_u094D.halfu0922_u094D.halfu0923_u094D.halfu0924_u094D.halfu0925_u094D.halfu0926_u094D.halfu0927_u094D.halfu0928_u094D.halfu0929_u094D.halfu092A_u094D.halfu092B_u094D.halfu092C_u094D.halfu092D_u094D.halfu092E_u094D.halfu092F_u094D.halfglyph206glyph207u0932_u094D.halfu0933_u094D.halfu0934_u094D.halfu0935_u094D.halfu0936_u094D.halfu0937_u094D.halfu0938_u094D.halfu0939_u094D.halfu0958_u094D.halfu0959_u094D.halfu095A_u094D.halfu095B_u094D.halfu095E_u094D.half&u0936_u094D.half_u0930_u094D.blwf.vatu&u0924_u094D.half_u0930_u094D.blwf.vatu&u0924_u094D.half_u0924_u094D.half.pres!u0915_u094D_u0937.akhn_u094D.half!u091C_u094D_u091E.akhn_u094D.halfglyph226glyph227glyph228glyph229glyph230glyph231glyph232u0940_u0902.abvsu0940_u0930_u094D.rphf.abvs&u0940_u0930_u094D.rphf.abvs_u0902.abvsglyph236glyph237glyph238glyph239u0930_u094D.blwf_u0941.blwsu0930_u094D.blwf_u0942.blwsglyph242glyph243glyph244glyph245u0931_u094D.halfglyph247u0915_u0930_u094D.blwf.vatuu0916_u0930_u094D.blwf.vatuu0917_u0930_u094D.blwf.vatuu091C_u0930_u094D.blwf.vatuu091D_u0930_u094D.blwf.vatuu0924_u0930_u094D.blwf.vatuu0926_u0930_u094D.blwf.vatuu092A_u0930_u094D.blwf.vatuu092B_u0930_u094D.blwf.vatuu092C_u0930_u094D.blwf.vatuu092D_u0930_u094D.blwf.vatuu092E_u0930_u094D.blwf.vatuu0935_u0930_u094D.blwf.vatuu0938_u0930_u094D.blwf.vatuu0939_u0930_u094D.blwf.vatuglyph263u0915_u094D.half_u0915.presu0915_u094D.half_u0924.presu0915_u094D.half_u0932.presu0915_u094D.half_u0935.presu0917_u094D.half_u0928.presu0919_u094D.half_u0915.presu0919_u094D.half_u0916.presu0919_u094D.half_u0917.presu0919_u094D.half_u0918.presu0919_u094D.half_u092E.pres,u0919_u094D.half_u0915_u094D_u0937.akhn.presu091A_u094D.half_u091A.presu091B_u094D.half_u0935.presu091C_u094D.half_u091C.presu091E_u094D.half_u091A.presu091E_u094D.half_u091C.presu091F_u094D.half_u091F.presu091F_u094D.half_u0920.presu091F_u094D.half_u092F.presu091F_u094D.half_u0935.presu0920_u094D.half_u0920.presu0920_u094D.half_u092F.presu0921_u094D.half_u0921.presu0921_u094D.half_u0922.presu0921_u094D.half_u092F.presu0922_u094D.half_u0922.presu0922_u094D.half_u092F.presu0926_u094D.half_u0917.presu0926_u094D.half_u0918.presu0926_u094D.half_u0926.presu0926_u094D.half_u0927.presu0926_u094D.half_u0928.presu0926_u094D.half_u092C.presu0926_u094D.half_u092D.presu0926_u094D.half_u092E.presu0926_u094D.half_u092F.presu0926_u094D.half_u0935.presu0928_u094D.half_u0928.presu092A_u094D.half_u0924.presu092A_u094D.half_u0932.presu092B_u094D.half_u0932.presu0932_u094D.half_u0932.pres1u0936_u094D.half_u0930_u094D.blwf.vatu_u091A.pres1u0936_u094D.half_u0930_u094D.blwf.vatu_u0928.pres1u0936_u094D.half_u0930_u094D.blwf.vatu_u0932.pres1u0936_u094D.half_u0930_u094D.blwf.vatu_u0935.presu0937_u094D.half_u091F.presu0937_u094D.half_u0920.presu0939_u094D.half_u0923.presu0939_u094D.half_u0928.presu0939_u094D.half_u092E.presu0939_u094D.half_u092F.presu0939_u094D.half_u0932.presu0939_u094D.half_u0935.pres1u0938_u094D.half_u0924_u0930_u094D.blwf.vatu.pres&u091C_u094D.half_u091C_u094D.half.presu0926_u0943.blwsu0930_u0941.pstsu0930_u0942.pstsu0939_u0943.blwsglyph324u0918_u0930_u094D.blwf.vatuu091A_u0930_u094D.blwf.vatuu0925_u0930_u094D.blwf.vatuu0927_u0930_u094D.blwf.vatuu0928_u0930_u094D.blwf.vatuu0932_u0930_u094D.blwf.vatu&u0919_u094D.half_u0915_u094D.half.halfu094B_u0902.abvsu094B_u0930_u094D.rphf.abvs&u094B_u0930_u094D.rphf.abvs_u0902.abvsu094C_u0902.abvsu094C_u0930_u094D.rphf.abvs&u094C_u0930_u094D.rphf.abvs_u0902.abvsu091E_u0930_u094D.blwf.vatuu0923_u0930_u094D.blwf.vatuu092F_u0930_u094D.blwf.vatuu0937_u0930_u094D.blwf.vatu,u0915_u094D_u0937.akhn_u0930_u094D.blwf.vatu,u091C_u094D_u091E.akhn_u0930_u094D.blwf.vatu&''(0123ijjknovwz{{||}€Š‹Œ¬­´µµ¶¶·øùüý` 2<devaÿÿ  DabvsJakhnPblwfVblws\half¸nukt¾presÄpstsÞrphfþvatuS,  !"#$%&'()*+,-./01 23456789:P;<=>?@ABCDEFGHIJTª²ºÂÊÒÚâêòú "*2:BJRZbjrz‚Š’š¢ª²ºÂÊÒÚâêòú "*2:BJRZbjrz‚Š’š¢ª²ºÂÊÒÚâêòú "*6@H¦ä¨ÊÚð2H^tŠ ¶Ìâø$:Pf|’¨¾Ôê,BXn„š°ÆÜò4J`vŒÀ " ¾ Ô ê   , B X n x ” ° Ì è <Xt¬Èäü ÀÄÈÚÞâ‚žª¬°Sm¼ÖÙêþþ-##.&&/))0++1² .@Rdv€Š”ž¨ ó³ò2 ®³­2 ±³°2 V³U2 Y³X2¯2²2´2ô2W2Z2 nuvyz®±³óVY" º{g»{NEL¶{`LoiLoLoLoLoLoLoLoLoLoLo!Lo"Lo$Lo%Lo'Lo(Lo*Lo8Lo9Lo:Lo?Lo@KpiKpKpKpKpKpKpKpKpKpKp!Kp"Kp$Kp'Kp(Kp*Kp8Kp9Kp:Kp?Kp@2  IqLq úpùoVi¶6.blv€Š”ž¨²¼ÆÐÚäîø  *<FPZdnx‚Œ– ª´¾ÈÒÜæðú",¼{½{¾{¿{À{Á{Â{Ã{Ä{Å{Æ{Ç{È{É{Ê{Ë{Ì{Í{Î{Ï{ Ð{Ð{Ñ{Ò{Ó{Ô{Õ{Ö{ÿ{Ù{Ú{Û{Ü{Ý{Þ{ß{à{á{â{ã{ä{å{æ{é{ê{T¼ç{E_ai„$‡‡(··)º»*ÀÀ,-Š &0:DNXblv€j‚jƒj„j…j†jYj‡jˆjajdj EFGLQRX[_`cNm`NmaRm#Rm&Rm)Rm+Nm!Nm"æ.8BL~ˆ’¤ÆØòXblvˆ’ÄqTX &,º^HGFEeHà  LJ $e#_"P!O &_%P)_(R'Q +_*R è˹T$*06<5e4_3^2]1\/W.V-H6X7T:b @P?OG &,FeEbD_C^BXAS >e=b<X;Jf¼¾ÀÂÃÅÆÇÈÉËÍÏÑÙÞßàæMnòóô MnòóôMnòóôMnòóôMnòóôMnòóô9Mnòóô;Mnòóô‰MnòóôEMnòóôMnòóôMnòóô[Mnòóô‡ KpJo`³{`zDNXblv€Š”ž¨²¼ÆÐÚäîø  *4>HR\fp¶¶¶N¶O¶¶¶[¶\¶¶P¶¶Q¶R¶¶ ¶ ¶ ¶ ¶]¶S¶ ¶·¶^¶¶¶¸¶_¶`¶ç¶æ¶EFGHJLMNSTUVWXZ[\]^_befghi‡º»ËÝŒpŒoõö÷ønòóômÿ–×QmFLMUWbh‚·»PQO×  !"$%'(**,35BEF+HH-TT.[_/Q×¹ABCDG?mÿÕ×jmjm Bdevaÿÿabvmblwm&.60ZŠÎ®\œ¸ A„Š–œ¢¨®´ºÀÆÌÒØÞäêðöü &,28>DJPV\bhntz€†Œ’˜ž¤ª°¶¼ÂÈÎÔÚàæìòøþ×|·Š2B=D-<'z-L/ʇÒe)bO‚—2L:|ÔŸŠ´œJÿ«’´'ÿ‘ŽWÿvÚÿ¦Âÿ¦ºÿ‹ïÿ–ôÿÁÄÿ™4ÿ‹7ÿ›6 ÿn?ÿ–rÿŽšÿNRÿ“¿Yÿ±Úÿó™ÿ®ôÊ ! ß Òÿáÿ–d R<ydœ7êA;EFIKOPQRSV[_cdi…†‡‰¸ !"#$%'(*,-./012589:=?@ABCDEF opqr{‹Œ¶ùúûü 28>DJPV\bhntÿq=ÿ~Eÿ2ÿ~Eÿ‰*ÿs%ÿv"ÿyJÿ?ÿ:ÿ~ÿãÿvÿÞ&,  7?uv1ÿ:.@  7çoOGÏonyzõ1ÿ¶< U¬²¸¾ÄÊÐÖÜâèîôú $*06<BHNTZ`flrx~„Š–œ¢¨®´ºÀÆÌÒØÞäêðöü &,28>DJPV\bhntz€†Œ’˜ž¤|˜˜y˜·C͘Ř̘ ˜}˜µ˜‚˜ú˜ó˜÷˜˜T˜X˜[˜¥˜¦˜ï˜¬˜˜Þ˜+˜¡š˜Ç˜Äš”˜‚˜—š˜¿˜Ð˜K˜O™U˜˜˜š™!˜“š@˜‘š˜Ã˜ˆš[˜ö˜«˜{˜Ñ™Óš|˜†—Tšñš–™B˜œ˜šC™Œš›šš²˜Š˜“™ç˜÷˜Ö˜Ùšð˜ìš˜î˜¡˜¦˜a™š˜¥˜¤˜˜˜5;??Ei‰-›6Ÿ 9·¸;º»=?  @AE99K<<LAFMJKS12sv}}€­´ FLRX^djpv|‚ˆŽ”š ¦ÿˆšÿ{šÿ™ÿ™ÿ†˜ÿy˜ÿšÿ»˜ÿq™ÿ†|ÿ‹„ÿ„ÿv|ÿ‘wÿ™wÿ¹yÿ“|–&.6>FNV^fnv~†Ž2í22Aÿ÷2]ÿŸ2wÿ“2÷2Bÿ©2³2ÿ2ÿŒ2 ÿó2mÿ…2Wÿ2ÿ—mtz®±×ìîðóõ÷VYð8@HPX`hpx€ˆ˜ ¨°¸ÀÈÐØàèj+jÊÿÍj3Ujÿëjÿ«ÿðj+jÿÅjøÿØj8]jÿè]jÿåhj=`jÿÛ[jšpj]]jcpjXˆjÿ…UjckjÿÕ]jmjÿ¨uj;;HKMPSWZZ \^bbeiÆe·ÊÁA£9ƨ£PyICU-1.9.5/test/noms.txt0000644000076500000000000000006110413621043015345 0ustar vajdawheel00000000000000école enfant faon fille demain Dominique ÉlevéPyICU-1.9.5/test/test_BreakIterator.py0000644000076500000000000000451213011412542020003 0ustar vajdawheel00000000000000# ==================================================================== # Copyright (c) 2005-2011 Open Source Applications Foundation. # # Permission is hereby granted, free of charge, to any person obtaining a # copy of this software and associated documentation files (the "Software"), # to deal in the Software without restriction, including without limitation # the rights to use, copy, modify, merge, publish, distribute, sublicense, # and/or sell copies of the Software, and to permit persons to whom the # Software is furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included # in all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS # OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING # FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER # DEALINGS IN THE SOFTWARE. # ==================================================================== # import sys, os from unittest import TestCase, main from icu import * class TestBreakIterator(TestCase): def assertIsInstance(self, obj, cls): if hasattr(TestCase, 'assertIsInstance'): TestCase.assertIsInstance(self, obj, cls) else: self.assertTrue(isinstance(obj, cls), u'%s is not an instance of %s' % (obj, cls)) def testCreateInstancePolymorph(self): bi = BreakIterator.createWordInstance(Locale.getEnglish()) self.assertIsInstance(bi, RuleBasedBreakIterator) bi = BreakIterator.createLineInstance(Locale.getEnglish()) self.assertIsInstance(bi, RuleBasedBreakIterator) bi = BreakIterator.createCharacterInstance(Locale.getEnglish()) self.assertIsInstance(bi, RuleBasedBreakIterator) bi = BreakIterator.createSentenceInstance(Locale.getEnglish()) self.assertIsInstance(bi, RuleBasedBreakIterator) bi = BreakIterator.createTitleInstance(Locale.getEnglish()) self.assertIsInstance(bi, RuleBasedBreakIterator) if __name__ == "__main__": main() PyICU-1.9.5/test/test_Charset.py0000644000076500000000000000500213011412542016631 0ustar vajdawheel00000000000000# ==================================================================== # Copyright (c) 2007-2010 Open Source Applications Foundation. # # Permission is hereby granted, free of charge, to any person obtaining a # copy of this software and associated documentation files (the "Software"), # to deal in the Software without restriction, including without limitation # the rights to use, copy, modify, merge, publish, distribute, sublicense, # and/or sell copies of the Software, and to permit persons to whom the # Software is furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included # in all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS # OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING # FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER # DEALINGS IN THE SOFTWARE. # ==================================================================== # import sys, os from unittest import TestCase, main from icu import * # We use u'stuff'.encode('encoding') instead of b'stuff' to represent # bytes using literals. This is to ensure 2to3 doesn't turn things # into unicode literals, but also to keep compatibility with Python # pre 2.6, which didn't know about the b prefix to literals. class TestCharset(TestCase): def testDetect(self): detector = CharsetDetector() detector.setText(u'foo'.encode('ascii')) match = detector.detect() self.assertTrue(match.getName() == 'UTF-8') def testDetectAll(self): detector = CharsetDetector(u'foo'.encode('ascii')) matches = detector.detectAll() self.assertTrue(matches[0].getName() == 'UTF-8') def testDeclared(self): bytes = u'beaut\xe9 probable'.encode('iso-8859-1') detector = CharsetDetector(bytes, 'iso-8859-1') self.assertTrue("ISO-8859-1" in (m.getName() for m in detector.detectAll())) def testUnicode(self): bytes = u'beaut\xe9 probable'.encode('iso-8859-1') ustring = unicode(CharsetDetector(bytes).detect()) self.assertTrue(ustring.encode('iso-8859-1') == bytes) if __name__ == "__main__": main() PyICU-1.9.5/test/test_Collator.py0000644000076500000000000001253613011412542017031 0ustar vajdawheel00000000000000# ==================================================================== # Copyright (c) 2005-2011 Open Source Applications Foundation. # # Permission is hereby granted, free of charge, to any person obtaining a # copy of this software and associated documentation files (the "Software"), # to deal in the Software without restriction, including without limitation # the rights to use, copy, modify, merge, publish, distribute, sublicense, # and/or sell copies of the Software, and to permit persons to whom the # Software is furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included # in all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS # OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING # FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER # DEALINGS IN THE SOFTWARE. # ==================================================================== # import sys, os from unittest import TestCase, main from icu import * class TestCollator(TestCase): def filePath(self, name): module = sys.modules[TestCollator.__module__].__file__ return os.path.join(os.path.dirname(module), name) def assertIsInstance(self, obj, cls): if hasattr(TestCase, 'assertIsInstance'): TestCase.assertIsInstance(self, obj, cls) else: self.assertTrue(isinstance(obj, cls), u'%s is not an instance of %s' % (obj, cls)) def testSort(self): collator = Collator.createInstance(Locale.getFrance()) input = open(self.filePath('noms.txt'), 'rb') names = [unicode(n.strip(), 'utf-8') for n in input.readlines()] input.close() ecole = names[0] names.sort() self.assertTrue(names[-1] is ecole) if (sys.version_info >= (3,)): names.sort(key=collator.getSortKey) else: names.sort(collator.compare) self.assertTrue(names[2] is ecole) def testCreateInstancePolymorph(self): collator = Collator.createInstance(Locale("epo")) # Esperanto self.assertIsInstance(collator, RuleBasedCollator) rules = collator.getRules() def testGetSortKey(self): # Do not test sort key byte sequences directly: # They are unstable, that is, likely to change # with every UCA/CLDR/ICU release. # Instead, test that compare() is consistent with # comparing the equivalent sort keys. collator = Collator.createInstance(Locale.getJapanese()) collator.setAttribute(UCollAttribute.NORMALIZATION_MODE, UCollAttributeValue.ON) collator.setAttribute(UCollAttribute.ALTERNATE_HANDLING, UCollAttributeValue.SHIFTED) collator.setAttribute(UCollAttribute.STRENGTH, UCollAttributeValue.TERTIARY) # In Japanese, the following characters should be different # only on quaternary level. hira_ge = u'\u3052' # Hiragana letter Ge kana_ge = u'\u30B2' # Katakana letter Ge self.assertEqual(0, collator.compare(hira_ge, kana_ge)) hira_ge_key = collator.getSortKey(hira_ge) kana_ge_key = collator.getSortKey(kana_ge) self.assertEqual(hira_ge_key, kana_ge_key) collator.setAttribute(UCollAttribute.STRENGTH, UCollAttributeValue.QUATERNARY) self.assertEqual(-1, collator.compare(hira_ge, kana_ge)) hira_ge_key = collator.getSortKey(hira_ge) kana_ge_key = collator.getSortKey(kana_ge) self.assertTrue(hira_ge_key < kana_ge_key) def setupCollator(self, collator): collator.setAttribute(UCollAttribute.NORMALIZATION_MODE, UCollAttributeValue.ON) collator.setAttribute(UCollAttribute.CASE_FIRST, UCollAttributeValue.UPPER_FIRST) collator.setAttribute(UCollAttribute.ALTERNATE_HANDLING, UCollAttributeValue.SHIFTED) collator.setAttribute(UCollAttribute.STRENGTH, UCollAttributeValue.QUATERNARY) collator.setAttribute(UCollAttribute.HIRAGANA_QUATERNARY_MODE, UCollAttributeValue.ON) def LoadCollatorFromRules(self): rules = u"&z<\u00e6 &h= '4.6': collator = self.LoadCollatorFromRules() s = u'hchz\u00e6' key0 = collator.getSortKey(s) bin = collator.cloneBinary() collator = self.LoadCollatorFromBinaryBuffer(bin) key1 = collator.getSortKey(s) self.assertTrue(key0 == key1) if __name__ == "__main__": main() PyICU-1.9.5/test/test_DateTimeParserGenerator.py0000644000076500000000000001113713011412542021766 0ustar vajdawheel00000000000000# -*- coding: utf-8 -*- # ==================================================================== # Copyright (c) 2016-2016 Open Source Applications Foundation. # # Permission is hereby granted, free of charge, to any person obtaining a # copy of this software and associated documentation files (the "Software"), # to deal in the Software without restriction, including without limitation # the rights to use, copy, modify, merge, publish, distribute, sublicense, # and/or sell copies of the Software, and to permit persons to whom the # Software is furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included # in all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS # OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING # FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER # DEALINGS IN THE SOFTWARE. # ==================================================================== # from unittest import TestCase, main from icu import * # These tests were lifted from the examples in ``dtptngsample.cpp`` in icu4c class TestDateTimePatternGenerator(TestCase): def setUp(self): cal = Calendar.createInstance() cal.setTimeZone(TimeZone.getGMT()) cal.set(2016, 4, 10, 0, 30, 0) # month value is 0-based self.date = cal.getTime() self.tz = TimeZone.createTimeZone('America/Los_Angeles') def testAddPattern(self): """Test overwriting a pattern with the same skeleton.""" locale = Locale.getFrance() dtpg = DateTimePatternGenerator.createInstance(locale) sdf = SimpleDateFormat(dtpg.getBestPattern('MMMMddHmm'), locale) sdf.setTimeZone(self.tz) self.assertEqual(sdf.format(self.date), u'09 mai à 17:30') self.assertEqual(sdf.toPattern(), u"dd MMMM 'à' HH:mm") dtpg.addPattern("dd'. von' MMMM", True) sdf.applyPattern(dtpg.getBestPattern('MMMMddHmm')) sdf.setTimeZone(self.tz) self.assertEqual(sdf.format(self.date), u'09. von mai à 17:30') self.assertEqual(sdf.toPattern(), u"dd'. von' MMMM 'à' HH:mm") def testGetBestPattern(self): """Test a few different languages and common patterns.""" skeletons = ('yQQQQ', # year + full name of quarter, i.e., 4th quarter 1999 'yMMMM', # year + full name of month, i.e., October 1999 'MMMMd', # full name of month + day of the month, i.e., October 25 'hhmm', # 12-hour-cycle format, i.e., 1:32 PM 'jjmm') # preferred hour format for the given locale, i.e., 24-hour-cycle format for fr_FR locales = ((Locale('en_US'), (u'2nd quarter 2016', u'May 2016', u'May 9', u'5:30 PM', u'5:30 PM')), (Locale('fr_FR'), (u'2e trimestre 2016', u'mai 2016', u'9 mai', u'5:30 PM', u'17:30')), (Locale('zh_CN'), (u'2016年第2季度', u'2016å¹´5月', u'5月9æ—¥', u'下åˆ5:30', u'下åˆ5:30')),) for locale, locale_data in locales: dtpg = DateTimePatternGenerator.createInstance(locale) for index, skeleton in enumerate(skeletons): pattern = dtpg.getBestPattern(skeleton) sdf = SimpleDateFormat(pattern, locale) sdf.setTimeZone(self.tz) self.assertEqual(sdf.format(self.date), locale_data[index]) def testReplaceFieldType(self): """Test replacing an element of a pattern.""" locale = Locale.getFrance() dtpg = DateTimePatternGenerator.createInstance(locale) sdf = SimpleDateFormat('EEEE d MMMM y HH:mm:ss zzzz', locale) sdf.setTimeZone(self.tz) pattern = sdf.toPattern() self.assertEqual(pattern, u'EEEE d MMMM y HH:mm:ss zzzz') self.assertEqual(sdf.format(self.date), u'lundi 9 mai 2016 17:30:00 heure d’été du Pacifique') newPattern = dtpg.replaceFieldTypes(pattern, 'vvvv') sdf.applyPattern(newPattern) sdf.setTimeZone(self.tz) self.assertEqual(sdf.toPattern(), u'EEEE d MMMM y HH:mm:ss vvvv') self.assertEqual(sdf.format(self.date), u'lundi 9 mai 2016 17:30:00 heure du Pacifique nord-américain') if __name__ == '__main__': main() PyICU-1.9.5/test/test_LayoutEngine.py0000644000076500000000000001043513011412542017651 0ustar vajdawheel00000000000000# -*- coding: utf-8 -*- # ==================================================================== # Copyright (c) 2011-2011 Open Source Applications Foundation. # # Permission is hereby granted, free of charge, to any person obtaining a # copy of this software and associated documentation files (the "Software"), # to deal in the Software without restriction, including without limitation # the rights to use, copy, modify, merge, publish, distribute, sublicense, # and/or sell copies of the Software, and to permit persons to whom the # Software is furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included # in all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS # OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING # FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER # DEALINGS IN THE SOFTWARE. # ==================================================================== # import sys, os from unittest import TestCase, main from icu import * try: if ICU_VERSION >= '58': raise NotImplementedError from fontTools.ttLib import TTFont except ImportError, e: print >>sys.stderr, "\nfontTools package not found, skipping LayoutEngine tests\n" except NotImplementedError: print >>sys.stderr, "\nLayoutEngine not available in ICU %s" %(ICU_VERSION) else: class TTXLEFont(LEFontInstance): def __init__(self, fname, size=12): super(TTXLEFont, self).__init__() self.ttx = TTFont(fname) self.size = size self.upem = self.ttx['head'].unitsPerEm self.cmap = self.ttx['cmap'].getcmap(3, 1).cmap def getFontTable(self, table): return self.ttx.getTableData(table) def getAscent(self): self.ttx['hhea'].ascent * self.size * 1. / self.upem def getDescent(self): self.ttx['hhea'].descent * self.size * 1. / self.upem def getLeading(self): self.ttx['hhea'].lineGap * self.size * 1. / self.upem def getUnitsPerEm(self): return self.upem def mapCharToGlyph(self, code): return self.ttx.getGlyphID(self.cmap[code]) def getGlyphAdvance(self, glyph): if glyph >= self.ttx['maxp'].numGlyphs: return (0., 0.) name = self.ttx.getGlyphName(glyph) x = self.ttx['hmtx'][name][0] * self.size * 1. / self.upem if 'vmtx' in self.ttx: y = self.ttx['vmtx'][name][0] * self.size * 1. / self.upem else: y = 0. return (x, y) def getGlyphPoint(self, glyph, point): return (0., 0.) def getXPixelsPerEm(self): return self.size def getYPixelsPerEm(self): return self.size def getScaleFactorX(self): return 1. def getScaleFactorY(self): return 1. try: if ICU_VERSION >= '58': raise NotImplementedError import fontTools except ImportError: pass except NotImplementedError: pass else: class TestLayoutEngine(TestCase): def filePath(self, name): module = sys.modules[TestLayoutEngine.__module__].__file__ return os.path.join(os.path.dirname(module), name) def setUp(self): self.font = TTXLEFont(self.filePath("lohit_hi.ttf")) self.layout = LayoutEngine.layoutEngineFactory(self.font, ScriptCode.deva, LanguageCode.nul) def testHello(self): self.layout.layoutChars(u"नमसà¥à¤¤à¥‡ दà¥à¤¨à¤¿à¤¯à¤¾") self.assertEqual(self.layout.getGlyphCount(), 13) if __name__ == "__main__": try: if ICU_VERSION >= '58': raise NotImplementedError import fontTools except ImportError: pass except NotImplementedError: pass else: main() PyICU-1.9.5/test/test_ListFormatter.py0000644000076500000000000000344513011412542020050 0ustar vajdawheel00000000000000# ==================================================================== # Copyright (c) 2014 Open Source Applications Foundation. # # Permission is hereby granted, free of charge, to any person obtaining a # copy of this software and associated documentation files (the "Software"), # to deal in the Software without restriction, including without limitation # the rights to use, copy, modify, merge, publish, distribute, sublicense, # and/or sell copies of the Software, and to permit persons to whom the # Software is furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included # in all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS # OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING # FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER # DEALINGS IN THE SOFTWARE. # ==================================================================== # import sys, os from unittest import TestCase, main from icu import * class TestListFormatter(TestCase): def testDefault(self): Locale.setDefault(Locale.getUS()) formatter = ListFormatter.createInstance() text = formatter.format(('a', 'b', 'c')) self.assertTrue(text == u'a, b, and c') def testLocale(self): formatter = ListFormatter.createInstance(Locale.getFrance()) text = formatter.format(('a', 'b', 'c')) self.assertTrue(text == u'a, b et c') if __name__ == "__main__": main() PyICU-1.9.5/test/test_LocaleData.py0000644000076500000000000002353513011412542017244 0ustar vajdawheel00000000000000# ==================================================================== # Copyright (c) 2007-2013 Open Source Applications Foundation. # # Permission is hereby granted, free of charge, to any person obtaining a # copy of this software and associated documentation files (the "Software"), # to deal in the Software without restriction, including without limitation # the rights to use, copy, modify, merge, publish, distribute, sublicense, # and/or sell copies of the Software, and to permit persons to whom the # Software is furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included # in all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS # OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING # FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER # DEALINGS IN THE SOFTWARE. # ==================================================================== # # This is a python translation of ICU's LocaleDataTest.java import sys, os from unittest import TestCase, main from icu import * NOT_FOUND_ERR = 'The requested resource cannot be found, error code: 2' def print_output(string): pass class ExemplarGroup: def __init__(_self, s, scriptCodes): _self.set = s _self.scs = scriptCodes def __hash__(_self): hash = 0 for i in range(len(_self.scs) if len(_self.scs) < 4 else 4): hash = (hash << 8) + _self.scs[i] return hash def __eq__(_self, other): return (_self.set == other.set) and (_self.scs == other.scs) class TestLocaleData(TestCase): def setUp(self): self.availableLocales = Locale.getAvailableLocales() def testPapersize(self): for locale in self.availableLocales.keys(): papersize = LocaleData(locale).getPaperSize() #language = Locale(locale).getLanguage() country = Locale(locale).getCountry() if (['BZ','CA','CL','CO','CR','GT','MX','NI','PA','PH','PR','SV','US','VE'].count(country) > 0): self.assertTrue(papersize == (279, 216)) elif country: self.assertTrue(papersize == (297, 210)) def testMeasurementSystem(self): for locale in self.availableLocales.keys(): measurementSystem = LocaleData(locale).getMeasurementSystem() #language = Locale(locale).getLanguage() country = Locale(locale).getCountry() # 0 means SI, 1 means US, 2 mean UK if (country in ['LR', 'MM', 'US']): self.assertTrue(measurementSystem == 1) elif country in ['GB']: self.assertTrue(measurementSystem in [0, 2]) elif country: self.assertTrue(measurementSystem == 0) def testExemplarSet(self): testedExemplars = set() equalCount = 0 for locale in self.availableLocales: scriptCodes = Script.getCode(locale) exemplarSets = [] for k in range(2): # it seems USET_CASE_INSENSITIVE = 2 option = 0 if k == 0 else 2 # standard = 0, auxiliary = 1, index = 2, count = 3 exemplarSet = LocaleData(locale).getExemplarSet(option, 0) exemplarSets.append(exemplarSet) exGrp = ExemplarGroup(exemplarSet, scriptCodes) if (not exGrp in testedExemplars): testedExemplars.add(exGrp) sets = [] for j in range(len(scriptCodes)): sets.append(UnicodeSet('[:' + Script(scriptCodes[j]).getShortName() + ':]')) existsInScript = False iter = UnicodeSetIterator(exemplarSet) while (not existsInScript and iter.nextRange()): if (iter.getCodepoint != iter.isString()): for j in range(len(sets)): if sets[j].contains(iter.getCodepoint(), iter.getCodepointEnd()): existsInScript = True break else: for j in range(len(sets)): if sets[j].contains(iter.getString): existsInScript = True break if existsInScript == False: print_output("ExemplarSet containment failed for locale : "+ locale) print_output(locale + " exemplar " + repr(unicode(exemplarSets[0]))) print_output(locale + " exemplar(case-folded) " + repr(unicode(exemplarSets[1]))) self.assertTrue(locale + " case-folded is a superset", exemplarSets[1].containsAll(exemplarSets[0])) if (exemplarSets[1] == exemplarSets[0]): ++equalCount self.assertTrue("case-folded is sometimes a strict superset, and sometimes equal",\ equalCount > 0 and equalCount < len(self.availableLocales)) def testExemplarSet2(self): testedExemplars = set() equalCount = 0 for locale in self.availableLocales: ld = LocaleData(locale) scriptCodes = Script.getCode(locale) exemplarSets = [] for k in range(2): # for casing option in (normal, uncased) # it seems USET_CASE_INSENSITIVE = 2 option = 0 if k == 0 else 2 for h in range(2): esType = 0 if h == 0 else 1 # standard = 0, auxiliary = 1, index = 2, count = 3 exemplarSet = LocaleData(locale).getExemplarSet(option, esType) exemplarSets.append(exemplarSet) exGrp = ExemplarGroup(exemplarSet, scriptCodes) if (not exGrp in testedExemplars): testedExemplars.add(exGrp) sets = [] for j in range(len(scriptCodes)): sets.append(UnicodeSet('[:' + Script(scriptCodes[j]).getShortName() + ':]')) existsInScript = False iter = UnicodeSetIterator(exemplarSet) while (not existsInScript and iter.nextRange()): if (iter.getCodepoint != iter.isString()): for j in range(len(sets)): if sets[j].contains(iter.getCodepoint(), iter.getCodepointEnd()): existsInScript = True break else: for j in range(len(sets)): if sets[j].contains(iter.getString): existsInScript = True break if existsInScript == False and h == 0: print_output("ExemplarSet containment failed for locale,option,type : " \ + locale + "," + str(option) + "," + str(esType)) print_output(locale + " exemplar(ES_STANDARD)" + repr(unicode(exemplarSets[0]))) print_output(locale + " exemplar(ES_AUXILIARY)" + repr(unicode(exemplarSets[1]))) print_output(locale + " exemplar(case-folded,ES_STANDARD)" + repr(unicode(exemplarSets[2]))) print_output(locale + " exemplar(case-folded,ES_AUXILIARY)" + repr(unicode(exemplarSets[3]))) self.assertTrue(locale + " case-folded is a superset", exemplarSets[2].containsAll(exemplarSets[0])) self.assertTrue(locale + " case-folder is a superset", exemplarSets[3].containsAll(exemplarSets[1])) if (exemplarSets[2] == exemplarSets[0]): ++equalCount if (exemplarSets[3] == exemplarSets[1]): ++equalCount self.assertTrue("case-folded is sometimes a strict superset, and sometimes equal",\ equalCount > 0 and equalCount < len(self.availableLocales) * 2) def testCoverage(self): ld = LocaleData(Locale().getName()) t = ld.getNoSubstitute() ld.setNoSubstitute(t) self.assertEqual(t, ld.getNoSubstitute()) for i in range(4): print_output(repr(ld.getDelimiter(i))) def testLocaleDisplayPattern(self): ld = LocaleData(Locale().getName()) print_output("Default locale LocaleDisplayPattern:" + ld.getLocaleDisplayPattern()); print_output("Default locale LocaleSeparator:" + ld.getLocaleSeparator()); for locale in self.availableLocales: ld = LocaleData(locale) try: print_output(locale + " LocaleDisplayPattern:" + repr(ld.getLocaleDisplayPattern())) getLocaleDisplayPattern = True except ICUError, e: # resource not found getLocaleDisplayPattern = str(e) == NOT_FOUND_ERR except: getLocaleDisplayPattern = False self.assertTrue(getLocaleDisplayPattern) try: print_output(locale + " LocaleSeparator:" + repr(ld.getLocaleSeparator())) getLocaleSeparator = True except ICUError, e: # resource not found getLocaleSeparator = str(e) == NOT_FOUND_ERR except: getLocaleSeparator = False self.assertTrue(getLocaleSeparator) if __name__ == "__main__": main() PyICU-1.9.5/test/test_MessageFormat.py0000644000076500000000000000750513011412542020007 0ustar vajdawheel00000000000000# -*- coding: utf-8 -*- # ==================================================================== # Copyright (c) 2005-2010 Open Source Applications Foundation. # # Permission is hereby granted, free of charge, to any person obtaining a # copy of this software and associated documentation files (the "Software"), # to deal in the Software without restriction, including without limitation # the rights to use, copy, modify, merge, publish, distribute, sublicense, # and/or sell copies of the Software, and to permit persons to whom the # Software is furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included # in all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS # OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING # FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER # DEALINGS IN THE SOFTWARE. # ==================================================================== # import sys, os from unittest import TestCase, main from icu import * class TestMessageFormat(TestCase): def testFormatMessage(self): x = 'x' f = Formattable(UnicodeString(x)) text = MessageFormat.formatMessage("This is a string: {0}.", [f]) self.assertTrue(text == "This is a string: x.") def testFormat(self): x = 'x' f = Formattable(UnicodeString(x)) msgFormat = MessageFormat("This is a string: {0}") text = msgFormat.format([f], FieldPosition()) self.assertTrue(text == "This is a string: x") if (sys.version_info < (3,) and 'PyPy' not in sys.version): # Reduced features of % operator might be intentional f = UnicodeString(x) text = msgFormat % f self.assertTrue(text == "This is a string: x") def testFormatAppend(self): x = 'x' f = Formattable(UnicodeString(x)) msgFormat = MessageFormat("This is a string: {0}") text = msgFormat.format([f], UnicodeString("x"), FieldPosition()) self.assertTrue(text == "xThis is a string: x") def testFormats(self): orig = TimeZone.createDefault().getID() tzid = 'America/Indiana/Vevay' msgFormat = MessageFormat("{0,time,short} {0,time,z}") formats = msgFormat.getFormats() formats[0].setTimeZone(TimeZone.createTimeZone(tzid)) self.assertTrue(msgFormat.getFormats()[0].getTimeZone().getID() == orig) msgFormat.setFormats(formats) self.assertTrue(msgFormat.getFormats()[0].getTimeZone().getID() == tzid) def testSelectFormat(self): try: from icu import SelectFormat except ImportError: return format = u"{0} est {1, select, female {allée} other {allé}} à Paris." msgFormat = MessageFormat(format, Locale("fr")) args = [Formattable("Kirti"), Formattable("female")] self.assertTrue(msgFormat.format(args) == u"Kirti est allée à Paris.") def testNamedArgs(self): if ICU_VERSION >= '4.0': msg = \ '{num_emails_to_send, plural, ' \ '=0 {unused plural form} ' \ '=1 {One email will be sent.} ' \ 'other {# emails will be sent.}}' messageFormat = MessageFormat(msg, Locale("en")) name0 = "num_emails_to_send" arg0 = Formattable(5) result = messageFormat.format([name0], [arg0]) self.assertTrue(result == u'5 emails will be sent.') if __name__ == "__main__": main() PyICU-1.9.5/test/test_Normalizer.py0000644000076500000000000000357413011412542017376 0ustar vajdawheel00000000000000# -*- coding: utf-8 -*- # ==================================================================== # Copyright (c) 2009-2010 Open Source Applications Foundation. # # Permission is hereby granted, free of charge, to any person obtaining a # copy of this software and associated documentation files (the "Software"), # to deal in the Software without restriction, including without limitation # the rights to use, copy, modify, merge, publish, distribute, sublicense, # and/or sell copies of the Software, and to permit persons to whom the # Software is furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included # in all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS # OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING # FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER # DEALINGS IN THE SOFTWARE. # ==================================================================== # import sys, os from unittest import TestCase, main from icu import * class TestNormalizer2(TestCase): def testNormalize(self): try: from icu import Normalizer2 except ImportError: return normalizer = Normalizer2.getInstance(None, "nfkc_cf", UNormalizationMode2.COMPOSE) self.assertTrue(normalizer.normalize("Hi There") == u'hi there') a = UnicodeString() normalizer.normalize("Hi There", a) self.assertTrue(a == UnicodeString(u'hi there')) if __name__ == "__main__": main() PyICU-1.9.5/test/test_Script.py0000644000076500000000000000622513011412542016514 0ustar vajdawheel00000000000000# ==================================================================== # Copyright (c) 2016-2016 Open Source Applications Foundation. # # Permission is hereby granted, free of charge, to any person obtaining a # copy of this software and associated documentation files (the "Software"), # to deal in the Software without restriction, including without limitation # the rights to use, copy, modify, merge, publish, distribute, sublicense, # and/or sell copies of the Software, and to permit persons to whom the # Software is furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included # in all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS # OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING # FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER # DEALINGS IN THE SOFTWARE. # ==================================================================== # import sys, os from unittest import TestCase, main from icu import * # python2 can be build with 16- or 32-bit unicode chars (UCS2 or UCS4) # python3 uses 32-bit unicode chars (logically) def is_unicode_32bit(): return len(u'\U0001f600') == 1 class TestScript(TestCase): def testSurrogatePairs(self): pairs = u'a\u0950\u4e2d\U00029efa' unicode_32bit = is_unicode_32bit() names = [Script.getScript(cp).getShortName() for cp in pairs] if unicode_32bit: self.assertEqual(['Latn', 'Deva', 'Hani', 'Hani'], names) else: self.assertEqual(['Latn', 'Deva', 'Hani', 'Zzzz', 'Zzzz'], names) pairs = UnicodeString(pairs) names = [Script.getScript(cp).getShortName() for cp in pairs] if unicode_32bit: self.assertEqual(['Latn', 'Deva', 'Hani', 'Hani', 'Hani'], names) else: self.assertEqual(['Latn', 'Deva', 'Hani', 'Zzzz', 'Zzzz'], names) names = [Script.getScript(pairs.char32At(i)).getShortName() for i in xrange(pairs.countChar32())] self.assertEqual(['Latn', 'Deva', 'Hani', 'Hani'], names) iterator = StringCharacterIterator(pairs) names = [] while iterator.hasNext(): desc = Script.getScript(iterator.next32PostInc()).getShortName() names.append(desc) self.assertEqual(['Latn', 'Deva', 'Hani', 'Hani'], names) def testSmileyFace(self): char = u'\U0001f600' u = UnicodeString(char) self.assertEqual(u.countChar32(), 1) if sys.version_info >= (3,): self.assertEqual(len(char), 1) self.assertEqual(str(u), char) elif is_unicode_32bit(): self.assertEqual(len(char), 1) self.assertEqual(unicode(u), char) else: self.assertEqual(len(char), 2) self.assertEqual(unicode(u), char) if __name__ == "__main__": main() PyICU-1.9.5/test/test_Spoof.py0000644000076500000000000001551313011412542016336 0ustar vajdawheel00000000000000# ==================================================================== # Copyright (c) 2014-2014 Open Source Applications Foundation. # # Permission is hereby granted, free of charge, to any person obtaining a # copy of this software and associated documentation files (the "Software"), # to deal in the Software without restriction, including without limitation # the rights to use, copy, modify, merge, publish, distribute, sublicense, # and/or sell copies of the Software, and to permit persons to whom the # Software is furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included # in all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS # OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING # FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER # DEALINGS IN THE SOFTWARE. # ==================================================================== # import sys, os from unittest import TestCase, main from icu import * class TestSpoofChecker(TestCase): def setUp(self): self.checker = SpoofChecker() def testCheck(self): checks = self.checker.check("xyz") self.assertEqual(checks, 0) def testAreConfusable(self): checks = self.checker.areConfusable("cxs", u"\u0441\u0445\u0455") self.assertEqual(checks, (USpoofChecks.MIXED_SCRIPT_CONFUSABLE | USpoofChecks.WHOLE_SCRIPT_CONFUSABLE)) checks = self.checker.areConfusable( "A long string that will overflow stack buffers. A long string that will overflow stack buffers. A long string that will overflow stack buffers. A long string that will overflow stack buffers. ", "A long string that wi11 overflow stack buffers. A long string that will overflow stack buffers. A long string that wi11 overflow stack buffers. A long string that will overflow stack buffers. ") self.assertEqual(checks, USpoofChecks.SINGLE_SCRIPT_CONFUSABLE) def testGetSkeleton(self): ML = 0 SL = USpoofChecks.SINGLE_SCRIPT_CONFUSABLE MA = USpoofChecks.ANY_CASE SA = USpoofChecks.SINGLE_SCRIPT_CONFUSABLE | USpoofChecks.ANY_CASE def checkSkeleton(checks, string, result): skeleton = self.checker.getSkeleton(checks, string) self.assertEqual(skeleton, result) checkSkeleton(MA, "I1l0O", "lllOO") # A long "identifier" that will overflow implementation stack buffers, # forcing heap allocations. checkSkeleton(SL, u" A 1ong \u02b9identifier' that will overflow implementation stack buffers, forcing heap allocations. A 1ong 'identifier' that will overflow implementation stack buffers, forcing heap allocations. A 1ong 'identifier' that will overflow implementation stack buffers, forcing heap allocations. A 1ong 'identifier' that will overflow implementation stack buffers, forcing heap allocations.", u" A long 'identifier' that vvill overflovv irnplernentation stack buffers, forcing heap allocations. A long 'identifier' that vvill overflovv irnplernentation stack buffers, forcing heap allocations. A long 'identifier' that vvill overflovv irnplernentation stack buffers, forcing heap allocations. A long 'identifier' that vvill overflovv irnplernentation stack buffers, forcing heap allocations.") checkSkeleton(SL, "nochange", "nochange") checkSkeleton(MA, "love", "love") checkSkeleton(MA, "1ove", "love") # Digit 1 to letter l checkSkeleton(ML, "OOPS", "OOPS") if ICU_VERSION < '55.1': # Digit 0 unchanged in lower case mode. checkSkeleton(ML, "00PS", "00PS") else: checkSkeleton(ML, "00PS", "OOPS") checkSkeleton(MA, "OOPS", "OOPS") checkSkeleton(MA, "00PS", "OOPS") # Digit 0 to letter O in any case mode only checkSkeleton(SL, u"\u059c", u"\u0301") checkSkeleton(SL, u"\u2A74", u"\u003A\u003A\u003D") checkSkeleton(SL, u"\u247E", u"\u0028\u006C\u006C\u0029") # "(ll)" if ICU_VERSION < '55.1': checkSkeleton(SL, u"\uFDFB", u"\u062C\u0644\u0020\u062C\u0644\u0627\u0644\u0647") else: checkSkeleton(SL, u"\uFDFB", u"\u062C\u0644\u0020\u062c\u0644l\u0644o") # This mapping exists in the ML and MA tables, does not exist in SL, SA # 0C83 ; 0C03 ; if ICU_VERSION < '55.1': checkSkeleton(SL, u"\u0C83", u"\u0C83") checkSkeleton(SA, u"\u0C83", u"\u0C83") else: checkSkeleton(SL, u"\u0C83", u"\u0983") checkSkeleton(SA, u"\u0C83", u"\u0983") checkSkeleton(ML, u"\u0C83", u"\u0983") checkSkeleton(MA, u"\u0C83", u"\u0983") # 0391 ; 0041 ; # This mapping exists only in the MA table. checkSkeleton(MA, u"\u0391", "A") if ICU_VERSION < '55.1': checkSkeleton(SA, u"\u0391", u"\u0391") checkSkeleton(ML, u"\u0391", u"\u0391") checkSkeleton(SL, u"\u0391", u"\u0391") else: checkSkeleton(SA, u"\u0391", u'A') checkSkeleton(ML, u"\u0391", u'A') checkSkeleton(SL, u"\u0391", u'A') # 13CF ; 0062 ; # This mapping exists in the ML and MA tables checkSkeleton(ML, u"\u13CF", "b") checkSkeleton(MA, u"\u13CF", "b") if ICU_VERSION < '55.1': checkSkeleton(SL, u"\u13CF", u"\u13CF") checkSkeleton(SA, u"\u13CF", u"\u13CF") else: checkSkeleton(SL, u"\u13CF", u'b') checkSkeleton(SA, u"\u13CF", u'b') # 0022 ; 0027 0027 ; # all tables. checkSkeleton(SL, u"\u0022", u"\u0027\u0027") checkSkeleton(SA, u"\u0022", u"\u0027\u0027") checkSkeleton(ML, u"\u0022", u"\u0027\u0027") checkSkeleton(MA, u"\u0022", u"\u0027\u0027") # 017F ; 0066 ; # This mapping exists in the SA and MA tables checkSkeleton(MA, u"\u017F", "f") checkSkeleton(SA, u"\u017F", "f") def testInvisible(self): checks = self.checker.check(u"abcd\u0301ef") self.assertEquals(checks, 0) checks = self.checker.check(u"abcd\u0301\u0302\u0301ef") self.assertEquals(checks, USpoofChecks.INVISIBLE) # Two acute accents, one from the composed a with acute accent, \u00e1, # and one separate. checks = self.checker.check(u"abcd\u00e1\u0301xyz") self.assertEquals(checks, USpoofChecks.INVISIBLE) if __name__ == "__main__": main() PyICU-1.9.5/test/test_Transliterator.py0000644000076500000000000000716613011412542020272 0ustar vajdawheel00000000000000# -*- coding: utf-8 -*- # ==================================================================== # Copyright (c) 2009-2015 Open Source Applications Foundation. # # Permission is hereby granted, free of charge, to any person obtaining a # copy of this software and associated documentation files (the "Software"), # to deal in the Software without restriction, including without limitation # the rights to use, copy, modify, merge, publish, distribute, sublicense, # and/or sell copies of the Software, and to permit persons to whom the # Software is furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included # in all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS # OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING # FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER # DEALINGS IN THE SOFTWARE. # ==================================================================== # import sys, os from unittest import TestCase, main from icu import * class TestTransliterator(TestCase): def testTransliterate(self): trans = Transliterator.createInstance('Accents-Any') inverse = trans.createInverse() string = u'\xe9v\xe9nement' if ICU_VERSION < '4.0': result = u"e<'>ve<'>nement" else: result = u"e\u2190'\u2192ve\u2190'\u2192nement" self.assertTrue(trans.transliterate(string) == result) self.assertTrue(inverse.transliterate(result) == string) def testUnicodeString(self): trans = Transliterator.createInstance('NumericPinyin-Latin') string = UnicodeString("Shang4hai3 zi4lai2shui3 lai2 zi4 hai3 shang4") result = u'Sh\xe0ngh\u01cei z\xecl\xe1ishu\u01d0 l\xe1i z\xec h\u01cei sh\xe0ng' self.assertTrue(trans.transliterate(unicode(string)) == result) self.assertTrue(trans.transliterate(string) == result) self.assertTrue(string == result) def testPythonTransliterator(self): class vowelSubst(Transliterator): def __init__(_self, char=u'i'): super(vowelSubst, _self).__init__("vowel") _self.char = char def handleTransliterate(_self, text, pos, incremental): for i in xrange(pos.start, pos.limit): if text[i] in u"aeiouüöä": text[i] = _self.char pos.start = pos.limit trans = vowelSubst() # see http://en.wikipedia.org/wiki/Drei_Chinesen_mit_dem_Kontrabass string = u"Drei Chinesen mit dem Kontrabass" result = u'Drii Chinisin mit dim Kintribiss' self.assertTrue(trans.transliterate(string) == result) # test registration Transliterator.registerInstance(trans) regTrans = Transliterator.createInstance("vowel") self.assertTrue(regTrans.transliterate(string) == result) def testPythonTransliteratorException(self): class faultySubst(Transliterator): def __init__(_self): super(faultySubst, _self).__init__("faulty") def handleTransliterate(_self, text, pos, incremental): raise ValueError("faulty") trans = faultySubst() self.assertRaises(ValueError, trans.transliterate, "whatever") if __name__ == "__main__": main() PyICU-1.9.5/test/test_UCS4.py0000644000076500000000000000364513011412542015771 0ustar vajdawheel00000000000000# ==================================================================== # Copyright (c) 2005-2010 Open Source Applications Foundation. # # Permission is hereby granted, free of charge, to any person obtaining a # copy of this software and associated documentation files (the "Software"), # to deal in the Software without restriction, including without limitation # the rights to use, copy, modify, merge, publish, distribute, sublicense, # and/or sell copies of the Software, and to permit persons to whom the # Software is furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included # in all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS # OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING # FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER # DEALINGS IN THE SOFTWARE. # ==================================================================== # import sys, os from unittest import TestCase, main from icu import * class Tests(TestCase): def testSortOfHighAndLowCodepoints(self): collator = Collator.createInstance(Locale.getFrance()) self.assertEqual(collator.compare(u'\U00023119', u'\u62d5'), 1, "Failed to collate low character before high", ) self.assertEqual(collator.compare(u'\U00023119'*10000, u'\u62d5'*10000), 1, "Failed to collate low character before high", ) if __name__ == "__main__": main() PyICU-1.9.5/test/test_UDate.py0000644000076500000000000000362211526550376016271 0ustar vajdawheel00000000000000# ==================================================================== # Copyright (c) 2006-2010 Open Source Applications Foundation. # # Permission is hereby granted, free of charge, to any person obtaining a # copy of this software and associated documentation files (the "Software"), # to deal in the Software without restriction, including without limitation # the rights to use, copy, modify, merge, publish, distribute, sublicense, # and/or sell copies of the Software, and to permit persons to whom the # Software is furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included # in all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS # OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING # FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER # DEALINGS IN THE SOFTWARE. # ==================================================================== # import sys, os from unittest import TestCase, main from datetime import datetime from icu import * class TestUDate(TestCase): def testConvertNaiveDatetime(self): def formatNaiveDatetime(): # Make a naive datetime dt = datetime(2006, 4, 18, 5, 12) # ... and format it return DateFormat.createTimeInstance(DateFormat.SHORT).format(dt) before = formatNaiveDatetime() # Change ICU's default timezone TimeZone.setDefault(ICUtzinfo.getInstance('US/Eastern').timezone) after = formatNaiveDatetime() self.assertTrue(before == after) if __name__ == "__main__": main() PyICU-1.9.5/transliterator.cpp0000644000076500000000000005344012523534357016462 0ustar vajdawheel00000000000000/* ==================================================================== * Copyright (c) 2009-2015 Open Source Applications Foundation. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. * ==================================================================== */ #include "common.h" #include "structmember.h" #include "bases.h" #include "transliterator.h" #include "unicodeset.h" #include "macros.h" DECLARE_CONSTANTS_TYPE(UTransDirection); /* UTransPosition */ class t_utransposition : public _wrapper { public: UTransPosition *object; }; static int t_utransposition_init(t_utransposition *self, PyObject *args, PyObject *kwds); static PyMethodDef t_utransposition_methods[] = { { NULL, NULL, 0, NULL } }; static void t_utransposition_dealloc(t_utransposition *self) { if (self->object) { if (self->flags & T_OWNED) delete self->object; self->object = NULL; } Py_TYPE(self)->tp_free((PyObject *) self); } DECLARE_STRUCT(UTransPosition, t_utransposition, UTransPosition, t_utransposition_init, t_utransposition_dealloc); /* Transliterator */ static int t_transliterator_init(t_transliterator *self, PyObject *args, PyObject *kwds); static PyObject *t_transliterator_getMaximumContextLength(t_transliterator *self); static PyObject *t_transliterator_countElements(t_transliterator *self); static PyObject *t_transliterator_getElement(t_transliterator *self, PyObject *arg); static PyObject *t_transliterator_getSourceSet(t_transliterator *self); static PyObject *t_transliterator_getTargetSet(t_transliterator *self); static PyObject *t_transliterator_createInverse(t_transliterator *self); static PyObject *t_transliterator_toRules(t_transliterator *self, PyObject *args); static PyObject *t_transliterator_transliterate(t_transliterator *self, PyObject *args); static PyObject *t_transliterator_finishTransliteration(t_transliterator *self, PyObject *args); static PyObject *t_transliterator_filteredTransliterate(t_transliterator *self, PyObject *args); static PyObject *t_transliterator_getFilter(t_transliterator *self); static PyObject *t_transliterator_orphanFilter(t_transliterator *self); static PyObject *t_transliterator_adoptFilter(t_transliterator *self, PyObject *arg); static PyObject *t_transliterator_getAvailableIDs(PyTypeObject *type); static PyObject *t_transliterator_createInstance(PyTypeObject *type, PyObject *args); static PyObject *t_transliterator_createFromRules(PyTypeObject *type, PyObject *args); static PyObject *t_transliterator_registerInstance(PyTypeObject *type, PyObject *args); static PyMethodDef t_transliterator_methods[] = { DECLARE_METHOD(t_transliterator, transliterate, METH_VARARGS), DECLARE_METHOD(t_transliterator, finishTransliteration, METH_VARARGS), DECLARE_METHOD(t_transliterator, filteredTransliterate, METH_VARARGS), DECLARE_METHOD(t_transliterator, getMaximumContextLength, METH_NOARGS), DECLARE_METHOD(t_transliterator, countElements, METH_NOARGS), DECLARE_METHOD(t_transliterator, getElement, METH_O), DECLARE_METHOD(t_transliterator, getSourceSet, METH_NOARGS), DECLARE_METHOD(t_transliterator, getTargetSet, METH_NOARGS), DECLARE_METHOD(t_transliterator, createInverse, METH_NOARGS), DECLARE_METHOD(t_transliterator, toRules, METH_VARARGS), DECLARE_METHOD(t_transliterator, getFilter, METH_NOARGS), DECLARE_METHOD(t_transliterator, orphanFilter, METH_NOARGS), DECLARE_METHOD(t_transliterator, adoptFilter, METH_O), DECLARE_METHOD(t_transliterator, getAvailableIDs, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_transliterator, createInstance, METH_VARARGS | METH_CLASS), DECLARE_METHOD(t_transliterator, createFromRules, METH_VARARGS | METH_CLASS), DECLARE_METHOD(t_transliterator, registerInstance, METH_VARARGS | METH_CLASS), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(Transliterator, t_transliterator, UObject, Transliterator, t_transliterator_init, NULL); /* PythonTransliterator */ UOBJECT_DEFINE_RTTI_IMPLEMENTATION(PythonTransliterator); PythonTransliterator::PythonTransliterator(t_transliterator *self, UnicodeString &id) : Transliterator(id, NULL) { this->self = self; Py_XINCREF(this->self); } PythonTransliterator::PythonTransliterator(t_transliterator *self, UnicodeString &id, UnicodeFilter *adoptedFilter) : Transliterator(id, adoptedFilter) { this->self = self; Py_XINCREF(this->self); } /** * Copy constructor. */ PythonTransliterator::PythonTransliterator(const PythonTransliterator& p) : Transliterator(p) { this->self = p.self; Py_XINCREF(this->self); } PythonTransliterator::~PythonTransliterator() { Py_XDECREF(this->self); this->self = NULL; } Transliterator* PythonTransliterator::clone(void) const { return new PythonTransliterator(*this); } void PythonTransliterator::handleTransliterate(Replaceable& text, UTransPosition& pos, UBool incremental) const { if (ISINSTANCE(&text, UnicodeString)) { PyObject *name = PyString_FromString("handleTransliterate"); PyObject *p_text = wrap_UnicodeString((UnicodeString *) &text, 0); PyObject *p_pos = wrap_UTransPosition(&pos, 0); PyObject *result = PyObject_CallMethodObjArgs((PyObject *) self, name, p_text, p_pos, incremental ? Py_True : Py_False, NULL); Py_DECREF(name); Py_DECREF(p_text); Py_DECREF(p_pos); Py_XDECREF(result); } } /* UTransPosition */ static int t_utransposition_init(t_utransposition *self, PyObject *args, PyObject *kwds) { static const char *kwnames[] = { "contextStart", "contextLimit", "start", "limit", NULL }; int contextStart = 0, contextLimit = 0, start = 0, limit = 0; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|iiii", (char **) kwnames, &contextStart, &contextLimit, &start, &limit)) return -1; self->object = new UTransPosition(); if (!self->object) { PyErr_NoMemory(); return -1; } self->object->contextStart = contextStart; self->object->contextLimit = contextLimit; self->object->start = start; self->object->limit = limit; self->flags = T_OWNED; return 0; } static int t_utransposition_setter(int32_t *slot, PyObject *value) { int32_t n; if (value == NULL) { PyErr_SetString(PyExc_TypeError, "Cannot delete attribute"); return -1; } n = PyInt_AsLong(value); if (PyErr_Occurred()) return -1; *slot = n; return 0; } static PyObject *t_utransposition_getContextLimit(t_utransposition *self, void *closure) { return PyInt_FromLong(self->object->contextLimit); } static int t_utransposition_setContextLimit(t_utransposition *self, PyObject *value, void *closure) { return t_utransposition_setter(&self->object->contextLimit, value); } static PyObject *t_utransposition_getContextStart(t_utransposition *self, void *closure) { return PyInt_FromLong(self->object->contextStart); } static int t_utransposition_setContextStart(t_utransposition *self, PyObject *value, void *closure) { return t_utransposition_setter(&self->object->contextStart, value); } static PyObject *t_utransposition_getLimit(t_utransposition *self, void *closure) { return PyInt_FromLong(self->object->limit); } static int t_utransposition_setLimit(t_utransposition *self, PyObject *value, void *closure) { return t_utransposition_setter(&self->object->limit, value); } static PyObject *t_utransposition_getStart(t_utransposition *self, void *closure) { return PyInt_FromLong(self->object->start); } static int t_utransposition_setStart(t_utransposition *self, PyObject *value, void *closure) { return t_utransposition_setter(&self->object->start, value); } static PyGetSetDef t_utransposition_properties[] = { {(char *) "contextLimit", (getter) t_utransposition_getContextLimit, (setter) t_utransposition_setContextLimit, (char *) "Ending index, exclusive, of the context to be considered for a transliteration operation.", NULL}, {(char *) "contextStart", (getter) t_utransposition_getContextStart, (setter) t_utransposition_setContextStart, (char *) "Beginning index, inclusive, of the context to be considered for a transliteration operation.", NULL}, {(char *) "limit", (getter) t_utransposition_getLimit, (setter) t_utransposition_setLimit, (char *) "Ending index, exclusive, of the text to be transliterated.", NULL}, {(char *) "start", (getter) t_utransposition_getStart, (setter) t_utransposition_setStart, (char *) "Beginning index, inclusive, of the text to be transliterated.", NULL}, {NULL} /* Sentinel */ }; /* Transliterator */ static int t_transliterator_init(t_transliterator *self, PyObject *args, PyObject *kwds) { UnicodeString *u, _u; UnicodeFilter *adoptedFilter; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "S", &u, &_u)) { self->object = new PythonTransliterator(self, *u); self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; case 2: if (!parseArgs(args, "SP", &u, &_u, TYPE_CLASSID(UnicodeFilter), &adoptedFilter)) { self->object = new PythonTransliterator(self, *u, (UnicodeFilter *) adoptedFilter->clone()); self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; default: PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; } if (self->object) return 0; return -1; } PyObject *wrap_Transliterator(Transliterator *transliterator) { return wrap_Transliterator(transliterator, T_OWNED); } PyObject *wrap_Transliterator(const Transliterator &transliterator) { return wrap_Transliterator(transliterator.clone(), T_OWNED); } static PyObject *t_transliterator_toRules(t_transliterator *self, PyObject *args) { UnicodeString u; int b = 0; switch (PyTuple_Size(args)) { case 0: PYTHON_CALL(self->object->toRules(u, 0)); return PyUnicode_FromUnicodeString(&u); case 1: if (!parseArgs(args, "b", &b)) { PYTHON_CALL(self->object->toRules(u, b)); return PyUnicode_FromUnicodeString(&u); } break; } return PyErr_SetArgsError((PyObject *) self, "toRules", args); } static PyObject *t_transliterator_transliterate(t_transliterator *self, PyObject *args) { UnicodeString *u0, _u0; UnicodeString *u1, _u1; t_utransposition *utransposition; int32_t start, limit, len; UChar32 c; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "U", &u0)) { PYTHON_CALL(self->object->transliterate(*u0)); Py_RETURN_ARG(args, 0); } if (!parseArgs(args, "s", &_u0)) { PYTHON_CALL(self->object->transliterate(_u0)); return PyUnicode_FromUnicodeString(&_u0); } break; case 2: if (!parseArgs(args, "UO", &UTransPositionType_, &u0, &utransposition)) { STATUS_PYTHON_CALL(self->object->transliterate(*u0, *utransposition->object, status)); Py_RETURN_ARG(args, 0); } if (!parseArgs(args, "sO", &UTransPositionType_, &_u0, &utransposition)) { STATUS_PYTHON_CALL(self->object->transliterate(_u0, *utransposition->object, status)); return PyUnicode_FromUnicodeString(&_u0); } break; case 3: if (!parseArgs(args, "Uii", &u0, &start, &limit)) { PYTHON_CALL(limit = self->object->transliterate(*u0, start, limit)); return PyInt_FromLong(limit); } if (!parseArgs(args, "sii", &_u0, &start, &limit)) { PYTHON_CALL(self->object->transliterate(_u0, start, limit)); return PyUnicode_FromUnicodeString(&_u0); } if (!parseArgs(args, "UOS", &UTransPositionType_, &u0, &utransposition, &u1, &_u1)) { STATUS_CALL(len = toUChar32(*u1, &c, status)); if (len == 1) { STATUS_PYTHON_CALL(self->object->transliterate(*u0, *utransposition->object, c, status)); } else { STATUS_PYTHON_CALL(self->object->transliterate(*u0, *utransposition->object, _u1, status)); } Py_RETURN_ARG(args, 0); } if (!parseArgs(args, "sOS", &UTransPositionType_, &_u0, &utransposition, &u1, &_u1)) { STATUS_CALL(len = toUChar32(*u1, &c, status)); if (len == 1) { STATUS_PYTHON_CALL(self->object->transliterate(_u0, *utransposition->object, c, status)); } else { STATUS_PYTHON_CALL(self->object->transliterate(_u0, *utransposition->object, _u1, status)); } return PyUnicode_FromUnicodeString(&_u0); } break; } return PyErr_SetArgsError((PyObject *) self, "transliterate", args); } static PyObject *t_transliterator_finishTransliteration(t_transliterator *self, PyObject *args) { UnicodeString *u, _u; t_utransposition *utransposition; if (!parseArgs(args, "UO", &UTransPositionType_, &u, &utransposition)) { self->object->finishTransliteration(*u, *utransposition->object); Py_RETURN_ARG(args, 0); } if (!parseArgs(args, "sO", &UTransPositionType_, &_u, &utransposition)) { self->object->finishTransliteration(_u, *utransposition->object); return PyUnicode_FromUnicodeString(&_u); } return PyErr_SetArgsError((PyObject *) self, "finishTransliteration", args); } static PyObject *t_transliterator_filteredTransliterate(t_transliterator *self, PyObject *args) { UnicodeString *u, _u; t_utransposition *utransposition; int incremental; if (!parseArgs(args, "UOB", &UTransPositionType_, &u, &utransposition, &incremental)) { self->object->filteredTransliterate(*u, *utransposition->object, incremental); Py_RETURN_ARG(args, 0); } if (!parseArgs(args, "sOB", &UTransPositionType_, &_u, &utransposition, &incremental)) { self->object->filteredTransliterate(_u, *utransposition->object, incremental); return PyUnicode_FromUnicodeString(&_u); } return PyErr_SetArgsError((PyObject *) self, "filteredTransliterate", args); } static PyObject *t_transliterator_getMaximumContextLength(t_transliterator *self) { return PyInt_FromLong(self->object->getMaximumContextLength()); } static PyObject *t_transliterator_countElements(t_transliterator *self) { return PyInt_FromLong(self->object->countElements()); } static PyObject *t_transliterator_getElement(t_transliterator *self, PyObject *arg) { int32_t i = PyInt_AsLong(arg); const Transliterator *transliterator; if (PyErr_Occurred()) return NULL; STATUS_CALL(transliterator = &self->object->getElement(i, status)); return wrap_Transliterator(*transliterator); } static PyObject *t_transliterator_getSourceSet(t_transliterator *self) { UnicodeSet set; self->object->getSourceSet(set); return wrap_UnicodeSet(new UnicodeSet(set), T_OWNED); } static PyObject *t_transliterator_getTargetSet(t_transliterator *self) { UnicodeSet set; self->object->getTargetSet(set); return wrap_UnicodeSet(new UnicodeSet(set), T_OWNED); } static PyObject *t_transliterator_createInverse(t_transliterator *self) { Transliterator *transliterator; STATUS_CALL(transliterator = self->object->createInverse(status)); return wrap_Transliterator(transliterator); } static PyObject *t_transliterator_getFilter(t_transliterator *self) { const UnicodeFilter *filter = self->object->getFilter(); if (filter == NULL) Py_RETURN_NONE; return wrap_UnicodeFilter((UnicodeFilter *) filter->clone(), T_OWNED); } static PyObject *t_transliterator_orphanFilter(t_transliterator *self) { UnicodeFilter *filter = self->object->orphanFilter(); if (filter == NULL) Py_RETURN_NONE; return wrap_UnicodeFilter(filter, T_OWNED); } static PyObject *t_transliterator_adoptFilter(t_transliterator *self, PyObject *arg) { UnicodeFilter *filter; if (arg == Py_None) self->object->adoptFilter(NULL); else if (!parseArg(arg, "P", TYPE_CLASSID(UnicodeFilter), &filter)) self->object->adoptFilter((UnicodeFilter *) filter->clone()); else return PyErr_SetArgsError((PyObject *) self, "adoptFilter", arg); Py_RETURN_NONE; } static PyObject *t_transliterator_getAvailableIDs(PyTypeObject *type) { StringEnumeration *se; STATUS_CALL(se = Transliterator::getAvailableIDs(status)); return wrap_StringEnumeration(se, T_OWNED); } static PyObject *t_transliterator_createInstance(PyTypeObject *type, PyObject *args) { Transliterator *transliterator; UnicodeString *u, _u; UTransDirection direction = UTRANS_FORWARD; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "S", &u, &_u)) { STATUS_CALL(transliterator = Transliterator::createInstance( *u, direction, status)); return wrap_Transliterator(transliterator); } break; case 2: if (!parseArgs(args, "Si", &u, &_u, &direction)) { STATUS_CALL(transliterator = Transliterator::createInstance( *u, direction, status)); return wrap_Transliterator(transliterator); } break; } return PyErr_SetArgsError(type, "createInstance", args); } static PyObject *t_transliterator_createFromRules(PyTypeObject *type, PyObject *args) { Transliterator *transliterator; UnicodeString *u0, _u0; UnicodeString *u1, _u1; UTransDirection direction = UTRANS_FORWARD; switch (PyTuple_Size(args)) { case 2: if (!parseArgs(args, "SS", &u0, &_u0, &u1, &_u1)) { STATUS_PARSER_CALL(transliterator = Transliterator::createFromRules( *u0, *u1, direction, parseError, status)); return wrap_Transliterator(transliterator); } break; case 3: if (!parseArgs(args, "SSi", &u0, &_u0, &u1, &_u1, &direction)) { STATUS_PARSER_CALL(transliterator = Transliterator::createFromRules( *u0, *u1, direction, parseError, status)); return wrap_Transliterator(transliterator); } break; } return PyErr_SetArgsError(type, "createFromRules", args); } static PyObject *t_transliterator_registerInstance(PyTypeObject *type, PyObject *args) { Transliterator *transliterator; if (!parseArgs(args, "P", TYPE_CLASSID(Transliterator), &transliterator)) { Transliterator::registerInstance(transliterator); Py_RETURN_NONE; } return PyErr_SetArgsError(type, "registerInstance", args); } static PyObject *t_transliterator_str(t_transliterator *self) { UnicodeString _u = self->object->getID(); return PyUnicode_FromUnicodeString(&_u); } void _init_transliterator(PyObject *m) { TransliteratorType_.tp_str = (reprfunc) t_transliterator_str; UTransPositionType_.tp_getset = t_utransposition_properties; INSTALL_CONSTANTS_TYPE(UTransDirection, m); INSTALL_STRUCT(UTransPosition, m); REGISTER_TYPE(Transliterator, m); INSTALL_ENUM(UTransDirection, "FORWARD", UTRANS_FORWARD); INSTALL_ENUM(UTransDirection, "REVERSE", UTRANS_REVERSE); } PyICU-1.9.5/transliterator.h0000644000076500000000000000537011450411421016106 0ustar vajdawheel00000000000000/* ==================================================================== * Copyright (c) 2009-2010 Open Source Applications Foundation. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. * ==================================================================== */ #ifndef _transliterator_h #define _transliterator_h class t_transliterator : public _wrapper { public: Transliterator *object; }; U_NAMESPACE_BEGIN class U_EXPORT PythonTransliterator : public Transliterator { protected: t_transliterator *self; public: /** * ICU "poor man's RTTI", returns a UClassID for the actual class. */ virtual UClassID getDynamicClassID() const; /** * ICU "poor man's RTTI", returns a UClassID for this class. */ static UClassID getStaticClassID(); PythonTransliterator(t_transliterator *self, UnicodeString& id); PythonTransliterator(t_transliterator *self, UnicodeString& id, UnicodeFilter *adoptedFilter); /** * Copy constructor. */ PythonTransliterator(const PythonTransliterator&); /** * Destructor. */ virtual ~PythonTransliterator(); /** * Transliterator API. */ virtual Transliterator* clone(void) const; /** * Implements {@link Transliterator#handleTransliterate}. */ virtual void handleTransliterate(Replaceable& text, UTransPosition& pos, UBool incremental) const; }; U_NAMESPACE_END extern PyTypeObject TransliteratorType; PyObject *wrap_Transliterator(Transliterator *transliterator, int flags); PyObject *wrap_Transliterator(const Transliterator &transliterator); void _init_transliterator(PyObject *m); #endif /* _transliterator_h */ PyICU-1.9.5/tzinfo.cpp0000644000076500000000000005557312717726574014740 0ustar vajdawheel00000000000000/* ==================================================================== * Copyright (c) 2007-2014 Open Source Applications Foundation. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. * ==================================================================== */ #include "common.h" #include "structmember.h" #include "datetime.h" #include "bases.h" #include "calendar.h" #include "tzinfo.h" #include "macros.h" #ifdef PYPY_VERSION #if !defined(PYPY_VERSION_NUM) || PYPY_VERSION_NUM < 0x05020000 typedef PyObject PyDateTime_TZInfo; #endif #endif /* A tzinfo extension that wraps an ICU timezone wrapper. * The tz field is supposed to be immutable. */ typedef struct { PyDateTime_TZInfo dt_tzinfo; t_timezone *tz; } t_tzinfo; /* A tzinfo extension that wraps an ICU tzinfo wrapper. * The tzinfo field can be changed and defaults to the default ICU tzinfo * when not set. When this field changes or the default ICU tzinfo is changed, * times expressed with this pseudo-timezone, named "World/Floating", appear * to float. */ typedef struct { PyDateTime_TZInfo dt_tzinfo; t_tzinfo *tzinfo; } t_floatingtz; static void t_tzinfo_dealloc(t_tzinfo *self); static PyObject *t_tzinfo_new(PyTypeObject *type, PyObject *args, PyObject *kwds); static int t_tzinfo_init(t_tzinfo *self, PyObject *args, PyObject *kwds); static PyObject *t_tzinfo_repr(t_tzinfo *self); static PyObject *t_tzinfo_str(t_tzinfo *self); static long t_tzinfo_hash(t_tzinfo *self); static PyObject *t_tzinfo_richcmp(t_tzinfo *self, PyObject *other, int op); static PyObject *t_tzinfo__resetDefault(PyTypeObject *cls); static PyObject *t_tzinfo_getDefault(PyTypeObject *cls); static PyObject *t_tzinfo_setDefault(PyTypeObject *cls, PyObject *tz); static PyObject *t_tzinfo_getFloating(PyTypeObject *cls); static PyObject *t_tzinfo_getInstances(PyTypeObject *cls); static PyObject *t_tzinfo_getInstance(PyTypeObject *cls, PyObject *arg); static PyObject *t_tzinfo_utcoffset(t_tzinfo *self, PyObject *dt); static PyObject *t_tzinfo_dst(t_tzinfo *self, PyObject *dt); static PyObject *t_tzinfo_tzname(t_tzinfo *self, PyObject *dt); static PyObject *t_tzinfo__getTimezone(t_tzinfo *self, void *data); static PyObject *t_tzinfo__getTZID(t_tzinfo *self, void *data); static PyObject *_instances; static t_tzinfo *_default, *_floating; static PyTypeObject *datetime_tzinfoType, *datetime_deltaType; static PyObject *FLOATING_TZNAME; static PyObject *toordinal_NAME; static PyObject *weekday_NAME; static PyMethodDef t_tzinfo_methods[] = { { "_resetDefault", (PyCFunction) t_tzinfo__resetDefault, METH_NOARGS | METH_CLASS, "" }, { "getDefault", (PyCFunction) t_tzinfo_getDefault, METH_NOARGS | METH_CLASS, "" }, { "setDefault", (PyCFunction) t_tzinfo_setDefault, METH_O | METH_CLASS, "" }, { "getFloating", (PyCFunction) t_tzinfo_getFloating, METH_NOARGS | METH_CLASS, "" }, { "getInstances", (PyCFunction) t_tzinfo_getInstances, METH_NOARGS | METH_CLASS, "" }, { "getInstance", (PyCFunction) t_tzinfo_getInstance, METH_O | METH_CLASS, "" }, { "utcoffset", (PyCFunction) t_tzinfo_utcoffset, METH_O, "" }, { "dst", (PyCFunction) t_tzinfo_dst, METH_O, "" }, { "tzname", (PyCFunction) t_tzinfo_tzname, METH_O, "" }, { NULL, NULL, 0, NULL } }; static PyGetSetDef t_tzinfo_properties[] = { { (char *) "timezone", (getter) t_tzinfo__getTimezone, NULL, (char *) "timezone property", NULL }, { (char *) "tzid", (getter) t_tzinfo__getTZID, NULL, (char *) "tzid property", NULL }, { NULL, NULL, NULL, NULL, NULL } }; PyTypeObject TZInfoType_ = { PyVarObject_HEAD_INIT(NULL, 0) "icu.ICUtzinfo", /* tp_name */ sizeof(t_tzinfo), /* tp_basicsize */ 0, /* tp_itemsize */ (destructor) t_tzinfo_dealloc, /* tp_dealloc */ 0, /* tp_print */ 0, /* tp_getattr */ 0, /* tp_setattr */ 0, /* tp_compare */ (reprfunc) t_tzinfo_repr, /* tp_repr */ 0, /* tp_as_number */ 0, /* tp_as_sequence */ 0, /* tp_as_mapping */ (hashfunc) t_tzinfo_hash, /* tp_hash */ 0, /* tp_call */ (reprfunc) t_tzinfo_str, /* tp_str */ 0, /* tp_getattro */ 0, /* tp_setattro */ 0, /* tp_as_buffer */ (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE), /* tp_flags */ "", /* tp_doc */ 0, /* tp_traverse */ 0, /* tp_clear */ (richcmpfunc) t_tzinfo_richcmp, /* tp_richcompare */ 0, /* tp_weaklistoffset */ 0, /* tp_iter */ 0, /* tp_iternext */ t_tzinfo_methods, /* tp_methods */ 0, /* tp_members */ t_tzinfo_properties, /* tp_getset */ 0, /* tp_base */ 0, /* tp_dict */ 0, /* tp_descr_get */ 0, /* tp_descr_set */ 0, /* tp_dictoffset */ (initproc) t_tzinfo_init, /* tp_init */ 0, /* tp_alloc */ (newfunc) t_tzinfo_new, /* tp_new */ 0, /* tp_free */ }; static void t_floatingtz_dealloc(t_floatingtz *self); static PyObject *t_floatingtz_new(PyTypeObject *type, PyObject *args, PyObject *kwds); static int t_floatingtz_init(t_floatingtz *self, PyObject *args, PyObject *kwds); static PyObject *t_floatingtz_repr(t_floatingtz *self); static PyObject *t_floatingtz_str(t_floatingtz *self); static PyObject *t_floatingtz_richcmp(t_floatingtz *self, PyObject *other, int op); static long t_floatingtz_hash(t_floatingtz *self); static PyObject *t_floatingtz_utcoffset(t_floatingtz *self, PyObject *dt); static PyObject *t_floatingtz_dst(t_floatingtz *self, PyObject *dt); static PyObject *t_floatingtz_tzname(t_floatingtz *self, PyObject *dt); static PyObject *t_floatingtz__getTimezone(t_floatingtz *self, void *data); static PyObject *t_floatingtz__getTZID(t_floatingtz *self, void *data); static PyMemberDef t_floatingtz_members[] = { { (char *) "tzinfo", T_OBJECT, offsetof(t_floatingtz, tzinfo), 0, (char *) "" }, { NULL, 0, 0, 0, NULL } }; static PyMethodDef t_floatingtz_methods[] = { { "utcoffset", (PyCFunction) t_floatingtz_utcoffset, METH_O, "" }, { "dst", (PyCFunction) t_floatingtz_dst, METH_O, "" }, { "tzname", (PyCFunction) t_floatingtz_tzname, METH_O, "" }, { NULL, NULL, 0, NULL } }; static PyGetSetDef t_floatingtz_properties[] = { { (char *) "timezone", (getter) t_floatingtz__getTimezone, NULL, (char *) "timezone property", NULL }, { (char *) "tzid", (getter) t_floatingtz__getTZID, NULL, (char *) "tzid property", NULL }, { NULL, NULL, NULL, NULL, NULL } }; PyTypeObject FloatingTZType_ = { PyVarObject_HEAD_INIT(NULL, 0) "icu.FloatingTZ", /* tp_name */ sizeof(t_floatingtz), /* tp_basicsize */ 0, /* tp_itemsize */ (destructor) t_floatingtz_dealloc, /* tp_dealloc */ 0, /* tp_print */ 0, /* tp_getattr */ 0, /* tp_setattr */ 0, /* tp_compare */ (reprfunc) t_floatingtz_repr, /* tp_repr */ 0, /* tp_as_number */ 0, /* tp_as_sequence */ 0, /* tp_as_mapping */ (hashfunc) t_floatingtz_hash, /* tp_hash */ 0, /* tp_call */ (reprfunc) t_floatingtz_str, /* tp_str */ 0, /* tp_getattro */ 0, /* tp_setattro */ 0, /* tp_as_buffer */ (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE), /* tp_flags */ "", /* tp_doc */ 0, /* tp_traverse */ 0, /* tp_clear */ (richcmpfunc) t_floatingtz_richcmp, /* tp_richcompare */ 0, /* tp_weaklistoffset */ 0, /* tp_iter */ 0, /* tp_iternext */ t_floatingtz_methods, /* tp_methods */ t_floatingtz_members, /* tp_members */ t_floatingtz_properties, /* tp_getset */ 0, /* tp_base */ 0, /* tp_dict */ 0, /* tp_descr_get */ 0, /* tp_descr_set */ 0, /* tp_dictoffset */ (initproc) t_floatingtz_init, /* tp_init */ 0, /* tp_alloc */ (newfunc) t_floatingtz_new, /* tp_new */ 0, /* tp_free */ }; static void t_tzinfo_dealloc(t_tzinfo *self) { Py_CLEAR(self->tz); Py_TYPE(&self->dt_tzinfo)->tp_free((PyObject *) self); } static void t_floatingtz_dealloc(t_floatingtz *self) { Py_CLEAR(self->tzinfo); Py_TYPE(&self->dt_tzinfo)->tp_free((PyObject *) self); } static PyObject *t_tzinfo_new(PyTypeObject *type, PyObject *args, PyObject *kwds) { t_tzinfo *tzinfo = (t_tzinfo *) type->tp_alloc(type, 0); if (tzinfo) tzinfo->tz = NULL; return (PyObject *) tzinfo; } static PyObject *t_floatingtz_new(PyTypeObject *type, PyObject *args, PyObject *kwds) { t_floatingtz *floatingtz = (t_floatingtz *) type->tp_alloc(type, 0); if (floatingtz) floatingtz->tzinfo = NULL; return (PyObject *) floatingtz; } static int t_tzinfo_init(t_tzinfo *self, PyObject *args, PyObject *kwds) { PyObject *tz; if (!PyArg_ParseTuple(args, "O", &tz)) return -1; if (!PyObject_TypeCheck(tz, &TimeZoneType_)) { PyErr_SetObject(PyExc_TypeError, tz); return -1; } Py_INCREF(tz); Py_XDECREF(self->tz); self->tz = (t_timezone *) tz; return 0; } static int t_floatingtz_init(t_floatingtz *self, PyObject *args, PyObject *kwds) { PyObject *tzinfo = NULL; if (!PyArg_ParseTuple(args, "|O", &tzinfo)) return -1; if (tzinfo && !PyObject_TypeCheck(tzinfo, &TZInfoType_)) { PyErr_SetObject(PyExc_TypeError, tzinfo); return -1; } Py_XINCREF(tzinfo); Py_XDECREF((PyObject *) self->tzinfo); self->tzinfo = (t_tzinfo *) tzinfo; return 0; } static PyObject *t_tzinfo_repr(t_tzinfo *self) { PyObject *format = PyString_FromString(""); PyObject *str = PyObject_Str((PyObject *) self->tz); #if PY_VERSION_HEX < 0x02040000 PyObject *args = Py_BuildValue("(O)", str); #else PyObject *args = PyTuple_Pack(1, str); #endif PyObject *repr = PyString_Format(format, args); Py_DECREF(args); Py_DECREF(str); Py_DECREF(format); return repr; } static PyObject *t_tzinfo_str(t_tzinfo *self) { return PyObject_Str((PyObject *) self->tz); } static PyObject *t_floatingtz_repr(t_floatingtz *self) { t_tzinfo *tzinfo = self->tzinfo ? self->tzinfo : _default; PyObject *format = PyString_FromString(""); PyObject *str = PyObject_Str((PyObject *) tzinfo->tz); #if PY_VERSION_HEX < 0x02040000 PyObject *args = Py_BuildValue("(O)", str); #else PyObject *args = PyTuple_Pack(1, str); #endif PyObject *repr = PyString_Format(format, args); Py_DECREF(args); Py_DECREF(str); Py_DECREF(format); return repr; } static PyObject *t_floatingtz_str(t_floatingtz *self) { Py_INCREF(FLOATING_TZNAME); return FLOATING_TZNAME; } static long t_tzinfo_hash(t_tzinfo *self) { PyObject *str = PyObject_Str((PyObject *) self->tz); long hash = PyObject_Hash(str); Py_DECREF(str); return hash; } static long t_floatingtz_hash(t_floatingtz *self) { return PyObject_Hash(FLOATING_TZNAME); } static PyObject *t_tzinfo_richcmp(t_tzinfo *self, PyObject *other, int op) { if (PyObject_TypeCheck(other, &TZInfoType_)) { PyObject *s1 = PyObject_Str((PyObject *) self->tz); PyObject *s2 = PyObject_Str((PyObject *) ((t_tzinfo *) other)->tz); PyObject *result = PyObject_RichCompare(s1, s2, op); Py_DECREF(s1); Py_DECREF(s2); return result; } if (PyObject_TypeCheck(other, &FloatingTZType_)) { PyObject *s1 = PyObject_Str((PyObject *) self->tz); PyObject *result = PyObject_RichCompare(s1, FLOATING_TZNAME, op); Py_DECREF(s1); return result; } Py_INCREF(Py_NotImplemented); return Py_NotImplemented; } static PyObject *t_floatingtz_richcmp(t_floatingtz *self, PyObject *other, int op) { if (PyObject_TypeCheck(other, &FloatingTZType_)) { t_tzinfo *tzi1 = self->tzinfo; t_tzinfo *tzi2 = ((t_floatingtz *) other)->tzinfo; return PyObject_RichCompare((PyObject *) (tzi1 ? tzi1 : _default), (PyObject *) (tzi2 ? tzi2 : _default), op); } if (PyObject_TypeCheck(other, &TZInfoType_)) { PyObject *s2 = PyObject_Str((PyObject *) ((t_tzinfo *) other)->tz); PyObject *result = PyObject_RichCompare(FLOATING_TZNAME, s2, op); Py_DECREF(s2); return result; } Py_INCREF(Py_NotImplemented); return Py_NotImplemented; } static PyObject *t_tzinfo__resetDefault(PyTypeObject *cls) { PyObject *tz = wrap_TimeZone(TimeZone::createDefault()); if (tz) { #if PY_VERSION_HEX < 0x02040000 PyObject *args = Py_BuildValue("(O)", tz); #else PyObject *args = PyTuple_Pack(1, tz); #endif PyObject *tzinfo = PyObject_Call((PyObject *) &TZInfoType_, args, NULL); Py_DECREF(args); Py_DECREF(tz); if (tzinfo) { if (!PyObject_TypeCheck(tzinfo, &TZInfoType_)) { PyErr_SetObject(PyExc_TypeError, tzinfo); return NULL; } Py_XDECREF((PyObject *) _default); _default = (t_tzinfo *) tzinfo; Py_RETURN_NONE; } } return NULL; } static PyObject *t_tzinfo_getFloating(PyTypeObject *cls) { if (_floating) { Py_INCREF((PyObject *) _floating); return (PyObject *) _floating; } Py_RETURN_NONE; } static PyObject *t_tzinfo_getDefault(PyTypeObject *cls) { if (_default) { Py_INCREF((PyObject *) _default); return (PyObject *) _default; } Py_RETURN_NONE; } static PyObject *t_tzinfo_setDefault(PyTypeObject *cls, PyObject *arg) { if (!PyObject_TypeCheck(arg, &TZInfoType_)) { PyErr_SetObject(PyExc_TypeError, arg); return NULL; } PyObject *prev = (PyObject *) _default; Py_INCREF(arg); _default = (t_tzinfo *) arg; if (prev) return prev; Py_RETURN_NONE; } static PyObject *t_tzinfo_getInstances(PyTypeObject *cls) { Py_INCREF(_instances); return _instances; } static PyObject *t_tzinfo_getInstance(PyTypeObject *cls, PyObject *id) { PyObject *instance = PyDict_GetItem(_instances, id); if (instance) { Py_INCREF(instance); return instance; } int cmp = PyObject_RichCompareBool(id, FLOATING_TZNAME, Py_EQ); if (cmp == -1) return NULL; if (cmp) instance = t_tzinfo_getFloating(cls); else { PyObject *tz = t_timezone_createTimeZone(&TimeZoneType_, id); if (!tz) return NULL; #if PY_VERSION_HEX < 0x02040000 PyObject *args = Py_BuildValue("(O)", tz); #else PyObject *args = PyTuple_Pack(1, tz); #endif instance = PyObject_Call((PyObject *) &TZInfoType_, args, NULL); Py_DECREF(args); Py_DECREF(tz); } if (instance) PyDict_SetItem(_instances, id, instance); return instance; } static double _udate(PyObject *dt) { PyObject *result = PyObject_CallMethodObjArgs(dt, toordinal_NAME, NULL); if (!result) return 0.0; #if PY_MAJOR_VERSION >= 3 unsigned long ordinal = PyLong_AsUnsignedLong(result); #else unsigned long ordinal = PyInt_AS_LONG(result); #endif Py_DECREF(result); return ((ordinal - 719163) * 86400.0 + PyDateTime_DATE_GET_HOUR(dt) * 3600.0 + PyDateTime_DATE_GET_MINUTE(dt) * 60.0 + PyDateTime_DATE_GET_SECOND(dt) + PyDateTime_DATE_GET_MICROSECOND(dt) / 1e6) * 1000.0; } static PyObject *t_tzinfo_utcoffset(t_tzinfo *self, PyObject *dt) { PyObject *weekday = PyObject_CallMethodObjArgs(dt, weekday_NAME, NULL); if (!weekday) return NULL; // python's MINYEAR is 1 int era = GregorianCalendar::AD; int year = PyDateTime_GET_YEAR(dt); // python's month is 1-based, 1 is January // ICU's month is 0-based, 0 is January int month = PyDateTime_GET_MONTH(dt) - 1; int day = PyDateTime_GET_DAY(dt); // python's weekday is 0-based, 0 is Monday // ICU's dayofweek is 1-based, 1 is Sunday int dayofweek = ((PyInt_AsLong(weekday) + 1) % 7) + 1; Py_DECREF(weekday); int millis = (int) ((PyDateTime_DATE_GET_HOUR(dt) * 3600.0 + PyDateTime_DATE_GET_MINUTE(dt) * 60.0 + PyDateTime_DATE_GET_SECOND(dt) + PyDateTime_DATE_GET_MICROSECOND(dt) / 1e6) * 1000.0); int offset; STATUS_CALL(offset = self->tz->object->getOffset(era, year, month, day, dayofweek, millis, status)); PyObject *args = PyTuple_New(2); PyObject *result; PyTuple_SET_ITEM(args, 0, PyInt_FromLong(0)); PyTuple_SET_ITEM(args, 1, PyInt_FromLong(offset / 1000)); result = PyObject_Call((PyObject *) datetime_deltaType, args, NULL); Py_DECREF(args); return result; } static PyObject *t_tzinfo_dst(t_tzinfo *self, PyObject *dt) { UDate date = _udate(dt); int raw, dst; if (date == 0.0 && PyErr_Occurred()) return NULL; STATUS_CALL(self->tz->object->getOffset(date, 1, raw, dst, status)); PyObject *args = PyTuple_New(2); PyObject *result; PyTuple_SET_ITEM(args, 0, PyInt_FromLong(0)); PyTuple_SET_ITEM(args, 1, PyInt_FromLong(dst / 1000)); result = PyObject_Call((PyObject *) datetime_deltaType, args, NULL); Py_DECREF(args); return result; } static PyObject *t_tzinfo_tzname(t_tzinfo *self, PyObject *dt) { return PyObject_Str((PyObject *) self->tz); } static PyObject *t_tzinfo__getTimezone(t_tzinfo *self, void *data) { Py_INCREF(self->tz); return (PyObject *) self->tz; } static PyObject *t_tzinfo__getTZID(t_tzinfo *self, void *data) { return PyObject_Str((PyObject *) self); } static PyObject *t_floatingtz_utcoffset(t_floatingtz *self, PyObject *dt) { return t_tzinfo_utcoffset(self->tzinfo ? self->tzinfo : _default, dt); } static PyObject *t_floatingtz_dst(t_floatingtz *self, PyObject *dt) { return t_tzinfo_dst(self->tzinfo ? self->tzinfo : _default, dt); } static PyObject *t_floatingtz_tzname(t_floatingtz *self, PyObject *dt) { Py_INCREF(FLOATING_TZNAME); return FLOATING_TZNAME; } static PyObject *t_floatingtz__getTimezone(t_floatingtz *self, void *data) { t_tzinfo *tzinfo = self->tzinfo ? self->tzinfo : _default; Py_INCREF(tzinfo->tz); return (PyObject *) tzinfo->tz; } static PyObject *t_floatingtz__getTZID(t_floatingtz *self, void *data) { Py_INCREF(FLOATING_TZNAME); return FLOATING_TZNAME; } void _init_tzinfo(PyObject *m) { #if PY_VERSION_HEX > 0x02040000 && !defined(PYPY_VERSION) PyDateTime_IMPORT; datetime_tzinfoType = PyDateTimeAPI->TZInfoType; datetime_deltaType = PyDateTimeAPI->DeltaType; #else PyObject *datetime = PyImport_ImportModule("datetime"); if (datetime) { datetime_tzinfoType = (PyTypeObject *) PyObject_GetAttrString(datetime, "tzinfo"); datetime_deltaType = (PyTypeObject *) PyObject_GetAttrString(datetime, "timedelta"); Py_DECREF(datetime); } #endif _instances = PyDict_New(); TZInfoType_.tp_base = datetime_tzinfoType; FloatingTZType_.tp_base = datetime_tzinfoType; if (PyType_Ready(&TZInfoType_) >= 0 && PyType_Ready(&FloatingTZType_) >= 0) { if (m) { Py_INCREF(&TZInfoType_); PyModule_AddObject(m, "ICUtzinfo", (PyObject *) &TZInfoType_); Py_INCREF(&FloatingTZType_); PyModule_AddObject(m, "FloatingTZ", (PyObject *) &FloatingTZType_); FLOATING_TZNAME = PyString_FromString("World/Floating"); toordinal_NAME = PyString_FromString("toordinal"); weekday_NAME = PyString_FromString("weekday"); Py_INCREF(FLOATING_TZNAME); PyModule_AddObject(m, "FLOATING_TZNAME", FLOATING_TZNAME); t_tzinfo__resetDefault(&TZInfoType_); PyObject *args = PyTuple_New(0); PyObject *floating = PyObject_Call((PyObject *) &FloatingTZType_, args, NULL); if (floating && PyObject_TypeCheck(floating, &FloatingTZType_)) _floating = (t_tzinfo *) floating; else Py_XDECREF(floating); Py_DECREF(args); } } } PyICU-1.9.5/tzinfo.h0000644000076500000000000000254711660066753014366 0ustar vajdawheel00000000000000/* ==================================================================== * Copyright (c) 2007-2010 Open Source Applications Foundation. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. * ==================================================================== */ #ifndef _tzinfo_h #define _tzinfo_h void _init_tzinfo(PyObject *m); #endif /* _tzinfo_h */ PyICU-1.9.5/unicodeset.cpp0000644000076500000000000011775712520274001015543 0ustar vajdawheel00000000000000/* ==================================================================== * Copyright (c) 2010-2015 Open Source Applications Foundation. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. * ==================================================================== */ #include "common.h" #include "structmember.h" #include "bases.h" #include "unicodeset.h" #include "macros.h" DECLARE_CONSTANTS_TYPE(UMatchDegree); DECLARE_CONSTANTS_TYPE(USetSpanCondition); /* UnicodeFunctor */ class t_unicodefunctor : public _wrapper { public: UnicodeFunctor *object; }; static PyObject *t_unicodefunctor_toMatcher(t_unicodefunctor *self); static PyMethodDef t_unicodefunctor_methods[] = { DECLARE_METHOD(t_unicodefunctor, toMatcher, METH_NOARGS), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(UnicodeFunctor, t_unicodefunctor, UObject, UnicodeFunctor, abstract_init, NULL); /* UnicodeMatcher */ class t_unicodematcher : public _wrapper { public: UnicodeMatcher *object; }; static PyObject *t_unicodematcher_matches(t_unicodematcher *self, PyObject *args); static PyObject *t_unicodematcher_toPattern(t_unicodematcher *self, PyObject *args); static PyObject *t_unicodematcher_matchesIndexValue(t_unicodematcher *self, PyObject *arg); static PyObject *t_unicodematcher_addMatchSetTo(t_unicodematcher *self, PyObject *arg); static PyMethodDef t_unicodematcher_methods[] = { DECLARE_METHOD(t_unicodematcher, matches, METH_VARARGS), DECLARE_METHOD(t_unicodematcher, toPattern, METH_VARARGS), DECLARE_METHOD(t_unicodematcher, matchesIndexValue, METH_O), DECLARE_METHOD(t_unicodematcher, addMatchSetTo, METH_O), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(UnicodeMatcher, t_unicodematcher, UObject, UnicodeMatcher, abstract_init, NULL); /* UnicodeFilter */ class t_unicodefilter : public _wrapper { public: UnicodeFilter *object; }; static PyObject *t_unicodefilter_toMatcher(t_unicodefilter *self); static PyObject *t_unicodefilter_matches(t_unicodefilter *self, PyObject *args); static PyObject *t_unicodefilter_toPattern(t_unicodefilter *self, PyObject *args); static PyObject *t_unicodefilter_matchesIndexValue(t_unicodefilter *self, PyObject *arg); static PyObject *t_unicodefilter_addMatchSetTo(t_unicodefilter *self, PyObject *arg); static PyObject *t_unicodefilter_contains(t_unicodefilter *self, PyObject *arg); static PyMethodDef t_unicodefilter_methods[] = { DECLARE_METHOD(t_unicodefilter, toMatcher, METH_NOARGS), DECLARE_METHOD(t_unicodefilter, matches, METH_VARARGS), DECLARE_METHOD(t_unicodefilter, toPattern, METH_VARARGS), DECLARE_METHOD(t_unicodefilter, matchesIndexValue, METH_O), DECLARE_METHOD(t_unicodefilter, addMatchSetTo, METH_O), DECLARE_METHOD(t_unicodefilter, contains, METH_O), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(UnicodeFilter, t_unicodefilter, UObject, UnicodeFilter, abstract_init, NULL); /* UnicodeSet */ class t_unicodeset : public _wrapper { public: UnicodeSet *object; }; static int t_unicodeset_init(t_unicodeset *self, PyObject *args, PyObject *kwds); #if U_ICU_VERSION_HEX >= 0x04000000 static PyObject *t_unicodeset_isBogus(t_unicodeset *self); static PyObject *t_unicodeset_setToBogus(t_unicodeset *self); #endif static PyObject *t_unicodeset_isEmpty(t_unicodeset *self); static PyObject *t_unicodeset_isFrozen(t_unicodeset *self); static PyObject *t_unicodeset_freeze(t_unicodeset *self); static PyObject *t_unicodeset_set(t_unicodeset *self, PyObject *args); static PyObject *t_unicodeset_applyPattern(t_unicodeset *self, PyObject *arg); static PyObject *t_unicodeset_applyIntPropertyValue(t_unicodeset *self, PyObject *args); static PyObject *t_unicodeset_applyPropertyAlias(t_unicodeset *self, PyObject *args); static PyObject *t_unicodeset_contains(t_unicodeset *self, PyObject *args); static PyObject *t_unicodeset_containsAll(t_unicodeset *self, PyObject *arg); static PyObject *t_unicodeset_containsNone(t_unicodeset *self, PyObject *args); static PyObject *t_unicodeset_containsSome(t_unicodeset *self, PyObject *args); static PyObject *t_unicodeset_span(t_unicodeset *self, PyObject *args); static PyObject *t_unicodeset_spanBack(t_unicodeset *self, PyObject *args); static PyObject *t_unicodeset_add(t_unicodeset *self, PyObject *args); static PyObject *t_unicodeset_addAll(t_unicodeset *self, PyObject *arg); static PyObject *t_unicodeset_retainAll(t_unicodeset *self, PyObject *arg); static PyObject *t_unicodeset_complementAll(t_unicodeset *self, PyObject *arg); static PyObject *t_unicodeset_removeAll(t_unicodeset *self, PyObject *arg); static PyObject *t_unicodeset_retain(t_unicodeset *self, PyObject *args); static PyObject *t_unicodeset_remove(t_unicodeset *self, PyObject *args); static PyObject *t_unicodeset_complement(t_unicodeset *self, PyObject *args); static PyObject *t_unicodeset_clear(t_unicodeset *self); static PyObject *t_unicodeset_closeOver(t_unicodeset *self, PyObject *arg); #if U_ICU_VERSION_HEX >= 0x04020000 static PyObject *t_unicodeset_removeAllStrings(t_unicodeset *self); #endif static PyObject *t_unicodeset_compact(t_unicodeset *self); static PyObject *t_unicodeset_getRangeCount(t_unicodeset *self); static PyObject *t_unicodeset_getRangeStart(t_unicodeset *self, PyObject *arg); static PyObject *t_unicodeset_getRangeEnd(t_unicodeset *self, PyObject *arg); static PyObject *t_unicodeset_resemblesPattern(PyTypeObject *type, PyObject *args); static PyObject *t_unicodeset_createFrom(PyTypeObject *type, PyObject *arg); static PyObject *t_unicodeset_createFromAll(PyTypeObject *type, PyObject *arg); static PyMethodDef t_unicodeset_methods[] = { #if U_ICU_VERSION_HEX >= 0x04000000 DECLARE_METHOD(t_unicodeset, isBogus, METH_NOARGS), DECLARE_METHOD(t_unicodeset, setToBogus, METH_NOARGS), #endif DECLARE_METHOD(t_unicodeset, isEmpty, METH_NOARGS), DECLARE_METHOD(t_unicodeset, isFrozen, METH_NOARGS), DECLARE_METHOD(t_unicodeset, freeze, METH_NOARGS), DECLARE_METHOD(t_unicodeset, set, METH_VARARGS), DECLARE_METHOD(t_unicodeset, applyPattern, METH_O), DECLARE_METHOD(t_unicodeset, applyIntPropertyValue, METH_VARARGS), DECLARE_METHOD(t_unicodeset, applyPropertyAlias, METH_VARARGS), DECLARE_METHOD(t_unicodeset, contains, METH_VARARGS), DECLARE_METHOD(t_unicodeset, containsAll, METH_O), DECLARE_METHOD(t_unicodeset, containsNone, METH_VARARGS), DECLARE_METHOD(t_unicodeset, containsSome, METH_VARARGS), DECLARE_METHOD(t_unicodeset, span, METH_VARARGS), DECLARE_METHOD(t_unicodeset, spanBack, METH_VARARGS), DECLARE_METHOD(t_unicodeset, add, METH_VARARGS), DECLARE_METHOD(t_unicodeset, addAll, METH_O), DECLARE_METHOD(t_unicodeset, retainAll, METH_O), DECLARE_METHOD(t_unicodeset, complementAll, METH_O), DECLARE_METHOD(t_unicodeset, removeAll, METH_O), DECLARE_METHOD(t_unicodeset, retain, METH_VARARGS), DECLARE_METHOD(t_unicodeset, remove, METH_VARARGS), DECLARE_METHOD(t_unicodeset, complement, METH_VARARGS), DECLARE_METHOD(t_unicodeset, clear, METH_NOARGS), DECLARE_METHOD(t_unicodeset, closeOver, METH_O), #if U_ICU_VERSION_HEX >= 0x04020000 DECLARE_METHOD(t_unicodeset, removeAllStrings, METH_NOARGS), #endif DECLARE_METHOD(t_unicodeset, compact, METH_NOARGS), DECLARE_METHOD(t_unicodeset, getRangeCount, METH_NOARGS), DECLARE_METHOD(t_unicodeset, getRangeStart, METH_O), DECLARE_METHOD(t_unicodeset, getRangeEnd, METH_O), DECLARE_METHOD(t_unicodeset, resemblesPattern, METH_VARARGS | METH_CLASS), DECLARE_METHOD(t_unicodeset, createFrom, METH_O | METH_CLASS), DECLARE_METHOD(t_unicodeset, createFromAll, METH_O | METH_CLASS), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(UnicodeSet, t_unicodeset, UnicodeFilter, UnicodeSet, t_unicodeset_init, NULL); /* UnicodeSetIterator */ class t_unicodesetiterator : public _wrapper { public: UnicodeSetIterator *object; PyObject *set; }; static int t_unicodesetiterator_init(t_unicodesetiterator *self, PyObject *args, PyObject *kwds); static PyObject *t_unicodesetiterator_isString(t_unicodesetiterator *self); static PyObject *t_unicodesetiterator_getCodepoint(t_unicodesetiterator *self); static PyObject *t_unicodesetiterator_getCodepointEnd(t_unicodesetiterator *self); static PyObject *t_unicodesetiterator_getString(t_unicodesetiterator *self); static PyObject *t_unicodesetiterator_next(t_unicodesetiterator *self); static PyObject *t_unicodesetiterator_nextRange(t_unicodesetiterator *self); static PyObject *t_unicodesetiterator_reset(t_unicodesetiterator *self, PyObject *args); static PyMethodDef t_unicodesetiterator_methods[] = { DECLARE_METHOD(t_unicodesetiterator, isString, METH_NOARGS), DECLARE_METHOD(t_unicodesetiterator, getCodepoint, METH_NOARGS), DECLARE_METHOD(t_unicodesetiterator, getCodepointEnd, METH_NOARGS), DECLARE_METHOD(t_unicodesetiterator, getString, METH_NOARGS), DECLARE_METHOD(t_unicodesetiterator, next, METH_NOARGS), DECLARE_METHOD(t_unicodesetiterator, nextRange, METH_NOARGS), DECLARE_METHOD(t_unicodesetiterator, reset, METH_VARARGS), { NULL, NULL, 0, NULL } }; static void t_unicodesetiterator_dealloc(t_unicodesetiterator *self) { if (self->flags & T_OWNED) delete self->object; self->object = NULL; Py_CLEAR(self->set); Py_TYPE(self)->tp_free((PyObject *) self); } DECLARE_TYPE(UnicodeSetIterator, t_unicodesetiterator, UObject, UnicodeSetIterator, t_unicodesetiterator_init, t_unicodesetiterator_dealloc); /* UnicodeFunctor */ static PyObject *t_unicodefunctor_toMatcher(t_unicodefunctor *self) { return wrap_UnicodeMatcher(self->object->clone()->toMatcher(), T_OWNED); } /* UnicodeMatcher */ static PyObject *t_unicodematcher_matches(t_unicodematcher *self, PyObject *args) { UnicodeString *u, _u; int32_t offset, limit, incremental; if (!parseArgs(args, "SiiB", &u, &_u, &offset, &limit, &incremental)) { UMatchDegree degree = self->object->matches(*(Replaceable const *) u, offset, limit, (UBool) incremental); return Py_BuildValue("(ii)", degree, offset); } return PyErr_SetArgsError((PyObject *) self, "matches", args); } static PyObject *t_unicodematcher_toPattern(t_unicodematcher *self, PyObject *args) { UnicodeString u; int escapeUnprintable = 0; switch (PyTuple_Size(args)) { case 0: self->object->toPattern(u); return PyUnicode_FromUnicodeString(&u); case 1: if (!parseArgs(args, "B", &escapeUnprintable)) { self->object->toPattern(u, (UBool) escapeUnprintable); return PyUnicode_FromUnicodeString(&u); } } return PyErr_SetArgsError((PyObject *) self, "toPattern", args); } static PyObject *t_unicodematcher_matchesIndexValue(t_unicodematcher *self, PyObject *arg) { int v; if (!parseArg(arg, "i", &v)) { UBool b = self->object->matchesIndexValue((uint8_t) v); Py_RETURN_BOOL(b); } return PyErr_SetArgsError((PyObject *) self, "matchesIndexValue", arg); } static PyObject *t_unicodematcher_addMatchSetTo(t_unicodematcher *self, PyObject *arg) { UnicodeSet *set; if (!parseArg(arg, "P", TYPE_CLASSID(UnicodeSet), &set)) { self->object->addMatchSetTo(*set); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "addMatchSetTo", arg); } /* UnicodeFilter */ static PyObject *t_unicodefilter_toMatcher(t_unicodefilter *self) { return wrap_UnicodeMatcher(self->object->clone()->toMatcher(), T_OWNED); } static PyObject *t_unicodefilter_matches(t_unicodefilter *self, PyObject *args) { UnicodeString *u; UnicodeString _u; int32_t offset, limit, incremental; if (!parseArgs(args, "SiiB", &u, &_u, &offset, &limit, &incremental)) { UMatchDegree degree = self->object->matches(*(Replaceable const *) u, offset, limit, (UBool) incremental); return Py_BuildValue("(ii)", degree, offset); } return PyErr_SetArgsError((PyObject *) self, "matches", args); } static PyObject *t_unicodefilter_toPattern(t_unicodefilter *self, PyObject *args) { UnicodeString *u, _u; int escapeUnprintable = 0; switch (PyTuple_Size(args)) { case 0: self->object->toPattern(_u); return PyUnicode_FromUnicodeString(&_u); case 1: if (!parseArgs(args, "U", &u)) { self->object->toPattern(*u, (UBool) escapeUnprintable); Py_RETURN_ARG(args, 0); } if (!parseArgs(args, "B", &escapeUnprintable)) { self->object->toPattern(_u, (UBool) escapeUnprintable); return PyUnicode_FromUnicodeString(&_u); } case 2: if (!parseArgs(args, "UB", &u, &escapeUnprintable)) { self->object->toPattern(*u, (UBool) escapeUnprintable); Py_RETURN_ARG(args, 0); } } return PyErr_SetArgsError((PyObject *) self, "toPattern", args); } static PyObject *t_unicodefilter_matchesIndexValue(t_unicodefilter *self, PyObject *arg) { int v; if (!parseArg(arg, "i", &v)) { UBool b = self->object->matchesIndexValue((uint8_t) v); Py_RETURN_BOOL(b); } return PyErr_SetArgsError((PyObject *) self, "matchesIndexValue", arg); } static PyObject *t_unicodefilter_addMatchSetTo(t_unicodefilter *self, PyObject *arg) { UnicodeSet *set; if (!parseArg(arg, "P", TYPE_CLASSID(UnicodeSet), &set)) { self->object->addMatchSetTo(*set); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "addMatchSetTo", arg); } static PyObject *t_unicodefilter_contains(t_unicodefilter *self, PyObject *arg) { UnicodeString *u; UnicodeString _u; if (!parseArg(arg, "S", &u, &_u)) { UChar32 c; int32_t len; STATUS_CALL(len = toUChar32(*u, &c, status)); if (len == 1) { UBool b = self->object->contains(c); Py_RETURN_BOOL(b); } } return PyErr_SetArgsError((PyObject *) self, "contains", arg); } /* UnicodeSet */ static int t_unicodeset_init(t_unicodeset *self, PyObject *args, PyObject *kwds) { UnicodeSet *set; UnicodeString *u0, *u1; UnicodeString _u0, _u1; switch (PyTuple_Size(args)) { case 0: self->object = new UnicodeSet(); self->flags = T_OWNED; break; case 1: if (!parseArgs(args, "S", &u0, &_u0)) { INT_STATUS_CALL(set = new UnicodeSet(*u0, status)); self->object = set; self->flags = T_OWNED; break; } if (!parseArgs(args, "P", TYPE_CLASSID(UnicodeSet), &set)) { self->object = new UnicodeSet(*set); self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; case 2: if (!parseArgs(args, "SS", &u0, &_u0, &u1, &_u1)) { UChar32 c0, c1; int32_t l0, l1; INT_STATUS_CALL(l0 = toUChar32(*u0, &c0, status)); INT_STATUS_CALL(l1 = toUChar32(*u1, &c1, status)); if (l0 == 1 && l1 == 1) { self->object = new UnicodeSet(c0, c1); self->flags = T_OWNED; break; } } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; default: PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; } if (self->object) return 0; return -1; } #if U_ICU_VERSION_HEX >= 0x04000000 static PyObject *t_unicodeset_isBogus(t_unicodeset *self) { UBool b = self->object->isBogus(); Py_RETURN_BOOL(b); } static PyObject *t_unicodeset_setToBogus(t_unicodeset *self) { self->object->setToBogus(); Py_RETURN_NONE; } #endif static PyObject *t_unicodeset_isEmpty(t_unicodeset *self) { UBool b = self->object->isEmpty(); Py_RETURN_BOOL(b); } static PyObject *t_unicodeset_isFrozen(t_unicodeset *self) { UBool b = self->object->isFrozen(); Py_RETURN_BOOL(b); } static PyObject *t_unicodeset_freeze(t_unicodeset *self) { self->object->freeze(); Py_RETURN_NONE; } static PyObject *t_unicodeset_set(t_unicodeset *self, PyObject *args) { UnicodeString *u0, *u1; UnicodeString _u0, _u1; if (!parseArgs(args, "SS", &u0, &_u0, &u1, &_u1)) { UChar32 c0, c1; int32_t l0, l1; STATUS_CALL(l0 = toUChar32(*u0, &c0, status)); STATUS_CALL(l1 = toUChar32(*u1, &c1, status)); if (l0 == 1 && l1 == 1) { self->object->set(c0, c1); Py_RETURN_SELF(); } } PyErr_SetArgsError((PyObject *) self, "set", args); return NULL; } static PyObject *t_unicodeset_add(t_unicodeset *self, PyObject *args) { UnicodeString *u0, *u1; UnicodeString _u0, _u1; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "S", &u0, &_u0)) { UChar32 c0; int32_t l0; if (u0->length() == 1) { STATUS_CALL(l0 = toUChar32(*u0, &c0, status)); if (l0 == 1) { self->object->add(c0); Py_RETURN_SELF(); } } else { self->object->add(*u0); Py_RETURN_SELF(); } } break; case 2: if (!parseArgs(args, "SS", &u0, &_u0, &u1, &_u1)) { UChar32 c0, c1; int32_t l0, l1; STATUS_CALL(l0 = toUChar32(*u0, &c0, status)); STATUS_CALL(l1 = toUChar32(*u1, &c1, status)); if (l0 == 1 && l1 == 1) { self->object->add(c0, c1); Py_RETURN_SELF(); } } break; } PyErr_SetArgsError((PyObject *) self, "add", args); return NULL; } static PyObject *t_unicodeset_addAll(t_unicodeset *self, PyObject *arg) { UnicodeString *u, _u; UnicodeSet *set; if (!parseArg(arg, "S", &u, &_u)) { self->object->addAll(*u); Py_RETURN_SELF(); } if (!parseArg(arg, "P", TYPE_CLASSID(UnicodeSet), &set)) { self->object->addAll(*set); Py_RETURN_SELF(); } PyErr_SetArgsError((PyObject *) self, "addAll", arg); return NULL; } static PyObject *t_unicodeset_retain(t_unicodeset *self, PyObject *args) { UnicodeString *u0, *u1; UnicodeString _u0, _u1; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "S", &u0, &_u0)) { UChar32 c0; int32_t l0; if (u0->length() == 1) { STATUS_CALL(l0 = toUChar32(*u0, &c0, status)); if (l0 == 1) { self->object->retain(c0); Py_RETURN_SELF(); } } } break; case 2: if (!parseArgs(args, "SS", &u0, &_u0, &u1, &_u1)) { UChar32 c0, c1; int32_t l0, l1; STATUS_CALL(l0 = toUChar32(*u0, &c0, status)); STATUS_CALL(l1 = toUChar32(*u1, &c1, status)); if (l0 == 1 && l1 == 1) { self->object->retain(c0, c1); Py_RETURN_SELF(); } } break; } PyErr_SetArgsError((PyObject *) self, "retain", args); return NULL; } static PyObject *t_unicodeset_retainAll(t_unicodeset *self, PyObject *arg) { UnicodeString *u, _u; UnicodeSet *set; if (!parseArg(arg, "S", &u, &_u)) { self->object->retainAll(*u); Py_RETURN_SELF(); } if (!parseArg(arg, "P", TYPE_CLASSID(UnicodeSet), &set)) { self->object->retainAll(*set); Py_RETURN_SELF(); } PyErr_SetArgsError((PyObject *) self, "retainAll", arg); return NULL; } static PyObject *t_unicodeset_complement(t_unicodeset *self, PyObject *args) { UnicodeString *u0, *u1; UnicodeString _u0, _u1; switch (PyTuple_Size(args)) { case 0: self->object->complement(); break; case 1: if (!parseArgs(args, "S", &u0, &_u0)) { UChar32 c0; int32_t l0; if (u0->length() == 1) { STATUS_CALL(l0 = toUChar32(*u0, &c0, status)); if (l0 == 1) { self->object->complement(c0); Py_RETURN_SELF(); } } else { self->object->complement(*u0); Py_RETURN_SELF(); } } break; case 2: if (!parseArgs(args, "SS", &u0, &_u0, &u1, &_u1)) { UChar32 c0, c1; int32_t l0, l1; STATUS_CALL(l0 = toUChar32(*u0, &c0, status)); STATUS_CALL(l1 = toUChar32(*u1, &c1, status)); if (l0 == 1 && l1 == 1) { self->object->complement(c0, c1); Py_RETURN_SELF(); } } break; } PyErr_SetArgsError((PyObject *) self, "complement", args); return NULL; } static PyObject *t_unicodeset_complementAll(t_unicodeset *self, PyObject *arg) { UnicodeString *u, _u; UnicodeSet *set; if (!parseArg(arg, "S", &u, &_u)) { self->object->complementAll(*u); Py_RETURN_SELF(); } if (!parseArg(arg, "P", TYPE_CLASSID(UnicodeSet), &set)) { self->object->complementAll(*set); Py_RETURN_SELF(); } PyErr_SetArgsError((PyObject *) self, "complementAll", arg); return NULL; } static PyObject *t_unicodeset_remove(t_unicodeset *self, PyObject *args) { UnicodeString *u0, *u1; UnicodeString _u0, _u1; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "S", &u0, &_u0)) { UChar32 c0; int32_t l0; if (u0->length() == 1) { STATUS_CALL(l0 = toUChar32(*u0, &c0, status)); if (l0 == 1) { self->object->remove(c0); Py_RETURN_SELF(); } } else { self->object->remove(*u0); Py_RETURN_SELF(); } } break; case 2: if (!parseArgs(args, "SS", &u0, &_u0, &u1, &_u1)) { UChar32 c0, c1; int32_t l0, l1; STATUS_CALL(l0 = toUChar32(*u0, &c0, status)); STATUS_CALL(l1 = toUChar32(*u1, &c1, status)); if (l0 == 1 && l1 == 1) { self->object->remove(c0, c1); Py_RETURN_SELF(); } } break; } PyErr_SetArgsError((PyObject *) self, "remove", args); return NULL; } static PyObject *t_unicodeset_removeAll(t_unicodeset *self, PyObject *arg) { UnicodeString *u, _u; UnicodeSet *set; if (!parseArg(arg, "S", &u, &_u)) { self->object->removeAll(*u); Py_RETURN_SELF(); } if (!parseArg(arg, "P", TYPE_CLASSID(UnicodeSet), &set)) { self->object->removeAll(*set); Py_RETURN_SELF(); } PyErr_SetArgsError((PyObject *) self, "removeAll", arg); return NULL; } static PyObject *t_unicodeset_applyPattern(t_unicodeset *self, PyObject *arg) { UnicodeString *u, _u; if (!parseArg(arg, "S", &u, &_u)) { STATUS_CALL(self->object->applyPattern(*u, status)); Py_RETURN_SELF(); } PyErr_SetArgsError((PyObject *) self, "applyPattern", arg); return NULL; } static PyObject *t_unicodeset_applyIntPropertyValue(t_unicodeset *self, PyObject *args) { UProperty prop; int32_t value; if (!parseArgs(args, "ii", &prop, &value)) { STATUS_CALL(self->object->applyIntPropertyValue(prop, value, status)); Py_RETURN_SELF(); } PyErr_SetArgsError((PyObject *) self, "applyIntPropertyValue", args); return NULL; } static PyObject *t_unicodeset_applyPropertyAlias(t_unicodeset *self, PyObject *args) { UnicodeString *u0, *u1; UnicodeString _u0, _u1; if (!parseArgs(args, "SS", &u0, &_u0, &u1, &_u1)) { STATUS_CALL(self->object->applyPropertyAlias(*u0, *u1, status)); Py_RETURN_SELF(); } PyErr_SetArgsError((PyObject *) self, "applyPropertyAlias", args); return NULL; } static PyObject *t_unicodeset_contains(t_unicodeset *self, PyObject *args) { UnicodeString *u0, *u1; UnicodeString _u0, _u1; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "S", &u0, &_u0)) { UChar32 c0; int32_t l0; if (u0->length() == 1) { STATUS_CALL(l0 = toUChar32(*u0, &c0, status)); if (l0 == 1) { UBool b = self->object->contains(c0); Py_RETURN_BOOL(b); } } else { UBool b = self->object->contains(*u0); Py_RETURN_BOOL(b); } } break; case 2: if (!parseArgs(args, "SS", &u0, &_u0, &u1, &_u1)) { UChar32 c0, c1; int32_t l0, l1; STATUS_CALL(l0 = toUChar32(*u0, &c0, status)); STATUS_CALL(l1 = toUChar32(*u1, &c1, status)); if (l0 == 1 && l1 == 1) { UBool b = self->object->contains(c0, c1); Py_RETURN_BOOL(b); } } break; } return PyErr_SetArgsError((PyObject *) self, "contains", args); } static PyObject *t_unicodeset_containsAll(t_unicodeset *self, PyObject *arg) { UnicodeString *u, _u; UnicodeSet *set; UBool b; if (!parseArg(arg, "S", &u, &_u)) b = self->object->containsAll(*u); else if (!parseArg(arg, "P", TYPE_CLASSID(UnicodeSet), &set)) b = self->object->containsAll(*set); else return PyErr_SetArgsError((PyObject *) self, "containsAll", arg); Py_RETURN_BOOL(b); } static PyObject *t_unicodeset_containsNone(t_unicodeset *self, PyObject *args) { UnicodeString *u0, *u1; UnicodeString _u0, _u1; UnicodeSet *set; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "S", &u0, &_u0)) { UBool b = self->object->containsNone(*u0); Py_RETURN_BOOL(b); } if (!parseArgs(args, "P", TYPE_CLASSID(UnicodeSet), &set)) { UBool b = self->object->containsNone(*u0); Py_RETURN_BOOL(b); } break; case 2: if (!parseArgs(args, "SS", &u0, &_u0, &u1, &_u1)) { UChar32 c0, c1; int32_t l0, l1; STATUS_CALL(l0 = toUChar32(*u0, &c0, status)); STATUS_CALL(l1 = toUChar32(*u1, &c1, status)); if (l0 == 1 && l1 == 1) { UBool b = self->object->containsNone(c0, c1); Py_RETURN_BOOL(b); } } break; } return PyErr_SetArgsError((PyObject *) self, "containsNone", args); } static PyObject *t_unicodeset_containsSome(t_unicodeset *self, PyObject *args) { UnicodeString *u0, *u1; UnicodeString _u0, _u1; UnicodeSet *set; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "S", &u0, &_u0)) { UBool b = self->object->containsSome(*u0); Py_RETURN_BOOL(b); } if (!parseArgs(args, "P", TYPE_CLASSID(UnicodeSet), &set)) { UBool b = self->object->containsSome(*u0); Py_RETURN_BOOL(b); } break; case 2: if (!parseArgs(args, "SS", &u0, &_u0, &u1, &_u1)) { UChar32 c0, c1; int32_t l0, l1; STATUS_CALL(l0 = toUChar32(*u0, &c0, status)); STATUS_CALL(l1 = toUChar32(*u1, &c1, status)); if (l0 == 1 && l1 == 1) { UBool b = self->object->containsSome(c0, c1); Py_RETURN_BOOL(b); } } break; } return PyErr_SetArgsError((PyObject *) self, "containsSome", args); } static PyObject *t_unicodeset_span(t_unicodeset *self, PyObject *args) { UnicodeString *u, _u; USetSpanCondition spanCondition; int32_t length; if (!parseArgs(args, "Si", &u, &_u, &spanCondition)) { length = self->object->span(u->getBuffer(), u->length(), spanCondition); return PyInt_FromLong(length); } return PyErr_SetArgsError((PyObject *) self, "span", args); } static PyObject *t_unicodeset_spanBack(t_unicodeset *self, PyObject *args) { UnicodeString *u, _u; USetSpanCondition spanCondition; int length; if (!parseArgs(args, "Si", &u, &_u, &spanCondition)) { length = self->object->spanBack(u->getBuffer(), u->length(), spanCondition); return PyInt_FromLong(length); } return PyErr_SetArgsError((PyObject *) self, "spanBack", args); } static PyObject *t_unicodeset_clear(t_unicodeset *self) { self->object->clear(); Py_RETURN_SELF(); } #if U_ICU_VERSION_HEX >= 0x04020000 static PyObject *t_unicodeset_removeAllStrings(t_unicodeset *self) { self->object->removeAllStrings(); Py_RETURN_SELF(); } #endif static PyObject *t_unicodeset_closeOver(t_unicodeset *self, PyObject *arg) { int32_t attribute; if (!parseArg(arg, "i", &attribute)) { self->object->closeOver(attribute); Py_RETURN_SELF(); } return PyErr_SetArgsError((PyObject *) self, "closeOver", arg); } static PyObject *t_unicodeset_compact(t_unicodeset *self) { self->object->compact(); Py_RETURN_SELF(); } static PyObject *t_unicodeset_getRangeCount(t_unicodeset *self) { int32_t count = self->object->getRangeCount(); return PyInt_FromLong(count); } static PyObject *t_unicodeset_getRangeStart(t_unicodeset *self, PyObject *arg) { int32_t index; if (!parseArg(arg, "i", &index)) { UnicodeString u = UnicodeString(self->object->getRangeStart(index)); return PyUnicode_FromUnicodeString(&u); } return PyErr_SetArgsError((PyObject *) self, "getRangeStart", arg); } static PyObject *t_unicodeset_getRangeEnd(t_unicodeset *self, PyObject *arg) { int32_t index; if (!parseArg(arg, "i", &index)) { UnicodeString u = UnicodeString(self->object->getRangeEnd(index)); return PyUnicode_FromUnicodeString(&u); } return PyErr_SetArgsError((PyObject *) self, "getRangeEnd", arg); } static PyObject *t_unicodeset_resemblesPattern(PyTypeObject *type, PyObject *args) { UnicodeString *u, _u; int32_t pos; if (!parseArgs(args, "Si", &u, &_u, &pos)) { UBool b = UnicodeSet::resemblesPattern(*u, pos); Py_RETURN_BOOL(b); } return PyErr_SetArgsError(type, "resemblesPattern", args); } static PyObject *t_unicodeset_createFrom(PyTypeObject *type, PyObject *arg) { UnicodeString *u, _u; if (!parseArg(arg, "S", &u, &_u)) return wrap_UnicodeSet(UnicodeSet::createFrom(*u), T_OWNED); return PyErr_SetArgsError(type, "createFrom", arg); } static PyObject *t_unicodeset_createFromAll(PyTypeObject *type, PyObject *arg) { UnicodeString *u, _u; if (!parseArg(arg, "S", &u, &_u)) return wrap_UnicodeSet(UnicodeSet::createFromAll(*u), T_OWNED); return PyErr_SetArgsError(type, "createFromAll", arg); } static PyObject *t_unicodeset_str(t_unicodeset *self) { UnicodeString u; self->object->toPattern(u); return PyUnicode_FromUnicodeString(&u); } static PyObject *t_unicodeset_richcmp(t_unicodeset *self, PyObject *arg, int op) { UnicodeSet *set; int b = 0; if (!parseArg(arg, "P", TYPE_CLASSID(UnicodeSet), &set)) { switch (op) { case Py_EQ: case Py_NE: b = *self->object == *set; if (op == Py_EQ) Py_RETURN_BOOL(b); Py_RETURN_BOOL(!b); case Py_LT: case Py_LE: case Py_GT: case Py_GE: PyErr_SetNone(PyExc_NotImplementedError); return NULL; } } return PyErr_SetArgsError((PyObject *) self, "__richcmp__", arg); } static PyObject *t_unicodeset_iter(t_unicodeset *self) { return PyObject_CallFunctionObjArgs((PyObject *) &UnicodeSetIteratorType_, (PyObject *) self, NULL); } static long t_unicodeset_hash(t_unicodeset *self) { return (long) self->object->hashCode(); } static Py_ssize_t _t_unicodeset_length(t_unicodeset *self) { return self->object->size(); } static int _t_unicodeset_contains(t_unicodeset *self, PyObject *arg) { UnicodeString *u, _u; if (!parseArg(arg, "S", &u, &_u)) { UChar32 c; int32_t l; if (u->length() == 1) { INT_STATUS_CALL(l = toUChar32(*u, &c, status)); if (l == 1) return self->object->contains(c); } else return self->object->contains(*u); } PyErr_SetArgsError((PyObject *) self, "in", arg); return -1; } static PyObject *_t_unicodeset_item(t_unicodeset *self, int n) { int len = self->object->size(); if (n < 0) n += len; if (n >= 0 && n < len) { UnicodeString u = UnicodeString(self->object->charAt(n)); return PyUnicode_FromUnicodeString(&u); } PyErr_SetNone(PyExc_IndexError); return NULL; } static PySequenceMethods t_unicodeset_as_sequence = { (lenfunc) _t_unicodeset_length, /* sq_length */ NULL, /* sq_concat */ NULL, /* sq_repeat */ (ssizeargfunc) _t_unicodeset_item, /* sq_item */ NULL, /* sq_slice */ NULL, /* sq_ass_item */ NULL, /* sq_ass_slice */ (objobjproc) _t_unicodeset_contains, /* sq_contains */ NULL, /* sq_inplace_concat */ NULL, /* sq_inplace_repeat */ }; /* UnicodeSetIterator */ static int t_unicodesetiterator_init(t_unicodesetiterator *self, PyObject *args, PyObject *kwds) { UnicodeSet *set; switch (PyTuple_Size(args)) { case 0: self->object = new UnicodeSetIterator(); self->flags = T_OWNED; break; case 1: if (!parseArgs(args, "p", TYPE_CLASSID(UnicodeSet), &set, &self->set)) { self->object = new UnicodeSetIterator(*set); self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; default: PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; } if (self->object) return 0; return -1; } static PyObject *t_unicodesetiterator_isString(t_unicodesetiterator *self) { UBool b = self->object->isString(); Py_RETURN_BOOL(b); } static PyObject *t_unicodesetiterator_getCodepoint(t_unicodesetiterator *self) { UChar32 c = self->object->getCodepoint(); UnicodeString u = fromUChar32(c); return PyUnicode_FromUnicodeString(&u); } static PyObject *t_unicodesetiterator_getCodepointEnd(t_unicodesetiterator *self) { UChar32 c = self->object->getCodepointEnd(); UnicodeString u = fromUChar32(c); return PyUnicode_FromUnicodeString(&u); } static PyObject *t_unicodesetiterator_getString(t_unicodesetiterator *self) { UnicodeString u = self->object->getString(); return PyUnicode_FromUnicodeString(&u); } static PyObject *t_unicodesetiterator_next(t_unicodesetiterator *self) { UBool b = self->object->next(); Py_RETURN_BOOL(b); } static PyObject *t_unicodesetiterator_nextRange(t_unicodesetiterator *self) { UBool b = self->object->nextRange(); Py_RETURN_BOOL(b); } static PyObject *t_unicodesetiterator_reset(t_unicodesetiterator *self, PyObject *args) { UnicodeSet *set; switch (PyTuple_Size(args)) { case 0: self->object->reset(); Py_RETURN_NONE; case 1: if (!parseArgs(args, "P", TYPE_CLASSID(UnicodeSet), &set)) { PyObject *setObject = PyTuple_GetItem(args, 0); Py_INCREF(setObject); Py_XDECREF(self->set); self->set = setObject; self->object->reset(*set); Py_RETURN_NONE; } break; } return PyErr_SetArgsError((PyObject *) self, "reset", args); } static PyObject *t_unicodesetiterator_iter(t_unicodesetiterator *self) { Py_RETURN_SELF(); } static PyObject *t_unicodesetiterator_iter_next(t_unicodesetiterator *self) { if (!self->object->next()) { PyErr_SetNone(PyExc_StopIteration); return NULL; } return t_unicodesetiterator_getString(self); } void _init_unicodeset(PyObject *m) { UnicodeSetType_.tp_str = (reprfunc) t_unicodeset_str; UnicodeSetType_.tp_richcompare = (richcmpfunc) t_unicodeset_richcmp; UnicodeSetType_.tp_hash = (hashfunc) t_unicodeset_hash; UnicodeSetType_.tp_iter = (getiterfunc) t_unicodeset_iter; UnicodeSetType_.tp_as_sequence = &t_unicodeset_as_sequence; UnicodeSetIteratorType_.tp_iter = (getiterfunc) t_unicodesetiterator_iter; UnicodeSetIteratorType_.tp_iternext = (iternextfunc) t_unicodesetiterator_iter_next; INSTALL_CONSTANTS_TYPE(UMatchDegree, m); INSTALL_CONSTANTS_TYPE(USetSpanCondition, m); REGISTER_TYPE(UnicodeFunctor, m); INSTALL_TYPE(UnicodeMatcher, m); REGISTER_TYPE(UnicodeFilter, m); REGISTER_TYPE(UnicodeSet, m); REGISTER_TYPE(UnicodeSetIterator, m); INSTALL_ENUM(UMatchDegree, "MISMATCH", U_MISMATCH); INSTALL_ENUM(UMatchDegree, "PARTIAL_MATCH", U_PARTIAL_MATCH); INSTALL_ENUM(UMatchDegree, "MATCH", U_MATCH); INSTALL_ENUM(USetSpanCondition, "SPAN_NOT_CONTAINED", USET_SPAN_NOT_CONTAINED); INSTALL_ENUM(USetSpanCondition, "SPAN_CONTAINED", USET_SPAN_CONTAINED); INSTALL_ENUM(USetSpanCondition, "SPAN_SIMPLE", USET_SPAN_SIMPLE); } PyICU-1.9.5/unicodeset.h0000644000076500000000000000305112520066436015200 0ustar vajdawheel00000000000000/* ==================================================================== * Copyright (c) 2010-2010 Open Source Applications Foundation. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. * ==================================================================== */ #ifndef _unicodeset_h #define _unicodeset_h extern PyTypeObject UnicodeFilterType_; extern PyTypeObject UnicodeSetType_; PyObject *wrap_UnicodeSet(UnicodeSet *, int); PyObject *wrap_UnicodeFilter(UnicodeFilter *, int); void _init_unicodeset(PyObject *m); #endif /* _unicodeset_h */