PyICU-1.5/0000755000076500000240000000000012062223456012522 5ustar vajdastaff00000000000000PyICU-1.5/_icu.cpp0000644000076500000240000002242611634225223014151 0ustar vajdastaff00000000000000/* ==================================================================== * 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 #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" #include "layoutengine.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) { 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; } 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); _init_layoutengine(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.5/bases.cpp0000644000076500000240000022021412026670331014322 0ustar vajdastaff00000000000000/* ==================================================================== * 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" /* 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[] = { { "owned", (getter) t_uobject__getOwned, NULL, "", 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_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); 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, 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), { 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]; sprintf(buf, "0x%lx", (unsigned long) self->object->getDynamicClassID()); 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 int t_unicodestring_hash(t_unicodestring *self) { return 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_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); } 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); INSTALL_MODULE_INT(m, UIDNA_DEFAULT); INSTALL_MODULE_INT(m, UIDNA_ALLOW_UNASSIGNED); INSTALL_MODULE_INT(m, UIDNA_USE_STD3_RULES); 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.5/bases.h0000644000076500000240000000356611740124267014004 0ustar vajdastaff00000000000000/* ==================================================================== * 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.5/calendar.cpp0000644000076500000240000015034212022710756015004 0ustar vajdastaff00000000000000/* ==================================================================== * 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); 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), 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 sensical 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); } 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, "_resetDefault", "", 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.5/calendar.h0000644000076500000240000000335211353452770014454 0ustar vajdastaff00000000000000/* ==================================================================== * 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.5/CHANGES0000644000076500000240000001762712062167327013536 0ustar vajdastaff00000000000000 For bug , see http://bugzilla.osafoundation.org/show_bug.cgi?id= 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 longers 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.5/charset.cpp0000644000076500000240000002425111621003626014656 0ustar vajdastaff00000000000000/* ==================================================================== * 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.5/charset.h0000644000076500000240000000255411323445325014332 0ustar vajdastaff00000000000000/* ==================================================================== * 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.5/collator.cpp0000644000076500000240000005517211634241312015052 0ustar vajdastaff00000000000000/* ==================================================================== * 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 int t_collator_hash(t_collator *self) { return 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.5/collator.h0000644000076500000240000000274611353510137014520 0ustar vajdastaff00000000000000/* ==================================================================== * 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.5/common.cpp0000644000076500000240000010511311754346577014540 0ustar vajdastaff00000000000000/* ==================================================================== * 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. * ==================================================================== */ #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; char chars[8]; int32_t length; } _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; int len = length < (int)sizeof(stop->chars)-1 ? length : sizeof(stop->chars)-1; stop->reason = reason; if (chars && len) strncpy(stop->chars, chars, len); stop->chars[len] = '\0'; stop->length = length; } PyObject *PyExc_ICUError; PyObject *PyExc_InvalidArgsError; EXPORT ICUException::ICUException() { code = NULL; msg = NULL; } 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(UnicodeString *string) { if (!string) { Py_INCREF(Py_None); return Py_None; } else if (sizeof(Py_UNICODE) == sizeof(UChar)) return PyUnicode_FromUnicode((const Py_UNICODE *) string->getBuffer(), (int) string->length()); else { int len = string->length(); PyObject *u = PyUnicode_FromUnicode(NULL, len); if (u) { Py_UNICODE *pchars = PyUnicode_AS_UNICODE(u); const UChar *chars = string->getBuffer(); for (int i = 0; i < len; i++) pchars[i] = chars[i]; } return u; } } EXPORT PyObject *PyUnicode_FromUnicodeString(const UChar *chars, int size) { if (!chars) { Py_INCREF(Py_None); return Py_None; } else if (sizeof(Py_UNICODE) == sizeof(UChar)) return PyUnicode_FromUnicode((const Py_UNICODE *) chars, size); else { PyObject *u = PyUnicode_FromUnicode(NULL, size); if (u) { Py_UNICODE *pchars = PyUnicode_AS_UNICODE(u); for (int i = 0; i < size; i++) pchars[i] = chars[i]; } return u; } } 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); UnicodeString result; if (U_FAILURE(status)) throw ICUException(status); _STOPReason stop; char *src; Py_ssize_t len; memset(&stop, 0, sizeof(stop)); if (!strcmp(mode, "strict")) { ucnv_setToUCallBack(conv, _stopDecode, &stop, NULL, NULL, &status); if (U_FAILURE(status)) throw ICUException(status); } PyBytes_AsStringAndSize(object, &src, &len); result = UnicodeString((const char *) src, (int32_t) len, conv, 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"; break; } status = U_ZERO_ERROR; int position = strstr(src, stop.chars) - src; PyObject *msg = PyString_FromFormat("'%s' codec can't decode byte 0x%x in position %d: %d (%s)", ucnv_getName(conv, &status), (int) (unsigned char) stop.chars[0], position, stop.reason, reasonName); PyErr_SetObject(PyExc_ValueError, msg); Py_DECREF(msg); ucnv_close(conv); throw ICUException(); } ucnv_close(conv); string.setTo(result); return string; } EXPORT UnicodeString &PyObject_AsUnicodeString(PyObject *object, const char *encoding, const char *mode, UnicodeString &string) { if (PyUnicode_Check(object)) { 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); UChar *chars = new UChar[len * 3]; UErrorCode status = U_ZERO_ERROR; int32_t dstLen; u_strFromUTF32(chars, len * 3, &dstLen, (const UChar32 *) pchars, len, &status); if (U_FAILURE(status)) { delete chars; throw ICUException(status); } string.setTo((const UChar *) chars, (int32_t) dstLen); delete chars; } } 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 - (((PyDateTime_Delta *) utcoffset)->days * 86400.0 + (double) ((PyDateTime_Delta *) utcoffset)->seconds); 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; } #ifdef _MSC_VER int __parseArgs(PyObject *args, const char *types, ...) { int count = PyObject_Size(args); va_list list; va_start(list, types); return _parseArgs(((PyTupleObject *)(args))->ob_item, count, types, list); } int __parseArg(PyObject *arg, const char *types, ...) { va_list list; va_start(list, types); return _parseArgs(&arg, 1, types, list); } int _parseArgs(PyObject **args, int count, const char *types, va_list list) { 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 for (int i = 0; i < count; i++) { PyObject *arg = args[i]; 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 '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++) { PyObject *arg = args[j]; switch (types[j]) { case 'A': /* previous Python arg object */ { PyObject **obj = va_arg(list, PyObject **); *obj = args[j - 1]; 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 '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.5/common.h0000644000076500000240000002427511740673642014205 0ustar vajdastaff00000000000000/* ==================================================================== * 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. * ==================================================================== */ #ifndef _common_h #define _common_h #ifdef _MSC_VER #define EXPORT __declspec(dllexport) #else #define EXPORT #endif #include #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 #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 #endif #if U_ICU_VERSION_HEX >= 0x04040000 #include #include #endif #if U_ICU_VERSION_HEX >= 0x04060000 #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 }; #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(UErrorCode status); EXPORT ICUException(UErrorCode status, char *format, ...); EXPORT ICUException(UParseError &pe, UErrorCode status); EXPORT ~ICUException(); EXPORT PyObject *reportError(); }; EXPORT PyObject *PyUnicode_FromUnicodeString(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); } }; #ifdef _MSC_VER #define parseArgs __parseArgs #define parseArg __parseArg int __parseArgs(PyObject *args, const char *types, ...); int __parseArg(PyObject *arg, const char *types, ...); int _parseArgs(PyObject **args, int count, const char *types, va_list list); #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.5/CREDITS0000644000076500000240000000121311355005146013535 0ustar vajdastaff00000000000000 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 - Thank you all ! PyICU-1.5/dateformat.cpp0000644000076500000240000013515412022767727015377 0ustar vajdastaff00000000000000/* ==================================================================== * 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 "calendar.h" #include "numberformat.h" #include "dateformat.h" #include "macros.h" /* 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); 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), { 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); } #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 /* 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; } /* 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); } #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 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 REGISTER_TYPE(DateFormatSymbols, m); INSTALL_TYPE(DateFormat, m); REGISTER_TYPE(SimpleDateFormat, m); #if U_ICU_VERSION_HEX >= 0x04000000 REGISTER_TYPE(DateInterval, m); REGISTER_TYPE(DateIntervalInfo, m); REGISTER_TYPE(DateIntervalFormat, 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); #if U_ICU_VERSION_HEX >= 0x04040000 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 } PyICU-1.5/dateformat.h0000644000076500000240000000266211323445340015024 0ustar vajdastaff00000000000000/* ==================================================================== * 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.5/docs.py0000644000076500000240000000714711574760361014045 0ustar vajdastaff00000000000000 # ==================================================================== # 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.5/errors.cpp0000644000076500000240000003350311525542647014557 0ustar vajdastaff00000000000000/* ==================================================================== * 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 occured"); _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.5/errors.h0000644000076500000240000000255011323445344014212 0ustar vajdastaff00000000000000/* ==================================================================== * 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.5/format.cpp0000644000076500000240000014163511754571651014542 0ustar vajdastaff00000000000000/* ==================================================================== * 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 "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 /* 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 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 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.5/format.h0000644000076500000240000000346211354161064014167 0ustar vajdastaff00000000000000/* ==================================================================== * 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.5/icu.py0000644000076500000240000000301112053756207013654 0ustar vajdastaff00000000000000 # ==================================================================== # 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.5/iterators.cpp0000644000076500000240000013274211634241330015246 0ustar vajdastaff00000000000000/* ==================================================================== * 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 } }; DECLARE_TYPE(StringCharacterIterator, t_stringcharacteriterator, UCharCharacterIterator, StringCharacterIterator, t_stringcharacteriterator_init, NULL); /* 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.5/iterators.h0000644000076500000240000000310411353521007014700 0ustar vajdastaff00000000000000/* ==================================================================== * 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.5/layoutengine.cpp0000644000076500000240000007307112053757345015752 0ustar vajdastaff00000000000000/* ==================================================================== * 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" #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 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_STATIC_INT(LayoutEngine, kTypoFlagKern); INSTALL_STATIC_INT(LayoutEngine, kTypoFlagLiga); INSTALL_ENUM(ScriptCode, "zyyy", zyyyScriptCode); INSTALL_ENUM(ScriptCode, "zinh", zinhScriptCode); 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"); } PyICU-1.5/layoutengine.h0000644000076500000240000000257711634232611015406 0ustar vajdastaff00000000000000/* ==================================================================== * 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.5/LICENSE0000644000076500000240000000240410413621043013517 0ustar vajdastaff00000000000000/* ==================================================================== * 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.5/locale.cpp0000644000076500000240000011015211621003626014460 0ustar vajdastaff00000000000000/* ==================================================================== * 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. * ==================================================================== */ #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" DECLARE_CONSTANTS_TYPE(ULocDataLocaleType); DECLARE_CONSTANTS_TYPE(UResType); /* 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_isBogus(t_locale *self); static PyObject *t_locale_setToBogus(t_locale *self); 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_getKeywordValue(t_locale *self, PyObject *arg); 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, isBogus, METH_NOARGS), DECLARE_METHOD(t_locale, setToBogus, METH_NOARGS), 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, getKeywordValue, METH_O), 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); static PyObject *t_resourcebundle_setAppData(PyTypeObject *type, PyObject *args); 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), DECLARE_METHOD(t_resourcebundle, setAppData, METH_CLASS | METH_VARARGS), { 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); } /* Locale */ static int t_locale_init(t_locale *self, PyObject *args, PyObject *kwds) { charsArg language, country, variant; 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; } 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_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; } 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_getKeywordValue(t_locale *self, PyObject *arg) { charsArg name; if (!parseArg(arg, "n", &name)) { char buf[ULOC_FULLNAME_CAPACITY]; UErrorCode status = U_ZERO_ERROR; int32_t 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); } 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()); } /* 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); } #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 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"); } } void _init_locale(PyObject *m) { LocaleType.tp_str = (reprfunc) t_locale_str; 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); REGISTER_TYPE(Locale, m); REGISTER_TYPE(ResourceBundle, 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); } PyICU-1.5/locale.h0000644000076500000240000000275111323445357014144 0ustar vajdastaff00000000000000/* ==================================================================== * 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.5/macros.h0000644000076500000240000006010211634275757014175 0ustar vajdastaff00000000000000/* ==================================================================== * 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 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.5/normalizer.cpp0000644000076500000240000005507611621003626015420 0ustar vajdastaff00000000000000/* ==================================================================== * 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 int t_normalizer_hash(t_normalizer *self) { return 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.5/normalizer.h0000644000076500000240000000256711344037065015070 0ustar vajdastaff00000000000000/* ==================================================================== * 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.5/numberformat.cpp0000644000076500000240000023170511740673671015751 0ustar vajdastaff00000000000000/* ==================================================================== * 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 /* 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); 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), 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); /* 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); } 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); } /* 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); 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 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.5/numberformat.h0000644000076500000240000000320411323445367015401 0ustar vajdastaff00000000000000/* ==================================================================== * 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.5/PKG-INFO0000644000076500000240000002465412062223456013632 0ustar vajdastaff00000000000000Metadata-Version: 1.0 Name: PyICU Version: 1.5 Summary: Python extension wrapping the ICU C++ API Home-page: http://pyicu.osafoundation.org/ Author: Open Source Applications Foundation Author-email: vajda@osafoundation.org License: UNKNOWN Description: --------------------- README file for PyICU --------------------- .. contents:: Welcome ------- Welcome to PyICU, a Python extension wrapping IBM's International Components for Unicode C++ library (ICU). PyICU is a project maintained by the Open Source Applications Foundation. 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 a 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: Topic :: Software Development :: Localization Classifier: Topic :: Software Development :: Internationalization PyICU-1.5/PyICU.egg-info/0000755000076500000240000000000012062223456015145 5ustar vajdastaff00000000000000PyICU-1.5/PyICU.egg-info/dependency_links.txt0000644000076500000240000000000112062223453021210 0ustar vajdastaff00000000000000 PyICU-1.5/PyICU.egg-info/PKG-INFO0000644000076500000240000002465412062223453016252 0ustar vajdastaff00000000000000Metadata-Version: 1.0 Name: PyICU Version: 1.5 Summary: Python extension wrapping the ICU C++ API Home-page: http://pyicu.osafoundation.org/ Author: Open Source Applications Foundation Author-email: vajda@osafoundation.org License: UNKNOWN Description: --------------------- README file for PyICU --------------------- .. contents:: Welcome ------- Welcome to PyICU, a Python extension wrapping IBM's International Components for Unicode C++ library (ICU). PyICU is a project maintained by the Open Source Applications Foundation. 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 a 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: Topic :: Software Development :: Localization Classifier: Topic :: Software Development :: Internationalization PyICU-1.5/PyICU.egg-info/SOURCES.txt0000644000076500000240000000167312062223453017035 0ustar vajdastaff00000000000000CHANGES CREDITS LICENSE PyICU.py README _icu.cpp bases.cpp bases.h calendar.cpp calendar.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 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 search.cpp search.h setup.py 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/collation-rules.txt test/lohit_hi.ttf test/noms.txt test/test_BreakIterator.py test/test_Charset.py test/test_Collator.py test/test_LayoutEngine.py test/test_MessageFormat.py test/test_Normalizer.py test/test_Transliterator.py test/test_UCS4.py test/test_UDate.pyPyICU-1.5/PyICU.egg-info/top_level.txt0000644000076500000240000000002412062223453017670 0ustar vajdastaff00000000000000docs _icu icu PyICU PyICU-1.5/PyICU.py0000644000076500000240000000267011354717030014031 0ustar vajdastaff00000000000000 # ==================================================================== # 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.5/README0000644000076500000240000001754311354706074013421 0ustar vajdastaff00000000000000 --------------------- README file for PyICU --------------------- .. contents:: Welcome ------- Welcome to PyICU, a Python extension wrapping IBM's International Components for Unicode C++ library (ICU). PyICU is a project maintained by the Open Source Applications Foundation. 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 a 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.5/regex.cpp0000644000076500000240000007226411642732076014361 0ustar vajdastaff00000000000000/* ==================================================================== * 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.5/regex.h0000644000076500000240000000254311344037063014010 0ustar vajdastaff00000000000000/* ==================================================================== * 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.5/samples/0000755000076500000240000000000012062223456014166 5ustar vajdastaff00000000000000PyICU-1.5/samples/break.py0000644000076500000240000000753311354706254015641 0ustar vajdastaff00000000000000# ==================================================================== # 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.5/samples/strsrch.py0000644000076500000240000001500111362445316016230 0ustar vajdastaff00000000000000# ==================================================================== # 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.5/search.cpp0000644000076500000240000004744011634241341014501 0ustar vajdastaff00000000000000/* ==================================================================== * 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.5/search.h0000644000076500000240000000255011353503672014145 0ustar vajdastaff00000000000000/* ==================================================================== * 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.5/setup.cfg0000644000076500000240000000007312062223456014343 0ustar vajdastaff00000000000000[egg_info] tag_build = tag_date = 0 tag_svn_revision = 0 PyICU-1.5/setup.py0000644000076500000240000000743112062166043014237 0ustar vajdastaff00000000000000 import os, sys try: from setuptools import setup, Extension except ImportError: from distutils.core import setup, Extension VERSION = '1.5' INCLUDES = { 'darwin': ['/usr/local/include'], 'linux': [], 'freebsd7': ['/usr/local/include'], 'win32': ['c:/icu/include'], 'sunos5': [], } CFLAGS = { 'darwin': ['-Wno-write-strings', '-DPYICU_VER="%s"' %(VERSION)], 'linux': ['-DPYICU_VER="%s"' %(VERSION)], 'freebsd7': ['-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'], 'freebsd7': ['-O0', '-g', '-DDEBUG'], 'win32': ['/Od', '/DDEBUG'], 'sunos5': ['-DDEBUG'], } LFLAGS = { 'darwin': ['-L/usr/local/lib'], 'linux': [], 'freebsd7': ['-L/usr/local/lib'], 'win32': ['/LIBPATH:c:/icu/lib'], 'sunos5': [], } LIBRARIES = { 'darwin': ['icui18n', 'icuuc', 'icudata', 'icule'], 'linux': ['icui18n', 'icuuc', 'icudata', 'icule'], 'freebsd7': ['icui18n', 'icuuc', 'icudata', 'icule'], 'win32': ['icuin', 'icuuc', 'icudt', 'icule'], 'sunos5': ['icui18n', 'icuuc', 'icudata', 'icule'], } platform = sys.platform if platform.startswith('linux'): platform = 'linux' 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) else: _libraries = LIBRARIES[platform] setup(name="PyICU", description='Python extension wrapping the ICU C++ API', long_description=open('README').read(), version=VERSION, test_suite="test", url='http://pyicu.osafoundation.org/', author='Open Source Applications Foundation', author_email='vajda@osafoundation.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', 'Topic :: Software Development :: Localization', 'Topic :: Software Development :: Internationalization'], ext_modules=[Extension('_icu', [filename for filename in 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.5/test/0000755000076500000240000000000012062223456013501 5ustar vajdastaff00000000000000PyICU-1.5/test/__init__.py0000644000076500000240000000146212062167164015620 0ustar vajdastaff00000000000000# 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.5/test/collation-rules.txt0000644000076500000240000025235511536347537017406 0ustar vajdastaff00000000000000[normalization on] [strength 4] [hiraganaQ on] &ヽ=ã‚ &[before 3]ã‚¡<<<ã‚¡|ー=ï½§|ー=ã|ー=ã‚¢|ー=ï½±|ー=ã‚|ー=ã‚«|ー=ï½¶|ー=ã‹|ー=ã‚•|ー=ガ|ー=ãŒ|ー=サ|ー=ï½»|ー=ã•|ー=ã‚¶|ー=ã–|ー=ã‚¿|ー=ï¾€|ー=ãŸ|ー=ダ|ー=ã |ー=ナ|ー=ï¾…|ー=ãª|ー=ãƒ|ー=ハ|ー=ㇵ|ー=ã¯|ー=ãƒ|ー=ã°|ー=パ|ー=ã±|ー=マ|ー=ï¾|ー=ã¾|ー=ャ|ー=ャ|ー=ゃ|ー=ヤ|ー=ï¾”|ー=ã‚„|ー=ラ|ー=ï¾—|ー=ㇻ|ー=ら|ー=ヮ|ー=ゎ|ー=ワ|ー=ワ|ー=ã‚|ー=ヵ|ー=ヷ|ー &[before 3]ã‚£<<<ã‚£|ー=ィ|ー=ãƒ|ー=イ|ー=ï½²|ー=ã„|ー=ã‚­|ー=ï½·|ー=ã|ー=ã‚®|ー=ãŽ|ー=ã‚·|ー=ï½¼|ー=ㇱ|ー=ã—|ー=ジ|ー=ã˜|ー=ãƒ|ー=ï¾|ー=ã¡|ー=ヂ|ー=ã¢|ー=ニ|ー=ニ|ー=ã«|ー=ヒ|ー=ヒ|ー=ㇶ|ー=ã²|ー=ビ|ー=ã³|ー=ピ|ー=ã´|ー=ミ|ー=ï¾|ー=ã¿|ー=リ|ー=リ|ー=ㇼ|ー=り|ー=ヰ|ー=ã‚|ー=ヸ|ー &[before 3]ã‚¥<<<ã‚¥|ー=ゥ|ー=ã…|ー=ウ|ー=ï½³|ー=ã†|ー=ク|ー=ク|ー=ㇰ|ー=ã|ー=ã‚°|ー=ã|ー=ス|ー=ï½½|ー=ㇲ|ー=ã™|ー=ズ|ー=ãš|ー=ッ|ー=ッ|ー=ã£|ー=ツ|ー=ツ|ー=ã¤|ー=ヅ|ー=ã¥|ー=ヌ|ー=ヌ|ー=ㇴ|ー=ã¬|ー=フ|ー=フ|ー=ㇷ|ー=ãµ|ー=ブ|ー=ã¶|ー=プ|ー=ã·|ー=ム|ー=ム|ー=ㇺ|ー=ã‚€|ー=ュ|ー=ï½­|ー=ã‚…|ー=ユ|ー=ユ|ー=ゆ|ー=ル|ー=ï¾™|ー=ㇽ|ー=ã‚‹|ー=ヴ|ー=ã‚”|ー &[before 3]ã‚§<<<ã‚§|ー=ェ|ー=ã‡|ー=エ|ー=ï½´|ー=ãˆ|ー=ケ|ー=ï½¹|ー=ã‘|ー=ã‚–|ー=ゲ|ー=ã’|ー=ã‚»|ー=ï½¾|ー=ã›|ー=ゼ|ー=ãœ|ー=テ|ー=テ|ー=ã¦|ー=デ|ー=ã§|ー=ãƒ|ー=ネ|ー=ã­|ー=ヘ|ー=ï¾|ー=ㇸ|ー=ã¸|ー=ベ|ー=ã¹|ー=ペ|ー=ãº|ー=メ|ー=ï¾’|ー=ã‚|ー=レ|ー=レ|ー=ㇾ|ー=れ|ー=ヱ|ー=ã‚‘|ー=ヶ|ー=ヹ|ー &[before 3]ã‚©<<<ã‚©|ー=ォ|ー=ã‰|ー=オ|ー=ï½µ|ー=ãŠ|ー=コ|ー=コ|ー=ã“|ー=ã‚´|ー=ã”|ー=ソ|ー=ソ|ー=ã|ー=ゾ|ー=ãž|ー=ト|ー=ト|ー=ㇳ|ー=ã¨|ー=ド|ー=ã©|ー=ノ|ー=ノ|ー=ã®|ー=ホ|ー=ホ|ー=ㇹ|ー=ã»|ー=ボ|ー=ã¼|ー=ãƒ|ー=ã½|ー=モ|ー=モ|ー=ã‚‚|ー=ョ|ー=ï½®|ー=ょ|ー=ヨ|ー=ï¾–|ー=よ|ー=ロ|ー=ï¾›|ー=ㇿ|ー=ã‚|ー=ヲ|ー=ヲ|ー=ã‚’|ー=ヺ|ー &[before 3]ã‚¢<<<ã‚¢|ヽ=ï½±|ヽ=ã‚|ã‚=ã‚¡|ヽ=ï½§|ヽ=ã|ã‚ &[before 3]イ<<<イ|ヽ=ï½²|ヽ=ã„|ã‚=ã‚£|ヽ=ィ|ヽ=ãƒ|ã‚ &[before 3]ウ<<<ウ|ヽ=ï½³|ヽ=ã†|ã‚=ã‚¥|ヽ=ゥ|ヽ=ã…|ã‚=ヴ|ヽ=ã‚”|ã‚=ウ|ヾ/ã‚™=ï½³|ヾ/ã‚™=ã†|ゞ/ã‚™=ã‚¥|ヾ/ã‚™=ゥ|ヾ/ã‚™=ã…|ゞ/ã‚™=ヴ|ヾ/ã‚™=ã‚”|ゞ/ã‚™ &[before 3]エ<<<エ|ヽ=ï½´|ヽ=ãˆ|ã‚=ã‚§|ヽ=ェ|ヽ=ã‡|ã‚ &[before 3]オ<<<オ|ヽ=ï½µ|ヽ=ãŠ|ã‚=ã‚©|ヽ=ォ|ヽ=ã‰|ã‚ &[before 3]ã‚«<<<ã‚«|ヽ=ï½¶|ヽ=ã‹|ã‚=ヵ|ヽ=ã‚•|ã‚ &[before 3]ガ<<<ガ|ヽ=ãŒ|ã‚ &[before 3]ã‚­<<<ã‚­|ヽ=ï½·|ヽ=ã|ã‚=ã‚®|ヽ=ãŽ|ã‚=ã‚­|ヾ/ã‚™=ï½·|ヾ/ã‚™=ã|ゞ/ã‚™=ã‚®|ヾ/ã‚™=ãŽ|ゞ/ã‚™ &[before 3]ク<<<ク|ヽ=ク|ヽ=ã|ã‚=ㇰ|ヽ=ã‚°|ヽ=ã|ã‚=ク|ヾ/ã‚™=ク|ヾ/ã‚™=ã|ゞ/ã‚™=ㇰ|ヾ/ã‚™=ã‚°|ヾ/ã‚™=ã|ゞ/ã‚™ &[before 3]ケ<<<ケ|ヽ=ï½¹|ヽ=ã‘|ã‚=ヶ|ヽ=ã‚–|ã‚ &[before 3]ゲ<<<ゲ|ヽ=ã’|ã‚ &[before 3]コ<<<コ|ヽ=コ|ヽ=ã“|ã‚=ã‚´|ヽ=ã”|ã‚=コ|ヾ/ã‚™=コ|ヾ/ã‚™=ã“|ゞ/ã‚™=ã‚´|ヾ/ã‚™=ã”|ゞ/ã‚™ &[before 3]サ<<<サ|ヽ=ï½»|ヽ=ã•|ã‚=ã‚¶|ヽ=ã–|ã‚=サ|ヾ/ã‚™=ï½»|ヾ/ã‚™=ã•|ゞ/ã‚™=ã‚¶|ヾ/ã‚™=ã–|ゞ/ã‚™ &[before 3]ã‚·<<<ã‚·|ヽ=ï½¼|ヽ=ã—|ã‚=ㇱ|ヽ=ジ|ヽ=ã˜|ã‚=ã‚·|ヾ/ã‚™=ï½¼|ヾ/ã‚™=ã—|ゞ/ã‚™=ㇱ|ヾ/ã‚™=ジ|ヾ/ã‚™=ã˜|ゞ/ã‚™ &[before 3]ス<<<ス|ヽ=ï½½|ヽ=ã™|ã‚=ㇲ|ヽ=ズ|ヽ=ãš|ã‚=ス|ヾ/ã‚™=ï½½|ヾ/ã‚™=ã™|ゞ/ã‚™=ㇲ|ヾ/ã‚™=ズ|ヾ/ã‚™=ãš|ゞ/ã‚™ &[before 3]ã‚»<<<ã‚»|ヽ=ï½¾|ヽ=ã›|ã‚=ゼ|ヽ=ãœ|ã‚=ã‚»|ヾ/ã‚™=ï½¾|ヾ/ã‚™=ã›|ゞ/ã‚™=ゼ|ヾ/ã‚™=ãœ|ゞ/ã‚™ &[before 3]ソ<<<ソ|ヽ=ソ|ヽ=ã|ã‚=ゾ|ヽ=ãž|ã‚=ソ|ヾ/ã‚™=ソ|ヾ/ã‚™=ã|ゞ/ã‚™=ゾ|ヾ/ã‚™=ãž|ゞ/ã‚™ &[before 3]ã‚¿<<<ã‚¿|ヽ=ï¾€|ヽ=ãŸ|ã‚=ダ|ヽ=ã |ã‚=ã‚¿|ヾ/ã‚™=ï¾€|ヾ/ã‚™=ãŸ|ゞ/ã‚™=ダ|ヾ/ã‚™=ã |ゞ/ã‚™ &[before 3]ãƒ<<<ãƒ|ヽ=ï¾|ヽ=ã¡|ã‚=ヂ|ヽ=ã¢|ã‚=ãƒ|ヾ/ã‚™=ï¾|ヾ/ã‚™=ã¡|ゞ/ã‚™=ヂ|ヾ/ã‚™=ã¢|ゞ/ã‚™ &[before 3]ツ<<<ツ|ヽ=ツ|ヽ=ã¤|ã‚=ッ|ヽ=ッ|ヽ=ã£|ã‚=ヅ|ヽ=ã¥|ã‚=ツ|ヾ/ã‚™=ツ|ヾ/ã‚™=ã¤|ゞ/ã‚™=ヅ|ヾ/ã‚™=ã¥|ゞ/ã‚™=ツ|ヽ=ツ|ヽ=ã¤|ã‚=ッ|ヾ/ã‚™=ッ|ヾ/ã‚™=ã£|ゞ/ã‚™=ツ|ヾ/ã‚™=ツ|ヾ/ã‚™=ã¤|ゞ/ã‚™ &[before 3]テ<<<テ|ヽ=テ|ヽ=ã¦|ã‚=デ|ヽ=ã§|ã‚=テ|ヾ/ã‚™=テ|ヾ/ã‚™=ã¦|ゞ/ã‚™=デ|ヾ/ã‚™=ã§|ゞ/ã‚™ &[before 3]ト<<<ト|ヽ=ト|ヽ=ã¨|ã‚=ㇳ|ヽ=ド|ヽ=ã©|ã‚=ト|ヾ/ã‚™=ト|ヾ/ã‚™=ã¨|ゞ/ã‚™=ㇳ|ヾ/ã‚™=ド|ヾ/ã‚™=ã©|ゞ/ã‚™ &[before 3]ナ<<<ナ|ヽ=ï¾…|ヽ=ãª|ã‚ &[before 3]ニ<<<ニ|ヽ=ニ|ヽ=ã«|ã‚ &[before 3]ヌ<<<ヌ|ヽ=ヌ|ヽ=ã¬|ã‚=ㇴ|ヽ &[before 3]ãƒ<<<ãƒ|ヽ=ネ|ヽ=ã­|ã‚ &[before 3]ノ<<<ノ|ヽ=ノ|ヽ=ã®|ã‚ &[before 3]ãƒ<<<ãƒ|ヽ=ハ|ヽ=ã¯|ã‚=ㇵ|ヽ=ãƒ|ヽ=ã°|ã‚=ãƒ|ヾ/ã‚™=ハ|ヾ/ã‚™=ã¯|ゞ/ã‚™=ㇵ|ヾ/ã‚™=ãƒ|ヾ/ã‚™=ã°|ゞ/ã‚™=パ|ヽ=ã±|ã‚=パ|ヾ/ã‚™=ã±|ゞ/ã‚™ &[before 3]ヒ<<<ヒ|ヽ=ヒ|ヽ=ã²|ã‚=ㇶ|ヽ=ビ|ヽ=ã³|ã‚=ヒ|ヾ/ã‚™=ヒ|ヾ/ã‚™=ã²|ゞ/ã‚™=ㇶ|ヾ/ã‚™=ビ|ヾ/ã‚™=ã³|ゞ/ã‚™=ピ|ヽ=ã´|ã‚=ピ|ヾ/ã‚™=ã´|ゞ/ã‚™ &[before 3]フ<<<フ|ヽ=フ|ヽ=ãµ|ã‚=ㇷ|ヽ=ブ|ヽ=ã¶|ã‚=フ|ヾ/ã‚™=フ|ヾ/ã‚™=ãµ|ゞ/ã‚™=ㇷ|ヾ/ã‚™=ブ|ヾ/ã‚™=ã¶|ゞ/ã‚™=プ|ヽ=ã·|ã‚=プ|ヾ/ã‚™=ã·|ゞ/ã‚™ &[before 3]ヘ<<<ヘ|ヽ=ï¾|ヽ=ã¸|ã‚=ㇸ|ヽ=ベ|ヽ=ã¹|ã‚=ヘ|ヾ/ã‚™=ï¾|ヾ/ã‚™=ã¸|ゞ/ã‚™=ㇸ|ヾ/ã‚™=ベ|ヾ/ã‚™=ã¹|ゞ/ã‚™=ペ|ヽ=ãº|ã‚=ペ|ヾ/ã‚™=ãº|ゞ/ã‚™ &[before 3]ホ<<<ホ|ヽ=ホ|ヽ=ã»|ã‚=ㇹ|ヽ=ボ|ヽ=ã¼|ã‚=ホ|ヾ/ã‚™=ホ|ヾ/ã‚™=ã»|ゞ/ã‚™=ㇹ|ヾ/ã‚™=ボ|ヾ/ã‚™=ã¼|ゞ/ã‚™=ãƒ|ヽ=ã½|ã‚=ãƒ|ヾ/ã‚™=ã½|ゞ/ã‚™ &[before 3]マ<<<マ|ヽ=ï¾|ヽ=ã¾|ã‚ &[before 3]ミ<<<ミ|ヽ=ï¾|ヽ=ã¿|ã‚ &[before 3]ム<<<ム|ヽ=ム|ヽ=ã‚€|ã‚=ㇺ|ヽ &[before 3]メ<<<メ|ヽ=ï¾’|ヽ=ã‚|ã‚ &[before 3]モ<<<モ|ヽ=モ|ヽ=ã‚‚|ã‚ &[before 3]ヤ<<<ヤ|ヽ=ï¾”|ヽ=ã‚„|ã‚=ャ|ヽ=ャ|ヽ=ゃ|ã‚ &[before 3]ユ<<<ユ|ヽ=ユ|ヽ=ゆ|ã‚=ュ|ヽ=ï½­|ヽ=ã‚…|ã‚ &[before 3]ヨ<<<ヨ|ヽ=ï¾–|ヽ=よ|ã‚=ョ|ヽ=ï½®|ヽ=ょ|ã‚ &[before 3]ラ<<<ラ|ヽ=ï¾—|ヽ=ら|ã‚=ㇻ|ヽ &[before 3]リ<<<リ|ヽ=リ|ヽ=り|ã‚=ㇼ|ヽ &[before 3]ル<<<ル|ヽ=ï¾™|ヽ=ã‚‹|ã‚=ㇽ|ヽ &[before 3]レ<<<レ|ヽ=レ|ヽ=れ|ã‚=ㇾ|ヽ &[before 3]ロ<<<ロ|ヽ=ï¾›|ヽ=ã‚|ã‚=ㇿ|ヽ &[before 3]ワ<<<ワ|ヽ=ワ|ヽ=ã‚|ã‚=ヮ|ヽ=ゎ|ã‚=ヷ|ヽ=ワ|ヾ/ã‚™=ワ|ヾ/ã‚™=ã‚|ゞ/ã‚™=ヷ|ヾ/ã‚™=ヮ|ヾ/ã‚™=ゎ|ゞ/ã‚™ &[before 3]ヰ<<<ヰ|ヽ=ã‚|ã‚=ヸ|ヽ=ヰ|ヾ/ã‚™=ã‚|ゞ/ã‚™=ヸ|ヾ/ã‚™ &[before 3]ヱ<<<ヱ|ヽ=ã‚‘|ã‚=ヹ|ヽ=ヱ|ヾ/ã‚™=ã‚‘|ゞ/ã‚™=ヹ|ヾ/ã‚™ &[before 3]ヲ<<<ヲ|ヽ=ヲ|ヽ=ã‚’|ã‚=ヺ|ヽ=ヲ|ヾ/ã‚™=ヲ|ヾ/ã‚™=ã‚’|ゞ/ã‚™=ヺ|ヾ/ã‚™ &[before 3]ン<<<ン|ヽ=ï¾|ヽ=ã‚“|ã‚ &ã‚¡=ï½§ &ã‚¢=ï½± &ã‚£=ィ &イ=ï½² &ã‚¥=ゥ &ウ=ï½³ &ã‚§=ェ &エ=ï½´ &ã‚©=ォ &オ=ï½µ &ã‚«=ï½¶ &ã‚­=ï½· &ク=ク &ケ=ï½¹ &コ=コ &サ=ï½» &ã‚·=ï½¼ &ス=ï½½ &ã‚»=ï½¾ &ソ=ソ &ã‚¿=ï¾€ &ãƒ=ï¾ &ッ=ッ &ツ=ツ &テ=テ &ト=ト &ナ=ï¾… &ニ=ニ &ヌ=ヌ &ãƒ=ネ &ノ=ノ &ãƒ=ハ &ヒ=ヒ &フ=フ &ヘ=ï¾ &ホ=ホ &マ=ï¾ &ミ=ï¾ &ム=ム &メ=ï¾’ &モ=モ &ャ=ャ &ヤ=ï¾” &ュ=ï½­ &ユ=ユ &ョ=ï½® &ヨ=ï¾– &ラ=ï¾— &リ=リ &ル=ï¾™ &レ=レ &ロ=ï¾› &ワ=ワ &ヲ=ヲ &ン=ï¾ &ヵ=ã‚• &ヶ=ã‚– &より<<ゟ &コト<<ヿ &' '=*' 'ï¿£ &'!'=ï¼ &'\"'=" &'#'=# &'$'=$ &'%'=ï¼… &'&'=& &''=' &'('=( &')'=) &'*'=* &'+'=+ &','=, &'-'=ï¼ &'.'=. &'/'=ï¼ &0=ï¼ &1=1 &2=ï¼’ &3=3 &4=ï¼” &5=5 &6=ï¼– &7=ï¼— &8=8 &9=ï¼™ &':'=: &';'=ï¼› &'<'=< &'='=ï¼ &'>'=> &'?'=? &'@'=ï¼  &A=A &B=ï¼¢ &C=ï¼£ &D=D &E=ï¼¥ &F=F &G=ï¼§ &H=H &I=I &J=J &K=K &L=L &M=ï¼­ &N=ï¼® &O=O &P=ï¼° &Q=ï¼± &R=ï¼² &S=ï¼³ &T=ï¼´ &U=ï¼µ &V=ï¼¶ &W=ï¼· &X=X &Y=ï¼¹ &Z=Z &'['=ï¼» &''=ï¼¼ &']'=ï¼½ &'^'=ï¼¾ &'_'=_ &'`'=ï½€ &a=ï½ &b=b &c=c &d=d &e=ï½… &f=f &g=g &h=h &i=i &j=j &k=k &l=l &m=ï½ &n=n &o=ï½ &p=ï½ &q=q &r=ï½’ &s=s &t=ï½” &u=u &v=ï½– &w=ï½— &x=x &y=ï½™ &z=z &'{'=ï½› &'|'=| &'}'=ï½ &'~'=~ &¢=ï¿  &£=ï¿¡ &Â¥=ï¿¥ &¦=¦ &¬=ï¿¢ &á„€=ᄀ=ㄱ &á„=ï¾¢=ㄲ &á„‚=ᄂ=ã„´ &ᄃ=ï¾§=ã„· &á„„=ᄄ=ㄸ &á„…=ᄅ=ㄹ &ᄆ=ï¾±=ã… &ᄇ=ï¾²=ã…‚ &ᄈ=ï¾³=ã…ƒ &ᄉ=ï¾µ=ã…… &ᄊ=ï¾¶=ã…† &á„‹=ï¾·=ã…‡ &ᄌ=ᄌ=ã…ˆ &á„=ï¾¹=ã…‰ &ᄎ=ᄎ=ã…Š &á„=ï¾»=ã…‹ &á„=ï¾¼=ã…Œ &á„‘=ï¾½=ã… &á„’=ï¾¾=ã…Ž &ᄚ=ï¾°=ã…€ &á„¡=ï¾´=ã…„ &á… =ï¾ =ã…¤ &á…¡=ï¿‚=ã… &á…¢=ᅢ=ã… &á…£=ï¿„=ã…‘ &á…¤=ï¿…=ã…’ &á…¥=ᅥ=ã…“ &á…¦=ᅦ=ã…” &á…§=ᅧ=ã…• &á…¨=ï¿‹=ã…– &á…©=ᅩ=ã…— &á…ª=ï¿=ã…˜ &á…«=ᅫ=ã…™ &á…¬=ï¿=ã…š &á…­=ï¿’=ã…› &á…®=ï¿“=ã…œ &á…¯=ï¿”=ã… &á…°=ï¿•=ã…ž &á…±=ï¿–=ã…Ÿ &á…²=ï¿—=ã…  &á…³=ᅳ=ã…¡ &á…´=ï¿›=ã…¢ &á…µ=ᅵ=ã…£ &ᆪ=ï¾£=ㄳ &ᆬ=ï¾¥=ㄵ &ᆭ=ᆭ=ã„¶ &ᆰ=ᆰ=ㄺ &ᆱ=ᆱ=ã„» &ᆲ=ᆲ=ㄼ &ᆳ=ï¾­=ㄽ &ᆴ=ï¾®=ㄾ &ᆵ=ᆵ=ã„¿ &â‚©=₩ &â†=ï¿© &↑=↑ &→=ï¿« &↓=↓ &│=│ &â– =ï¿­ &â—‹=ï¿® &ã€=、 &。=。 &「=ï½¢ &ã€=ï½£ &[last regular ]<*一ä¸-丆𠀀-𠀂万-丌äºå„𠀃-𠀆𪜀ðªœð«€ä¸-专丗𠀇-𠀌𪜂ã€ä¸”-世丘-ä¸ð €-ð €—ãã‚丞-丢𠀘-𠀚𠀜𠀞-ð € ð«ä¸£-严丽𠀡-𠀤𠀦-𠀨𠀪𠀫ð«‚並丧𠀬-𠀮𠀰-𠀴𪜃𠀵𠀶𠀸𠀺𠀻𪜄𠀽-ð €ð ¤¢ðªœ…ð -ð …𪜆ð †-ð ˆð Šð ‹ð Œð ð Ž-ð ’ð«ƒð “ð ”ð •ð —-ð ›ð ð¤³ðªœ‡ð –ð Ÿð  ä¸¨ä¸©ð ¡ð ¢ãƒã„个丫中-丰ð £ðªœˆä¸±ð ¥ð ¦ä¸²ð §ð ¨ä¸³ð ©-ð ¬ä¸´ð ­-ð ¯ðªœ‰ä¸µð °ð ±ð ³ð ´ð µð ¶ð ¸ð ¹ð ºð »ä¸¶ä¸·ðªœŠä¸¸ä¹‰ð ¼ð ½ä¸¹ä¸ºð ¿ä¸»ä¸¼ð ‚€ð ‚𠂂𪜋举𠂃𠂄𠂅丿-ä¹ã…乂-乄𠂆-ð ‚Šä¹…-么乊𠂋-ð ‚Žð«„之乌尹ð ‚-ð ‚“ä¹-ä¹ð ‚”-ð ‚¡ã†ä¹‘-乔𠂢-ð ‚§ð ‚©-𠂫𠂭𪜌乕𠂯乖𠂲𠂳𠂶乗𠂴𠂷ðªœä¹˜ð ‚¹-𠂾𪜎ðªœð ‚¿-𠃂𠃃𠃄𠃆𠃅𠃇𠃈⺂-⺄乙-乛𠃉-𠃎𠃑乜ä¹é¾´ð ƒð ƒã‡-ã‰ä¹ž-ä¹ ð ƒ’-𠃔ãŠã‹ä¹£-书ð ¾ð ƒ•-ð ƒãŒ-ã乧𠃞-𠃣ðªœã-ã•乨-买𠃤-𠃨𪜑ã–-ã˜ä¹±ä¹²ð ƒ©ð ƒªð ƒ¬ð §ðªœ’𪜓ã™-ã›ä¹³-乸𠃭-𠃯𪜔ãœ-ã ä¹¹-乼𠂸𠃲-𠃷𪜕乽𠃸-𠃻𤱡𪜖𪜗⻲ã¡-ã£ä¹¾-亀𠃼-𠄂𪜘ã¤äºð¥€ðªœ™ðªœšäº‚-亄𠄃𠄄𪜛𠄅-𠄈𢆡ã¥ð „‰ã¦ð „Šð „‹äº…𠄌了ð „-ð „亇𠄑ã§äºˆð „’-𠄔争𠀩𠄕亊𠄖-𠄘𪜜ã¨äº‹ð „™ð „šð „›ðªœð „œð „二𠄞-ð „ äº-äºäº‘-亖𠄡亗亘-亚𠄢-𠄧些亜𠀥𠄨-𠄪ã©äº-亟𠄫-𠄯𠄰-𠄳𠄵-𠄸𠄹𠄺𠄻𠄼-𠄾𠄿𪜞𠅀𪜟亠亡亢亣ð …𠅂𪜠𪜡ãªã«äº¤-产𠅃-ð …‡ð«…ã¬äº¨-亪𠅈-𠅋𪜢ã­äº«äº¬ð …Œ-𠅒亭-亲𠅓-𠅕亳𠅖𠅘-ð …ð …ž-𠅧𪜣亴亵𠅨-𠅯𠅲𪜤ã®äº¶äº·ð …³-𠅸𠅺-𠅼𠆀𠅾𠅿ð †-𠆉𪜥亸𠆋-𠆒𠆔𠆖-𠆘ã¯ð †šð †ðªœ¦äº¹ð †žð †Ÿð † ð †¡âº…人亻𠆢亼-亿𠆣-𠆥什-仓𠆦-𠆨𪜧ã°-ã·ä»”-仭𠆩-𠆭𠆯𠆰𠆳ð«†ã¸-㑀仮-伬佤𠆴-𠇑𠇓-𠇕𪜨-𪜫ã‘-㑈伭-佣佥-佨𠇖-ð ˆðªœ¬-𪜴㑉-㑖佩-侭鿇𠈃-𠈣𠈥-𠈬𪜵-𪜷𪜸-𪜺ð«‡ð«ˆã‘—-㑢侮-ä¿­ð ˆ­-𠉠𠉡𠉢𪜻-ðª‚㑣㑥-ã‘­ä¿®-倿𠉣-𠊆𠊇-𠊦𠋟ðªƒ-ðªŠð«‰ã‘¤ã‘®-㑲å€-å¿ð Š§-ð ‹ð ‹’-ð ‹žð ‹ -𠋢𠋣-𠋬ðª‹-ðª•ð«Šã‘³-㑺傀-å‚©ð ‹­-𠌅𠌇-ð Œð Œ -𠌩ðª–-ðªŸã‘»-ã’傪-åƒð Œ«-ð ¡ð £ð ¤ð ¦-ð ¬ð Žµðª -ðª¤ð«‹ã’‚-ã’僎-僱僳僴僷ð ¥ð ­-𠎗𠎙𠎚ð Ž-ð Ž´ð ðª¥-ðª§ðª¨-ðªªã’‘-㒘僲僵僶僸-å„ð Ž·-ð ð ‘ð ”-ð ¦ðª«-ðª¯ã’™-ã’œå„-儞儫ð ’ð ¨-ð ‡ðª°-ðª³ã’㒞償-優儬ð ˆ-ð ›ð -ð ¢ðª´-ðª¶ã’Ÿã’ å„­-儲ð £-ð ºðª·-ðª¹ã’¡-㒣儳-儵ð »-ð ‘𠑃-ð ‘Œðªº-ðª¼ã’¤-㒦儶ð ‘-ð ‘–ð ‘žðª½ã’§ã’¨å„·-儺𠑗-ð ‘ð ‘Ÿ-ð ‘£ðª¾å„»å„¼ð ‘¤-𠑩㒩儽𠑪-𠑯儾𠑰㒪𠑲𠑳𠑵儿⺎⺑兀å…-元𠑶兄𠑷𠑸㒫充-å…Šð ‘¹-𠑼克-å…‘ð ‘½-𠒂㒬兒-å…–ð ’ƒ-ð ’‹ðª¿å…—-兙𠒌-ð ’𪞀ð«Œã’­å…šå…›ð ’-ð ’–ðªžã’®å…œ-å…žð ’—-ð ’å…Ÿå… ð ’ž-𠒣兡𠒤-𠒦𪞂兢𠒧-𠒯𠒰-𠒲𠒴-𠒷𪞃-𪞅兣𠒳𠒸-𠒾𠒿-𠓅𠓇㒯𠓆𠓈-𠓊𠓋𠓎𪞆ð “ð “ð “兤𠓑𠓒𠓓𠓔𠓕𠓖𠓗-𠓙𠓚入兦𠓛內𠓜-𠓞㒰㒱𠓟㒲全氽𠇒𠓠-𠓣㒳㒴𠓤-𠓨兩𠓩兪𠓪-𠓬𠓭-𠓰𪞇𠓱𠌆𠓲𠓳𠓴-𠓷𠓸-𠓻𠓼𠓽𠓾𠓿八𠔀公-å…¯ð ”-𠔄兰𠔅𠔆共-兴龹𠔈𠔉𪞈㒵-㒷兵𠔊-ð ”å…¶-å…¸ð ”𠔑𠩖㒸兹养𠔒-𠔗兺兼𠔙-𠔛兽𠔜ð ”𠔞-𠔧𪞉兾兿𠔨-𠔮𪞊𠔯-𠔱𠭻𪞋𪞌冀𠔳-ð ”µðªžð œå†ð ”¶ð ”·ð ”¸-𠔺㒹⺆冂𠔼冃-冈𠔽-𠕀冉-册ð •-ð •Šå†å†Žð •‹-ð •å†ð •-𠕕𪞎㒺å†ð •–-𠕚冑冒𠕛𠕜ð«å†“冔ð •-𠕟㒻㒼冕𠕠-𠕢㒽最𠕣-𠕥㒾𠕦𠕧𠕨𠕩𠕪𠕬𠕭𠕮𠕯𠕰𠕱㒿𠕲冖⺴㓀ã“冗冘𠕳𠕴写冚𠕵-𠕸军农𠕹-ð •¿å†ð –€-ð –ƒðªžðªžå†žð –„-𠖆𪞑㓂冟冠𠖇-𠖋冡-冧𠖌-𠖒𪞒冨𠖓𪞓㓃𠖔-𠖙𪞔𠖚𠖛冩𠖜-𠖞𪞕㓄冪𠖠𠖡𠖢𠖣-𠖥𠖦-𠖨𠖩𠖪𠖫冫𠖬㓅𠖭冬-冯𠖮-𠖰𪞖㓆㓇冰-冴𠖱-𠖶𪞗-𪞚㓈况-冻𠖷-ð –¿ð —𪞛-ðªžã“‰-ã“冼-净𠗀𠗂-𠗇𪞞㓎ã“å‡-凃𠗈-𠗗𪞟-𪞡ð«Žã“-㓒凄-凎𠗘-𠗤𪞢-𪞥㓓å‡-凑𠗥-𠗰𪞦-𪞨ð«ã“”㓕凒-凖𠗱-𠗹𪞩𪞪㓖凗𠗺-𠘃𪞫𪞬㓗凘𠘄-𠘉𠘓𪞭凙-凜𠘊-𠘑𪞮å‡å‡žð ˜’𠘔𠘕𪞯凟𠘖-𠘜𥂳ð ˜-𠘡𠘢𠘣𪞰𠘤𠘥𠘦⺇几𠘧𠘨凡-凣凤𠘩-𠘰凥-凧𠘱-𠘴凨-凫𠘵-𠘻𪞱凬𠘼-𠙅𪞲凭-凯𠙆-𠙎𠫮ð ™-ð ™‘ð ™’-𠙖𪞳㓘凰𠙘𠙙𠙛-𠙞𪞴凱凲ð ‰ð ™Ÿ-𠙣𠙤-𠙧𪞵凳凴𠙨-𠙪𠙫𠙭-𠙰𠙱𠙲𠙳凵𠙴𠙵凶𠙶-𠙸凷-击𠙹-𠙻𠙽𪞶㓙凼𠙾-𠚅𠚆-𠚊函𠚋-ð šðªž·å‡¾ð šŽ-ð šð š’𠚓𪞸𠚔-𠚗凿𠚘𪞹𪞺𪞻𠚙𠚚ð¢­ð šœð šð šžð¢‡•𪞼𠚟𪞽𠚠𠚡𠚢⺈⺉刀-刂𠚣刃刄𠚤刅-刈𠚥-𠚬㓚-㓜刉-åˆð š­-ð š´ð š¶ð š»ã“㓞刎-创𠚵𠚷-𠚺𠚼-ð ›ðªž¾-𪟀㓟㓠刜åˆåˆž-刭𠛎-𠛦ðªŸðªŸ‚ã“¡-㓦刮-剂𠛧-ð œðªŸƒ-𪟅㓧-㓫剃-剑ð œ-𠜰𪟆𪟇ð«ã“¬-㓰剒-剧𠜱-ð œð ¶ðªŸˆðªŸ‰ã“±-㓶剨剪-剱剶ð -ð µð ·-ð ¾ðªŸŠ-ðªŸã“·-㓻剩割-創ð ¿-ð ž›ð ž-𠞤𪟎-ðªŸã“¼ã“½å‰·-剿𠞥-ð ŸðªŸ‘-𪟓㓾-㔉劀-劄𠟂-ð ŸŸð Ÿ¡-𠟥㔊劅-åŠð Ÿ ð Ÿ¦-𠟹𪟔㔋-ã”åŠ-劔𠟺-𠠊𪟕𪟖㔎ã”劕𠠌-ð  šã”ð  ›-𠠠㔑劖𠠡-𠠣㔒𠠤𠠦-𠠩劗劘𠠥𠠪-𠠭劙劚𠠮𠠯𠠰𠠱力劜𠠲åŠåŠžð  ³-𠠵㔓㘞功-劢𠆮𠠶-𠠸㔔-㔖劣-动𠠹-ð ¡ã”—㔘助-労𠡂-ð ¡ðªŸ—-𪟙㔙-㔛劵-势𠡑-ð ¡ðªŸšðªŸ›ã”œå‹€-å‹‹ð ¡ž-𠡪𪟜ã”-㔟勌-å‹‘ð ¡«-𠡺ðªŸ-𪟟㔠勒-勖勘-勚𠡻-𠢄𪟠㔡勛-勞𠢅-𠢒𪟡𪟢募-勧𠢓-𠢟𪟣ð«‘㔢勨-å‹­ð ¢ -𠢯𪟤𪟥勮-勲𠢰-𠢵𪟦勳𠢶-𠢸㔣-㔦勴-å‹¶ð ¢¹-𠢿㔧𠣀-𠣃勷𠣄𠣅勸𠣆𠣇𪟧𠣈𠣉𠣊𠣋勹勺勻-匂𠣌匃-匇ð £-ð £åŒˆð £‘-𠣓匉𠣔-𠣗匊-匌𠣘-ð £åŒð £ž-𠣣匎𠣤-𠣭㔨åŒåŒð £®-𠣴㔩匑匒𠣵-𠣷㔪匓𠣸-𠣼𠣽-𠤂匔𠤃𠤄-𠤇𠤈-𠤊𠤋-ð ¤åŒ•𠤎𪟨㔫化ð ¤åŒ—ð ¤ðªŸ©ð ¤‘-𠤕㔬𠤖𠤗-ð ¤ðªŸªð ¤ž-𠤡㔭匘匙𠤣𠤤𠤥𪟫𠤦-𠤨𠤩𠤪匚𠤬𠤭匛-匞匟-匢𠤮-𠤱𪟬㔯㔰匣-匥𠤳-𠤷𪟭𪟮匦𠤸-𠤻匧-匩𠤼-𠥂𠥄-𠥈𪟯匪匫龨𠥉-ð ¥ðªŸ°ã”±åŒ¬-匮𠥎ð ¥ð ¥-𠥕㔲-㔴匯𠥖-𠥘㔵匰-匲𠥙-𠥛𪟱匳𠥜-𠥡匴𠥢𠥣匵𠥤𠥥匶𠥦𠥧匷𠥨𠥩𪟲𠥪㔶𠥫𠥬匸匹区𠥭𠤲𠥮𠥯㔷医𠥰-𠥲匼𠥳匽𠥃𠥴𠥵𠥶匾-å€ã”¸ð ¥·ð ¥¸ð ¥¹ð ¥ºåå‚åƒã”¹å…-åˆð ¥»ð ¥¼ð ¥¿å‰åŠåŒð †±ð ¥½ð ¥¾ð ¦€ð ¦ã”ºã”»å‹å-å𠦂-ð ¦ð ¦‘-𠦗𪟳ð«’å‘-å–龺𠦘-𠦢𣥥ð«“å—å˜ð«”𠦣-𠦩𪟴å™ð ¦ª-𠦯𪟵åšð ¦°-𠦳㔼𠦴-𠦼𪟶𠦽-𠦿𪟷𠧀-𠧄𪟸𪟹𠧅-𠧈𪟺𠧉-ð §ðªŸ»ð §ŽðªŸ¼å›ð §ð §ð §‘⺊åœð §’ååžðªŸ½åŸ-å¢ð §“ð €ð §”-𠧘⻧å£å¤ð §™-𠧜𡥋𪟾㔽å¥-å§ð §ž-𠧨𠧩-𠧲𠭉𠧳-𠧷𠧹𪟿å¨ð §º-𠧿𠨀-𠨂𠨄𠨅𠨆𠨇𪠀𠨈-𠨊𠨋𠨌⺋å©ã”¾ã”¿åªå«å¬ð ¨-ð ¨å­-å¯ð ¨‘å°å±ð ¨’-ð ¨—ã•€å²-åµð ¨˜ã•å¶-åºðª å»-å½ð ¨™-ð ¨ðª ‚𠨞å¾å¿ð ¨Ÿ-𠨡厀åŽð ¨¢-𠨤𠨥𠨦𠨧-𠨪𠨫âºåŽ‚åŽƒ-历𠨬厇-厉𠨭-𠨳𪠃㕂-㕄厊-åŽð ‚¬ð ‚®ð ¨´-𠨿㕅-㕇厎-厑𠂰𠩀-𠩉𪠄ð«•㕈㕉厒-厕𠩊-𠩕𪠅𪠆㕊厖-厛𠩗-𠩦𪠇-𪠊㕋-ã•厜-原虒𠩧-𠩷𪠋-𪠎ð«–ð«—厠-厣厩𠩸-𠩾𠪀-𠪆ðª ðª ã•Žåޤ-厨𠪇-ð ªðª ‘𪠒ã•厪厫𠩿𠪑-𠪘𪠓-𪠕ã•㕑厬-厰𠪙-𠪬𪠖𪠗㕒厱厲𠪭-𠪸𪠘𪠙𠪺-𠪾㕓厳𠪿𪠚𠫀-𠫆厴𠫇𪠛𠫉𠫊𠫋𠫌-ð «Žã•”ð «ð «åŽµð «‘ð «’åŽ¶ð «“-𠫖㕕厷-厹𠫗𠫘厺-厼𠫙-ð «åŽ½åŽ¾ð «ž-𠫥县𠫦-𠫨å€-å‚ð «©-𠫭𠫯𠫰-𠫲𠫴-𠫸𪠜㕖𠫹-ð «¼ðª ã•—㕘åƒå„𠫽𠫾𪠞å…ð «¿-𠬅𦎅𪠟𠬆-𠬌𪠠å†ð ”²ð ¬-ð ¬ã•™å‡ð ¬‘𠬒𪠡𠬓𠬕-𠬗𠬔𠬘𠬙𪠢⺀åˆå‰ã•šã•›åŠ-åŽð ¬š-𠬠𪠣𪠤å-å‘𠬡-𠬨㕜å’𠬩-𠬰𪠥ã•å“𠬱-𠬸𪠦㕞å”-å˜ð ¬¹-𠬾𪠧𪠨㕟å™-å𠫳𠬿-𠭈𪠩𪠪åžåŸð ­Š-𠭔𪠫𪠬𠭕-𠭤㕠𠭥-𠭮𪠭𪠮å ï¨Žð ­¯-𠭵𠭷-𠭺𪠯㕡𠭼-𠮂𡪞𪠰𠮃-𠮆å¡ð ®‡-𠮌𪠱ð ®-ð ®å¢ð ®å£¡ð ®‘𠮒𠮓𠮔𠮕𠮖𠮗𠮘å£ð ®™-𠮞㕣-ã•¥å¤-å¾ð ™¼ð ®Ÿ-𠮪𪠲㕦-㕨å¿-å—ð ®«-𠯊ð«˜ã•©-ã•¶å˜-呜𠈂𠯋-𠯶𠯷-𠰇𪠳-𪠵㕷-ã•¿å‘-å’ð °ˆ-𠰽𠰾-ð ±ðª ¶-𪠹㖀-ã–Žå’ž-哟𠀷𠀹ð ±-𠱼𠱽-𠲫𪠺-𪡃ð«™ã–-ã–žå“ -唧𠲬-𠳓𠳔-𠳤𠳦-𠳪𠳬-𠴥𪡄-𪡎㖟-㖵唨-唽唾唿-啘啚-啞啠-啪啬-啹𠳥𠴧-ð µ­ð µ®-ð ¶¶ðª¡-𪡛㖶-㗑啙啫啺-喌喎-喾噅𠶷-ð ·“ð ·”-ð ·¡ð ·£-𠸵𠸻-𠸾𪡜-𪡩㗒-ã—¡å–å–¿-嗵𠷢𠸶-𠸺𠸿-𠹯𠹳𠹴-𠻓𪡪-𪡷㗢-ã—°å—¶-嘞嘡-嘧噑噓ð ·ð »”-𠼑𠼒-𠽠𪡸-𪢄ð«šã—±-㗺嘟嘠嘨-噄噆-å™å™’噔噖-å™å™´ð †Šð “ð §ð ¹°-𠹲𠽡-𠾛𠾜-𠾦𠾨-𠿆𡀔𡀦𪢅-ðª¢ð«›ã—»-㘄噞-噳噵-噼𠿇-𡀓𡀕-𡀟𡀠-𡀥𡀧-ð¡€¼ð¢¨ð¨—“𪢎-𪢔㘅-㘈噽-嚓嚺𡀽-𡂎𪢕-𪢘ð«œã˜‰-ã˜åš”-嚤ð¡‚-𡃟𡃰𪢙-𪢞ð«ã˜-㘒嚥-嚰𡃠-𡃯𡃱-𡄈𡄊-ð¡„𪢟-𪢡㘓㘔嚱-嚹𡄑-𡄰𪢢-𪢤㘕-㘗嚻-囄å›ð¡„±-𡅔𡅣㘘囅-囉囊囋囎𡅗-𡅢𡅤-𡅯𪢥ð«žã˜™ã˜šå›Œå›å›ð¡…°-𡅸囑-囓𡅹-𡆅𪢦𪢧㘛囔囕𡆆-𡆎㘜ð¡†-𡆘𡆙𡆚𡆞囖𡆛-ð¡†ð§®¥ð¡†Ÿå›—𡆠-𡆢ã˜å›˜-囜龱ð ¤ð¡†£-𡆦㘟å›-団𡆧-𡆳囤-囵𡆴-𡇇𪢨㘠㘡囶-图𠀯𡇈-𡇌𡇎-𡇑𪢩㘢囿圀𡇒-𡇟𪢪㘣åœ-圆𡇠-𡇯𪢫圇-國åœð¡‡°-𡇻𡈀𪢬𪢭圌-圎åœð¡‡¼-𡇿ð¡ˆ-𡈉𤔗圑-圕𡈊-𡈔𪢮㘤圖-圙𡈕-𡈡𪢯圚𡈢-𡈤𡈦-𡈩圛圜𡈥𡈪-𡈬𪢰𡈭-𡈱𡈲𡈳𡈴㘥𡈵-𡈷𡈸-𡈺åœåœžð¡ˆ»åœŸåœ åœ¡é¾¶ð¡ˆ¼-𡈾㘦圢-圧𡈿-𡉇𪢱𪢲在-场𡉈-𡉖𪢳-𪢷㘧-㘰圻-å ð¡‰˜-𡊃𪢸-𪣂㘱-㘵å¡-åžåž‚垃-垊𡊄-𡊶𪣃-𪣊㘶-㘾型-垵城𡊷-ð¡‹›ð¡‹-𡋬𪣋-𪣓㘿-㙆垶-åŸåŸ-埛ï¨ð¡‹­-𡌥𣑧𪣔-𪣣㙇-ã™åŸœ-埩埫-堕𡌦-ð¡£ðª£¤ðª£¥ðª£¦-𪣱㙎-㙘埪堖-堼堾-å¡‚å¡„-塈ð¡¤-𡎦𡎧-𡎭𪣲-𪣽ð«Ÿã™™-㙟堽塃塉-塱𡎮-ð¡¬ð§¯§ðª£¾-𪤋𪤌ðª¤ã™ -㙦塲-墛ð¡­-ð¡ð¦¥ˆðª¤Ž-𪤘ð« ã™§-㙯墜-墧墩-墹𠚛ð¡ž-ð¡‘𪤙-𪤞㙰-㙶墺-壌龳𡑞-𡑹𡑻-𡒈𪤟-𪤥ð«¡ã™·-㙺å£-壗龼𡒉-ð¡’ ð¡’¢-𡒯𪤦-𪤫㙻-㙽壘壙𡒰-ð¡’¿ð¡“-ð¡“𪤬-𪤯㙾㙿壚-壠壢𡓀ð¡“-ð¡“šð¡“œ-𡓥𪤰㚀壣-壥𡓦-𡓰𪤱壦𡓱-𡓶𡓸𡓹𡓻-ð¡”𡓺𡔂-𡔉壧壨𡔊-𡔎ãšå£©ð¡”-𡔕㚂壪𡔖𡔗𡔘𡔙𡔚士壬壭𡔛壮𡔜壯-壳ð¡”𡔞𡔟壴壵𡔠-𡔢壶𡔣-𡔩𪤲壷壸𡔪-𡔭㚃壹-壻𡔮𡔯壼𡔰𡔲-𡔵𪤳壽壾𡔶𡔸-𡔻㚄壿夀𡔼𡔽å¤ð¡”¾-ð¡•€ð¡•-𡕄𡕅𡕇-ð¡•Šð¡•‹ð¡•Œð¡•ð¡…•ð¡•-𡕑𪤴夂𡕒夃处𡕓𡕔夅𡕕𡕖夆𡕗-𡕙备㚅夈𡕚𠙚𡕛𡕜𪌛ð¡•𪤵夊𡕞𡕟夋𡕠𡕡夌𡕢-𡕥㚆㚇変å¤å¤Žå¤ð €¼ð¡•¦ð¡•§-𡕬𠌞𡕭𠭶𡕮-𡕱𪤶å¤ð¡•²-𡕵𡕶𡕷𡕸-𡕺𡕻夑夓𡕼-𡕿夒𡖀ð¡–夔𡖂𡖃夕㚈外-夘𡖄-𡖆夙-夛𡖇-𡖉𪤷ð«¢ð¡–Š-ð¡–Œð«£ãš‰å¤œå¤ð¡–-ð¡–𪤸ð¡–𡖑𪤹夞𠅗𡖒-𡖜𢻈𪤺够夠ð¡–-𡖥𪤻㚊夡𠅱𠨃𡖦-𡖮𡖰𪤼𡖯𡖱-𡖵㚋㚌夢-夥𡖶-𡖾𢆣𪤽夦𡖿-ð¡—𪤾𠆓𠆕𡗂-𡗅𪤿𠆙𡗆-ð¡—ˆãšð¡—‰ð¡—Šð¡—‹ð¡—Œð¡—ð¡—𡗎𪥀ð¡—𣡳𡗑大夨天-夭𡗒-ð¡—”ðª¥ãšŽå¤®-头𡗕-𡗛𪥂ãš-㚑夵-夼𠀛ð¡—-𡗤𪥃㚒㚓夽-奂𡗥-𡗶𪥄-𪥆㚔-㚙奃-奉奋-å¥ð¡—·-𡘌𪥇-𪥌㚚㚛奎-奖ð¡˜-𡘜ðª¥-ðª¥å¥Šå¥—-奚ð¡˜-𡘳ðª¥-𪥒ð«¤ãšœ-㚞奛-奞𡘴-𡙆𪥓-𪥕㚟奟-奥𡔱𡙇-𡙚𪥖-𪥘㚠奦-奨𡙛-𡙫𪥙-𪥛奩-奬𡙬-𡙶𪥜-𪥞奭𡙷-𡚅𪥟-𪥡㚡奮奯𡚆-𡚎ð¤ ð«¥ð¡š-𡚖奰𡚗𡾗𪥢𡚘-𡚚𡚛𪥣𡚜ð¡šå¥±ð¡šžð¡šŸð¡š -𡚢奲𡚣𡚤𡚥女𡚦㚢奴-奶𡚧-𡚭㚣-㚨奷-妈𡚮-𡚻𪥤𪥥㚩-㚯㛠妉-妌妎-妫𡚼-𡛘𪥦-𪥬ð«¦ãš°-ã›å¦¬-å§—ð¡›™-ð¡œðª¥­-𪥰㛂-㛌å¦å§˜-å§«å§­-娃娅-娈𡜂-𡜭𪥱-𪥵ð«§ð«¨ã›-㛟㛡-㛤姬娉-娫娭-娴娽𡜮-ð¡ðª¥¶-𪥺ð«©-ð««ã›¥-㛭娬娵-娼娾-å©¶ð¡ž-𡞒𡞓-𡞛𪥻-𪦅㛮-㜄婷-åªåª‘-媯å«ð¡žœ-𡟋𡟌-𡟧𡠣𪦆-ðª¦ð«¬ãœ…-㜔åªåª°-嫎å«-嫔𡟨-𡠕𪦑-𪦖㜕-㜢嫕-嫲𡠗𡠙-𡠢𡠤-𡠱𡠳-𡡎𪦗-𪦟ð«­ãœ£-㜨嫳-å¬ð¡ –𡠘𡠲ð¡¡-ð¡¢ð¡¢ðª¦ -𪦥ð«®ãœ©-㜭å¬-嬢嬴𡢎𡢑-𡣄𪦦-𪦪㜮㜯嬣-嬳嬵-嬷𡣅-𡣡𡣣-𡣩𪦫㜰㜱嬸嬺-嬽𡣪-𡣼𪦬-𪦯㜲-㜵嬹嬾嬿𡣽-ð¡¤ð¡¤žðª¦°ðª¦±ãœ¶-㜸孀-孆𡤎-𡤗𪦲㜹孇-孉𡤘-ð¡¤ð¡¤Ÿð¡¤ ðª¦³ðª¦´ãœºå­Š-孌𡤡-𡤪å­ð¡¤«-𡤭𪦵孎å­ð¡¤®-𡤳𡤴-𡤶㜻㜼𡤷-𡤺𡤻å­-孓𡤼孔𡤽孕𡤾-𡥂㜽孖-孙𡉗𡥃-𡥅㜾㜿孚-孞𡥆-𡥊𡥌ð¡¥ðª¦¶-𪦹ã€å­Ÿ-孧𠃱𡥎-𡥚𪦺ãå­¨-孪𡥛-𡥧𪦻ã‚ãƒå­«-孭𡥨-𡥭𢈲𨹴孮-孰孲𡥮-𡥵𪦼-𪦾ã„孱𡥶-𡦂𪦿ã…孳孴𡦃-ð¡¦å­µ-孷𡦑-𡦖𪧀ã†ð¡¦—-ð¡¦ð«¯ã‡å­¸å­¹ð¡¦ž-𡦨ðª§å­ºå­»ð¡¦©ðª§‚𪧃𡦪-𡦬孼𡦭-𡦰孽孾𡦱-𡦶𪧄孿𡦷ãˆð¡¦¸å®€ã‰ð¡¦¹ãŠã‹å®-宄𡦺-𡦼ãŒãå®…-安𡦽-ð¡§ŠãŽ-ã‘宊-å®’ð¡§‹-𡧕𪧅-𪧇ã’宓-审𡧖-𡧨𪧈𪧉ã“-ã–客-宦宨-宫𡧩-𡧿𪧊-𪧌ã—-ãšå®§å®¬-宾𡨀-𡨡ðª§-ðª§ã›-ã¡å®¿-寉𡨢-𡨼𪧑-𪧓ã¢ã£å¯Š-寕寪𡨽-𡩞𪧔-𪧚ã¤-ã¨å¯–-å¯ð¡©Ÿ-𡩺𪧛-𪧠ã©-ã¬å¯ž-寨𡩻-ð¡ªðª§¡-𪧥ð«°ã­-ã¯å¯©å¯«-寮𡪟-𡪽𪧦-𪧪ð«±å¯¯å¯°ð¡ª¾-ð¡«ðª§«-𪧮寱寲𡫑-ð¡«ðª§¯ã°ð¡«ž-𡫫𪧰-𪧲寳-寵𡫬-𡫶寶𡫷-𡫻𪧳𪧴ã±å¯·ð¡«¼-𡬃𪧵𡬄-𡬋𡬌ð¡¬ð¡¬ð¡¬ðª§¶ð¡¬‘𡬓-𡬕ã²ð¡¬–-𡬘𡬎𡬙𡬚𡬒𡬛𡬜寸ð¡¬ã³å¯¹å¯º-导𡬞𪧷ã´å¯½-寿ãµå°€ð¡¬Ÿ-𡬦å°å°‚将𡬧-𡬬ã¶å°ƒ-尅𡬭將-尉𡬮-𡬲𪧸𪧹ã·å°Š-尌𡬳-𡬸𪧺𡬹-𡬼å°ð¡¬½-ð¡­‚å°Žð¡­ƒ-𡭉𣊒𪧻𪧼𡭊-𡭌𪧽ð¡­-ð¡­ðª§¾ð¡­ð¡­‘𡭒𡭓⺌âºå°ð¡­”å°å°‘ð¡­•ð¡­–å°’-尕龸𡭗𡭘尖-尘𡭙-ð¡­œð¡­-𡭤𪧿尙尚𠈤𡭥-𡭩𪨀尛-å°ð¡­ª-ð¡­³ã¸ð¡­´-ð¡­¼ðª¨ðª¨‚ð¡­½-ð¡®ã¹å°žð¡®Ž-𡮗尟尠𠅽𡮘-ð¡®ãºå°¡ð¡®ž-𡮥𪨃ã»ð¡®¦-𡮯𪨄𡮰-𡮳𪨅𡮴-𡮶𢇔𪨆𡮷-ð¡®»ð¤¯ð¡®¼-𡮾𡮿𡯀âºâºå°¢å°£ð¡¯ð¡¯‚尤𡯃𡯄-𡯊ã¼å°¥-尧𡯋-𡯎ã½å°¨-å°¬ð¡¯-𡯙ã¾ã¿å°­ð¡¯š-𡯡㞀ãžå°®å°¯ð¡¯¢-𡯤𡯦𡯧㞂𡯨-𡯲㞃-㞆𡯳-𡯸㞇㞈尰就𡯹-𡰂𪨇㞉㞊尲-å°´ð¡°ƒ-𡰊𪨈𡰋-ð¡°å°µð¡°-ð¡°•ð¡°–-𡰚尶尷𡰛𡰜ð¡°ð¡°žð¡°Ÿð¡° ð¡°¡ð¡°¢å°¸ð¡°£å°ºãž‹å°»å°¼ð¡°¤-𡰨𡰴㞌ãžå°½ð¡°©-ð¡°³ð«²ãžŽå°¾-屃𡰵-𡰽𪨉-𪨋ãž-㞑屄-届𡰾-𡱋𪨌㞒-㞖屋-å±ð¡±Œ-𡱡𢇀ðª¨ðª¨Žãž—å±-屘𡱢-𡱹ðª¨ðª¨ãž˜ãž™å±™-å±ð¡±º-𡲓𪨑㞚㞛属-屡𡲔-𡲫𪨕-𪨘𡲬-𡳃𪨒-𪨔㞜-㞞屢屣𡳄-ð¡³ðª¨™ðª¨šãžŸãž å±¤-å±§ð¡³-𡳞𪨛𪨜𡳟-𡳧ðª¨å±¨ð¡³¨ð¡³©ðª¨žå±©å±ªð¡³ªð¡³«ãž¡å±«ð¡³¬-𡳰𪨟𪨠𡳱-𡳴屬𡳵-𡳷𡳸-𡳺𪨡屭𡳻𡳼𡳽屮𡳾㞢屯𡳿屰𡴀-𡴅㞣㞷𡴆-ð¡´Šð¡´‹-ð¡´ð¡´Ž-𡴔𡴕-𡴚𡴛𡴜ð¡´-𡴣𡴤𡴥𡴦-𡴩𡴪𡴫𡴬山乢屲𡴭-𡴯㞤-ãž§å±³-å±·ð¡´°-𡴽㞨-㞯屸-岃𡴾-𡵒𪨢-𪨥ð«³ãž°-㞶㞸岄-岌岎-岜𡵓-𡶂𪨦-𪨨㞹-㟃å²-峅𡶃-𡶣𡶥-𡶪𪨩-𪨮㟄-㟆å²å³†-å³§ð¡¶«-𡷔𪨯-𪨴ð«´ãŸ‡-㟖峨-å´…ð¡·•-ð¡¸ð¦Š¤ðª¨µ-𪨺ð«µãŸ—-㟥崆-崰𡸑-𡹖𡹗-𡹩𪨻-ðª©ãŸ¦-㟯崱-嵉嵋-åµï¨‘𡹪-𡺩𪩂-𪩇㟰-㟸嵊嵞-嵶𡺪-𡻗𪩈-𪩋㟹-ã „åµ·-嶎𡻘-𡼉𪩌-𪩒㠅-ã å¶-嶥𡼊-𡼼𪩓-𪩖㠑-㠗嶦-嶶𡼽-𡽈𡽊-𡽛𪩗-𪩚㠘-㠜嶷-嶺嶼-嶿𡽉𡽜-ð¡¾ð¡¾»ðª©›-ðª©ã -ã Ÿå·€-巂𡾂-𡾖𡾠㠠-㠣嶻巃-巅𡾘-𡾟𡾡-𡾭𣦭𪩞㠤巆-巌𡾮-𡾺㠥㠦å·å·å·ð¡¾¼-𡿆𪩟㠧巎巑-巕巗𡿇-𡿑𪩠巖巘-å·šð¡¿’ð¡¿“ð¡¿”-ð¡¿œð¡¿-𡿟𡿠𡿡𡿣𡿤㠨𡿢𡿥巛-å·ð¡¿¦ð¡¿¨ð¡¿§ã ©å·žå·Ÿð¡¿©-ð¡¿­å· ð¡¿®-𡿰𪩡𡿱-ð¡¿¶ð¡¿·-𡿻𪩢𠙗𡿼𡿽巢巣𡿾-𢀀ð¢€ð¢€‚巤𢀃𢀄-𢀆𢀇𢀈𢀉𢀊𢀋𢀌ð¢€ð¢€Žð¢€ð¢€å·¥ã ªð¢€‘-𢀕左-巨𢀖-𢀙巩巪𢀚𢀛𪩣巫𢀜-𢀞𢀟巬巭𢀠㠫㠬差𢀡𢀢𢀣𪩤㠭巯𢀤𢀥𪩥巰𢀦𢀧𪩦𪩧㠮𢀨-𢀫𢀬𢑰𤀢𢀭𪩨𢀮𪩩𢀯𢀰-𢀲𪩪⺒己-巳巴𢀳㠯𢀴𢀵𢀶巵𪩬㠰巶𢀷𢀸𪩫巷-巻𢀹-𢀻巼𢀼-𢀿㠱ð¢€-ð¢„å·½ð¢…-ð¢‰ðª©­ðª©®ð¢Šðª©¯ð¢‹ð¢Œð¢ð¢ðª©°ðª©±ð¢Žð¢ð¢‘巾巿-å¸ã ²ã ³å¸‚-帅ð¢’-ð¢”𪩲㠴-㠶帆-师ð¢•-ð¢¤ã ·-㠼帉-å¸ð¢¥-ð¢ºã ½-㡀帑-帜ð¢»-ð¢‚ã¡-㡆å¸-帧ð¢‚-𢂰㡇㡈帨-帱𢂱-𢃌𪩳㡉-㡎帲-帼ð¢ƒ-𢃪𪩴-𪩷ã¡-㡖帽-幇幉𢃫-𢄉𪩸-𪩺㡗-㡛幊-å¹ð¢„Š-𢄞㡜-㡟幈幑-幙幛𢄟-𢄲𪩻㡠㡡幚幜-幥𢄳-𢅌𪩼㡢-㡤幦-幩ð¢…-𢅞𪩽㡥㡦幪-幬𢅟-𢅨𪩾幭-幯𢅩-𢅬幰𢅭-𢅷𪩿㡧㡨幱𢅸-𢅺𪪀𢅻-𢅽㡩㡪𢅾-ð¢†ð¢†‚𢆃-𢆆𢆇𢆈干平𢆉年幵𢆊-𢆌ðªªå¹¶-幸ð¢†-ð¢†ð¢†‘-𢆕𢆖-𢆙𢆚𪪂𪪃𢆛-ð¢†ðªª„幹𢆞-𢆠𪪅𪪆𢆢𢆤𢆥𪪇𢆦-𢆩𢆪𪪈𢆫𪪉𢆬𢆭𢆮⺓乡幺幻𢆯-𢆱幼𢆲-𢆵𢆶𪪊𢆷-𢆺𢆻-𢆾幽𢆿𢇂𪪋ð¢‡ð¢‡ƒ-𢇆𢇇-𢇉㡫㡬幾𢇊𠅹𢇋㡭𢇌-ð¢‡ð¢‡-𢇓㡮𢇖广庀-広𠆲㡯-㡱庄-庆𢇗-𢇢㡲㡳庇-应庘𢇣-𢇱𪪌ðªªã¡´-㡻底-店庙-废𢇲-𢈆𪪎ðªªã¡¼-㢂庠-度𢈇-𢈘ðªªðªª‘㢃-㢇座-庯𢈙-𢈱𪪒-𪪗㢈-㢌庰-庼𢈳-𢉕𢉗-𢉚𪪘𪪙ð«¶ð«·ã¢-ã¢åº½-廃廊𢉛-𢉻𢉽𢉾𪪚𪪛㢑廅-廉廋廌𢉼𢉿-𢊔𪪜ðªªã¢’-㢕廄å»-廘𢊕-𢊬𪪞-𪪠㢖-㢘廙-廤𢊭-ð¢‹ðªª¡-𪪣㢙-㢜廥-廪𢋂-ð¢‹ðªª¤ðªª¥ð¢‹‘-𢋛ð¢‹-𢋠𪪦-𪪨廫𢋡-𢋭ã¢å»¬å»­é¾ð “Œð¢‹®-𢋺𪪪㢞廮-廰𢋻-𢌃廱𢌄-𢌆𪪫廲𢌈-𢌌ð¢Œ-𢌑𢌒廳𢌓𢌔𢌕𢌖廴𢌗㢟廵𢌘-𢌚𪪬延廷𢌜㢠廸廹𢌛ð¢Œð¢Œžðªª­ðªª®å»º-廼𢌟廽𢌠-𢌥𪪯𢌦𢌧𪪰𢌨-𢌪𪪱𢌫𣉡𦋪𪪲廾𢌬廿开𢌭å¼ð¢Œ®ð¢Œ¯å¼‚𢌰-𢌲弃-弅𢌳𢌵-𢌺𪪳弆𢌻𢌽-ð¢ðªª´å¼‡å¼ˆð¢Œ´ð¢Œ¼ð¢‚-ð¢Œå¼‰ð¢-ð¢“𪪵ð¢”-ð¢™ð¢š-ð¢¡ðªª¶ð¢¢-ð¢¥ðªª·ã¢¡ð¢¦-ð¢«ã¢¢å¼Šð¢¬ã¢£ð¢®-ð¢±ð¢²-ð¢´ðªª¸ðªª©ð¢µð¢¶ðªª¹ð¢·ð¢¸ð¢¹å¼‹ð¢ºå¼Œð¢»ð¢¼å¼å¼Ž-å¼ð¢½ð¢¾ã¢¤ð¢¿-𢎃𢎄𢎅㢥𢎆-𢎊𢎋𢎌ð¢Žå¼‘𢎎㢦弒ð¢Žð¢Žð£¦ð¢Ž‘𢎒𢎓𢎔𢎕𢎖弓𢎗𢎘㢧弔-弖𢎙-𢎡弗弘𢎢-𢎪㢨-㢫弙-弜𢎫-𢎶𪪺㢬㢭å¼-张𢎷-ð¢…㢮-㢱弡-弪ð¢†-ð¢“𪪻㢲-㢷弫-弯𠄴𠔘ð¢”-ð¢£ðªª¼ðªª½ã¢¸ã¢¹å¼°-å¼³ð¢¤-ð¢­ðªª¾ã¢º-㢼弴-å¼¹ð¢®-ð¢¿ðªª¿ã¢½-㢿强-å¼¾ð¢€-ð¢‰ðª«€ðª«ã£€-㣂弿-彂ð¢Š-ð¢‘㣃彃-å½…ð¢’-ð¢ðª«‚㣄㣅彆-彉ð¢ž-ð¢¤å½Šå½‹ð¢¥-ð¢ªå½Œð¢¬-ð¢±ðª«ƒå½ð¢²-ð¢·ð¢¸-ð¢¾ð¤¯½ð¢¿-𢑅㣆𢑆-𢑉𪫄彎𢑊å½ð¢‘‹ð¢‘Œðª«…ð¢‘𢑎⺔⺕å½å½‘归当ð¢‘-𢑒𪫆𢑓㣇彔录𢑔𢑕彖𢑗-𢑚𢑛-ð¢‘彗𢑞-𢑡彘𢑢-𢑤彙彚𢑥-𢑧𢑨-𢑬𢑭𢑮𣼙㣈彛彜𢑯𢑱𢑲å½å½žð¢‘³-𢑶𪫇彟𢑷-𢑺𢑻𢑼𢑽𢑾彠𢑿彡𢒀-𢒂㣉𢒃-𢒆㣊形-彤𢒇𢒈㣋-ã£ð¢’‰-ð¢’彥彦𢒎ð«¸å½§å½¨ð¢’-𢒓𣥲𪫈㣎彩彫彬𢒔-ð¢’ã£ã£å½­ð¢’ž-𢒣彮𢒤-𢒨㣑彯彰𢒩𢒪㣒影𢒫-𢒯𪫉㣓𢒰-𢒳𢒴𪫊𢒵𢒷𢒶彲𢒸-𢒺𢒻彳𢒼𢒽㣔𢒾𢒿㣕彴彵𢓀-𢓃㣖㣗彶-彻鿈鿉𢓄-𢓑𪫋㣘㣙彼-径𢓒-𢓛𪫌㣚-㣡待-å¾å¾”𢓜-𢓩㣢㣣徎-従徕𢓪-𢔀ðª«ðª«Žã£¤-㣩徖-徙徛-徤ð¢”-𢔞ðª«ðª«ã£ª-㣮徚徥-徫𢔟-𢔫𢔭-𢔱𪫑-𪫓㣯徬-徰𢔲-𢕎𢕧𪫔𪫕㣰-㣲徱徳徴ð¢•-𢕦𢕨𢕩𪫖-𪫘㣳㣴徲徵-徺𢕪-𢕸㣵㣶徻徼𢕹-𢖄𢖆𢖇𪫙㣷徽徾𢖈-𢖊𢖌-𢖎𪫚ð¢–-𢖗𪫛𪫜㣸徿𢖘-𢖚𢖜㣹忀å¿ð¢–-𢖠𢖢忂𢖣𢖤𢖥𢖦𢖧𢖨⺖⺗心忄𢖩㣺必忆𢖪㣻忇-忊𢖫-𢖱ðª«ã£¼-㤀忋-応𢖲-𢗈𪫞ã¤-㤋å¿-怆𢗉-𢗾𪫟-𪫥ð«¹ã¤Œ-㤙怇-怿𢗿-𢘄𢘅𢘆-𢘳𪫦-𪫬㤚-㤭㤺æ€-æ½ð¢˜´-𢙠𢙡-𢙰𪫭-𪫴㤮-㤹㤻-㤽æ¾-悯𢙱-𢚯𢚰-𢚿𪫵-𪫾㤾-㥙悰-惯𢛀-𢛣𢛤-𢜧𪫿-𪬆㥚-㥫惰-愦慨𢜨-ð¢ð¢ž-𢞌𪬇-𪬒㥬-㥻愧-æ…‘ð¢ž-𢟑𢟒-𢟟𪬓-𪬞㥼-㦈慒-æ…§æ…©-慬慮-憈𠕫𢟠-𢠜ð¢ -𢠰𦑑𪬟-𪬧㦉-㦖慭憉-憳𢠱-𢡶𢡷-𢢑𪬨-𪬭㦗-㦙憴-憺憼-懔𢢒-ð¢£ð¦¡—𪬮-𪬶㦚-㦠憻懕-懨𢣎-𢣺𪬷-𪬹㦡㦢懩-懴𢣻-𢤥𦻇𪬺-𪬾㦣-㦧懵-懸𢤦-𢥊𪬿𪭀㦨-㦪懹-懻𢥋-𢥖ðª­ðª­‚懼-懿𢥗-𢥤𪭃𪭄㦫㦬戀-戂𢥥-𢥮𪭅𪭆戃戄𢥯-𢥺𪭇戅戆𢥻-𢦂𪭈𢦃𢦄㦭戇𢦅-𢦇𢦈𢦉𢦊𢦋戈戉-戋𢦌ð¢¦ðª­‰æˆŒ-æˆð¢¦Ž-𢦑𪭊㦮㦯我-戓𢦒-𢦙㦰-㦲戔-戗𢦚-𢦥㦳战𢦦-𢦶𪭋𪭌㦴-㦶戙𢦷-𢦾ðª­ðª­Žã¦·æˆš-æˆð¢¦¿-𢧇ðª­ðª­ã¦¸æˆžæˆŸæˆ¦ð¢§ˆ-𢧓𪭑㦹戠-戥𢧔-𢧡𪭒㦺戧-戬𠎶𢧢-𢧧𢧩-𢧱𪭓㦻㦼戭-戯戱𢧨𢧲-𢨆戰𢨇-ð¢¨ð¢¨‘𢨒𪭔-𪭖㦽戲戴𢨓-𢨗戳𢨘𢨙𢨚-ð¢¨ð¢¨ž-𢨠𢨡-𢨣戵𪭗戶-戸戹𢨤𢨥𢨦-𢨩㦾戺-戼𢨪-𢨮㦿㧀戽-所𢨯-𢨵ã§ã§‚æ‰-扃𢨶-𢩄𪭘扄-扇𢩅-𢩌扈ð¢©-ð¢©ðª­™æ‰‰æ‰Šð¢©‘-𢩕𢩖𢩗𤟵𢩘-𢩛𢩜-𢩞𪭚𢩟𢩠𢩡ð¨³ð¢©¢ðª­›ð¢©£ð¢©¤âº˜æ‰‹-æ‰é¾µæ‰Žð¢©¥-𢩧㧃-ã§…æ‰-扖𢩨-𢩬㧆-ã§ˆæ‰æ‰—-扞扠-扬𢩭-𢪂𪭜㧉-㧑扟扭-扷批-报𢪃-𢪳ðª­-𪭣㧒-㧠扸抦-择𢪴-𢫟𢫠-𢫣𪭤-𪭪ð«ºã§¡-㧱拪-挧𢫤-𢬔𢬕-𢬮𪭫-𪭳ð«»ã§²-㧸挨-æ¤ð¢¬¯-𢭪𢭫-𢮀𪭴-𪮀㧹-㨈æ¥-æµæ¶æ·-掱掳-掽ð¢®-𢮺𢮻-𢯨ðª®-𪮋㨉-㨕㨗㨘掲掾-æ„æ†-æ…æ‘’𢯩-ð¢°ð¢°‘-𢰾𢱀-𢱞𪮌-𪮖ð«¼ã¨–㨙-㨬æ†-æ°æ²-摊𢱟-𢲅𢲆-𢲲𪮗-𪮢ð«½ã¨­-ã©‚æ…æ‘‹-æ‘‘æ‘“-æ‘•æ‘—-撄撇𢲳-𢳢𢳣-𢴟𪮣-𪮪ð«¾ã©ƒ-ã©‘æ±æ‘–撅撆撈-撺擆𢴠-𢵘𢵙-𢵾𢷅𪮫-𪮴㩒-㩙撻-擅擇-擞𢵿-𢷄𢷆-𢷊𪮵-𪮷㩚-㩟擟-擤擦-擱𢷋-𢷵𪮸-𪮺㩠-㩫擥擲-攆𢷶-𢸢𪮻-𪯀ð«¿ã©¬ã©­æ”‡-æ”æ”’𢸣-𢹌ðª¯ã©®-㩰攑攓-攚ð¢¹-𢹡𢹣-𢹫𪯂㩱-ã©´æ”›-æ”𢹢𢹬-ð¢ºæ”ž-攤攦攧𢺂-𢺕𪯃㩵-㩷攥攨-攫𢺖-ð¢ºðª¯„攬攭𢺞-𢺫㩸㩹攮𢺬-𢺯𢺰-𢺲𢺳𢺴支攰𢺵𢺶㩺𢺷-𢺽𪯆攱𢺾-𢻀㩻㩼ð¢»-𢻇𢻉㩽𢻊-ð¢»ðª¯…㩾攲𢻎-𢻔𢻕-𢻙𢻚-𢻜ð¢»-𢻟𪯇攳𢻠-𢻤𢻥-𢻩𢻪⺙攴攵收攷㩿㪀攸-攼𢻫-𢻲ãªãª‚攽-政𢻳-𢼈𪯈㪃-㪆敀-故𢼉-𢼚𪯉𪯊㪇-㪉敆-敌𢼛-𢼸ð£‹ðª¯‹ðª¯ŒãªŠ-㪎啟æ•-敛𢼹-𢽙𢽜𢽷ðª¯ðªµŠãª-㪚敜-敪敭𢽚𢽛ð¢½-𢽶𢽸-𢽾𢾣𪯎ðª¯ãª›-㪟敫敬敮-数𢽿-𢾢𢾤ðª¯ãª -㪣敱-敳𢾦-𢿅𪯑𪯒㪤-㪦整-敻𢿇-ð¢¿ð£šðª¯“-𪯖㪧-㪪敼-敿𢿞-𢿽𪯗-𪯙斀-斂𢿾-𣀃𣀅-ð£€ðª¯šãª«ãª¬æ–ƒè´ð£€„ð£€-𣀚𪯛𪯜斄𣀛-𣀢𩠮㪭斅斆𣀣-𣀭𩠰㪮𣀮-𣀲ðª¯ðª¯žð£€³ð£€´ð£€µ-ð£€ºðª¯Ÿð£€»ð£€¼ð£€½ð£€¾ð£€¿ð£€æ–‡ð£ãª¯æ–ˆð£‚𪯠⻫斉ð£ƒ-ð£…𪯡𪯢ð£†-ð£‰ðª¯£ãª°æ–Šæ–‹ð£Šð£Œð£ðª¯¤æ–Œ-æ–ð£Ž-ð£“æ–æ–‘ð£”-ð£–𪯥-𪯧㪱斒ð£—-ð£™ð©–°ðª¯¨-𪯪ð£›-ð£¡æ–“ð£¢ð££ð£¤ð£¥ð£¦æ–”ð£§ð£¨æ–•ð£©ð£ªæ––ð£«æ–—ð£¬ãª²ãª³æ–˜ð£­ãª´ð£®-ð£°ãªµð£±ð£²ðª¯«ãª¶æ–™æ–šð£³-ð£¶ðª¯¬ãª·æ–›æ–œð£·-ð£»ãª¸æ–ð£¼-𣂀斞斟ð£‚𣂃-𣂅斠斡𣂂𣂆-𣂈𪯭㪹𣂉-𣂋𪯮斢㪺斣𣂌ð£‚𪯯𣂎ð£‚ð£‚𪯰㪻斤𣂑斥𣂒𣂓斦-斩𣂔-𣂘𪯱㪼㪽斪斫𣂙𣂚㪾㪿𣂛-ð£‚æ–¬æ–­ð£‚ž-𣂠㫀斮斯𣂡-𣂪𣂬𣂭新斱𣂮-ð£‚µð¥‡´ã«æ–²ð£‚¶-𣂺㫂斳𣂻-𣂿斴𣃀-𣃆斵斶𣃇-𣃋斷𣃌-ð£ƒð£ƒ‘-𣃓𣃔𣃕𣃖斸方㫃𣃗𣃘𣃙㫄斺-於𣃚-𣃜𪯲𪯳㫆施-æ—€ð£ƒ-𣃥𪯴㫅㫇-㫉æ—-旆旊𣃦-𣃲𪯵-𪯷㫊-㫌旇-旉旋-æ—𣃳-ð£ƒ»ðª¯¸ð«ž€ã«æ—旑𣃼-𣄇𪯹-𪯼旒-旕𣄈-ð£„ðª¯½ð«žæ—–旗𣄎-𣄓𪯾㫎ã«ð£„”-𣄖𪯿𪰀旘旙𣄗-𣄜ðª°ðª°‚æ—šð£„æ—›ð£„ž-𣄣旜-旞𣄤𪰃𪰄旟𣄥𪰅𣄦𣄧𣄨𣄩𣄪𣄫𣄬无旡𣄭𣄮𣄯既𣄰𣄱-𣄳旣𣄴𣄵旤𣄶-𣄸𣄹𣄺⺛⺜日旦旧𣄻-𣄽ã«ã«‘æ—¨-旯𣄾-𣅃𣅅㫒-ã«—æ—°-旸𣅄𣅆-𣅙𪰆𪰇㫘-㫚旹-昙𣅚-𣅶𪰈-𪰎㫛-㫤昚-昿𣅷-𣆈𣆊-𣆑ðª°-𪰘𫞂𫞃㫥-㫮晀-晖𣆒-𣆱𪰙-𪰤𫞄㫯-ã«´å‹—æ™—-晩曽𣆲-𣇡𪰥-𪰨㫵-㬀晪-暃暑𣇢-𣈣𪰩-𪰮ã¬-㬌暄-æšæš’-暙𣈤-𣉑𪰯-𪰷ã¬-ã¬æšš-暨𣉒-𣉠𣉢-𣉺𪰸-𪰽㬑-㬖暩-暷𣉻-𣊈𣊊-𣊑𣊓-ð£Šð£‹‡ðª°¾-𪱅㬗-㬟暸-æ›é¾§ð£Š‰ð£Šž-𣋆𣋈𪱇-𪱌㬠-㬢曎-曗曚ð žð£‹‰-ð£‹ðª±†ðª±ã¬£-㬨曘曙曛曜𠆛𣋞-𣋱𥫂𪱎-ðª±ã¬©ã¬ªæ›-曢𣋲-𣋾㬫曣-曨𣋿-𣌇曩𣌈-𣌌𪱑-𪱓㬬㬭ð£Œ-𣌕㬮曪-曬𣌖曭曮𣌗-𣌙𣌛𪱔㬯曯𣌜ð£Œð£ŒŸð£Œ æ›°æ›±ã¬°æ›²æ›³æ›´æ›µð£Œ¡ð£Œ¢æ›¶ð£Œ£-𣌦曷𣆉𣌧-𣌬書曺𣌭-𣌶曹曻曼𣌷-ð£Œºæ›¾æ›¿æœæœ‚𣌻-𣌽會𣌾-ð£‚æœ„朅ð£ƒ-ð£…ð£†-ð£Šðª±•㬱朆ð£‹-ð£Žðª±–𪱗㬲ð£ð£ð£‘-ð£•ð£–ð£—𪱘ð£˜ð£™æœ‡ð£šð ‘±ð£›ð£œâºæœˆð£æœ‰ð£žðª±™ð£Ÿ-ð££ðª±šã¬³æœŠ-æœð£¤ðª±›æœŽ-朑ð£¥-ð£§ð£©-ð£¬ðª±œðª±ã¬´ã¬µæœ’-朕ð£­ð£®ðª±žð«ž…㬶㬷朖-望ð£±-ð£¶ðª± -𪱢㬸朜-期ð£·-𣎃𦜳𪱣𫞆𫞇朠朡𣎄-𣎌𪱤-𪱧㬺㬻朢ð£Ž-𣎑𪱟𪱨-𪱪㬼-㬾膤𣎒-𣎙𪱫𪱬㬿朣-朥𣎚𣎛ð£Ž-𣎢𪱭㭀𣎜𣎣-𣎨𦡖朦𣎩-𣎭朧𣎮𣎯𪱮𪱯𣎰𣎱𣎲𪱰木朩𣎳𣎴未-朰𣎵-ð£Ž·ã­æœ±-æƒð£Ž¸-ð£€ã­‚-ã­†æ„-æ©æžð£-ð£“𪱱-𪱵㭇-ã­æª-枀枂-æž­ð£”-ð£†ð£‡ðª±¶-𪱹𫞈㭑-ã­—æž®-æ ‘ð£ˆ-ð£œð£-ð£´ðª±º-𪲂㭘-ã­§æ ’-桪鿄ð£µ-𣑊𣑋-𣑦𣑨-𣑾𪲃-ðª²ð«ž‰ð«žŠã­¨-㭵㭷桫-棂𣑿-𣒗𣒘-𣓀ðª²-𪲞㭶㭸-㮊棃-椮ð£“-𣔰𪲟-𪲮𪲯㮋-㮠㮢㮣椯-榉榋榌榔榘﨓𣔱-𣔸𣔹-𣕣𣕥-𣖩𪲰-𪲿𪳀-𪳇㮤-㮽榊æ¦-榓榕-榗榙-槡槩樮﨔𣕤𣖪-𣖷𣖸-𣘔𪳈-𪳜𫞋𫞌㮾-ã¯ã¯‘㯒㯠槢-槨槪-樭樯-樱橥橴𣘕-𣘯𣘰-𣙑𣙓-𣙺ðª³-𪳬ð«ž-ð«žã¯ã¯“-㯟㯡-㯩樲-橤橦-橳橵-橼𣙒𣙻-𣚙𣚚-𣛯𪳭-𪳼ð«žã¯ª-㯶橽-檪𣛰-𣜡𣜣-𣜵𣜶-ð£€ðª³½-𪴈𫞑㯷-㯽檫-櫊ð£-ð£˜ð£š-𣞎𪴉-ðª´ð«ž’㯾-㰈櫋-櫦櫫櫭ð£™ð£ž-𣟃𣟑ðª´-𪴕㰉-ã°“ã°–æ«§-櫪櫬櫮-櫶𣟄-ð£Ÿð£Ÿ’-𣟮𪴖-𪴚㰔㰕櫸-欅欌𣟯-ð£ ð£ ƒ-𣠘𪴛-𪴞㰗㰘櫷欆-æ¬‹æ¬æ¬Žð£ ‚𣠙-𣠶𪴟-𪴡㰙-ã°œæ¬-欒𣠷-𣡊𪴢𪴣欓-欕𣡋-ð£¡ð¥¤”𪴤𪴥欖-欛𣡞-𣡨𪴦欜æ¬ð£¡©-𣡱𪴨𣡲𣡴𣡵𪴧欞欟𣡶-𣡸𣡹𣡺𣡻𣡼𣡽𣡾𣡿欠次欢𣢀ã°ã°žæ¬¤ð£¢-𣢈㰟-㰢欣欥-欧𣢉-𣢖𪴩㰣-㰨欨-欪𣢗-𣢦𪴪𪴫㰩-㰭欫-欱𣢧-𣢹㰮-㰱欲-欸𣢺-𣣇𪴬𪴭㰲-㰶㰸欹-欼欽款欿𣣈-𣣜𪴮㰹-㰾歀-æ­ˆð££-𣣫𣣭-𣣱𪴯𪴰㰿-ã±æ­‰-æ­ð££²-𣤇𪴱㱂㱃歎-歓𣤈-𣤗𪴲㱄㱅歔-歚𣤘-𣤟㱆-㱉歛-æ­ð£¤ -𣤧歞歟𣤨-𣤫㱊歠𣤬-𣤰㱋𣤱-𣤳𪴳𣤴𣤵𣤷𣤸㱌歡𣤶𣤹-𣤼ã±ð£¤½ð£¤¾ðª´´ã±Žð£¤¿ð£¥€ð£¥æ­¢é¾°ð£¥‚æ­£ð£¥ƒð£¥„ã±æ­¤ð£¥…𣥆ã±ã±‘步𣥇𣥈𣥊-𣥌武-歩𣥉ð£¥-𣥡𪴵㱒-㱔歪歫𣥢-𣥤歬歭𣥦-𣥱𪴶𣥳-𣥸𪴷⻭㱕㱖歮歯𣥹-𣦆𪴸歰-歳𣦇-𣦊𣦌-𣦎𤚜𪴹𪴺𫞓㱗歴ð£¦-𣦓𪴻歵歶𣦔-𣦛𪴼歷𣦜-𣦠𪴽𪴾𣦡-𣦥𪴿㱘歸𣦦-𣦫𣦬𣦮𣦯𣦰𣦱𣦲𣦳𣦴⺞歹𣦵𣦶歺𣦷㱙死𣦸-𣦾歼𣦿-𣧈㱚-ã±æ­½-æ®ð£§‰-𣧜㱞-㱠殂-殇ð£§-𣧱𪵀ðªµã°·ã±¡æ®ˆ-残𣧲-𣨄𪵂𪵃㱢㱣殌-殓𣨅-𣨕𪵄㱤-㱩殔-殚𣨖-𣨰𪵅㱪-㱮殛殜𣨱-𣩃㱯-ã±²æ®-殡𣩄-𣩌𪵆㱳㱴殢-殦ð£©-𣩜𫞔㱵-ã±·æ®§-殫ð£©-𣩧㱸殬-殮𣩨-𣩮𪵇殯𣩯-𣩶殰殱𣩷𣩸㱹㱺𣩹-𣩻殲𣩼𣩽𣩾㱻𣩿-ð£ªæ®³ã±¼ã±½æ®´ð£ª‚-𣪄段殶𣪅-𣪇㱾㱿殷𣪈-𣪊𪵈𪵉㲀殸-殻𣪋-𣪘𪵋ã²-㲃殼殽𣪙-𣪟𪵌-𪵎㲄殾-毂𣪠-𣪬ðªµã²…毃毄𣪮-𣪵毅毆𣪶-𣪺𤛗ðªµã²†-㲈毇毈𣪻-𣫋㲉𣫌-ð£«ðªµ‘𪵒㲊ð£«-𣫗毉𣫘-ð£«ð£«žð£«Ÿð£« ð£«¡æ¯Šð£«¢-𣫥𣫦-ð£«¨ð£«©ðªµ“ð£«ªð£««æ¯‹æ¯Œð£«¬æ¯æ¯Žð£«­æ¯æ¯ð£«®æ¯‘毒𣫯-𣫲𣫳𣫴𣫵-𣫸毓𣫹𣫺-ð£«¼ðªµ”ð£«½ð£«¾ð£«¿ð£¬€ð£¬æ¯”毕𠂱𣬂𣬃𣬄-𣬇㲋毖-毘毙𣬈-𣬊𣬋𣬌ð£¬ð£¬Ž-𣬑𪵕𣬒𣬓𣬔毚𣬕𣬖𣬗𣬘𣬙𣬚毛𣬛𪵖㲌𣬜-𣬠毜æ¯ð£¬¡-𣬨ã²-㲑毞毟𣬩-𣬷𪵗𪵘㲒毠毡𣬸-𣭛𪵙𪵚㲓毢-毪𣭜-𣭰𪵛𪵜㲔-㲚毫-毮𣭱-𣮇㲛-㲞毯-毶𣮈-𣮧ðªµðªµžã²Ÿ-㲣毷-毽𣮨-𣯄𪵟㲤-㲩毾𣯅-𣯢𪵠毿-氂𣯣-𣯷𪵡㲪-㲮氃-氇𣯸-𣰉氈-氊𣰊-𣰙㲯㲰氋𣰚-𣰪𪵢㲱氌𣰫-𣰰𠫈𣰱-𣰵𣰶-𣰺æ°ð£°»-𣰾𣰿-ð£±ã²²æ°Žð£±‚𣱃𣱄æ°âº æ°æ°‘𫞕氒𫞖氓𣱅𣱆𣱇-𣱊㲳𣱋-𣱎ð£±ð£±ð£±‘𣱒𣱓𣱔气氕氖-氘𣱕𣱖氙氚𣱗𣱘㲴氛-æ°ð£±™-𣱛𪵣氞-氢𣱜-𣱠𪵤氣-氩𣱡㲵氪氫𣱣𪵥氬-氰𣱢𣱤𣱥氱𣱦-𣱨𪵦氲氳𣱩𪵧㲶𣱪𣱫㲷𣱬𣱭𣱮𣱯𣱰⺡⺢水氵氺𣱱㲸氶-氹𣱲-𣱴㲹-㲼氻氼氾-汉𣱵-𣱿𪵨㲽-㲿汊-汤𣲀-ð£²ðªµ©-𪵬㳀-㳊汥-沪𣲎-𣲱𪵭-𪵰㳋-㳕沫-泙泛-æ³´æ³¶-泾𣲲-𣳔𣳕-𣳣𪵱-𪵶㳖-㳣泚泿-洌洎-æ´•æ´—-浕𣳤-𣳿𣴀-ð£´ðªµ·-𪵽㳤-ã³³æ´æ´–æµ–-涘涚-涩𣴞-𣴸𣴹-𣵶𣷚𪵾-𪶋𫞗㳴-㴎涙涪-渂渄-渎æ¸-渗渚湴𣵷-𣷙𣷛-𣷬𣷭-𣷻𣸊𪶌-𪶖𫞘ã´-㴤渃渘渙減-渟渠渡-湳湵-溌滋滞𣷼-𣸉𣸋-ð£¸ð£¸-𣹜𪶗-𪶩㴥-ã´»æº-滊æ»-滙滛-æ»æ»Ÿ-滪漓ð£¹-𣹪𣹫-𣻌𦴶𪶪-𪶾𫞙-𫞛㴼-㵉滌滚滫-漊漌-æ¼’æ¼”-漼漾-æ½ð£»-𣻜ð£»-𣻳𣻵-𣼘𣼚-𣽂𪶿-𪷊㵊-㵜漋漽潎-潿æ¾-澘澚-æ¾æ¿ð£»´ð£½ƒ-ð£½ð£½ž-𣾨𣾪-𣾿ð£¿-𣿄𪷋-𪷜𫞜ãµ-㵮澙澞-æ¿æ¿‘-濓濖𣾩𣿅-𣿺𣿻-𤀡ðª·-𪷧ð«žãµ¯-㵼澀濔濕濗-濲濴-濸𣿀𤀣-ð¤ð¤Ÿð¤ ðª·¨-𪷲㵽-㶃濹-瀔ð¤žð¤¡-𤂜𤂞-𤂠𤂢-𤂲𪷳-𪷹㶄-㶋濳瀕-瀮ð¤‚𤂡𤂳-𤃧𪷺-𪷿𫞞㶌-㶑瀯-ç𤃨-ð¤„𪸀-𪸂㶒-㶘ç‚-ççç𢌇𤄎-𤄵𪸃-𪸇㶙㶚ç‘-ç˜ð¤„¶-𤅉𪸈𪸉㶛-ã¶ç™-çœð¤…Š-𤅟𪸊𪸋㶞㶟ç-ç¡ð¤… -𤅨𪸌ç¢ç£ð¤…©-𤅯㶠çŽç¤-ç¦ð¤…°-𤅶ç§ç¨ð¤…·-𤅻𤅼𤅽𤅾𤅿ç©çªð¤†€ð¤†âº£ç«ç¬ç­ð¤†‚ðª¸ã¶¡ã¶¢ç®-ç³ç‚‡ð¤†ƒ-𤆌㶣-ã¶¥ç´-ç‚€ð¤†-𤆜𪸎-ðª¸ã¶¦-㶪ç‚-炆炈-炞ð¤†-𤆻𪸑-𪸗㶫-㶲炟-烃𤆼-𤇮𪸘-𪸢㶳-㶸烄-烮𤇯-𤈤𪸣-𪸪𫞟㶹-ã·çƒ¯-ç„“ç„•-焘𤈥-𤉡𪸫-𪸲𫞠㷂-ã·ç„”ç„™-煀煮𤉢-𤊫𤊬-𤊱𪸳-𪹃㮡㷎-ã·žç…-ç…­ç…¯-煸煺𤊲-𤋧𤋨-𤋲𤋴-𤌆ð¤ðª¹„-𪹑㷟-㷪煹煻-熙熦蒸𤌇-𤌱𤌳-ð¤Žðª¹’-𪹜ðª¹-𪹠𫞡㷫-㷲熚-熥熧-熵黙龦龽𤌲ð¤-ð¤¨ð¤ª-ð¤¿ð¤Žð¤Žƒ-𤎜𪹡-𪹩㷳-㷽熶-燞ð¤©ð¤Ž-ð¤Ÿð¤¡-ð¤¨ð¤©-ð¤±ð¤²ð¤³ð¤´ðª¹ª-𪹳㷾-㸃營-燷ð¤µ-ð¤£ðª¹´-𪹻㸄㸅燸-爃ð¤¤-𤑂𤑄-𤑑𦦨𪹼-𪺀㸆㸇㸉爄-爊爌-爎爕𤑒-𤑲ðªºðªº‚㸈㸊-㸌爋çˆ-爔爖-爘𤑳-𤒠𤒨𪺃-𪺅ã¸çˆ™-爛𤒡-𤒧𤒪-𤒹㸎爜-爠𤒩𤒺𤒻𤒽-𤓇𪺆𪺇ã¸ã¸çˆ¡çˆ¢ð¤’¼ð¤“ˆ-𤓎ð¤“-𤓖𪺈爣𤓗-𤓛𪺉爤-爦𤓜-𤓞𤓠-𤓣𪺊𪺋㸑𤓤𤓥𤓦-𤓩𪺌爧𤓪𤓬爨𤓫𤓭爩𤓮⺤⺥爪爫𤓯𤓰𤓱𤓲-𤓵ðªºã¸’㸓爬爭𤓶-𤓼爮-爰𤓽-𤔋𪺎爱𤔌-ð¤”㸔ð¤”-𤔓ðªºçˆ²ð¤””-𤔖𤔘-𤔛ðªº-𪺓𤔜-𤔡𪺔𪺕㸕爳𤔢-𤔦噕爴𤔧-𤔭𪺖𪺗𤔮-𤔱𤔲-𤔸𤔼𪺘𪺙爵𤔹𤔻𤔽𤔾𤔺𤔿𤕀𤕂-𤕆𤕇𤕈-𤕊𤕋𤕌ð¤•𪺚父爷𤕎ð¤•爸ð¤•𤕑㸖𤕒㸗爹𤕓𤕔𪺛㸘𤕕𪺜𤕖𤕗㸙爺𤕘𤕙𤕚𤕛爻𤕜㸚ð¤•ðªºçˆ¼ð¤•žð¤•Ÿð¤• ð¤•¡çˆ½ð¤•¢ð¤•£ð¤•¤ð¤•¥çˆ¾ð Ž›ð¤•¦-𤕨𤕩𠑂𡄉⺦丬爿𤕪𤕫𤕬𤕭𤕮牀𤕯-𤕱㸛ç‰ð¤•²-𤕵牂𤕶-𤕺𤕻-𤖃𪺞㸜𤖄-𤖋𪺟牃𤖌-𤖎牄ð¤–-𤖒牅𤖓-𤖕𪺠𤖖-𤖛牆𤖜-𤖟𪺡𤖠𤖡𤖢𤖣𤖤𤖥𤖦𤖧片𤖨𤖩-𤖫ã¸ã¸žç‰ˆð¤–¬-𤖰牉牊𤖱-𤖹㸟-㸡𤖺-𤖿𪺢𤗀-𤗆𪺣𪺤牋-ç‰ð¤—‡-𤗗𪺥牎-牒𤗘-𤗡㸢牓牔𤗢-𤗧牕-牗𤗨-𤗲𤗳-𤗹𪺦㸣𤗺-𤗾㸤𤗿-𤘂牘𤘃㸥𤘄㸦牙𤘅𤘆𪺧𤘇㸧𤘈𤘉𤘊𤘋牚𤘌-ð¤˜ðªº¨ð¤˜ð¤˜‘𤘒𤘓⺧牛牜𤘔㸨ç‰-牟𤘕-𤘗㸩㸪牠牡牢牣牤𤘘-𤘛𪺩㸫-㸯牥-牬𤘜-𤘷㸰-㸴牭-牵𤘸-ð¤™ðªºªðªº«ð«ž¢ã¸µ-㸸牶-牺𤙑-𤙚𪺬-𪺮㸹-㹀牻-牿çŠð¤™›-𤙮ã¹-㹃犀犂-犋𤙯-𤚌𪺯㹅-㹈犌-犑ð¤š-𤚛ð¤š-𤚨𤚿𪺰㹄㹉-㹋犒-犗𤚩-𤚾𤛀-𤛉𪺱-𪺳㹌-ã¹çŠ˜-犛𤛊-𤛖𤛘-𤛠𪺴㹑-㹓犜-犟𤛡-𤛮𪺵㹔-㹖犠𤛯-𤛸㹗㹘𤛹𤛺㹙犡-犦𤛻-ð¤œçŠ§çŠ¨ð¤œ‚-𤜆㹚𤜇-𤜋𪺶㹛犩𤜌-ð¤œð¤œ‘-𤜓犪𤜔𤜕𤜖-𤜘犫𤜙⺨犬犭犮𡗜𤜚犯犰𤜛-𤜠犱-犸𤜡-𤜮㹜-㹠犹-狈𤜯-ð¤Žð¤®ðªº·ã¹¡-㹪狉-狞ð¤-ð¤­ðªº¸ðªº¹ð«ž£ã¹«-㹰狟-狲ð¤¯-𤞘𤞣𪺺𪺻㹱-㹸狳-猃𤞙-𤞢𤞤-𤟂𪺼𪺽㹹-㺀猄-猡猪猫𤟃-𤟛𪺾-ðª»ð«ž¤ãº-㺆猢-猩猬-猹çç“𤟜-𤟴𤟶-𤠌𪻂-𪻅㺇-ãºçŒº-ç€ç‚çƒç…-çŠð¤ -𤠸𪻆𪻇㺎-㺓ç„çŒ-ç’ç”ç•𤠹-𤡢𪻈㺔-㺙ç‹ç–-ç¤ð¤¡£-𤢋𪻉㺚-㺜ç¥-ç­ð¤¢Œ-𤢥ãº-㺟ç®-ç´ð¤¢¦-𤢳𪻊㺠çµ-ç¸ð¤¢´-𤣄𪻋㺡㺢ç¹-ç»ð¤£…-𤣌𪻌㺣-㺦ç¼ç½ð¤£-ð¤£ç¾ç¿ð¤£‘-𤣖玀𤣗-𤣚çŽ-玃𤣛-𤣞㺧𤣟-𤣢𤣣𤣤玄𤣥玅𤣦玆率玈𤣧𤣨⺩玉王𤣩玊玌çŽãº¨-㺫玎-玑𤣪-𤣬ðª»ãº¬-㺯玒-玛𤣭-𤣸㺰-㺶玜-玱𤣹-𤤎𪻎-𪻔𫞥㺷-㺾玲-ç‘ð¤¤-𤤴𪻕𪻖㺿-㻈ç’-ç²ç‰ð ´¦ð¤¤µ-𤥕𪻗-𪻟𫞦㻉-ã»ç³-ç¶ç¸-çˆçŠ-ç“𤥖-𤥺𪻠-𪻥㻑-㻜ç·ç”-ççŸ-ç¼ð¤¥»-𤦮𪻦-𪻲𫞧ã»-㻦çžç½-瑟𤦯-𤧩𪻳-𪼂㻧-㻪瑠-瑸𤧪-𤨓𪼃-ðª¼ð«ž¨ã»«-㻴瑹-璌璎璓𤨔-𤨿ð¤©ðª¼-𪼖𫞩㻵-㻼ç’ç’-ç’’ç’”-璡璣璤𤩀𤩂-𤩪𪼗-𪼠㻽-㼂璢璥-璴𤩫-𤪊𪼡-𪼦璵-瓂𤪋-𤪨𤪴𪼧𪼨㼃-㼆瓃-瓋𤪩-𤪳𤪵-𤪽𪼩-𪼫㼇瓌-瓒𤪾-𤫈𪼬-𪼯瓓-瓖𤫉-𤫓𪼰瓗-瓙𤫔-𤫘㼈瓚𤫙-𤫟𪼱瓛𤫠𪼲𤫣-𤫧𤫢𤫨𤫩瓜ç“𤫪𪼳㼉㼊𤫫-𤫯𪼴㼋㼌瓞瓟𤫰-𤫴ã¼ã¼Žç“ ð¤«µ-𤫹ã¼ð¤«º-𤬀瓡ð¤¬-𤬆𪼵ã¼-㼒𤬈-𤬌㼓㼔𤬇ð¤¬ð¤¬-𤬕瓢𤬎ð¤¬ð¤¬–𤬗㼕𤬘-𤬚瓣𤬛-ð¤¬ç“¤ð¤¬žð¤¬Ÿð¤¬ ð¤¬¡ç“¥ð¤¬¢ã¼–𤬣𤬤𤬥瓦㼗瓧𤬦𤬧㼘㼙瓨瓩𤬨-𤬫𪼶㼚㼛瓪-瓲𤬬-𤬲𪼷𪼸㼜-㼠瓳-瓵𤬳-𤬽𪼹㼡-㼦瓶-瓸𤬾-𤭋㼧-㼪瓹-瓼𤭌-𤭚㼫-㼱瓽-ç”𤭛-𤭦𤭲𤮖𪼺𪼻㼲-㼷甂-甆𤭧-𤭱𤭳-𤭸𪼼㼸-㼺甇-甉𠪹𤭹-𤮄𪼽𪼾㼻-㼾甊-甎𤮅-ð¤®ã¼¿-ã½…ç”-甒𤮎-𤮕𤮗㽆㽇甓-甕𤮘-𤮟㽈㽉甖𤮠𤮡𤮢-𤮥甗𤮦-𤮬㽊𤮭-𤮯𪼿𤮰-𤮵㽋𤮶㽌𤮷𤮸𤮹甘𤮺甙𤮻-𤯀甚ð¤¯-𤯄𫞪ã½ð¤¯…甛甜𤯆𪽀㽎ç”甞𤯇ã½ð¤¯ˆã½ð¤¯‰ð¤¯Šð¤¯‹ð¤¯Œã½‘ð¤¯ð¤¯Žð¤¯ð¤¯‘𤯒生𤯓𤯔ðª½ð¤¯•-𤯗甠𤯘-𤯞甡𤯟產産𤯠-𤯥𪽂㽒甤-甦𤯦-𤯫𤯬-𤯱𪽃-𪽅甧𤯲-𤯴㽓𤯵㽔𤯶𤯷-𤯹𤯺𤯻𤯼𤯾𤯿𤰀ð¤°ð¤°‚用甩甪𤰃𪽆甫甬𤰄𠂵𠃰𡶤𤰅𤰆甭甮𠳫𤰇𤰈甯𤰉𤰊𤰋𤰌ð¤°ð¤°Žð¤°ð¤°‘ð¤°ç”°-电𤰒甶𤰓𤰔㽕-ã½—ç”·-町甼𠃫𤰕-𤰜𪽇画甽-ç•…ð¡‡ð¢‘–ð¤°-𤰨𪽈㽘-㽚畆-畓𤰩-𤱋𪽉-𪽌㽛㽜畔-畟𤱌-𤱠𤱢-𤱤ðª½-ðª½ã½ã½žç•¡-畧畩異𤱥-𤱺𪽑𪽒𫞫㽟㽠番-畯畲-畴𤱻-ð¤²ðª½“-𪽗㽡-㽤畵-畺𤲑-𤲪𪽘-𪽚㽥畱畻-畽𤲫-𤲶𪽛𪽜㽦-㽨畾畿𤲷-𤳇ðª½ðª½žã½©ç–€-疂𤳈-𤳎ð¤³ð¤³‘𪽟-𪽡㽪疃疄𤳒-𤳚𤳜-𤳣𪽢㽫㽬疅𤳤-𤳨ð¨´ðª½£ã½­ç–†ç–‡ð¤³©-𤳰𤳲㽮疈𤳱𤳳-𤳸𪽤𤳹-𤳾𪽥𪽦疉疊𤳿-ð¤´ã½¯ð¤´‚-𤴄𤴅𤴆𤴇-𤴋𤴌ð¤´ð¤´Žð¤´ð¤´ð¤´‘𤴒⺪疋𤴓𤴔𤴕疌𤴖𤴘ç–𤴗疎ç–𤴙-𤴛㽰𤴜ð¤´ç–疑𤴞𤴟-𤴢𪽧𤴣𤴤疒𤴥㽱㽲疓-疗𤴦-𤴮㽳-ã½¶ç–˜-疠𤴯-𤴶㽷-㽼疡-疯疺𤴷-𤵖𪽨-𪽫㽽-㾉疰-疹疻-痉𤵗-𤵶𪽬-𪽮𫞬㾊-ã¾’ç—Š-痖𤵷-𤶔𪽯㾓-㾡痗-痫𤶕-ð¤·ðª½°ðª½±ã¾¢-㾩痬-瘆𤷂-𤷺𪽲㾪-㾵瘇-瘘瘟瘧𤷻-𤸩𪽳-𪽵㾶-ã¿ç˜™-瘞瘠-瘦瘨-瘫𤸪-𤹜𪽶𪽷𫞭㿂-㿈瘬-瘿癊ð¤¹-𤺂𤺞㿉㿊癀-癉癋-癎𤺃-ð¤ºð¤ºŸ-𤺹𪽸𪽹㿋-ã¿ç™-癞𤺺-𤻔㿑-㿓癟-癡癣𤻕-𤻯𪽺㿔癢癤-癦𤻰-𤻿㿕-ã¿—ç™§-癫𤼀-𤼊㿘癬-癮𤼋-ð¤¼ã¿™ç™¯ç™°ð¤¼-𤼗㿚㿛癱癲𤼘-𤼛𤼜-𤼞癳𤼟-𤼡𤼢㿜癴𤼣𤼤癵癶𤼥𤼦癷癸-発𤼧𤼨𤼩-𤼫𤼬-𤼮登發𤼯-𤼲𤼳-𤼵𤼶𤼷𤼸𤼹𤼺𤼼𤼻白百癿𤼽𤼾ã¿çš€-皃𤼿-ð¤½çš„𤽂-𤽇㿞皅-皈𤽈-𤽗𪽻𪽼㿟畠皉-çšð¤½˜-𤽤𪽽𫞮㿠㿡皎-皑𤽥-𤽫皒-皖𠌟𤽬-𤽸𪽾𪽿㿢皗-皙𤽹-𤾇𪾀ðª¾ã¿£ã¿¤ð¤¾ˆ-𤾓𪾂𪾃㿥皚-皞𤾔-𤾚𪾄㿦皟-皡𤾛-𤾟皢-皥𤾠-𤾦皦-皨𤾧-𤾪㿧皩𤾫-𤾳皪皫𤾴-𤾷㿨皬𤾸-𤾺𪾅𤾻-𤾽皭𤾾𤾿𤿀-𤿃㿩𤿄𤿅皮𤿆𤿇㿪皯𤿈-ð¤¿ðª¾†ã¿«ã¿¬ð¤¿Ž-𤿔𪾇㿭㿮皰皱𤿕-𤿞㿯㿰皲𤿟-𤿦㿱皳皴𤿧-𤿮𤿰-𤿲㿲㿳皵龾𤿯𤿳-𤿿㿴㿵皶-皹𥀀-𥀌𪾈𪾉㿶㿷皺ð¥€-𥀓㿸皻𥀔-𥀞皼𥀟-𥀡㿹皽𥀢-𥀪𥀫-𥀮㿺皾𥀯-𥀳𥀴𥀵𥀶-𥀸𥀹𥀺皿盀ç›ð¥€¿ð¥€ã¿»ç›‚ð¥-ð¥…𫞯㿼㿽盃-盈ð¥†-ð¥ðª¾Šðª¾‹ð«ž°ã¿¾-䀀盉-监ð¥Ž-ð¥ð¥«ðª¾Œðª¾ä€ä€‚ç›’-盘盛ð¥ž-ð¥ªðª¾Žä€ƒç›™ç›šç›œð¥¬-ð¥¶ðª¾ðª¾ä€„䀅ç›-盟ð¥·-𥂂𪾑𪾒𫞱䀆盠-監𥂃-𥂆𪾓𪾔盤𥂇-𥂒𪾕䀇䀈盥-盧𥂓-𥂤𪾖䀉盨-盪𥂥-𥂲𥂴-𥂷𪾗𪾘盫盬𥂸-𥂺𥂼-𥃀𪾙䀊𥂻ð¥ƒ-𥃆𪾚盭𥃇-𥃑䀋𥃒𦪹𪾛䀌𥃓-𥃗𪾜𥃘𥃙𥃞𥃚-ð¥ƒðª¾ð¥ƒŸð¥ƒ ð¥ƒ¡ä€ðª¾žð¥ƒ¢ð¥ƒ£âº«ç›®ð¥ƒ¤ð¥ƒ¥ä€Žä€ç›¯ð¥ƒ¦-𥃱ä€-䀔盰-盵𥃲-𥄂𪾟𪾠䀕-䀞盶-çœð¥„ƒ-𥄰𪾡-𪾣䀟-䀦眎-眬眿𥄱-𥅙𪾤-𪾧𫞲䀧-䀮眭-眾ç𠌪𥅚-𥆉𪾨-𪾪𫞳䀯-ä€ç€ç‚-ç‘鿃𥆊-𥇄𥇆-𥇈𥇫𪾫𪾬ä-ä‰ç’-ç ç¢-ç­ð¢°¿ð¢¾¥ð£ª­ð¥‡…𥇉-𥇪𥇬-𥇳𥇵-ð¥ˆðª¾­-𪾰äŠ-ä–ç¡ç®-瞆𥈂-𥈻𪾱-𪾴ä—-ä¡çž‡-瞓𥈼-𥉳𥊇𪾵-𪾸ä¢-äªçž”-瞣𥉴-𥊆𥊈-𥊩𥋖𪾹-𪾻ä«-ä³çž¤-瞷𥊪-𥋕𥋗𪾼-𪿀ä´-äºçž¸-矂𥋘-𥋾矃-矊𥋿-𥌔𥌖-𥌙ðª¿ä»-ä¾çŸ‹-çŸð¥Œš-𥌬𪿂ä¿ä‚€çŸ-矓𥌭-𥌹ð¥‚𪿃𪿄ä‚𥌺-ð¥ð¥ƒð¥…-ð¥‡ä‚‚䂃矔ð¥ˆ-ð¥ŽçŸ•矗ð¥-ð¥’䂄矘矙ð¥“矖矚ð¥”-ð¥˜ð¥™ð¥šð¥›ð¥œðª¿…䂅矛ð¥ä‚†ð¥žä‚‡çŸœð¥Ÿð¥ ðª¿†çŸð¥¡-ð¥¦ä‚ˆð¥§-ð¥©çŸžçŸŸð¥ª-ð¥±ðª¿‡çŸ ð ¢ð¥²-ð¥µä‚‰ð¥¶-ð¥Žð¥Ž‚-𥎉𥎊-ð¥Žä‚Š-䂌ð¥Ž-𥎒𥎎𥎓-𥎕𥎖-𥎜ä‚𥎞-𥎠ð¥Žð¥Ž¡-𥎣䂎矡𥎤𥎥矢矣𥎦𥎧矤知𥎨矦-矨𥎩-𥎯𪿈𪿉ä‚ä‚矩𥎰-𥎸䂑䂒矪矫𥎹-ð¥ðª¿Šä‚“矬短𠅰ð¥Ž-ð¥—䂔矮ð¥˜-ð¥©ðª¿‹ä‚•ð¥ª-ð¥±ðª¿Œð¥²-ð¥ºðª¿ðª¿Žð¥»-ð¥¿çŸ¯çŸ°ð¥€-ð¥†ð¥‡-ð¥‹çŸ±ð¥Œ-ð¥çŸ²ðª¿ðª¿ð¥‘ð¥’ð¥ð¥“ð¥”石䂖ð¥•ð¥–䂗矴-矶ð¥—-ð¥œä‚˜ä‚™çŸ·-ç ð¥-ð¥¨ä‚š-䂞泵砂-ç œð¥©-𥑅𪿑-𪿓䂟-䂨ç -ç¡ð¥‘†-𥑲𪿔-𪿘䂩-䂯硂-硛𥑳-𥒩𪿙-ðª¿ä‚°-䂶硜-硷𥒪-𥓉𪿞-𪿣䂷-䃇硸-硽硿-碜碰𥓊-𥓹𪿤-𪿩䃈-äƒç¡¾ç¢-碯碱-碹ç£ð¥“º-𥔬𪿪𪿫䃑-䃗確-磀磂-磙磜磤𥔭-𥕋𪿬-𪿮䃘-䃞䃠磚磛ç£-磣磥-磮𥕌-𥕯𪿯-𪿴䃟䃡-䃨磯-礅𥕰-𥖖𪿵-𪿷䃩-䃯礆-礖ð£žð¥–—-𥖩𪿸-𪿺䃰礗-礡𥖪-𥖺𪿻-𪿽䃱-䃳礢-礬𡕎𥖻-𥗑䃴-䃷礭-礴𥗒-𥗜𪿾䃸䃹礵ð¥—-𥗪礶礷𥗫-𥗳𪿿䃺礸𥗴𥗵𥗷𥗸礹𥗹䃻𥗺-𥗽𥗾-𥘀ð¥˜ð¥˜‚𥘃𥘄⺬-⺮示礻𥘅礼𥘆䃼礽𥘇-𥘌社-祃ð¥˜-𥘔𫀀ð«€äƒ½-䄀祄-祎视鿆𥘕-𥘪𫀂𫀃ä„-䄃ç¥-祢𥘫-ð¥™ð«€„-𫀆䄄-䄆祣-祥祧-祯𥙎-𥙪𫀇-𫀊𫞴䄇-䄊祦祰-祸禄視𣂫𥙫-𥚇𫀋-ð«€ð«žµä„‹-䄒祹-禃禅禆𥚈-𥚥ð«€-𫀙䄓-䄗禇-禙𢿆𥚦-𥛄𫀚𫀛䄘䄙禚-禣𠖟𥛅-𥛗𫀜-𫀟䄚-䄞禤-禦𥛘-𥛭𫀠𫀡䄟禧-禫𥛮-𥜂𫞶䄠䄡禬-禯鿅𥜃-𥜑𫀢䄢禰禱𥜒-𥜙𫀣䄣禲𥜚-𥜟䄤𥜠-𥜤禳禴𥜥-𥜩禵𥜪-𥜯禶禷𥜰-𥜳𥜴𥜵𫀤𥜶-𥜸𧆆𥜹𥜺䄥禸𥜻禹禺𥜼离𥜽禼𥜾禽è¬ð¥œ¿ð¥ð¥‚ð¥ƒð Ž˜ð ¾§ð¥„ð¥…-ð¥‡ð¦¦”𣜢ð¥ˆð¥‰ð«€¥ð¥Šð¥‹ç¦¾ð¥Œð¥-ð¥ð«€¦ä„¦ä„§ç¦¿-秃ð¥-ð¥“䄨-ä„­ç§„-ç§Šð¥”-ð¥¢ð«€§ä„®-䄵秋-ç§—ð¥£-ð¥½ð«€¨ð«€©ä„¶-䄹秘-ç§°ð¥¾-𥞗𫀪-𫀭䄺-ä…Šç§±-秾稆𥞘-𥞱𥟅𫀮-𫀱𫞷䅋-ä…“ç§¿-稅稇-税𠞜𥞲-𥟄𥟆-𥟌𫀲-𫀸䅔-ä…Ÿç¨-稥ð¥Ÿ-𥟼𫀹-𫀻𫞸䅠-䅫稦-稳穊𥟽-𥠰𫀼-ð«€ä…¬-䅶稴-穃𥠱-𥡛ð«-ð«„ä…·-䅽穄-穈穋-穒𥡜-𥢉ð«…ä…¾-䆀穉穓-穞𥢊-𥢳ð«†ä†-䆇穟-穣𥢴-𥣉𥣋-𥣔ð«‡ð«ˆç©¤-穫𥣊𥣕-𥣡𥣣-𥣧䆈䆉穬-穯𥣢𥣨-𥣶𥣸-𥣿ð«‰ä†Š-ä†ð¥¤€-𥤅䆎ä†ç©°ç©³ð¥¤†-𥤉穱𥤊-𥤒穲𥤓𥤕𥤖𥤗-𥤚𥤛-ð¥¤ð¥¤žð¥¤Ÿä†ð¥¤ ð¥¤¡ç©´ð¥¤¢ç©µä†‘究穷𥤣-𥤦𫞹䆒穸-穻𥤧-𥤳䆓-䆖穼-窃𥤴-𥥆ð«Šä†—-䆙窄-窎𥥇-𥥟ð«‹ä†š-䆠çª-窕𥥠-𥥵ð«Œð«ä†¡-䆥窖-çªð¥¥¶-𥦚ð«Ž-ð«ä†¦-䆩窞-窧𥦛-𥦷ð«‘-ð«“䆪䆫窨-窭𥦸-ð¥§ð«”ð«•䆬-䆮窮-窴ð¥§-𥧡𥧣-𥧫ð«–䆯-䆴窵-窽𥧬-𥧻𥧽-𥨋ð«—-ð«šä†µ-䆻窾-竃𥧼𥨌-𥨟𥨩ð«›ä†¼ä†½ç«„竅𥨠-𥨨ð«œä†¾ä†¿ç«†ð¥¨ª-𥨯𥨲䇀竇𥨰𥨱𥨳𥨴𥨶-𥨺竈竉𥨵𥨻-𥩈ä‡ç«Šð¥©‰ð«žºð¥©Šð¥©‹ð«ð¥©Œð¥©ð¥©-𥩑𥩎𥩒𥩓𥩔立䇂竌ç«ð¥©•𥩖𫞻䇃䇄竎ç«ð¥©—𥩘ð«žä‡…䇆ç«-竗𥩙-𥩟ð«Ÿâ»¯ä‡‡-䇊竘-竞𥩠-𥩰ð« ð«¡ä‡‹ç«¡ð¥©±-𥩽ð«¢ð«ž¼ä‡Œä‡ç«¢-竧𥩾-𥪉ð«£ð«¤ä‡Ž-䇑竨-竫𥪊-𥪗ð«¥ð«¦ç«¬ç«­ç«¯ç«°ð¥ª˜-𥪤ð«§ð«¨ð¥ª¥-𥪬ð«©-ð««ä‡’竮竱𥪭𥪮𥪰𥪱ð«¬ä‡“竲-竴𥪯𥪲-𥪹𥪻ð«­ä‡”竵𥪼-ð¥«ð¥«ƒð¥«„䇕𥪺𥫅-𥫇ð«®ç«¶ç«·ð¥«ˆ-ð¥«ð¥«Žð¥«ç«¸ð¥«ð¥«‘ð«¯ð¥«“𥫔𥫒𥫕𥫖竹𥫗𥫘竺竻𥫙-𥫜ð«°ä‡–竼-笃ð¥«-𥫮ð«±ä‡—-ä‡ç¬…-笕𥫯-𥬋ð«²-ð«·ä‡ž-䇦笖-笾𥬌-𥬩𥬿ð«¸-ð«»ä‡§-䇴笄笿-ç­ð¥¬ª-𥬾𥭀-ð¥­ð«¼ð«½ä‡µ-䈀筞-简節ð¥­-𥮌ð«¾-𫂃äˆ-äˆç®-箫ð¥®-ð¥¯ð«‚„-𫂇𫂈𫂉䈎-䈩箬-箿ç¯-篈篊-篓𥯑-𥰎ð¥°-𥰗𫂊-ð«‚𫞽-𫞿䈪-䈷築篔-篯簑簕𥰘-𥱪𥱫-𥱴ð«‚-𫂗䈸-䉇篰-ç°ç°’-簔簖簗𥱵-𥲾𥲿𥳀𥳂-𥳅𥴎𫂘-𫂟䉈-䉎ä‰-䉚䉣簘-ç°²ð¥³ð¥³†-ð¥´ð¥´-𥴗𥴘-𥴠𫂠-𫂤ä‰ä‰›-䉢䉤簳-籂𥴡-𥵛𫂥𫂦䉥籃-ç±ç±•籖𥵜-𥶄𫂧䉦-䉭ç±-籔𥶅-𥶴𫂨-𫂫䉮-䉱籗-籡𥶵-𥷓𫂬䉲-䉴籢-籨𥷔-𥷧𫂭䉶籪𥷨-𥷻𫂮籩籫-籮𥷼-𥸇𫂯䉷籯籰𥸈-ð¥¸ä‰¸ð¥¸-𥸖𥸗𥸚-ð¥¸ð«‚°ð¥¸˜ð¥¸™ð¥¸ž-𥸠䉹籱𥸡𥸢𥸣籲𥸤米𥸥𥸦籴-籶𥸧-𥸪𫂱𫂲䉺娄籷-粂𥸫-𥸲𫂳𫂴䉻䉼粃-粑𥸳-𥹀𫂵-𫂷䉽-䊀畨粒-ç²ç²£ð¥¹-𥹖𥹘𥹙𥹱𫂸-ð«‚¼äŠ-䊆粞-粢粤-粭𥹗𥹚-𥹰𫂽-𫃀䊇-䊌粮-粵糀𥹲-𥺗ð«ƒäŠ-䊒粶-粿ç³ð¥º˜-𥻀𫃂-𫃅䊓-䊙糂-糎ð¡¢ð¥»-𥻣𫃆-𫃈䊚䊛䨀ç³-糘ð¢«ð¥»¤-𥻾𫃉-𫃌䊜-䊢糙-糢糨𥻿-𥼖ð«ƒð«ƒŽð«Ÿ€äŠ£-䊩糣-糧𥼗-𥼵ð«ƒ-𫃑䊪-䊬糩-糭𥼶-𥽎𫃒-𫃕䊭䊮糮-ç³°ð¥½-𥽖𫃖䊯糲𥽗-𥽠𥽢𥽣䊰糱糳糴𥽡𥽤-𥽫𫃗-𫃙䊱䊲糵𥽬-𥽰𥽱-𥽵䊳䊴糶𥽶-𥽺𥽻-𥽿糷𥾀ð¥¾ð¥¾‚𥾃𥾄⺯糸糹糺系䊵糼-糿𥾅-𥾋𫃚𫃛䊶-䊹紀-紉𥾌-𥾘𫃜ð«ƒäŠº-䋇紊-紧𥾙-𥿂𫃞䋈-䋔紨-経𥿃-𥿥𫃟-𫃡䋕-䋞çµ-絚絜-絷𥿦-𦀑𫃢-𫃤䋟-䋦絛絸-ç¶›ç·ð¦€’-ð¦…𫃥-𫃩䋧-䋲綜-ç·ç·‘緒緔緕ð¦†-ð¦¿ð«ƒªð«ƒ«ð«ƒ¬-𫃲䋳-䌄緓緖-縇𦂀-𦂦𦂨-𦂻𦂼-ð¦ƒð«ƒ³-𫃷ð«ŸäŒ…-䌋縈-縨𦂧𦃂-ð¦„𦄃-𦄈𫃸-𫃼䌌-䌕縩-繇繉繊繌ç¹ð¦„‚𦄉-𦄻𫃽-𫄀䌖-䌛繈繎-繥繧繱𦄼-𦅴ð«„-𫄄𫟂䌜-䌢繋繦繨-ç¹°ç¹²-繺𦅵-𦆛𦆥𫄅-𫄋䌣-䌧繻-纃𦆜-𦆣𦆦𦆧𦆩𦆪𦆬-𦆺𫄌-𫄎䌨䌩纄-çºð¦†¤ð¦†¨ð¦†«ð¦†»-ð¦‡ð¦‡ƒ-𦇓ð«„-𫄑䌪-䌭纑纒𦇂𦇔-𦇦𫄒-𫄔䌮纓-纖𦇧-𦇯𫄕䌯-䌲纗𦇰-𦇷𦇹䌳䌴纘-纛𦇸𦇺𦇻𫄖𦇼𦇽𫄗䌵纜çºð¦‡¾-𦈂𫄘𦈃𦈄纞𦈅𦈆𦈇⺰纟𫄙纠䌶纡-纫纶䌸纬-纵纷-纾𫄚-ð«„䌷䌹线-ç»ð¦ˆˆð«„žð«„ŸäŒºäŒ»ç»‘-统𦈉𫄠-𫄣𫟃䌼绠-绨𦈊-𦈌𫄤-𫄩𫟄䌽绩-ç¼ð¦ˆ-ð¦ˆð«„ªð«„«ð«Ÿ…䌾䌿缂-缘𦈑-𦈕𫄬-𫄮𫟆ä€ç¼™-缤𦈖-𦈙𫄯𫄰缥-缫𦈚𫄱-𫄴缬-缯𦈛-ð¦ˆð«„µð«„¶äç¼°-缴𦈞𦈟𫄷𦈠𦈡𫄸𫟇缵𫄹缶𦈢缷ä‚缸𦈣-𦈥äƒç¼¹ç¼ºç¼¼ð¦ˆ¦-𦈨ä„-ä†ä‡äˆä‰ç¼»ç¼½ð¦ˆ©-𦈮äŠç¼¾-罀𦈯-𦈳𦈴-𦈷𫄺ä‹äŒç½ç½‚𦈸-𦉀𫄻ð¦‰-𦉇𫄼𫄽ä罃𦉈-𦉎𫄾罄-罆ð¦‰-𦉔罇-罉𦉕-𦉘罊罋ð¤•𦉙-𦉜𫄿罌ð¦‰ð¦‰žç½ð¦‰Ÿð¦‰ ç½Žç½ð¦‰¡äŽð¦‰¢-𦉤ç½ð¤«¡ð¦‰¥ð¦‰¦ð¦‰§ð¦‰¨ð¦‰©âº±-⺳⺵ä网-罓𦉪𦉫𦉭𦉰𦉯𦉬𦉮𦉱-𦉶ää‘ç½”-罗𦉷-𦊀𫅀ä’-ä”罘-罚ð¦Š-ð¦Šð«…ä•-ä—ç½›-罢𦊎-𦊣𦊥-𦊩𦊳𫅂ä˜ç½£ð¦Šª-𦊲𦊴-𦊻𫅃-ð«……ä™äšç½¤-罦𦊼-𦋄𦋑ä›-äžç½§-置署𦋅-ð¦‹ð¦‹’-𦋜𫅆𫅇äŸç½¯-罱罳罴ð¦‹-𦋩𦋫-𦋮𫅈罵-罸𦋯-𦋼𫅉ä ä¡ç½¹-罼𦋽-𦌑𫅊ä¢ç½½-ç¾ð¦Œ’-𦌞𧷅ä£ç¾‚𦌟-𦌨ð§°ð«…‹ä¤ç¾ƒ-羆𦌪-𦌴𫅌𦌵-𦌺ä¥ð¦Œ»ð¦Œ¼ð«…羇𦌽ä¦ç¾ˆç¾‰ð¦Œ¾-ð¦…ð¦†ð¦‡ð¦ˆ-ð¦Šâº¶-⺸羊ð¦‹-ð¦ç¾‹ç¾Œð¦Ž-ð¦ð«…Žç¾-羑ð¦‘-ð¦–𫟈ä§-ä©ç¾’-羔羖-ç¾™ð¦—-ð¦¤ð¦®äª-ä­ç¾•羚-羟ð¦¥-ð¦­ð¦¯-ð¦¸ð«…-ð«…’ä®-ä°ç¾ -ç¾¢ð¦¹-𦎄𫅓𫅔ä±ç¾£-羪𦎆-𦎖𫅕ä²-ä¶ç¾«ð¦Ž—-𦎡ä·ç¾¬-羰𦎢-𦎮𫅖-ð«…˜ä¸ä¹ç¾±ç¾²ð¦Ž¯-𦎶𫅙äºð¦Ž·-ð¦„ð«…š-ð«…œä»ä¼ç¾³-羵𦌩ð¦…-ð¦”ð«…ð«…žç¾¶-ç¾¹ð¦•-ð¦›ç¾ºð¦œ-ð¦¡ð«…Ÿç¾»ç¾¼ð¡…–ð¦¢-ð¦§ä½ð¦¨ð¦©ð«… ð«…¡ð¦ªð¦«ð¦¬ð¦­ð¦®ð£Œžð¦¯ð¦°ð¦±ç¾½ð¦³ð¦²ç¾¾ç¾¿ð¦´-ð¦ð«…¢ä¾ä¿ç¿€-翆ð¦‚-ð¦”𫅣䎀-䎆翇-ç¿’ð¦•-ð¦¢ð«…¤äއ-䎊翓-翚ð¦£-ð¦·ð«…¥-𫅧䎋-䎎翛-ç¿ð¦¸-𦑄𦑆𫅨𫅩äŽ-䎓翞-翤𦑅𦑇-ð¦‘𦑒-𦑗𫅪翥-翭𦑘-𦑯𦑻𫅫𫅬䎔䎕翮-翱𦑰-𦑺𦑼-𦒂𦒞𫅭𫅮翲-翶翼𦒃-𦒌𫅯䎖-䎘翷-ç¿»ð¦’-𦒛𦒟𫅰𫅱翽翾𦒜ð¦’𦒠𦒡䎙翿耀𦒢-𦒥𦒪𦒫䎚𦒦𦒨𦒩𦒬𦒧𦒭-𦒯𫅲𦒰⺹è€-考𦒱𦒲䎛𦒳-𦒵耄者耆𦒶-𦒹耇-耉𦒺-𦒿𫅳𫅴䎜-䎞耊耋𦓀ð¦“𫅵𦓂𫅶𦓄𦓅𫅷𦓆𦓇𦓃𦓈𦓉𦓊𫅸𦓋𦓌ð¦“而ð¦“𦓎ð¦“𦓑䎟䎠è€-耑䎡𦓒𦓓𦓔𦓕𦓖𦓗𦓘-𦓜ð¦“𦓞𦓟-𦓡𦓢𦓣耒𦓤耓𦓥-𦓧䎢耔𦓨-𦓪耕-耙𦓫䎣耚-耟𦓬-𦓮𫅹耠𦓯-𦓳𫅺𫅻䎤䎥耡耢𦓴-𦓶𫅼䎦-䎪耣-耥𦓷-ð¦”䎫䎬耦耧𦔂-𦔊𫅽耨-耪𦔋-𦔒𫅾䎭-䎯耫耬𦔓-𦔚䎰耭耮𦔛-𦔞𦔠-𦔤𫅿𦔟𦔥-𦔨耯䎱耰𦔩𦔪耱耲𦔫𦔬𦔭耳䎲耴𦔮耵𦔯-𦔶𫆀𫟉耶耷𦔷-𦔻䎳䎴耸-è‚𦔼-ð¦•ð«†äŽµäŽ¶èƒ-èð¦•-𦕟䎷èŽ-è”è ð¦• -𦕢𦕤-𦕴𫆂𫆃䎸䎹è•-è˜ð¦•£ð¦•µ-𦖇𦖗𫆄-𫆆䎺-䎾è™-èŸè¡-è£ð¦–ˆ-𦖖𦖘-𦖡𫆇𫆈䎿ä€è¤-è«ð¥§¢ð¦–¢-𦖻𦗇𫆉ä-äƒè¬è­ð¦–¼-𦗆𦗈-ð¦—𫆊-ð«†ä„-ä‡è¯-è³ð¦—-𦗞𫆎ð«†äˆè®è´-è·ð¦—Ÿ-𦗲ð«†ð«†‘è¸ð¦—³-𦗽𫆒ä‰è¹-è¼ð¦—¾-𦘄𦘅-𦘉äŠè½è¾ð¦˜Š-𦘌ð¦˜ð¦˜Žð¦˜ð¦˜ð¦˜‘𫆓⺺⺻è¿è‚€ð¦˜’𦘓𦘔è‚-肃𦘕-𦘗𦘘-𦘚ä‹è‚„-肆𦘛𦘜𫆔肇肈ð¦˜-𦘟𫆕𦘠-𦘢𦘣𦘤-𦘦𦘧𦘨⺼肉肊äŒäè‚‹-è‚𦘩-𦘳äŽäè‚-肠𦘴-𦘾ä-äè‚¡-èƒð¦˜¿-𦙩𫆖-𫆘äž-ä¥èƒ‚-胬脉𡋜ð£¨ð¦™ª-𦚜𫆙-𫆜ä¦-ä®èƒ­-脈脊-è„”ð£¯ð£°ð¦š-𦛓ð«†ð«†žä¯-ä»è„•-脸𦛔-𦜅𫆟-𫆡㬹ä¼-äŒè„¹-腚𦜆-𦜲𦜴-ð¦’ð¦“-ð¦™ð«†¢-𫆥ä-ä›å¹è…›-è…¾ð¦š-𦞘𦟓𦟔𫆦-𫆨äœ-äªè…¿-膑𦞙-𦟒𦟕-𦟗𫆩-𫆮𫟊ä«-ä´è†’-膣𦟘-𦠂𫆯-𫆴äµ-ä½è†¥-膶𦠃-𦠽𦡄𦡮𫆵-𫆸ä¾-ä‘膷-臌𦠾-𦡃𦡅-ð¦¡ð¦¡-𦡕𦡘-𦡭𦡯𫆹-𫆻䑂-ä‘…è‡-臓𤑃𦡎𦡰-𦢉𫆼𫆽䑆-䑈臔臕臗臘𦢊-𦢤𫆾𫆿䑉䑊臖臙-臜𦢥-𦢷𫇀㔮䑋-䑎è‡ð¦¢¸-𦢾ð«‡ä‘臞臟𦢿-𦣅𫇂臠-臢ð¤“𦣆-ð¦£ð«‡ƒð¦£‘-𦣕𦣖𦣗𦣘-𦣚𦣛𦣜𫇄臣𦣞ð¦£è‡¤è‡¥ð¦£Ÿð¦£ -𦣣𫇅ä‘𦣤𦣥臦𦣦-𦣩𫇆𫇇臧𦣫𦣬𦣮𫇈𦣭𦣯𦣪臨臩𦣰𦣱䑑𦣲𦣳𫇉𦣴𦣵𦣶𦣷𦣸自𦣹臫𦣺-𦣼𦣽𦣾-𦤀臬臭ð¦¤-𦤋𦤌-ð¦¤è‡®-臰ð¦¤-𦤓𫇊𦤔𦤕-𦤗臱𦤘-ð¦¤ð«‡‹è‡²ð¦¤ž-𦤠𦤡-𦤤𦤥𫇌𦤦-𦤪𦤫-𦤮𦤯𦤰𦤱𦤲ð«‡è‡³ð¦¤³ð¦¤´ð¦¤µä‘’致𦤶-𦤸𦤹𦤺𦤻-𦤾臵-臸𦤿𦥀䑓臹ð¦¥ð«‡Žè‡ºð¦¥‚-𦥄ð«‡ð«‡ð¦¥…-𦥇臻𦥉-ð¦¥ð¦¥Žð¦¥ð¦¥ð«‡‘⺽臼𦥑-𦥓𦥔臽臾𦥕𦥖𦥙臿𦥗𦥘𦥚-𦥜𦥧䑔舀èˆð¦¥-𦥤䑕舂𦥥𦥦𦥨-𦥬舃舄𦥭-𦥲𫟋舅𦥳-𦥺䑖與𦥻-𦦄䑗興𦦅-𦦎䑘舆舉ð¦¦-𦦓𦦕-𦦗𦦘-𦦠舊𦦡-𦦧𫇒舋𠤫𦦩-𦦬𦦯𦦭𦦮𦦰-𦦵𦦶-𦦸𦦹𦦺𦦻𤓟𦦼𦦽-𦦿𦧀𫇓ð¦§ð¦§‚𦧃𦧄𦧅𠔻舌𦧆èˆ-èˆð«‡”𦧇䑙䑚èˆð¦§ˆ-ð¦§ä‘›èˆ‘𦧑-𦧔舒𦧕-𦧜ð¦§ð¦§žð«‡•𫇖舓-舕𦧟-𦧦䑜舖舗𦧧-𦧬舘𦧭-𦧰𫇗𦧱-𦧳舙𦧴-𦧶舚𦧷𫇘𦧸𦧹𦧺𫇙𦧻𦧼𦧽舛舜èˆä‘舞𦧾𦧿䑞𦨀ð¦¨ä‘Ÿð¦¨ƒð¦¨‚𦨄𦨅𦨆舟𠂨𦨇䑠舠𦨈-ð¦¨ä‘¡-䑣舡-舤𦨎-𦨔𫇚䑤䑥舥-舱𦨕-𦨠䑦-䑩舲-舻𦨡-𦨮䑪-䑮舼-舿𦨯-𦨲𦨴-𦨼䑯䑰艀-艉𦨳𦨽-𦩉䑱-䑸艊-è‰ð¦©Š-𦩜𨦞𫇛䑹-䑻艎-艔ð¦©-𦩳𦩿𫇜ð«‡ä‘¼-䑾艕-艙𦩴-𦩾𦪀-𦪅䑿-䒅艚-è‰ð¦ª†-ð¦ªð«‡žä’†-䒈艞-艠𦪑-𦪧𫇟艡-艥𦪨-𦪰䒉艦-艩𦪱-𦪵𫇠艪𦪶-𦪸𦪺-𦪼艫𦪽-𦫂𫇡-𫇣艬𦫃𦫄艭𦫅𦫆𦫇𦫉𦫈𦫊艮良艰𦫋𦫌ð¦«ð¦«Žð¦«ð¦«è‰±ð¦«‘𦫒色䒊𦫓艳䒋艴𦫔-𦫙𦫚𦫛-ð¦«è‰µð¦«ž-𦫣𦫤-𦫩䒌ä’𦫪-𦫮𫇤䒎ä’艶𦫯-𦫱ä’艷𦫲⺾-⻀䒑艸艹艺龷𦫳-𦫵䒒-䒔艻-节𦫶-𦬀𫇥𫇦䒕-䒙芃-芗ð¦¬-𦬒𫇧𫇨䒚-䒥芘-芾苀-è‹èŒ¾ð¦¬“-𦬶𫇩-𫇭䒦-䒯芿è‹-茑茓-茕𦬷-𦭦𦭧-𦭬𫇮-𫇵𫟌ð«Ÿä’°-ä“茒茖-茜茞-茢茤-茽茿-è’è”-è¯ð¦­­-𦮃𦮄-𦮵𫇶-𫇾𫟎䓂-䓔䓖èŒèŒ£è°-莬莮-莽鿊𦮶-𦯑𦯒-𦯰𦯲-𦰕𦰗-𦰩𫇿-ð«ˆð«Ÿ-𫟑䓕䓗-ä“­è“莾-è¤è¥-è¨è‘—龿𦯱𦰖𦰪-𦲡𦲢-𦳀ð«ˆ-𫈠䓮-䓻莭è©-è«è­-葖葘-è’ð¦³-𦳌ð¦³-𦴵𦴷-𦵆𦵈-𦵎ð¦µ-𦵠𫈡-𫈵𫟒𫟓䓼-ä”è’-è’·è’¹-蓤蓦𤎀𦵇𦵡-𦵷𦵸-𦷷𦷸-𦷾𫈶-𫉇𫟔䔎-䔬蓥蓧-蔼𦷿-𦸈𦸉-𦸼𦸾-𦺄𫉈-𫉌ð«‰-𫉜𫟕䔭-䕄蔽-蕵𦸽𦺆-𦺳𦺴-𦻆𦻈-𦻽𦻿-𦼨𦽭ð«‰-𫉤𫟖䕅-ä•‘è•¶-薨薪-薬薮龩﨟𦻾𦼩-𦽡𦽢-𦽬𦽮-𦾩𦿡𦿸𫉥-𫉴䕒-ä•è–©è–­è–¯-藓蘤𦾪-𦿓𦿖-𦿜𦿞-𦿠𦿢-𦿷𦿹𦿺𦿻-𧀟𫉵-𫊄䕞-䕥藔-è—­è—¯-藵𦿔𦿕ð¦¿ð§€ -ð§³ð§´-ð§ºð§ƒŒð«Š…-𫊋䕦-䕲藮藶-蘑蘓蘔蘢ð§»-𧃋𧃎𫊌ð«Š-ð«Šä•³-䕷蘒蘕-蘡蘣蘥-蘰ð§ƒð§ƒ-ð§„Œð«Š-𫊓䕸-䕺蘲-蘷鿀ð§„-𧄵𫊔-𫊖䕻-䕽蘱蘸-è™ð§„¶-𧅕𫊗䕾虂-è™…ð§…–-𧅭𫊘-𫊚䕿䖀虆-虉𧅮-ð§…´ð§…¶-ð§…¹ä–ð§…º-𧆅𫊛𫊜䖂-䖄虊𧆇-𧆎䖅䖆𧅵ð§†-𧆒虋虌𧆔𧆕𦺅𧆖𧆚𧆗䖇𧆙𧆓𧆘è™â»ä–ˆè™Žè™ð§†›ä–‰å½ªè™ð§†œ-𧆞ð«Šð«Šžä–Š-ä–虑虓虔𧆟-𧆢𫊟䖎ä–處-虚𧆣-𧆰ä–ä–‘è™›-è™ð§†±-𧆹𫊠𫊡䖒-䖖虞號𧆺-𧇀虠虡ð§‡-𧇎𫊢䖗虢虣ð§‡-𧇛䖘虤-虦𧇜-𧇰䖙虧虨𧇱-𧇺𫊣䖚䖛虩𧇻-ð§ˆð§ˆƒð§ˆ„䖜𧈂𧈅-𧈊𧈋-ð§ˆð§ˆ‘-𧈗𧈘𧈙𧈚𧈛虪𧈜虫ä–虬ð§ˆð§ˆžè™­-虲𧈟-𧈧𫊤䖞-䖠虳-蚃𡯥𧈨-𧈺𫊥𫊦䖡-䖣蚄-蚇蚉-蚪蚬𧈻-ð§‰ð«Š§-𫊫䖤-䖬蚫蚭-è›ï¨¡ð§‰ž-𧊎𫊬-𫊲䖭-䖵蚈è›-蛕蛗-è›´ð§Š-𧊪𧊬𧊭𧊯-𧋇𫊳-𫊼䖶-䖾蛖蛵-蜗蜫è†ð§Š«ð§Š®ð§‹ˆ-ð§‹ð§‹Ÿ-𧌂𧌞𫊽-ð«‹ä–¿-䗊䗕蜘-蜪蜬-è…è‡-è‹ð§‹žð§Œƒ-ð§Œð§ŒŸ-𧌯𧌱-ð§„ð§…-ð§‘ð«‹‚-𫋉䗋-䗔䗖èŒ-è¸èº-螀蟡𧌰ð§’-ð§Žð§Ž‘-ð§Ž ð§‡ð«‹Š-ð«‹Žä——-ä—žè¹èž-螩蟗𧎡-ð§†ð§ˆ-ð§®ð§¯-ð§·ð«‹-ð«‹•ä—Ÿ-䗮螪-蟒è ð¢‹œð§¸-ð§¯ð§±-ð§½ð§¾-𧑃𫋖-𫋙䗯-䗳蟓-蟖蟘-蟠蟢-蟵蠎𧑄-ð§’ð«‹š-ð«‹žä—´-䗻蟶-蠀蠂-è è ð§’Ž-𧓈𫋟-𫋢䗼-ä˜è -蠙𧓉-ð§“°ð«‹£-𫋥𫟗䘂-䘄蠚-蠤蠴𧓱-𧔜𫋦𫋧䘅-䘉蠥-è ¬ð§”-𧕂𫋨䘊-䘌蠭-蠳𧕃-ð§•’ð§•”-ð§•šè µ-蠺𧕓𧕛-ð§•®ä˜è »ð§•¯-𧕼蠼𧕽-𧖃𧖊蠽蠾𧖄-𧖉𧖋-ð§–䘎蠿𧖑-ð§–—ð ‘´ð§–˜-𧖛𫋩𧖜-𧖟𧖡𧖢𧖣𧖤-𧖦血𧖧-ð§–©ä˜è¡è¡‚ð§–ªä˜è¡ƒè¡„ð§–«-𧖯𫋪䘑衅𧖰-𧖲𫋫衆-衉𧖳𧖴䘒𧖵-𧖹䘓𧖺-𧖿𧗄䘔𧗀-𧗃𧗅𧗆-ð§—Šð§—‹-ð§—𫋬𧗎-𧗓𧗔𧗕𧗖𧗗衊𧗘𧗙𧗚𧗛衋𧗜行ð§—-ð§— è¡è¡Žð§—¡-𧗥䘕è¡ð§—¦-ð§—©è¡-衔𧗪𫋭䘖衕-衘𢔬𧗫-𧗱𫋮衙𧗲-𧗷𧗸𧗺𧗻衚-è¡ð§—¹ð§—¼ð§—½ð«‹¯ð«Ÿ˜ä˜—䘘衞-衡𢖅𧗾𢖋𧗿-ð§˜ð«Ÿ™ð§˜‚𧘃𫋰𧘄䘙𢖡𧘅𧘆𫋱衢⻂衣衤𧘇䘚䘛补𧘈-𧘌䘜-䘞衦-衬ð§˜-𧘜䘟-䘡衭-袇ð§˜-𧘼𫋲-𫋴䘢-䘧袈-袮袰𧘽𧘿-ð§™ð«‹µ-𫋷䘨-䘮袯袱-裉𧘾𧙞-𧙿𫋸-𫋼䘯-䘲裊-裥𧚀-𧚣𫋽𫟚䘳-䙂裧-褄𧚤-𧚺𧚼-𧛎𫋾-𫌄䙃-ä™è£¦è¤…-è¤ð§š»ð§›-𧛷𫌅𫌆䙎-䙓褞-褲褴𧛸-𧜜𧜨𫌇-𫌉䙔-ä™è¤³è¤µ-襅襔ð§œ-𧜧𧜩-𧜬𧜮-ð§ð«ŒŠ-ð«Œä™ž-䙣襆-襓襕鿋𧜭ð§‚-ð§°ð«Œ-𫌒䙤䙥襖-襢ð§±-𧞌𫌓𫌔䙦-䙩襣-襨ð§ž-𧞖𧞘-𧞦𫌕䙪襩-襮𧞗𧞧-𧞱𧞳-𧞵𫌖䙫襯-襲𧞲𧞶-𧟂䙬䙭襳襴襽𧟃-𧟇𫌗䙮䙯襵-襷𧟈-𧟋𫌘𫌙䙰襸-襼𧟌-ð§Ÿð§Ÿ-𧟔䙱𧟕-𧟗𧟘𧟙𧟚𧟛𧟜ð§Ÿð§Ÿžð§ŸŸâ»ƒâ»„襾-覀𧟠-𧟢𧟣䙲è¦ð§Ÿ¤-𧟦䙳𧟧-𧟩䙴覂𧟪-𧟬𫌚䙵䙶覃覄𧟭𧟮𫟛覅𧟯𧟰𧟱-𧟸𧟹-𧟻𧟼-𧟾𫌛𧟿覆𧠀ð§ è¦‡è¦ˆð§ ‚𧠃𧠄覉覊𧠅見𧠆𧠇覌覙𧠈䙷䙸è¦è¦Žð§ ‰-ð§ ð«Œœä™¹-ä™»è¦-覔𧠎-𧠛䙼-䙿覕覗覘覚𧠜-ð§ §ð«Œäš€äšè¦›è¦œð§ ¨-𧠺𫌞䚂䚃è¦-覡𧠻-𧡊𫌟𫌠䚄䚅覢-覥𧡋-𧡠𫌡䚆-䚉覦-親𧡡-𧡶𫌢𫌣䚊-䚌覫-覯𧡷-ð§¢äšäšŽè¦°-観𧢂-𧢋𫌤äš-䚓覴-覸𧢌-𧢑覹-覻𧢒-𧢗𫌥䚔覼覽𧢘-𧢛覾覿ð¥„𧢜-𧢡𫟜𧢢-𧢥觀𧢦-𧢫𫌦𫌧䚕𧢬𧢭𧢮䚖𧢯𧢰𧢱⻅è§è§‚觃规觅觇-觉𫌨𫌩觊𫌪觋觌è§è§Žð«Œ«è§è§è§‘𫌬𫌭⻆⻇角𧢲𧢳觓觔𧢴-ð§¢¶ð§¢·-𧢺䚗觕-觙𧢻-ð§£è§šè§›è§è§žð§£‘-𧣠䚘-䚚觜觟-觧𧣡-𧣧𫌮𫌯䚛觨-觫𧣨-𧣳䚜-䚠觬-觯𧣴-𧤊䚡-䚤觰觱𧤋-𧤚𧤢𫌰𫌱䚥䚦觲觳𧤛-𧤡𧤣-𧤮䚧觴鵤𧤯-𧤹䚨䚩䚬觵觶𧤺-𧥃䚪䚫觷-觹𧥄-𧥇觺𧥈-𧥋觻觼𧥌-ð§¥è§½è§¾ð§¥‘𧥒𧥓𧥔䚭觿𧥕𧥖𧥗𧥘𧥙𧥚言è¨ð§¥›ð§¥œð§¥-𧥟䚮-䚰訂-計𧥠䚱䚲訉-訚𧥡-𧥭𫌲𫌳䚳-䛃訛-訳𧥮-𧦛𫌴𫌵䛄-䛓訴-詠𧦜-𧧂𫌶-𫌹䛔-䛜詡-誊誠é¿ð§§ƒ-𧧳𧨜𫌺𫌻ä›-䛨誋-誟誡-誮𧧴-𧨛ð§¨-𧨥𫌼-𫌾䛩-䛸誯-諚諩𧨦-𧩢𫌿ð«€ä›¹-䛽諛-諨諪-謃𧩣-𧪗ð«-ð«…䛾-䜂謄-謢ð œð§ª˜-ð§«‘ð«†-ð«ˆäœƒ-䜊謣-謾𧫒-ð§«½ð«‰-ð«Œäœ‹-䜑謿-譌譎-譜龻𧫾-𧬦ð«-ð«äœ’-䜘è­è­-譲𧬧-ð§­ð«ð«‘䜙-䜞譳-譽𧭂-ð§­ð§­’-ð§­›ð«’䜟-䜡譾-è®…ð§­‘ð§­œ-ð§­·ð«Ÿäœ¢è®†-è®ð§­¸-𧮄ð«“讑-讖𣌚𧮅-ð§®ð«”-ð«–è®—-讙𧮑-𧮘讚讛𧮙-ð§®ð«—讜-讞𧮞-𧮡𧮢-𧮤𧮦𧮧ð«˜è®Ÿð§®¨ð§®©â»ˆè® è®¡-讥讦-è®±ð«™äœ£è®²-诀ð«šð«›ð«Ÿžè¯-诒𧮪ð«œ-ð«¡ð«ŸŸäœ¤è¯“-诩ð«¢-ð«¦è¯ª-诶ð«§-ð«ªäœ¥è¯·-è°Šð««-ð«®ð«Ÿ ð«Ÿ¡è°‹-è°žð«¯-ð«´äœ¦äœ§è°Ÿ-è°§ð«µ-ð«¸ð«Ÿ¢äœ¨è°¨-è°¬ð«¹ð«ºè°­-è°²ð«»ð«¼è°³-è°µð«½ð«¾ð«¿äœ©è°¶è°·ð§®«äœªð«Ž€äœ«è°¸ð§®¬-𧮮谹-谻𧮯-ð§®²ð«Žäœ¬äœ­ð§®³ð§®´è°¼ð§®µ-𧮷䜮谽𧮸𧮹䜯谾𧮺-𧮿𫎂𧯀-𧯅䜰谿-è±ð§¯†-𧯉䜱豂𧯊豃𡓛𧯋-𧯒𧯓𧯔𧯕𧯖䜲豄豅𧯗𧯘𧯙豆䜳𧯚豇豈𧯛-ð§¯äœ´è±‰ð§¯žð§¯Ÿäœµð§¯ -𧯤䜶豊豋𧯥𧯦𧯨䜷-䜹𧯩-𧯬䜺豌-豎𧯭-𧯶𫎃䜻-䜿𧯷-𧯻ä€-ä‚è±ð§¯¼-ð§°‚ð§°ˆè±ð¡•†ð§°ƒ-𧰇𫎄𧰉-ð§°è±‘ð§°‘-ð§°–äƒð§°—𧰘𧰙-ð§°œð§°-ð§°Ÿð§° ä„豒𧰡𧰢豓𧰣𧰤豔𧰥豕𧰧𧰨豖𧰦𫎅𧰩ä…è±—ð§°ª-ð§°­ä†ä‡è±˜-è±ð§°®-𧰴𫎆äˆè±ž-象𧰵-ð§°¾ä‰è±¢-豦𧰿-𧱌豧-豪ð§±-𧱗𫎇𫎈äŠ-äŒð§±˜-ð§±§ääŽè±«-豮𧱨-𧱱𫎉豯-豳𧱲-𧱺ä豴豵𧱻-ð§²ää‘豷𧲂-𧲆豶𧲇-𧲋ä’𧲌-ð§²ä“ð§²-𧲓𧲗𧲔-𧲖𧲘𧲙ä”ä•𧲚-𧲜ð§²ð§²žð§²Ÿè±¸ð§² ð§²¡è±¹-豻𧲢𧲣𫎊ä–-ä™è±¼è±½ð§²¤-𧲫äšä›è±¾-貃𧲬-𧲽貄-貊𧲾-𧳉𫎋äœè²‹-è²ð§³Š-𧳘ääžè²Žè²ð§³™-𧳥𧳱äŸè²-貓𧳦-ð§³°ð§³²-𧳴𫎌ä è²”-è²–ð§³µ-ð§´€ð«Žä¡ä¢è²—-è²™ð§´-ð§´…ð§´‡-ð§´‹ä£-ä¦è²šð§´†ð§´Œ-ð§´ð§´‘-ð§´•ð§´ð§´–-ð§´œð§´ð§´žð§´Ÿð§´ ð§´¡ð§´¢è²›è²œð§´£è²è²ž-è² ð§´¤-𧴩𫎎財-貤𧴪-ð§´²ð«Ž-𫎑ä§ä¨è²¥-貮𧴳-𧵈𫎒𫎓ä©-ä¯è²¯-è³ð§µ‰-𧵢𫎔𫎕ä°-ä²è³‚-賎𣣬𧵣-𧶄𫎖㕢ä³-äµè³-賘𧶅-𧶚𫎗-𫎙ä¶-ä¿è³™-賬𧶛-𧶰𫎚𫎛䞀-䞄賭-賵𠠋𧶱-ð§·„ð§·†-𧷋𫎜-𫎞䞅䞆賶-賽𧷌-ð§·ð«ŽŸð«Ž äž‡è³¾-贀贂-è´…ð§·ž-𧷻𫎡䞈贆-贌𧷼-𧸕𫎢䞉è´-è´ð§¸–-𧸥è´-贔𧸦-𧸰䞊贕-贘𧸱-𧸼𧸿𫎣𫎤䞋贙贚𧸽𧸾𧹀-𧹇𫎥贛𧹈-𧹋贜𧹌ð§¹ð§¹Ž-ð§¹â»‰è´è´ž-贠贡财责-贯𧹑贰-贻𧹒𫎦𫎧䞌贼-赆赇-赊𧹓𫎨äžäžŽèµ‹-赕𧹔-𧹖𫎩äžäžèµ–赗𫎪赘-赛赜𧹗èµ-赠𫎫赡赢𫎬赣赤𧹘𧹙𧹚䞑赥-赧𧹛𧹜ð§¹-𧹟𫎭䞒赨-赪𧹠-𧹢𫎮䞓䞔赫𧹣-𧹦𧹧-𧹫𫎯赬-赮𧹬-𧹱赯𧹲-𧹵𧹶𧹷𫎰𧹸-𧹼䞕𧹽-𧹿𧺀ð§ºð§º‚-𧺅走赱𧺆𧺇赲-赵龪𧺈-𧺎䞖-䞘赶-赸ð§º-𧺜䞙-䞜赹-赿﨣ð§º-𧺵𫎱äž-䞤趀-趋𧺶-ð§»ð«Ž²äž¥-䞪趌-è¶”ð§»-𧻮𫎳𫎴䞫-䞲趕-趚𧻯-ð§¼ð§¼ð«Žµ-𫎷䞳-䞸趛-趤𧼎-𧼜𧼞𧼠-𧼧𫎸-𫎺䞹-䞼趥-趧𧼟𧼨-𧽈𫎻𫎼䞽-䟀趨𧽉-ð§½ð«Ž½äŸ-䟆𧽞-𧽵𫎾𫎿䟇趩-è¶­ð§½¶-𧾌䟈-䟋趮ð§¾-𧾘䟌趯趰𧾙-ð§¾ äŸ-äŸð§¾¡-ð§¾§äŸè¶±ð§¾¨-𧾭䟑𧾮𧾯䟒𧾰-𧾴趲𧾵𧾶⻊足𧾷𧾸𧾹䟓䟔趴𧾺-𧿀䟕䟖趵-趸ð§¿-ð§¿‘ð«€äŸ—-䟞趹-趻趽-è·„ð§¿’-ð§¿±ð«-ð«ƒäŸŸ-䟭跅-跞践𧿲-𨀔ð«„-ð«†äŸ®-䟳趼跟-è·´è·¶-跻𨀕-𨀿ð«‡-ð«‹äŸ´-䟻䟽跼-踎ð¨€-ð¨´ð«Œ-ð«ŽäŸ¼äŸ¾-ä Œè¸-踪踬-踯踺ð¨µ-𨂜𨂟ð«-ð«“ä -䠖踫踰-踹踻-è¹…ð¨‚𨂞𨂠-𨃒ð«”-ð«˜ä —-ä è¹†-蹓𨃓-𨄂𨄄ð«™-ð«›ä ž-䠢蹔-蹧蹮躀𨄃𨄅-𨅉𨅚ð«œ-ð«Ÿä £-䠧蹨-蹭蹯-蹿𨅊-𨅙𨅛-𨆀ð« -ð«¢ð«Ÿ£ä ¨ä ©èº-躉ð¨†-𨆩ð«£-ð«¦ä ªä «èºŠ-èºð¨†ª-𨇀ð«§ð«¨ä ¬èº-躖ð¨‡-𨇕䠭䠮躗-躜𨇖-𨇣ð«©ä ¯èº-躠𨇤-𨇭䠰躡-躥𨇮-𨇺躦躧𨇻-𨈀躩躪ð¨ˆ-𨈃䠱躨𨈄-𨈇𨈈-𨈊𨈋𨈌ð¨ˆð¨ˆŽèº«ð¨ˆ-𨈑𨈒躬𨈓-𨈗躭-躯𨈘-𨈨䠲-䠶躰𨈩-𨈷䠷-䠺躱躲𨈸-𨉇ð«ªð««èº³-躵𨉈-𨉓ð«¬ä »èº¶-躼𨉔-𨉡䠼躽躾𨉢-𨉥𨉧-𨉭䠽䠾躿𨉦𨉮-𨉸ð«­ð«®è»€è»ð¨‰¹-𨉾ð«¯ä ¿è»‚-軅𨉿-𨊌ð«°ä¡€è»†ð¨Š-𨊒ð«±è»‡ð¨Š“-𨊗𨊘-𨊚ä¡ð¨Š›ð¨Šœè»ˆð¨Šð¨Šžð¨ŠŸè»‰è»Šè»‹ä¡‚-䡄軌è»ð¨Š -𨊦䡅軎-軕𨊧-𨊲ð«²ä¡†-䡎軖-軣𨊳-ð¨‹ð«³ä¡-䡒軤-軬軮-軽龫𨋎-𨋧ð«´ð«µä¡“-䡗軭軾-輌𨋨-ð¨Œä¡˜-ä¡›è¼-輕𨌂-𨌟ð«¶-ð«¸ä¡œ-䡟輖-輬𨌠-ð¨†ð«¹ä¡ -䡤輭-è¼¼ð¨‡-ð¨¨ð«ºð«»ä¡¥-䡪輽-è½…ð¨©-𨎉ð«¼ð«½ä¡«-䡱轆-轌鿂𨎊-𨎣ð«¾ð«¿ä¡²-䡵è½-轔𨎤-𨎱ð«€ä¡¶è½•-轚𨎲-ð¨‡ð¨˜¼ð«ä¡·-䡹轛-轟ð¨ˆ-ð¨ð«‚䡺䡻轠-è½¢ð¨‘-ð¨è½£è½¤ð¨ž-ð¨¨ä¡¼ð¨©-ð¨²ð¨³ð¨´ä¡½ð¨µ-ð¨¸ð¨½ä¡¾è½¥ð¨¹ð¨»ð¨¾ð¨ºð¨¼ð¨¿ð¨€ð¨ð¨‚ä¡¿ð¨ƒð«ƒð¨„⻋车轧轨䢀轩-轫ð«„ð«…ä¢è½¬-è½°ð¨…ð¨†ð«†ð«‡ä¢‚è½±-è½»ð¨‡ð«ˆ-ð«Šð«Ÿ¤è½¼-较ð¨ˆð«‹ð«Œè¾„-辆ð«è¾‡-辎ð«Ž-ð«‘è¾-è¾”ð«’ð«“辕-è¾—ð«”𫟥辘ð«•ð«–辙辚ð¨‰ð«—ð«˜ð«Ÿ¦ð«™ð¨Šè¾›ð¨‹ð¨Œð¨ð¨Žð¨-ð¨‘辜è¾ð¨’ð¨“ð«šè¾ž-è¾ ð¨”-ð¨—ð«›ð«œè¾¡-è¾£ð¨˜-ð¨›ä¢ƒè¾¤ð¨œ-ð¨Ÿè¾¥-辪ð¨ -ð¨§è¾«ð¨¨-ð¨¯è¾¬ð¨°-ð¨²è¾­ð¨µ-ð¨¹ä¢„è¾®ð¨º-ð¨¼ð«è¾¯ð¨½ð¨¾ð¨¿ð¨‘€ð¨‘𨑂辰𨑃𨑄辱䢅農𨑅-𨑇䢆䢇辳𨑈𨑉辴𨑊䢈䢉𨑋𨑌⻌-⻎辵辶𠔇辷ð«žè¾¸-è¾½ð¨‘-ð¨‘𫟧䢊䢋巡达-迉𨑑-𨑡ð«Ÿä¢Œ-ä¢è¿Š-迟迬﨤𨑢-ð¨’ð« ð«¡ä¢ä¢‘è¿ -è¿«è¿­-迳𨒂-𨒤ð«¢-ð«¤ä¢’-䢘迴-迷迸迹-逊𨒥-𨓄ð«¥ä¢™-䢛逋-逧𨓅-𨓪ð«¦-ð«ªä¢œ-䢠逨-逻𨓫-ð¨”ð¨”-𨔜𨔠ð««-ð«²ä¢¡é€¼-é—𨔎ð¨”-𨔟𨔡-𨕜ð«³-ð«¹ð«Ÿ¨ð«Ÿ©ä¢¢-䢥é˜-é¥ð¨•-𨖅ð«º-ð«½ä¢¦-䢩é¦-é±é³ð¨–†-𨖳ð«¾-𫑃䢪-䢭é²é´-é¶é·é¸-é¼é‚†ð¨–´-𨗒𨗔-𨗤𫑄-𫑊䢮é½-邅邉𨗥-𨘆𫑋𫟪䢯䢰邇邈𨘇-𨘠𩄮𫑌-ð«‘䢱邊-邌𨘡-𨘶ð«‘ð«‘‘é‚𨘷-𨘻𨘽-ð¨™é‚Žð¨™‚-𨙑𫑒-𫑕𨙒-𨙘𫑖é‚é‚𨙙-𨙞䢲𨙟-𨙣𨙤𨙥𨙦𨙧邑𨙨䢳邒邓𨙩𨙪䢴邔-é‚𨙫-𨙵𫑗䢵-䢷邞-邬𨙶-𨚒𫑘𫑙䢸-䢺邭-邻𨚓-𨚮𫑚𫑛𫟫䢻-䣂邼-郑郓𨚯-𨛊𫑜䣃-䣉郒郔-郧𨛋-𨛪ð«‘-𫑟䣊-ä£éƒ¨-郸𨛫-𨜎𫑠-𫑢𫟬ä£-䣒郹-鄊ð¨œ-𨜖𨜘-𨜱𫑣𫑤𫟭䣓-䣗鄋-鄗𨜗𨜲-ð¨Šð«‘¥ð«‘¦ä£˜-䣜鄘-é„¥ð¨‹-ð¨ªð¨¹ð«‘§-ð«‘©ä£-䣠鄦-鄲ð¨«-ð¨¸ð¨º-ð¨žä£¡é„³-鄷𨞑-𨞦𫑪𫑫䣢鄸鄹𨞧-𨞹𫑬鄺-鄾𨞺-𨟌𫑭鄿酀酂ð¨Ÿ-𨟘𫑮-ð«‘°é…酃𨟙-𨟟酄-酆𨟠-𨟣𫑱酇酈𨟤-𨟧䣣䣤𨟨𨟩-𨟮𨟯𫑲酉䣥䣦酊酋䣧䣨酌-酒𨟰-𨟳𫑳䣩-䣭酓-酞𨟴-𨠊䣮-䣳酟-酥𨠋-𨠣䣴-䣹酦-酱𨠤-𨠶𫑴𫑵𫟮䣺䣻酲-酿𨠷-𨡋𫑶-𫑸䣼-䣿醀-醌𨡌-𨡨𫑹䤀-䤈é†-醗𨡩-𨢄䤉-䤌醘-醤𨢅-𨢠𫑺ä¤é†¥-醬𨢡-𨢼𫑻䤎-䤒醭-醱𨢽-𨣕𫑼𫑽醲-醸𨣖-𨣥䤓䤔醹-醻𨣦-𨣭𫑾䤕䤖𨣮-𨣵醼𨣶-𨣽𫑿䤗䤘醽-釀𨣾-𨤂é‡é‡‚𨤃𨤄釃釄𨤅𨤆釅𨤇-𨤉䤙𨤊-𨤌ð¨¤ð¨¤Žé‡†é‡‡ð¨¤é‡ˆð¨¤ð¨¤‘釉释𫒀𨤒-𨤔𨤕-𨤗𨤘𨤙𤳛𨤚-𨤜ð¨¤é‡‹ð¨¤žð¨¤Ÿð¨¤ ð¨¤¡é‡Œé‡ð«Ÿ¯ð¨¤£ð¨¤¤ä¤šé‡Žð¨¤¢ð¨¤¥ð«’é‡ð¨¤¦-𨤩𫒂𨤪𨤫𨤬𫒃𨤭-𨤯𨤰𨤱𡣢𨤲𨤳𫒄é‡ð¨¤´-𨤷𫒅𥣷𨤸𨤹𨤺𨤻𨤼金釒釓釔䤛釕-釢𨤽-ð¨¥ä¤œé‡£-釼𨥂-𨥉𫒆-ð«’‰ä¤-䤠釽-鈬𨥊-𨥤𫒊-𫒎䤡-䤣鈭-鉴éŠé¾¯ð¨¥¥-ð¨¦ð«’-𫒔䤤-䤪鉵-鉻鉽-銎éŠ-銱𨦂-ð¨¦ð¨¦Ÿ-𨦫𫒕-𫒜𫟰䤫-䤲銲-鋶﨧𨦬-ð¨§ð¨§ž-𨧥ð«’-𫒥䤳-䤶鉼鋷-錧錩-é†éˆé¾¬ï¨¨ð¨§¦-𨨎ð¨¨-𨨮𫒦-𫒯䤷-䤼錨é‡é‰-鎇𨨯-𨩧𨩨-𨪆𫒰-𫒷䤽-䥇鎈-鎨鎪-鎿龲𨪇-𨫃𨫄-𨫎𫒸-𫒾𫟱䥈-䥓鎩é€-é²é¹ð¨«-𨬌𫒿𫓀-𫓃䥔-䥜é³éµ-é¸éº-é¨ð¨¬-𨬔𨬖-ð¨­ð¨­‘-𨭔𫓄-ð«“Žä¥-䥦é´é©-é‘𨬕𨭕-𨮑ð«“-𫓕䥧-䥮鑂-鑔鑧𨮒-𨮷𫓖-𫓚䥯-䥴鑕-鑦𨮸-𨯜𫓛𫓜䥵-䥷鑨-鑬ð¨¯-𨯹ð«“-𫓟䥸鑭-鑳𨯺-𨰈𨰱𫓠-𫓢鑴-鑺𨰉-ð¨°ð«“£é‘»-鑿𨰞-𨰨𫓤钀-钂𨰩-𨰰䥹钃钄𨰲-𨰶𨰷-𨰹𨰺𨰻𨰼𨰽â»é’…钆钇针-钌𫓥𫟲é’-钗𨰾𨰿𫓦𫟳䥺-䥼钘-钯𨱀-𨱂𫓧-𫓫𫟴𫟵䥽-䥿钰-铎𨱃-𨱆𫓬-𫓮𫟶𫟷䦀é“-铷𫓯-𫓴𫟸-𫟻ä¦é“¸-锕𨱇𨱈𫓵-𫓷𫟼锖-锱𨱉-𨱌𫓸-𫓿𫟽锲-镅𨱎𫔀-𫔄𫟾𫟿䦂镆-é••ð¨±ð¨±ð«”…-𫔈𫠀镖-é• ð¨±ð¨±’𫔉𫔊䦃-䦅镡-镫𨱑𨱓𨱔𫔋-ð«”镬-镱𨱕𨱖ð«”𫔑镲𫔒ð« é•³é•´ð«”“镵镶𫔔𫔕䦆⻑⻒長镸𨱗𨱘𨱙䦇镹镺𨱚-𨱥䦈䦉镻𨱦-𨱱䦊𨱲-𨱿𫔖𨲀-𨲆镼𨲇-𨲒𫔗𡑺𨲓-ð¨²ð¨²ž-𨲤䦋𨲥-𨲬镽𨲭-𨲲𨲳-𨲷镾𨲸-𨲺𨲻-𨲿𨳀ð¨³ð¨³‚𨳃𨳄𨳅𨳆⻓长門𨳇𨳈é–閂𨳉𫔘閃-閅𨳊-ð¨³ä¦Œä¦é–†-é–Šð¨³-𨳖𫔙䦎-䦑開-閗𨳗-𨳲𫔚𫔛䦒-䦔閘-閠𨳳-𨴌𫔜-𫔠䦕-䦛閡-é–ªð¨´-𨴦䦜-䦟閫-閴𨴧-𨵇𫔡-𫔤䦠-䦨閵閶閸-闂𨵈-𨵤𫔥-𫔧䦩-䦯閷闃-é—𨵥-𨵿𫔨é—-闘𨶀-𨶛䦰闙-é—𨶜-𨶫𫔩䦱闞-闡𨶬-𨷂䦲-䦴闢-闦𨷃-𨷓𨷕-𨷗𫔪䦵闧𨷔𨷘-𨷞𨷟-𨷥𨷦-𨷮𨷶𨷯-𨷵𨷸𫔫𨷷𨷹𨷺𨷻𨷼𨷽𨷾⻔门闩闪闫-闯𨷿-ð¨¸ð«”¬é—°-闷𨸂𨸃𫔭-𫔯闸闹𫔰𫠂䦶闺-阂𨸄𨸅𫔱䦷阃-阆𫔲𫔳阇-é˜ð«”´ä¦¸é˜‘-阕𨸆-𨸈阖-阙𨸉𨸊𫔵𫔶阚𫔷𫔸𨸋𨸌阛ð¨¸ð«”¹ð¨¸Žâ»â»•⻖阜é˜ð¨¸ä¦¹ä¦ºé˜žé˜Ÿð¨¸-𨸕䦻阠-阤𨸖-𨸙𫔺䦼-䧀阥-阶ð ²ð¨¸š-𨸩𫔻ä§-䧃阷-陉𨸪-𨹀𫔼𫔽䧄-䧈陊-陕ð¨¹-𨹗𫔾-𫕀䧉-ä§é™–-陙陛-险𨹘-𨹳ð«•-𫕃ä§-䧖陚陪-険𨹵-ð¨ºð«•„ð«•…ä§—-䧙陻-éšð¨ºž-𨺿𫕆-ð«•𫠃䧚-ä§Ÿéš‘-隙﨩𨻀-𨻭𫕎ð«•ä§ -䧣隚-隡𨻮-𨼉ð«•-𫕓䧤-䧦䧩隢-隥𨼊-𨼩𫕔-𫕗䧧䧨䧪隦-隫𨼪-𨼾䧫-䧭隬-隲𨼿-𨽌隳ð¨½-𨽕䧮隴𨽖-𨽡𫕘䧯隵𨽢-𨽥䧰𨽦-𨽫𨽬𨽭𨽮𨽯𨽰𨽱𨽲𨽳𨽴𨽵隶𨽶𨽷𨽸-𨽻𫕙隷𨽼-𨽾隸𨽿𨾀ð¨¾ð¨¾‚𨾃𨾄隹䧱隺-难𨾅-𨾇䧲䧳隿雀𨾈-𨾑䧴-ä§¶é›-雈𨾒-𨾟𫕚䧷䧸䧹䧺雉-é›ð¨¾ -𨾱䧻é›-雒𨾲-𨿊𫕛䧼䧽雓𨿋-𨿟䧾䧿雔雕𨿠-𨿾ä¨ä¨‚雖𨿿-𩀖䨃雗-é› ð©€—-𩀣𫕜䨄雡-難𩀤-𩀳䨅-䨇𩀴-ð©†é›¤ð©‡-ð©’䨈ð©“-ð©›ð©œ-ð©¦é›¥é›¦ð©§-ð©«ä¨‰ð©¬-ð©®ð©¯-ð©±é›§ð©²ð©³ä¨Šð©´ð©µâ»—雨ð©¶ð©·ð©¸ð«•䨋雩-雫ð©¹-ð©‚𫕞䨌ä¨é›¬-雳𩂂-𩂑𫕟𫕠䨎雴-雾𩂒-ð©‚¡ð«•¡ð«•¢ä¨-䨖雿-éœð©‚¢-𩂶𫕣𫕤䨗-䨙霂-霊𩂷-𩃑𫕥𫕦䨚-ä¨éœ‹-霗𩃒-𩃴𫕧𫕨䨞-䨤霘-霠𩃵-𩃽𩃿-𩄖𫕩𫕪䨥-䨪霡-霥𩃾𩄗-𩄭𩄯-𩄺𫕫䨫-䨯霦-霭𩄻-𩅜𫕬𫕭䨰䨱霮-霴ð©…-𩅻𫕮-𫕱霵-霻𩅼-ð©†ð«•²ä¨²-䨴霼-é€ð©†‘-𩆣𫕳𫕴䨵䨶é𩆤-𩆬䨷é‚-éˆð©†­-𩆴𫕵𫕶䨸é‰ð©†µ-𩆾éŠð©†¿-𩇇䨹é‹-éŽð©‡ˆð©‡‰é𩇊-𩇎𫕷ð©‡ð©‡ð©‡‘䨺𩇒é𩇓𩇔䨻⻘é‘é’𩇕𫕸é“é”𩇖𩇗é•é–𩇘-𩇛𫕹𫕺é—-é™ð©‡œéšé›éœð©‡ð©‡žð«•»ð©‡Ÿé𩇠𩇡𫕼𩇢𩇣䨼𩇤𩇥éžð©‡¦-𩇨䨽䨾𩇩-𩇬䨿éŸð©‡­-𩇴𩇵𩇶𩇷𫕽䩀é ð©‡¸-𩇻𩇼𩇽é¡ä©ð©‡¾-ð©ˆð«•¾ð«•¿ð©ˆ‚é¢é£ð š‘𩈃-𩈅䩂-䩄𩈆-𩈌䩅-䩇é¤ð©ˆ-𩈘𫖀é¥ð¤Ž‚𩈙-𩈠ð«–䩈䩉é¦ð©ˆ¡-𩈪𫖂䩊𩈫-𩈱𩈲-𩈷𫖃𩈸-𩈺䩋𩈻-𩉀䩌ä©é§ð©‰-𩉉𫖄䩎𩉊𩉋é¨ð©‰Œ-ð©‰ä©ð©‰‘𩉒𩉓𩉔𩉕𩉖-𩉘𩉙𩉚é©éªð©‰›ð©‰œä©-ä©’é«-é±ð©‰-𩉠䩓-䩘é²-é¹ð©‰¡-𩉷䩙-䩞éº-鞆𩉸-ð©Šð«–…𫖆䩟鞇-éž’ð©Š-𩊨𫖇𫖈䩠-ä©§éž“-鞙𩊩-𩊾䩨-䩮鞚-鞡𩊿-𩋞䩯-䩵鞢-éž°ð©‹Ÿ-𩌂䩶-䩻鞱-鞷𥌕𩌃-𩌥䩼-䩾鞸-鞻𩌦-ð©‚𫖉䩿-䪄鞼-éž¿ð©ƒ-ð©’𫖊䪅䪆韀-韃ð©“-ð©¤ð«–‹äª‡äªˆéŸ„韅ð©¥-ð©±äª‰éŸ†-韈ð©²-ð©·äªŠäª‹ð©¸-ð©ºð©¼-ð©¾äªŒäªéŸ‰ð©¿-𩎆䪎𩎇𩎈-𩎊韊𩎋𩎌ð©Žð©ŽŽð©Žð©Žð©Ž‘韋𫖌韌𩎒äªð©Ž“-𩎗ð«–äª-䪓éŸéŸŽð©Ž˜-𩎣éŸ-韑𩎤-𩎮𫠄䪔韒𩎯-𩎷䪕韓-韕𩎸-ð©„𫖎䪖-䪘韖-韚ð©…-ð©Žäª™äªšéŸœ-韟ð©-ð©—韛韠ð©˜-ð©Ÿð«–䪛韡韢ð© -ð©§äªœéŸ£ð©¨-ð©­äªð©®-ð©±éŸ¤éŸ¥ð©²ð©³ð«–ð©´ð©µð©¶-ð©¸ð©¹ð©ºð©»â»™éŸ¦éŸ§ð©¼ð«–‘韨ð©½ð©¾ð«–’韩𫖓韪韫ð©¿ð©€ð« …韬𫖔𫖕𫖖韭䪞韮ð©ð©‚䪟韯ð©ƒéŸ°ð©„䪠韱ð©…-ð©‡ð©ˆäª¡äª¢éŸ²ð©‰ð©Šäª£ð©‹ð©ð©Žäª¤ð©Œð©ð©ð©‘-ð©“䪥ð©”ð©•ð©–音竟章䪦-䪨ð©—䪩韴韵ð©˜ð©™ð«–—䪪韶韷ð©š-ð©ð«–˜ð©ž-ð©¦äª«äª¬éŸ¸ð©§-ð©¬ð©­-ð©°äª­éŸ¹éŸºð©±-ð©´ð«–™äª®äª¯éŸ»éŸ¼ð©µ-ð©¸éŸ½-響ð©¹-ð©¾ð«–šð©¿-ð©‘𫖛䪰𩑂-𩑆頀𩑇𩑈𫖜𩑉𩑊é ð©‘‹é ‚-é „ð©‘Œ-ð©‘䪱䪲項-é ‰ð©‘-𩑘䪳-䪵頊-頓頙𩑙-𩑯ð«–䪶-䪾頔-領頚𩑰-𩒎𫖞䪿-ä«‚é ›-頣頦-é ¬ð©’-𩒭䫃-䫊頤頥頭-頽𩒮-𩓜𫖟𫖠䫋-ä«“é ¿-顊ð©“-ð©“¿ð«–¡ä«”-ä«é ¾é¡‹-顕𩔀-𩔘𫖢𫖣䫞-ä«§é¡–-類𩔙-𩔲𫖤䫨-䫫顟-顣𩔳-𩕈𫖥𫖦䫬-䫱顤-顨𩕉-𩕞𫖧䫲-ä«´é¡©-é¡«ð©•Ÿ-𩕫𫖨顬-顯𩕬-𩕽䫵䫶顰𩕾-𩖅𫖩䫷顱顲𩖆-𩖈𩖉-𩖎顳顴ð©–-𩖑𩖒𩖓⻚页顶顷顸-须𫖪顼-预𫖫𫠆颅-颈𫖬𫖭颉-é¢ð«–®-ð«–±é¢-颖𫖲𫖳颗𩖕𩖖𫖴-𫖶题-é¢ð«–·é¢ž-颡𫖸𫖹颢颣颤𩖗颥颦𫖺颧風䫸𩖘𩖙䫹颩颪𩖚-𩖡䫺-䫽颫颬𩖢-𩖯𩖱-𩖳𫖻䫾-䬃颭-颱𩖴-𩗃𫖼䬄䬅颲颳𠙬𩗄-𩗒䬆-䬊颴颵𩗓-𩗧䬋-ä¬é¢¶é¢·ð©—¨-𩘄𫖽䬑-䬗颸-颺𩘅-ð©˜ð©˜-𩘛𫖾𫖿䬘-䬚颻-飀𩘎𩘜-𩘬𫗀-𫗂䬛䬜é£-飄𩘭-𩘷ä¬é£…-飊𩘸-𩙇飋𩙈-ð©™ð«—ƒð«—„䬞𩙎-ð©™ð«—…䬟𩙑-𩙕𫗆𩙖-𩙚𩙛𩙜飌é£ð©™ð©™žð©™Ÿð©™ ð©™¡ð©™¢ð©™£ð©™¤â»›é£Žé£ð«—‡ð« ‡é£-飒𩙥𩙦𫠈𩙧𫗈飓𩙨-𩙪𫗉飔飖𩙫𩙬𫗊飕飗𩙭𩙮飘飙飚𩙯𩙰𫗋飛𩙱𩙲𩙳𩙴䬠𫗌䬡𩙵𩙶-𩙸𩙹飜𩙺𩙻𩙼𩙽é£ð©™¾â»œé£žâ»-⻟食飠𠋑𩙿-ð©šð©šƒð©š‚䬢飡-飤𩚄-𩚆䬣-䬥飥-飨𩚇-𩚔䬦-䬪飩-飲𩚕-𩚧ð«—䬫-䬴飳-飹飻-飿𩚨-𩛈𫗎䬵-䬻飺餀-é¤ð©›‰-𩛜ð«—-𫗒䬼-ä­‚é¤-餙é¤ð©›-𩛹𫗓䭃-䭇餚-餜餞-餩𩛺-𩜢𩜤-𩜬䭈-ä­é¤ª-餵餷𩜣𩜭-ð©˜ð«—”-ð«——ä­-䭔餶餸-饃ð©™-ð©³ð©µ-ð©¼ð«—˜ä­•-䭗饄-饉ð§ˆð©´ð©½-𩞠𫗙𫗚䭘-䭜饊-饓𡓷𩞡-𩞵𩞷-𩞽𫗛ä­-䭠饔-饙𩞶𩞾-𩟒䉵䭡-䭤饚-饜𩟓-𩟣𫗜ð«—䭥𩟤-𩟬é¥ð©Ÿ­-𩟵䭦䭧饞饟𩟶䭨𩟷-𩟺䭩饠饡𩟻饢𩟼𩟽⻠饣饤饥饦饧𫗞饨-饮𩟾-𩠀𫗟𫗠饯-饴ð© ð© ‚ð«—¡-𫗣饵-饼𩠃𫗤𫗥饽-馂𩠄𩠅𩠇𫗦-𫗨馃-馆𩠆𩠈𩠉𫗩𫗪馇馈馊馋𩠊𩠋𫗫-𫗯馉馌-é¦ð© Œð«—°ð«—±é¦‘馒ð© ð© Žä­ªé¦“馔ð© ð«—²ð«—³ð«—´ð«—µé¦•⻡首ð© é¦—𩠑𩠒𩠓𩠔𩠕-𩠙𫗶䭫䭬𩠚-ð©  ð© ¡-𩠧𫗷馘𩠨𩠩𫗸䭭𩠪-𩠭䭮𩠯𩠱𫗹𩠲𫗺𩠳𩠴𩠵𩠶𩠷𫗻𩠸𩠹香𩠺馚𩠻-𩠽䭯馛-é¦ð© ¾-ð©¡ð©¡ƒð©¡„𩡂𩡅𩡆𫗼𫗽馞-馠𩡇𩡈䭰-䭲馡-馣𩡉-ð©¡‹ð©¡ð«—¾é¦¤é¦¥ð©¡Œ-ð©¡Žð©¡-𩡒𫗿馦馧𩡓-𩡘馨𩡙-𩡜𫘀ð«˜é¦©ð©¡-𩡡𫘂𩡢𩡣𫘃馪𩡤𥗶𩡥䭳馫𩡦𫘄馬𩡧𫠉𩡨䭴馭馮𩡩-𩡯䭵䭶馯-馵𩡰-𩡶𫘅䭷-䭾馶-駇𩡷-𩡾𩢀-𩢅𩢇-𩢌𫘆-𫘉䭿-䮅駈-駠𩡿𩢆ð©¢-𩢭䮆-ä®é§¡-駲𩢮-𩣕𫘊䮎-ä®’é§´-騃𩣖-𩣬𩤷䮓-䮛駳騄-験𩣭-𩤖𩤞𫘋-𫘎䮜-䮢騔-騨𩤗-ð©¤ð©¤Ÿ-𩤶𩤸-𩤼ð«˜-𫘑䮣-䮩騩-騸𩤽-𩥪𫘒-𫘖䮪-䮱騹-驇龭𩥫-ð©¦ä®²-䮶驈-驕𩦂-ð©¦ð«˜—ä®·-䮹驖-驜𩦞-𩦵𫘘䮺-䮼é©-驟𩦶-ð©§ð«˜™ä®½ð©§‚-𩧎䮾驠-é©£ð©§-𩧓䮿驤-驧龮𩧔-𩧗𫘚䯀驨驩𩧘-ð©§žä¯é©ªð©§Ÿð©§ é©«ð©§¡ð©§¢ð©§£ð©§¤ä¯‚𩧥⻢马驭驮-驰𫘛驱-驴𩧦𫘜ð«˜é©µ-骀𩧧-𩧭𩧯𫘞𫘟𫠊䯃éª-骉𩧮𩧰-𩧶𫘠𫘡䯄骊-éªð©§·-𩧺𫘢-𫘤éª-骖𩧻-𩧽𫘥-𫘧骗-骛𩧾-𩨃𩨅-𩨊𫘨𫘩䯅骜-骟𩨄𩨋-ð©¨ð«˜ª-𫘬骠-骢𫘭𫘮𫠋骣𩨎ð©¨ð«˜¯ð«˜°ð« Œéª¤ð©¨éª¥éª¦éª§ð«˜±â»£éª¨ä¯†ä¯‡éª©ð©¨‘-𩨓骪-骮𩨔-𩨛䯈䯉骯-骱𩨜-𩨫䯊-䯎骲-骷𩨬-𩨼ä¯-䯔骸-骼𩨽-𩩈𫘲䯕-䯚骽骾𩩉-𩩖䯛䯜骿-é«ð©©—-𩩬ä¯-䯠髂-é«…ð©©­-𩩿𫘳𫘴䯡髆-髌𩪀-𩪈䯢é«-é«ð©ª‰-𩪖䯣é«ð©ª—-𩪟䯤髑-體𩪠-𩪫䯥髕𩪬-𩪱䯦髖𩪲-𩪶髗𩪷-𩪺𩪻𩪼𩪽𩪾高髙䯧𫘵䯨𩪿𩫀䯩髚ð©«-𩫉髛𩫊-ð©«ð«˜¶ð©«Ž-𩫔𫘷𩫕-𩫙髜𩫚-ð©«ä¯ªð©«žð©«Ÿð©« -𩫤𩫥𩫦䯫é«ð©«§é«žð©«¨-𩫪𩫫𩫬䯬𩫭𩫮𩫯𩫰𩫱𩫲𩫳髟𫘸䯭䯮髠𩫴-𩫸髡髢𩫹-𩫾𫘹𫘺䯯-䯴髣-髪𩫿-ð©¬ð«˜»ä¯µä¯¶é««-髴𩬑-𩬯𫘼䯷䯸髵-髻鬇𩬰-𩭆𫘽䯹-䯼髼-鬂𩭇-ð©­ð«˜¾ð«˜¿ä¯½-䰃鬃-鬆鬈𩭞-𩭹𫙀ð«™ä°„-䰇鬉-é¬ð©­º-ð©®•ð«™‚ä°ˆ-ä°‹é¬-鬓𩮖-𩮮䰌ä°é¬”-鬘é¬ð©®¯-𩯂𫙃䰎鬙-鬜𩯃-𩯚鬞-鬠𩯛-𩯥ä°-䰒鬡鬢𩯦-𩯯䰓䰔鬣𩯰-𩯹䰕𩯺-𩰀鬤ð©°-ð©°„ð©°…-𩰇䰖𩰈𩰉鬥𩰊𩰋𩰌鬦ð©°-ð©°é¬§ð©°é¬¨ð©°‘𩰒鬩𩰓𩰔䰗鬪𩰕䰘𩰖-𩰘鬫𩰙𩰚𩰛鬬鬭𩰜-𩰞鬮𩰟鬯𩰠𩰡𩰢𩰣𩰤𩰥𩰦𩰧𩰨鬰𩰩𩰪鬱鬲𩰫𩰬䰙䰚𩰭𩰮𫙄䰛𩰯𩰰𫙅䰜鬳𩰱-𩰸鬴𩰹-𩰽鬵鬶𩰾-𩱂鬷𩱃-𩱆鬸𩱇-𩱋鬹鬺𩱌-𩱑𫙆ä°é¬»ð©±’-𩱕𩱖-𩱟𩱠-𩱣䰞ð©»ð©±¤ð©±¥ð©±¦-𩱪𩱫𩱬𩱭𩱮𫙇𩱯𩱰𩱱-𩱳𩱴𩱵𩱶𩱷𩱸⻤鬼𩱹-𩱼𫙈鬽𩱽-𩲉䰟鬾-魂𩲊-𩲠𫙉䰠䰡魃-魆𩲡-𩲹䰢䰣魇𩲺-𩳋𫙊魈魉𩳌-𩳡𫙋䰤-ä°§é­Š-é­ð©³¢-𩳴𫙌ð«™ä°¨ä°©ð©³µ-ð©´…ä°ªé­ð©´†-ð©´é­‘-é­”ð©´-𩴛䰫-ä°­é­•é­–ð©´œ-𩴭𫙎䰮𩴮-𩴰䰯䰰魗-魙𩴱-𩴹𩴺-𩴾𩴿𩵀-𩵃𩵄𩵅𩵆𩵇𩵈𩵉𩵊䰱魚𤋳𩵋䰲䰳魛-魞𩵌-𩵓ð«™ä°´-ä°¶é­Ÿ-魢𩵔-𩵟𩶷ð«™ä°·-䰾魣-魹𩵠-𩶀𫙑𫙒䰿-䱉魺-鮘鮣ð©¶-ð©¶ ð«™“-𫙗䱊-䱎鮙-鮢鮤-鮴鮺𩶡-𩶶𩶸-𩷌𫙘-𫙟ä±-䱘鮵-鮹鮻-鯓鯽ð©·-ð©·¶ð«™ -𫙣䱙-䱪鯔-鯵鯻𩷷-𩸽𫙤-𫙧䱫-䱴鯶-鯺鯼鯾-鰛鰠𩸾-𩹰𫙨-𫙪䱵-䱽鰜-é°Ÿé°¡-鰰𩹱-𩺬𫙫-𫙯ð« ä±¾-䲈鰱-鱈鷠𩺭-ð©»—ð«™°-𫙶䲉-ä²é±‰-鱛𩻘-ð©¼ð«™·-ð«™¼ä²-䲕鱜-鱧鱩-鱫𩼂-𩼤𫙽-ð«šð« Žä²–-䲘鱨鱬-鱰𩼥-𩼺𫚂𫚃䲙鱱-鱶𩼻-𩽌𫚄䲚䲛鱷鱸ð©½-𩽙𩽚-𩽦𫚅鱹𩽧-𩽯鱺𩽰-𩽲𫚆𩽳𩽴𩽵-𩽸𫚇鱻䲜⻥鱼鱽鱾𫚈-𫚊ä²é±¿-鲃𩽹-𩽻𫚋-ð«šð« ä²žä²Ÿé²„-é²ð©¾€ð«šŽ-𫚒ð« é²‘-鲟𩽼-𩽿𫚓-𫚘鲠-鲬ð©¾-𩾄𩾉𫚙-𫚛鲭-鲻𩾅-𩾈𫚜-𫚡䲠䲡鲼鲽鲿-鳋𩾊𩾋𫚢-𫚥𫠑䲢-䲤鲾鳌-鳒𫚦鳓-鳛𩾌𫚧𫚨𫠒鳜-鳟𫚩𫚪鳠-é³£ð©¾ð«š«é³¤ð«š¬ð©¾Žð«š­é³¥ð« “鳦ð©¾-𩾑𫚮䲥鳧-鳰𩾒-𩾜䲦-䲫鳱-é³¶ð©¾-𩾯䲬-䲸鳷-鴉鴋-鴎𩾰-𩿛𫚯-𫚲䲹-䳊鴊é´-鴬𩿜-𪀑𫚳-𫚷𫠔䳋-䳔鴭-鵉𪀒-ðª‰ð«š¸-𫚻䳕-䳜鵊-鵣鵥ðªŠ-ðª¶ð«š¼-𫛀ä³-䳥鵦-é¶é¶‘ðª·-𪂵ð«›-𫛈䳦-ä³°é¶é¶’-鶫𪂶-𪃹𫛉-ð«›‹ä³±-䳶鶬-é·Šé·Œ-é·ðªƒº-𪄬𫛌-ð«›ä³·-䳽鷋é·-鷟𪄭-𪅮ð«›ð« •ä³¾-䴆鷡-鷸鷺-鷼𪅯-𪆫𪆭𫛑-ð«›•ä´‡-䴋鷹鷽-鸊𪆬𪆮-ðª‡ð«›–ä´Œä´é¸‹-鸒𪇑-ðª‡ðª‡Ÿ-𪇬𫛗䴎鸓鸔𪇭-𪈂𫛘ä´é¸•-鸗𪈃-𪈗鸘-鸚𪈘-𪈤鸛鸜𪈥-𪈭é¸é¸žð§– ðªˆ®-𪈳𫛙ä´ð©–”𪈴-𪈷𪈸-𪈺𪈻-𪈽䴑䴒𪈾𪈿𪉀⻦鸟鸠鸡鸢-鸤䴓鸥-鸩ðª‰-𪉃𫛚-𫛞𫠖鸪-鸶𪉄𫛟-𫛤䴔䴕鸷-鸿𪉅-𪉋𫛥-𫛪鹀-鹈𪉌ðª‰ð«›«-𫛯䴖鹉-鹔𪉎𫛰-𫛵䴗鹕-é¹—é¹™-鹜ðª‰ðª‰ð«›¶-𫛼䴘鹘é¹-鹤𪉑-𪉔𫛽𫛾鹥-鹨𫛿-𫜂鹩-鹬𫜃𫜄䴙鹭-鹰𫜅鹱鹲𫜆𪉕鹳鹴鹵𠧸𪉖𪉗䴚鹶𪉘-𪉛鹷𪉜-𪉡𪉢𫜇䴛𪉣-𪉥𫜈鹸𪉦-𪉬鹹𪉭-𪉴𫜉䴜鹺鹻𪉵-𪉹𪉺-𪉾ä´ðª‰¿-𪊂鹼鹽𪊃-𪊅䴞𪊆𪊇𪊈𪊉𪊊𫠗鹾𫜊鹿𢉖麀-麂𪊋𪊌𫜋䴟ðªŠðªŠŽä´ -䴢麃麄ðªŠ-𪊚𫜌䴣-䴥麅-麈𪊛-𪊤麉-麋𪊥-𪊳ð«œä´¦éºŒ-éºðªŠ´-𪋃𫜎䴧麑-麗𪋄-ðª‹éº˜-麛𪋎-𪋖䴨麜éºðª‹—-𪋛䴩麞𪋜-𪋠麟𪋡-𪋩ð«œä´ªä´«éº ðª‹ª-𪋭麡𪋮-𪋴𪋵麢𪋶𪋷𪋸麣𪋹麤𪋺𪋻麥𪋼-𪌀䴬-䴮麧ðªŒ-𪌄䴯䴰麨-麫𪌅-𪌓䴱-䴴麬-麮𪌔-𪌚𪌜-𪌡䴵麯麰𪌢-𪌬䴶-䴸麱麲𪌭-𪌻䴹-䴽麳麴𪌼-ðª‹ð«œéºµðªŒ-ðªšä´¾-äµ€ðª›-ðª¢äµäµ‚䵅麶ðª£-ðª±äµƒðª²-ðª·äµ„ðª¸-ðª¾äµ†ðª¿ðªŽ€ðªŽðªŽ‚𪎃-𪎅麷𪎆𪎇⻨麦ðªŽðªŽˆéº¸ðªŽ‰ðªŽŠð«œ‘𪎋𫜒𪎌𫜓麹𪎎ðªŽð«œ”麺𫜕ðªŽéº»ðªŽ‘麼麽𪎒-𪎔䵇麾𪎕-𪎚𪎛-𪎟𪎠-𪎢𫜖麿𪎣𪎤黀𪎥-𪎧𫜗䵈䵉é»ðªŽ¨ðªŽ©ðªŽªðªŽ«ðªŽ¬ðªŽ­-𪎯黂𪎰𪎱𪎲⻩黃黄𪎳𪎴䵊黅黆𪎵-𪎹𫜘黇-黉𪎺䵋黊黋𪎻-ðªäµŒðª‚-ðª…äµðª†-ðª’䵎ðª“-ðª˜ðª™-ðªžäµðªŸ-ðª£äµðª¤-ðª¦é»Œðª§-ðª©ðªªðª«ðª¬é»ðª­äµ‘黎ðª®ðª¯äµ’䵓ðª°-ðªµé»ðª¶-ðª¾ðª¿ðª€ðªäµ”-äµ–ðª‚-ðª†äµ—-äµ™ðª‡-ðªŠäµšé»ðª‹äµ›ðªŒ-ðªðªäµœðª’ðª‘ðª“ðª”-ðª–黑黒ðª—äµðª˜äµžðª™-ðª›äµŸäµ å¢¨é»“ðªœ-ðª£äµ¡é»”-默ðª¤-ðª±äµ¢äµ£é»š-點ðª²-ðª¾äµ¤-䵧黟-黡ðª¿-𪑇䵨䵩黢黣𢖛𪑈-𪑑䵪-䵬黤-黪𪑒-𪑢𪑤𫜙𫜚䵭-䵯黫-黯𪑣𪑥-𪑽𫜛黰黱𪑾-𪒎䵰黲-é»´ðª’-𪒗䵱𪒘-𪒨䵲-䵴黵𪒩-𪒳䵵黶𪒴-𪒸黷𪒹-𪒾黸𪒿-𪓂𪓃𪓄𪓅𪓆𪓇𪓈𪓉𪓊黹黺𫜜黻𪓋黼𪓌ðª“-ðª“ðª“黽𪓑𪓒𪓓黿𪓔-𪓙䵶鼀-鼂𪓚-𪓠䵷鼃鼄𪓡-𪓦ð«œðª“§-𪓫鼅𪓬𪓭䵸𪓮-𪓶鼆鼇𪓷𪓸䵹𪓹鼈鼉𪓺𪓽𫜞鼊𪓼𪓾𪓿𪔀ðª”⻪黾鼋鼌𫜟é¼é¼Žðª”‚é¼-鼑𪔃䵺鼒𪔄-𪔆𫜠𪔇𪔈𪔉𫜡䵻䵼𪔊鼓鼔𡔷𪔋𪔌𡒡ðª”-ðª”äµ½-䵿鼕鼖ðª”-𪔓䶀鼗𪔔-𪔛𪔜-𪔡ä¶é¼˜-鼛𪔢-𪔥𪔦-𪔭鼜𪔮é¼é¼žðª”¯-𪔲鼟𥀻𪇞𪔳𪔴𥀼𪔵𪔶𥀽𪔷𥀾鼠鼡𫜢𪔸𪔹䶂𪔺-𪔼䶃鼢-鼤𪔽-𪕈䶄鼥-鼬𪕉-𪕑𫠘䶅鼭𪕒-𪕙𪕟鼮-鼰𪕚-𪕞𪕠-𪕧䶆鼱𪕨-𪕪䶇鼲-鼵𪕫-𪕴䶈䶉鼶-鼹𪕵-𪕾𪖀-𪖄𪖅-𪖉𫜣𪖊𪖋鼺𪖌ðª–𪖎ðª–é¼»ðª–鼼鼽𪖑𪖒鼾鼿𪖓𪖔䶊䶋𪖕-𪖙𫜤䶌齀é½ðª–š-𪖠ä¶ä¶Žðª–¡-𪖤ä¶ðª–¥-𪖬齂𪖭𪖮齃齄𪖯-𪖲齅齆𪕿𪖳-𪖵齇𪖶-𪖺𪖻-𪖽ä¶é½ˆðª–¾-𪗀䶑ðª—𪗂𪗃齉齊𪗄𪗅䶒䶓齋𪗆齌𠆜𪗇𪗈é½ðª—‰ðª—Šðª—‹ðª—Œé½Žðª—Žðª—é½ðª—-𪗑𪗒𪗓⻬é½é½‘齒𣦋齓齔𪗔-𪗗䶔齕𪗘-𪗚䶕䶖齖-齘𪗛-𪗤𫠙䶗-䶙齙-齣𠎜𪗥-𪗶䶚䶛齤-齩𪗷-ðª˜ð«œ¥ä¶œä¶é½ª-齬𪘎-𪘤𫜦䶞䶟齭-齱𪘥-𪘸䶠-䶢齲-齷𪘹-𪙈𫠛䶣䶤齸-齻𪙉-𪙙䶥䶦𪙚-𪙢䶧𪙣-𪙯𫜧䶨齼齽𪙰-𪙵䶩䶪𪙶𪙷-𪙼𪙽-𪚀ðªš-𪚄𪚅𪚆-𪚉䶫齾𪚊𪚋𪚌ðªšðªšŽâ»®é½¿é¾€é¾é¾‚𫜨龃-龆𫠚龇龈ðªšð«œ©ð«œªé¾‰é¾Šð«œ«ðªšð«œ¬ð«œ­ð« œé¾‹é¾Œð«œ®ð«œ¯ð«œ°é¾é¾Žé¾ðªš‘-𪚔龑𪚕-𪚘𪚚𪚛龒𪚙䶬龓-龕𪚜-𪚟𪚠𪚡𫜱𪚢𪚣𪚤龖龗龘𪚥⻰龙䶭䶮龚龛𫜲⻱龜𪚦𪛉𪚨䶯𪚩𪚪䶰𪚫-𪚵䶱䶲é¾ðªš§ðªš¶-𪚽𪚾𪚿𪛀𪓻ðª›ðª›‚-𪛄龞𪛅𪛆ð« ðª›‡ðª›ˆé¾Ÿð«œ³é¾ ä¶³é¾¡ðª›Šé¾¢ä¶´é¾£ðª›‹-ðª›é¾¤é¾¥ðª›Ž-𪛑䶵𪛒𪛓𫜴𪛔𪛕𪛖 &'('一')'<<<㈠ &'('七')'<<<㈦ &'('三')'<<<㈢ &'('ä¹')'<<<㈨ &'('二')'<<<㈡ &'('五')'<<<㈤ &'('代')'<<<㈹ &'('ä¼')'<<<㈽ &'('休')'<<<㉠&'('å…«')'<<<㈧ &'('å…­')'<<<㈥ &'('労')'<<<㈸ &'('å')'<<<㈩ &'('å”')'<<<㈿ &'('å')'<<<㈴ &'('呼')'<<<㈺ &'('å››')'<<<㈣ &'('土')'<<<㈯ &'('å­¦')'<<<㈻ &'('æ—¥')'<<<㈰ &'('月')'<<<㈪ &'('有')'<<<㈲ &'('木')'<<<㈭ &'('æ ª')'<<<㈱ &'('æ°´')'<<<㈬ &'('ç«')'<<<㈫ &'('特')'<<<㈵ &'('監')'<<<㈼ &'('社')'<<<㈳ &'('ç¥')'<<<㈷ &'('祭')'<<<㉀ &'('自')'<<<㉂ &'('至')'<<<㉃ &'('財')'<<<㈶ &'('資')'<<<㈾ &'('金')'<<<㈮ &0点<<<㘠&10æ—¥<<<ã© &10月<<<㋉ &10点<<<㢠&11æ—¥<<<㪠&11月<<<㋊ &11点<<<㣠&12æ—¥<<<ã« &12月<<<ã‹‹ &12点<<<㤠&13æ—¥<<<㬠&13点<<<㥠&14æ—¥<<<ã­ &14点<<<㦠&15æ—¥<<<ã® &15点<<<ã§ &16æ—¥<<<㯠&16点<<<㨠&17æ—¥<<<ã° &17点<<<ã© &18æ—¥<<<ã± &18点<<<㪠&19æ—¥<<<ã² &19点<<<ã« &1æ—¥<<<ã  &1月<<<ã‹€ &1点<<<ã™ &20æ—¥<<<ã³ &20点<<<㬠&21æ—¥<<<ã´ &21点<<<ã­ &22æ—¥<<<ãµ &22点<<<ã® &23æ—¥<<<ã¶ &23点<<<㯠&24æ—¥<<<ã· &24点<<<ã° &25æ—¥<<<㸠&26æ—¥<<<ã¹ &27æ—¥<<<㺠&28æ—¥<<<ã» &29æ—¥<<<ã¼ &2æ—¥<<<ã¡ &2月<<<ã‹ &2点<<<ãš &30æ—¥<<<ã½ &31æ—¥<<<ã¾ &3æ—¥<<<㢠&3月<<<ã‹‚ &3点<<<ã› &4æ—¥<<<㣠&4月<<<㋃ &4点<<<㜠&5æ—¥<<<㤠&5月<<<ã‹„ &5点<<<ã &6æ—¥<<<㥠&6月<<<ã‹… &6点<<<ãž &7æ—¥<<<㦠&7月<<<㋆ &7点<<<㟠&8æ—¥<<<ã§ &8月<<<㋇ &8点<<<ã  &9æ—¥<<<㨠&9月<<<㋈ &9点<<<ã¡ &〔三〕<<<🉠&〔二〕<<<🉂 &〔å‹ã€•<<<🉇 &〔安〕<<<🉃 &〔打〕<<<🉅 &〔敗〕<<<🉈 &〔本〕<<<🉀 &〔点〕<<<🉄 &〔盗〕<<<🉆 &一<<<â¼€ &一<<<㆒ &一<<<㊀ &一<<<🈩 &ä¸<<<㆜ &七<<<㊆ &三<<<㆔ &三<<<㊂ &三<<<🈪 &上<<<㆖ &上<<<㊤ &下<<<㆘ &下<<<㊦ &丙<<<㆛ &丨<<<â¼ &中<<<㆗ &中<<<㊥ &中<<<🈭 &丶<<<⼂ &丿<<<⼃ &ä¹™<<<⼄ &ä¹™<<<㆚ &ä¹<<<㊈ &亅<<<â¼… &二<<<⼆ &二<<<㆓ &二<<<㊠&二<<<🈔 &五<<<㊄ &亠<<<⼇ &交<<<🈘 &人<<<⼈ &人<<<㆟ &ä¼<<<㊭ &休<<<㊡ &優<<<㊠&å„¿<<<⼉ &å…¥<<<⼊ &å…«<<<⼋ &å…«<<<㊇ &å…­<<<㊅ &冂<<<⼌ &å†<<<🈞 &冖<<<â¼ &写<<<㊢ &冫<<<⼎ &几<<<â¼ &凵<<<â¼ &刀<<<⼑ &åˆ<<<🈠 &å‰<<<🈜 &割<<<🈹 &力<<<â¼’ &労<<<㊘ &勹<<<⼓ &匕<<<â¼” &匚<<<⼕ &匸<<<â¼– &医<<<㊩ &å<<<â¼— &å<<<〸 &å<<<㊉ &å„<<<〹 &å…<<<〺 &å”<<<㊯ &åœ<<<⼘ &å©<<<â¼™ &å°<<<㊞ &厂<<<⼚ &厶<<<â¼› &åˆ<<<⼜ &åŒ<<<🈒 &å£<<<â¼ &å¯<<<🉑 &å³<<<㊨ &å³<<<🈮 &åˆ<<<🈴 &å<<<㊔ &å¹<<<🈥 &å•<<<㉄ &å–¶<<<🈺 &å›—<<<⼞ &å››<<<㆕ &å››<<<㊃ &土<<<⼟ &土<<<㊠&地<<<㆞ &士<<<â¼  &声<<<🈤 &夂<<<⼡ &夊<<<â¼¢ &夕<<<â¼£ &多<<<🈕 &夜<<<㊰ &大<<<⼤ &大正<<<ã½ &天<<<ㆠ&天<<<🈗 &女<<<â¼¥ &女<<<㊛ &å­<<<⼦ &å­—<<<🈑 &å­¦<<<㊫ &宀<<<â¼§ &å®—<<<㊪ &寸<<<⼨ &å°<<<⼩ &å°¢<<<⼪ &å°¸<<<⼫ &å±®<<<⼬ &å±±<<<â¼­ &å·›<<<â¼® &å·¥<<<⼯ &å·¦<<<㊧ &å·¦<<<🈬 &å·±<<<â¼° &å·¾<<<â¼± &å¹²<<<â¼² &å¹³æˆ<<<ã» &幺<<<â¼³ &å¹¼<<<㉅ &广<<<â¼´ &å»´<<<â¼µ &廾<<<â¼¶ &弋<<<â¼· &弓<<<⼸ &å½<<<â¼¹ &彡<<<⼺ &å½³<<<â¼» &後<<<🈠&å¾—<<<🉠&心<<<â¼¼ &戈<<<â¼½ &戶<<<â¼¾ &手<<<⼿ &手<<<🈠&打<<<🈱 &投<<<🈧 &指<<<🈯 &æ•<<<🈨 &支<<<â½€ &æ”´<<<â½ &æ–‡<<<⽂ &æ–‡<<<㉆ &æ–—<<<⽃ &æ–™<<<🈛 &æ–¤<<<⽄ &æ–°<<<🈟 &æ–¹<<<â½… &æ— <<<⽆ &æ—¥<<<⽇ &æ—¥<<<㊠&明治<<<ã¾ &映<<<🈙 &昭和<<<ã¼ &æ›°<<<⽈ &月<<<⽉ &月<<<㊊ &月<<<🈷 &有<<<㊒ &有<<<🈶 &木<<<⽊ &木<<<㊠&æ ª<<<㊑ &æ ªå¼ä¼šç¤¾<<<ã¿ &欠<<<⽋ &æ­¢<<<⽌ &æ­£<<<㊣ &æ­¹<<<â½ &殳<<<⽎ &毋<<<â½ &æ¯<<<⺟ &比<<<â½ &毛<<<⽑ &æ°<<<â½’ &æ°”<<<⽓ &æ°´<<<â½” &æ°´<<<㊌ &注<<<㊟ &満<<<🈵 &æ¼”<<<🈦 &ç«<<<⽕ &ç«<<<㊋ &ç„¡<<<🈚 &爪<<<â½– &父<<<â½— &爻<<<⽘ &爿<<<â½™ &片<<<⽚ &牙<<<â½› &牛<<<⽜ &特<<<㊕ &犬<<<â½ &玄<<<⽞ &玉<<<⽟ &瓜<<<â½  &瓦<<<⽡ &甘<<<â½¢ &生<<<â½£ &生<<<🈢 &用<<<⽤ &ç”°<<<â½¥ &甲<<<㆙ &申<<<🈸 &ç”·<<<㊚ &ç–‹<<<⽦ &ç–’<<<â½§ &ç™¶<<<⽨ &白<<<⽩ &çš®<<<⽪ &çš¿<<<⽫ &監<<<㊬ &ç›®<<<⽬ &矛<<<â½­ &矢<<<â½® &石<<<⽯ &示<<<â½° &社<<<㊓ &ç¥<<<㊗ &ç¦<<<🈲 &禸<<<â½± &禾<<<â½² &秘<<<㊙ &ç©´<<<â½³ &空<<<🈳 &ç«‹<<<â½´ &竹<<<â½µ &ç®<<<㉇ &ç±³<<<â½¶ &糸<<<â½· &終<<<🈡 &ç¼¶<<<⽸ &网<<<â½¹ &羊<<<⽺ &ç¾½<<<â½» &è€<<<â½¼ &而<<<â½½ &耒<<<â½¾ &耳<<<⽿ &è¿<<<â¾€ &肉<<<â¾ &臣<<<⾂ &自<<<⾃ &至<<<⾄ &臼<<<â¾… &舌<<<⾆ &舛<<<⾇ &舟<<<⾈ &艮<<<⾉ &色<<<⾊ &艸<<<⾋ &è™<<<⾌ &虫<<<â¾ &è¡€<<<⾎ &行<<<â¾ &è¡£<<<â¾ &襾<<<⾑ &見<<<â¾’ &è§’<<<⾓ &è§£<<<🈖 &言<<<â¾” &è°·<<<⾕ &豆<<<â¾– &豕<<<â¾— &豸<<<⾘ &è²<<<â¾™ &財<<<㊖ &販<<<🈣 &資<<<㊮ &赤<<<⾚ &èµ°<<<â¾› &èµ°<<<🈰 &è¶³<<<⾜ &身<<<â¾ &車<<<⾞ &è¾›<<<⾟ &è¾°<<<â¾  &è¾µ<<<⾡ &éŠ<<<🈫 &é©<<<㊜ &é‚‘<<<â¾¢ &é…‰<<<â¾£ &釆<<<⾤ &里<<<â¾¥ &金<<<⾦ &金<<<㊎ &é•·<<<â¾§ &é–€<<<⾨ &阜<<<⾩ &éš¶<<<⾪ &éš¹<<<⾫ &雨<<<⾬ &é‘<<<â¾­ &éž<<<â¾® &é¢<<<⾯ &é©<<<â¾° &韋<<<â¾± &韭<<<â¾² &音<<<â¾³ &é <<<â¾´ &é …<<<㊠ &風<<<â¾µ &飛<<<â¾¶ &食<<<â¾· &首<<<⾸ &香<<<â¾¹ &馬<<<⾺ &骨<<<â¾» &高<<<â¾¼ &髟<<<â¾½ &鬥<<<â¾¾ &鬯<<<⾿ &鬲<<<â¿€ &鬼<<<â¿ &é­š<<<â¿‚ &é³¥<<<⿃ &é¹µ<<<â¿„ &鹿<<<â¿… &麥<<<⿆ &麻<<<⿇ &黃<<<⿈ &é»<<<⿉ &黑<<<⿊ &黹<<<â¿‹ &黽<<<⿌ &鼎<<<â¿ &鼓<<<⿎ &é¼ <<<â¿ &é¼»<<<â¿ &齊<<<â¿‘ &é½’<<<â¿’ &é¾<<<â¿“ &龜<<<â¿” &龟<<<⻳ &é¾ <<<â¿• PyICU-1.5/test/lohit_hi.ttf0000644000076500000240000023711411634256064016034 0ustar vajdastaff00000000000000FFTMNOj§>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.5/test/noms.txt0000644000076500000240000000006110413621043015203 0ustar vajdastaff00000000000000école enfant faon fille demain Dominique ÉlevéPyICU-1.5/test/test_BreakIterator.py0000644000076500000240000000451212062167164017655 0ustar vajdastaff00000000000000# ==================================================================== # 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.5/test/test_Charset.py0000644000076500000240000000500212062167164016503 0ustar vajdastaff00000000000000# ==================================================================== # 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.5/test/test_Collator.py0000644000076500000240000001272712062167236016705 0ustar vajdastaff00000000000000# ==================================================================== # 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, codecs 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.assertLess(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): f = codecs.open(self.filePath("collation-rules.txt"), 'r', 'utf-8') rulelines = f.readlines() f.close() rules = UnicodeString("".join(rulelines)); collator = RuleBasedCollator(rules) self.setupCollator(collator) return collator def LoadCollatorFromBinaryBuffer(self, bin): collator = RuleBasedCollator(bin, RuleBasedCollator("")) self.setupCollator(collator) return collator def testCollatorLoading(self): if ICU_VERSION >= '4.6': collator = self.LoadCollatorFromRules() key0 = collator.getSortKey(u'\u3069\u3052\u3056') bin = collator.cloneBinary() collator = self.LoadCollatorFromBinaryBuffer(bin) key1 = collator.getSortKey(u'\u3069\u3052\u3056') self.assertTrue(key0 == key1) if __name__ == "__main__": main() PyICU-1.5/test/test_LayoutEngine.py0000644000076500000240000000737512062167164017534 0ustar vajdastaff00000000000000# -*- 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: from fontTools.ttLib import TTFont except ImportError, e: print >>sys.stderr, "\nfontTools package not found, skipping LayoutEngine tests\n" 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: import fontTools except ImportError: 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: import fontTools except ImportError: pass else: main() PyICU-1.5/test/test_MessageFormat.py0000644000076500000240000000744612062167164017665 0ustar vajdastaff00000000000000# -*- 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,)): # 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.5/test/test_Normalizer.py0000644000076500000240000000357412062167164017250 0ustar vajdastaff00000000000000# -*- 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.5/test/test_Transliterator.py0000644000076500000240000000751612062167164020143 0ustar vajdastaff00000000000000# -*- 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 TestTransliterator(TestCase): def testTransliterate(self): trans = Transliterator.createInstance('Accents-Any', UTransDirection.FORWARD) 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', UTransDirection.FORWARD) 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", UTransDirection.FORWARD) 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.5/test/test_UCS4.py0000644000076500000240000000364512062167164015643 0ustar vajdastaff00000000000000# ==================================================================== # 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.5/test/test_UDate.py0000644000076500000240000000362211526550376016127 0ustar vajdastaff00000000000000# ==================================================================== # 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.5/transliterator.cpp0000644000076500000240000005162212016244323016304 0ustar vajdastaff00000000000000/* ==================================================================== * Copyright (c) 2009-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 "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 char *kwnames[] = { "contextStart", "contextLimit", "start", "limit", NULL }; int contextStart = 0, contextLimit = 0, start = 0, limit = 0; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|iiii", 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[] = { {"contextLimit", (getter) t_utransposition_getContextLimit, (setter) t_utransposition_setContextLimit, "Ending index, exclusive, of the context to be considered for a transliteration operation.", NULL}, {"contextStart", (getter) t_utransposition_getContextStart, (setter) t_utransposition_setContextStart, "Beginning index, inclusive, of the context to be considered for a transliteration operation.", NULL}, {"limit", (getter) t_utransposition_getLimit, (setter) t_utransposition_setLimit, "Ending index, exclusive, of the text to be transliterated.", NULL}, {"start", (getter) t_utransposition_getStart, (setter) t_utransposition_setStart, "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; if (!parseArgs(args, "Si", &u, &_u, &direction)) { STATUS_CALL(transliterator = Transliterator::createInstance(*u, direction, status)); return wrap_Transliterator(transliterator); } 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; if (!parseArgs(args, "SSi", &u0, &_u0, &u1, &_u1, &direction)) { STATUS_PARSER_CALL(transliterator = Transliterator::createFromRules(*u0, *u1, direction, parseError, status)); return wrap_Transliterator(transliterator); } 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.5/transliterator.h0000644000076500000240000000537011450411421015744 0ustar vajdastaff00000000000000/* ==================================================================== * 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.5/tzinfo.cpp0000644000076500000240000005513511660066761014557 0ustar vajdastaff00000000000000/* ==================================================================== * 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 "datetime.h" #include "bases.h" #include "calendar.h" #include "tzinfo.h" #include "macros.h" /* 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 int 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[] = { { "timezone", (getter) t_tzinfo__getTimezone, NULL, "timezone property", NULL }, { "tzid", (getter) t_tzinfo__getTZID, NULL, "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 int 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[] = { { "tzinfo", T_OBJECT, offsetof(t_floatingtz, tzinfo), 0, "" }, { 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[] = { { "timezone", (getter) t_floatingtz__getTimezone, NULL, "timezone property", NULL }, { "tzid", (getter) t_floatingtz__getTZID, NULL, "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 int t_tzinfo_hash(t_tzinfo *self) { PyObject *str = PyObject_Str((PyObject *) self->tz); int hash = PyObject_Hash(str); Py_DECREF(str); return hash; } static int 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 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.5/tzinfo.h0000644000076500000240000000254711660066753014224 0ustar vajdastaff00000000000000/* ==================================================================== * 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.5/unicodeset.cpp0000644000076500000240000013472511621003626015377 0ustar vajdastaff00000000000000/* ==================================================================== * 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 "unicodeset.h" #include "macros.h" DECLARE_CONSTANTS_TYPE(UMatchDegree); DECLARE_CONSTANTS_TYPE(UProperty); 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 int t_unicodeset_hash(t_unicodeset *self) { return 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(UProperty, 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(UProperty, "ALPHABETIC", UCHAR_ALPHABETIC); INSTALL_ENUM(UProperty, "BINARY_START", UCHAR_BINARY_START); 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, "DEPRECATED", UCHAR_DEPRECATED); 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); 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); 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, "ISO_COMMENT", UCHAR_ISO_COMMENT); 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, "UNICODE_1_NAME", UCHAR_UNICODE_1_NAME); INSTALL_ENUM(UProperty, "UPPERCASE_MAPPING", UCHAR_UPPERCASE_MAPPING); INSTALL_ENUM(UProperty, "STRING_LIMIT", UCHAR_STRING_LIMIT); INSTALL_ENUM(UProperty, "INVALID_CODE", UCHAR_INVALID_CODE); 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.5/unicodeset.h0000644000076500000240000000304711353227537015047 0ustar vajdastaff00000000000000/* ==================================================================== * 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 */