././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1573605241.8449998 PyICU-2.4.2/0000755000076500000000000000000000000000000012654 5ustar00vajdawheel00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1573605177.0 PyICU-2.4.2/CHANGES0000644000076500000000000004001100000000000013643 0ustar00vajdawheel00000000000000Version 2.4.1 -> 2.4.2 ---------------------- - fixed build issues with ICU < 59 Version 2.4 -> 2.4.1 -------------------- - added missing header files to MANIFEST.in Version 2.3.1 -> 2.4 -------------------- - workedaround mystery variations in test_Script.testSurrogatePairs - added support for RuleBasedBreakIterator.getBinaryRules() - added support for RuleBasedBreakIterator(binaryRules) - added wrappers for LocaleBuilder - added workaround for MSVC++ compiler issue (kochelmonster) - added support for ICU 65.1 - added wrappers for DecimalFormat.get|setMultiplierScale() - added wrapper for Locale.createUnicodeKeywords() - added wrappers for new MeasureUnit static factory methods - added wrappers for LocaleMatcher - added wrappers for LocaleMatcher::Builder as LocaleMatcher.Builder - added wrappers for LocaleMatcher::Result as LocaleMatcher.Result - added support for constructing Locale objects from keywords - locale.addLikelySubtags() and minimizeSubtags() now modify locale in place - added wrappers for BytesTrie, BytesTrie.Builder|Iterator|State - added wrappers for UCharsTrie, UCharsTrie.Builder|Iterator|State - added wrappers for GenderInfo - added support for implementing a subclass of Replaceable in Python - added support for using PythonReplaceable with Transliterator methods Version 2.3 -> 2.3.1 -------------------- - fixed build error with ICU 61, ICU 62 Version 2.2 -> 2.3 ------------------ - added support for also trying pkg-config for build configuration (Linux) - fixed compilation issue in collator.cpp when not using c++11 (and icu < 60) - added support for ICU 64.1 - filled out wrappers for missing NumberFormatter methods and classes Version 2.1 -> 2.2 ------------------ - added wrappers for AlphabeticIndex and ImmutableIndex - added wrapper for NumberingSystem - added wrapper for UGraphemeClusterBreak enum - added wrapper for UHangulSyllableType enum - added wrappers for Edits and Edits::Iterator and Edits support with CaseMap - added support for ICU 63.1 - added wrappers for Locale::to|fromLanguageTag - added wrappers for UIndicPositionalCategory, UIndicSyllabicCategory enums - added wrapper for UVerticalOrientation enum Version 2.0.6 -> 2.1 -------------------- - added wrapper for ULineBreak enum - fixed crasher with pypy3 6.0 Version 2.0.5 -> 2.0.6 ---------------------- - fixed another build error with ICU < 62 Version 2.0.4 -> 2.0.5 ---------------------- - fixed build error with ICU < 62 - added casemap.h to MANIFEST.in Version 2.0.3 -> 2.0.4 ---------------------- - added support for ICU 62.1 - added support for CaseMap (without Edits) Version 2.0.2 -> 2.0.3 ---------------------- - added wrappers for Region class and URegionType enum - added wrappers for MeasureFormat.formatMeasure and formatMeasurePerUnit - fixed build errors with ICU 59.1 - replaced occurrences of nullptr with NULL, -std=c++11 req'd w/only ICU >= 60 Version 2.0.1 -> 2.0.2 ---------------------- - fixed build error with ICU < 53 Version 2.0 -> 2.0.1 -------------------- - made Measure wrapper abstract when building with ICU < 53.1 - str(Measure) uses NumberFormatter when available Version 1.9.8 -> 2.0 -------------------- - use icu-config for configuring compiler and linker (Constantine Peresypkin) - added wrappers for UBidiPairedBracketType enum - added wrappers for UWordBreakValues enum - added wrappers for UJoiningGroup enum - added wrappers for 120+ MeasureUnit static factory methods - added wrapper for NoUnit class - added wrapper for TimeUnit class - added missing Measure constructor(Formattable or number, MeasureUnit) - added wrappers for NumberFormatter and related classes and enums, and tests - added wrapper for SimpleFormatter and tests - fixed bugs in test_LocaleData.py using undefined values (Fredrik Roubert) - added wrapper for UMemory and made it UObject's base - removed unused docs.py Version 1.9.7 -> 1.9.8 ---------------------- - fixed bugs in "UnicodeString as sequence"; it's a sequence of 16-bit UChar - added support for ICU 60.1 Version 1.9.6 -> 1.9.7 ---------------------- - fixed bug in setup.py with Python 3 when ICU_VERSION obtained from env - added workaround for https://gcc.gnu.org/bugzilla/show_bug.cgi?id=54249 - added support for ICU 59.1 Version 1.9.5 -> 1.9.6 ---------------------- - turned icu into a package and moved docs.py into it - fixed a bunch of warnings about missing int/int32_t casts - added reduced version of missing in < 2.7 check_output() used in setup.py - added wrapper for MessageFormat::getFormatNames() - added check for ICU_VERSION env variable before calling icu-config - added wrappers for static Normalizer2 constructors that appeared in ICU 49 - hopefully workedaround 'daylight' #define on Windows Version 1.9.4 -> 1.9.5 ---------------------- - added icu-config --version check in setup.py to exclude libicule from libs - fixed bug with Python3.3+ <-> UnicodeString conversion with surrogate pairs - reworked Python3.3+ <-> UnicodeString with no allocations (Markus Scherer) - fixed bugs with 32bit Python2..Python3.2 <-> UnicodeString conversions - added conditionals around uses of features in newer ICUs (Keegan Parker) Version 1.9.3 -> 1.9.4 ---------------------- - added wrappers for uloc_addLikelySubtags(), uloc_minimizeSubtags() on Locale - fixed bug in some script.cpp wrappers not accepting surrogate pairs - added wrapper for UnicodeString.countChar32() and test - fixed crasher due to ICUException not incref'ing members during copy - added support for ICU 58.1 (conditionally removed layout engine wrapper) - fixed bug in StringCharacterIterator's dealloc freeing random memory - reworked Python <-> Unicode conversions for Python 3.3+ to use new APIs Version 1.9.2 -> 1.9.3 ---------------------- - added missing conditionals around uses of features in newer ICU versions - added wrappers for TimeZone::getIDForWindowsID, TimeZone::getWindowsID - added wrappers for DateTimePatternGenerator - added missing Context and BooleanAttribute wrappers on DateFormat - added support for ICU 57.1 - build tested with Python 2.7.5, Python 3.5.1 and PyPy 2.2.1 Version 1.9 -> 1.9.2 -------------------- - added MANIFEST.in to ensure nothing's missing in the 'sdist' package - enabled -Wwrite-strings and fixed warnings - added missing conditionals around uses of features in newer ICU versions Version 1.8 -> 1.9 ------------------ - fixed utf-8 conversion error position reporting (bug 13113) - fixed delete/delete[] bug in common.cpp (Fredrik Roubert) - added support for ICU 54.1 - added wrapper for USpoofChecker and related enums - added support for ICU 55.1 - replaced UnicodeString idna methods with new uidna.h UTS #46 wrapper (55.1) - added wrapper for Char functions and related enums (from uchar.h) - added wrapper for Shape defines and shapeArabic() (from ushape.h) - added wrapper for RelativeDateTimeFormatter (bug 13115) - build tested with Python 2.7.5, Python 3.3.0 and PyPy 2.2.1 Version 1.7 -> 1.8 ------------------ - added wrapper for Locale::getRoot() - added tp_hash implementation for Locale type based on Locale::hashCode() - fixed bug 13112 (Markus Scherer) - added support for building with PyPy (tested on PyPy 2.2.1 / Python 2.7.3) - added Locale(lcid) constructor calling uloc_getLocaleForLCID() - added wrapper for CompactDecimalFormat and its createInstance() method Version 1.6 -> 1.7 ------------------ - added missing #include for - fixed issues building against ICU 4.2 - added wrapper for Script.isRightToLeft() (bug 13081) - added support for ICU 53.1 (bug 13110) - added wrappers for other Script functions introduced in ICU 51 Version 1.5 -> 1.6 ------------------ - removed wrappers for some layoutengine.cpp internal flags (bug 13074) - added wrappers for ULocaleData functions (bug 13080) - added wrappers for uscript functions and UScriptCode enum (bug 13081) - generalized freebsd setup.py support (Laurence Parry) - added support for ICU 52.1 - added wrapper for Locale::setKeywordValue() - added Locale::removeKeywordValue() - added support for ListFormatter - build tested with Python 2.7 and Python 3.3.0 Version 1.4 -> 1.5 ------------------ - added wrapper for MessageFormat::format(argumentNames, arguments, ...) - fixed bug in t_transliterator_filteredTransliterate passing UBool for int - added wrapper for DateFormat::format(Calendar) - added wrapper for Calendar::set(UCalendarDateFields field, value) - added wrappers for UnicodeString::toTitle() w/o iterator (Fredrik Roubert) - added support for ICU 50.1 - improved test_Collator's testGetSortKey() (Markus Scherer) - added pypi classifiers to PyICU project info, including Python 3 tag - build tested with Python 2.7 and Python 3.3.0 Version 1.3 -> 1.4 ------------------ - fixed bug with default tzinfo set on ICUtzinfo type (bug 13038) - fixed bug 13040 (Martin Hosken) - added wrapper for Transliterator::toRules() - added missing wrapper for RuleBasedNumberFormat(URBNFRuleSetTag, Locale) - added support for ICU 49.1.1 - implemented wrapper for new NumberFormat.parseCurrency() - fixed bug in CurrencyAmount.str() not calling correct getDouble() overload - added ScriptCode constants new in 49.0 Version 1.2 -> 1.3 ------------------ - fixed bug 13031 - PyICU ready for Python 3.2 (tests pass 2to3'd) (Martin von Gagern) - added auto-conversion of test sources for Python 3 during setup - added support for LEFontInstance and LayoutEngine (Martin Hosken, bug 13035) - fixed bugs in RegexMatcher and RegexPattern not keeping their inputs - added support for ICU 4.8.1.1 Version 1.1 -> 1.2 ------------------ - fixed bug 13009 (Martin von Gagern) - fixed bug 13011 (Martin von Gagern) - some unit test beautification (Martin von Gagern) - added macros for RTTI checks (Martin von Gagern) - fixed bug 13012 - fixed bug 13013 (Yuriy Pilgun) - added wrappers for Locale::isBogus()/setToBogus() (Jimmy Yuen Ho Wong) - fixed bug 13022 (Martin von Gagern) - added support for ICU 4.8 Version 1.0 -> 1.1 ------------------ - added support for ICU 4.6 - switched to using RTTI if ICU >= 4.6 instead of poor man's ICU RTTI - fixed bug with incorrect icu.VERSION string on Windows build Version 1.0 -> 1.0.1 -------------------- - removed variable length array uses in regex.cpp (Chandler Carruth) - fixed bug 12983 - fixed bug with BreakIterator.setText() not keeping reference to text - fixed incorrect conditional include in locale.cpp (Ralf Haring) - fixed incorrect spellings of PyErr_SetFromWindowsErrWithFilename (ditto) - fixed incorrect declaration of PythonTransliterator (Christian Heimes) Version 0.9 -> 1.0 ------------------ - added support for UnicodeSet, UnicodeFunctor, UnicodeFilter, UnicodeMatcher - added support for RegexPattern and RegexMatcher - added support for Normalizer - added support for UTransPosition (Christoph Burgmer) - added support for UTransPosition and UnicodeFilter methods to Transliterator - fixed bug in UnicodeString single character assignment method - added support for extending Transliterator from Python (Christoph Burgmer) - improved support for in-place operations on UnicodeStrings - added support for Transliterator::registerInstance (Christoph Burgmer) - added support for ICU 4.4 - added support for Normalizer2, FilteredNormalizer2 if ICU version >= 4.4 - added support for SelectFormat if ICU version >= 4.4 - added support for TimeUnitFormat if ICU version >= 4.2 - added support for PluralRules and PluralFormat if ICU version >= 4.0 - added support for DateInterval, DateIntervalFormat if ICU version >= 4.0 - added support for CurrencyPluralInfo if ICU version >= 4.2 - added support for UnicodeSetIterator and UnicodeSet iterates via it - added support for SearchIterator and StringSearch - added some missing Collator and RuleBasedCollator methods - refreshed README and CREDITS - fixed bugs with UnicodeString-converted text arg ownership in iterators - added missing conditionals for features in ICU versions >= 4.0 - README now marked-up with reStructuredText (Christoph Burgmer) - PyICU main module renamed to 'icu' (with deprecation warning for old name) - UnicodeString objects are now hashable - reviewed all wrapped ICU setters for parameter ownership - removed symbol prefixes from wrapped typed enums symbols - added ResourceBundle.setAppData() implementation that memory maps file Version 0.8 -> 0.9 ------------------ - fixed 64-bit random crasher bug in registerType()/isInstance() - fixed bug 11548 - added entries for freebsd7 to setup.py (Jan Gehring) - added support for building on Solaris (Christian Kesselheim) - added missing wrapper for Collator.getSortKey() - added support for built-in Transliterators (bug 12870) - removed support for ICU internal URES_TABLE32 ResourceBundle type - added support for TimeZone::getDSTSavings() (Jimmy Yuen Ho Wong) - added support for ICU 4.2 - refreshed README Version 0.6 -> 0.8 ------------------ - ICUtzinfo and FloatingTZ types now written in C for faster performance - fixed bug 8180 - fixed bug 9229 - reworked FloatingTZ to optionally wrap a specific tzinfo instead of default - incorporated c++ patches by Fredrik Roubert - changed Exact unicode and string check to allow subclasses - replaced Makefile with setup.py for distutils-based build (Bernd Zeimetz) - PyICU supported with ICU 3.6 or 3.8 - PyICU supported on 64-bit processors (bug 11394) Version 0.5 -> 0.6 ------------------ - integrated patch to support Python 2.3 and MSVC 6 - changed naive datetime to UDate conversion to use ICUtzinfo.default - fixed bug not checking return value of PyImport_ImportModule - PyICU now wraps ICU 3.6 - added support for building with Python 2.5 - added support for CharsetDetector and CharsetMatch C ICU APIs - added UnicodeString.encode() to access compression and conversion APIs - added support for IDNA APIs to UnicodeString - added support for MessageFormat(string) %(objs) style formatting - fixed bug in Formattable constructor not accepting a python unicode string - added support for BreakIterator::DONE - added support for BreakIterator::getText() - added support for BreakIterator::nextBoundary() to bypass iterator code Version 0.4 -> 0.5 ------------------ - changed OS X linking to resolve all symbols at link time - Collator.getCollationKey() wasn't working - added Collator.getCollationKey(string) overload - using u_strFromUTF32() now to convert 4 byte unicode to 2 byte unicode - improved support for Python 2.3 - PyICU no longer uses SWIG, wrappers are written by hand - all APIs returning UnicodeString now return 'unicode' - all APIs returning UnicodeString also take a UnicodeString arg to return it Version 0.3 -> 0.4 ------------------ - PyICU now wraps ICU 3.4 - added Calendar.getType(), changed Calendar.__repr__() - added Locale.createKeywords(), Locale.getKeywordValue() - moved Locale to locale.i and added support for ResourceBundle - replaced TimeZone.adoptDefault() with TimeZone.getDefault() Version 0.2 -> 0.3 ------------------ - added support for CanonicalIterator, CollationElementIterator - added static formatMessage() method on MessageFormat - added static encoding helper methods to UnicodeString - reworked PyString_AsUnicodeString() to report decode errors by default - added support for Collator, RuleBasedCollator and CollationKey - added test_Collator unit tests - added test_MessageFormat unit tests - fixed various MessageFormat bugs - fixed bug in ICUtzinfo, now returning copy of ICU TimeZone instance - fixed bug in TimeZone.adoptDefault() not checking type of pointer - added __eq__, __ne__ and __hash__ methods to ICUtzinfo - MessageFormat.getFormats() now returns copies of concrete formats Version 0.1 -> 0.2 ------------------ - added most missing UnicodeString methods - added support for the BreakIterator and CharacterIterator classes Version 0.0 -> 0.1 ------------------ - initial release ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1429154135.0 PyICU-2.4.2/CREDITS0000644000076500000000000000153300000000000013676 0ustar00vajdawheel00000000000000 PyICU is a Python extension wrapping IBM's ICU library and wouldn't be possible without the tireless efforts of the people and open source projects below. - the ICU developers, http://icu-project.org - the Open Source Applications Foundation, for hosting the project http://www.osafoundation.org - Andi Vajda, PyICU project founder and maintainer - Christoph Burgmer for the Transliterator Python subclass - Jan Gehring for Freebsd 7 build entries - Christian Kesselheim for Solaris build entries - Jimmy Yuen Ho Wong for TimeZone::getDSTSavings() - Bernd Zeimetz for replacing Makefile with setup.py - Martin von Gagern, Python 3 support, bug fixes - Fredrik Roubert for various bug fixes (see CHANGES) - Markus Scherer for various bug fixes (see CHANGES) - Martin Hosken for bug fixes (see CHANGES) - Thank you all ! ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1143939619.0 PyICU-2.4.2/LICENSE0000644000076500000000000000240400000000000013661 0ustar00vajdawheel00000000000000/* ==================================================================== * 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. * ==================================================================== */ ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1573510664.0 PyICU-2.4.2/MANIFEST.in0000644000076500000000000000102300000000000014406 0ustar00vajdawheel00000000000000include README.md include bases.h include calendar.h include casemap.h include char.h include charset.h include collator.h include common.h include dateformat.h include errors.h include format.h include gender.h include idna.h include iterators.h include layoutengine.h include locale.h include macros.h include measureunit.h include normalizer.h include numberformat.h include regex.h include script.h include search.h include shape.h include spoof.h include transliterator.h include tries.h include tzinfo.h include unicodeset.h ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1573605241.8455305 PyICU-2.4.2/PKG-INFO0000644000076500000000000002475400000000000013765 0ustar00vajdawheel00000000000000Metadata-Version: 2.1 Name: PyICU Version: 2.4.2 Summary: Python extension wrapping the ICU C++ API Home-page: https://github.com/ovalhub/pyicu Author: Andi Vajda Author-email: github@ovaltofu.org License: MIT Description: # README file for PyICU ## Welcome Welcome to PyICU, a Python extension wrapping the ICU C++ libraries. ICU stands for "International Components for Unicode". These are the i18n libraries of the Unicode Consortium. They implement much of the Unicode Standard, many of its companion Unicode Technical Standards, and much of Unicode CLDR. The PyICU source code is hosted on GitHub at https://github.com/ovalhub/pyicu. The ICU homepage is http://site.icu-project.org/ See also the CLDR homepage at http://cldr.unicode.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 icu-config program is available or that the ``INCLUDES``, ``LFLAGS``, ``CFLAGS`` and ``LIBRARIES`` dictionaries in ``setup.py`` contain correct values for your platform. Starting with ICU 60, -std=c++11 must appear in your CFLAGS. - ``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, the ``utf-8`` encoding is assumed when converting them to ``UnicodeString`` objects. To convert a Python ``str`` encoded in an encoding other than ``utf-8`` to an ICU ``UnicodeString`` use the ``UnicodeString(str, encodingName)`` constructor. ICU's C++ APIs accept and return ``UnicodeString`` arguments in several ways: by value, by pointer or by reference. When an ICU C++ API is documented to accept a ``UnicodeString`` reference parameter, it is safe to assume that there are several corresponding PyICU python APIs making it accessible in simpler ways: For example, the ``'UnicodeString &Locale::getDisplayName(UnicodeString &)'`` API, documented at http://icu-project.org/apiref/icu4c/classLocale.html can be invoked from Python in several ways: 1. The ICU way >>> from icu import UnicodeString, Locale >>> locale = Locale('pt_BR') >>> string = UnicodeString() >>> name = locale.getDisplayName(string) >>> name >>> name is string True <-- string arg was returned, modified in place 2. The Python way >>> from icu import Locale >>> locale = Locale('pt_BR') >>> name = locale.getDisplayName() >>> name u'Portuguese (Brazil)' A ``UnicodeString`` object was allocated and converted to a Python ``unicode`` object. A UnicodeString can be coerced to a Python unicode string with Python's ``unicode()`` constructor. The usual ``len()``, ``str()``, comparison, ``[]`` and ``[:]`` operators are all available, with the additional twists that slicing is not read-only and that ``+=`` is also available since a UnicodeString is mutable. For example: >>> name = locale.getDisplayName() u'Portuguese (Brazil)' >>> name = UnicodeString(name) >>> name >>> unicode(name) u'Portuguese (Brazil)' >>> len(name) 19 >>> str(name) <-- works when chars fit with default encoding 'Portuguese (Brazil)' >>> name[3] u't' >>> name[12:18] >>> name[12:18] = 'the country of Brasil' >>> name >>> name += ' oh joy' >>> name ### error reporting The C++ ICU library does not use C++ exceptions to report errors. ICU C++ APIs return errors via a ``UErrorCode`` reference argument. All such APIs are wrapped by Python APIs that omit this argument and throw an ``ICUError`` Python exception instead. The same is true for ICU APIs taking both a ``ParseError`` and a ``UErrorCode``, they are both to be omitted. For example, the ``'UnicodeString &DateFormat::format(const Formattable &, UnicodeString &, UErrorCode &)'`` API, documented at http://icu-project.org/apiref/icu4c/classDateFormat.html is invoked from Python with: >>> from icu import DateFormat, Formattable >>> df = DateFormat.createInstance() >>> df >>> f = Formattable(940284258.0, Formattable.kIsDate) >>> df.format(f) u'10/18/99 3:04 PM' Of course, the simpler ``'UnicodeString &DateFormat::format(UDate, UnicodeString &)'`` documented here: http://icu-project.org/apiref/icu4c/classDateFormat.html can be used too: >>> from icu import DateFormat >>> df = DateFormat.createInstance() >>> df >>> df.format(940284258.0) u'10/18/99 3:04 PM' ### dates ICU uses a double floating point type called ``UDate`` that represents the number of milliseconds elapsed since 1970-jan-01 UTC for dates. In Python, the value returned by the ``time`` module's ``time()`` function is the number of seconds since 1970-jan-01 UTC. Because of this difference, floating point values are multiplied by 1000 when passed to APIs taking ``UDate`` and divided by 1000 when returned as ``UDate``. Python's ``datetime`` objects, with or without timezone information, can also be used with APIs taking ``UDate`` arguments. The ``datetime`` objects get converted to ``UDate`` when crossing into the C++ layer. ### arrays Many ICU API take array arguments. A list of elements of the array element types is to be passed from Python. ### StringEnumeration An ICU ``StringEnumeration`` has three ``next`` methods: ``next()`` which returns a ``str`` objects, ``unext()`` which returns ``unicode`` objects and ``snext()`` which returns ``UnicodeString`` objects. Any of these methods can be used as an iterator, using the Python built-in ``iter`` function. For example, let ``e`` be a ``StringEnumeration`` instance:: ```python [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:: ```python tz = ICUtzinfo(TimeZone.createTimeZone('US/Mountain')) datetime.now(tz) ``` or, even simpler:: ```python tz = ICUtzinfo.getInstance('Pacific/Fiji') datetime.now(tz) ``` To get the default time zone use:: ```python defaultTZ = ICUtzinfo.getDefault() ``` To get the time zone's id, use the ``tzid`` attribute or coerce the time zone to a string:: ```python ICUtzinfo.getInstance('Pacific/Fiji').tzid -> 'Pacific/Fiji' str(ICUtzinfo.getInstance('Pacific/Fiji')) -> 'Pacific/Fiji' ``` Platform: UNKNOWN Classifier: Development Status :: 5 - Production/Stable Classifier: Environment :: Console Classifier: Intended Audience :: Developers Classifier: License :: OSI Approved Classifier: Operating System :: OS Independent Classifier: Programming Language :: C++ Classifier: Programming Language :: Python Classifier: Programming Language :: Python :: 2 Classifier: Programming Language :: Python :: 3 Classifier: Programming Language :: Python :: Implementation :: CPython Classifier: Programming Language :: Python :: Implementation :: PyPy Classifier: Topic :: Software Development :: Localization Classifier: Topic :: Software Development :: Internationalization Description-Content-Type: text/markdown ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1573605241.8138077 PyICU-2.4.2/PyICU.egg-info/0000755000076500000000000000000000000000000015277 5ustar00vajdawheel00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1573605241.0 PyICU-2.4.2/PyICU.egg-info/PKG-INFO0000644000076500000000000002475400000000000016410 0ustar00vajdawheel00000000000000Metadata-Version: 2.1 Name: PyICU Version: 2.4.2 Summary: Python extension wrapping the ICU C++ API Home-page: https://github.com/ovalhub/pyicu Author: Andi Vajda Author-email: github@ovaltofu.org License: MIT Description: # README file for PyICU ## Welcome Welcome to PyICU, a Python extension wrapping the ICU C++ libraries. ICU stands for "International Components for Unicode". These are the i18n libraries of the Unicode Consortium. They implement much of the Unicode Standard, many of its companion Unicode Technical Standards, and much of Unicode CLDR. The PyICU source code is hosted on GitHub at https://github.com/ovalhub/pyicu. The ICU homepage is http://site.icu-project.org/ See also the CLDR homepage at http://cldr.unicode.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 icu-config program is available or that the ``INCLUDES``, ``LFLAGS``, ``CFLAGS`` and ``LIBRARIES`` dictionaries in ``setup.py`` contain correct values for your platform. Starting with ICU 60, -std=c++11 must appear in your CFLAGS. - ``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, the ``utf-8`` encoding is assumed when converting them to ``UnicodeString`` objects. To convert a Python ``str`` encoded in an encoding other than ``utf-8`` to an ICU ``UnicodeString`` use the ``UnicodeString(str, encodingName)`` constructor. ICU's C++ APIs accept and return ``UnicodeString`` arguments in several ways: by value, by pointer or by reference. When an ICU C++ API is documented to accept a ``UnicodeString`` reference parameter, it is safe to assume that there are several corresponding PyICU python APIs making it accessible in simpler ways: For example, the ``'UnicodeString &Locale::getDisplayName(UnicodeString &)'`` API, documented at http://icu-project.org/apiref/icu4c/classLocale.html can be invoked from Python in several ways: 1. The ICU way >>> from icu import UnicodeString, Locale >>> locale = Locale('pt_BR') >>> string = UnicodeString() >>> name = locale.getDisplayName(string) >>> name >>> name is string True <-- string arg was returned, modified in place 2. The Python way >>> from icu import Locale >>> locale = Locale('pt_BR') >>> name = locale.getDisplayName() >>> name u'Portuguese (Brazil)' A ``UnicodeString`` object was allocated and converted to a Python ``unicode`` object. A UnicodeString can be coerced to a Python unicode string with Python's ``unicode()`` constructor. The usual ``len()``, ``str()``, comparison, ``[]`` and ``[:]`` operators are all available, with the additional twists that slicing is not read-only and that ``+=`` is also available since a UnicodeString is mutable. For example: >>> name = locale.getDisplayName() u'Portuguese (Brazil)' >>> name = UnicodeString(name) >>> name >>> unicode(name) u'Portuguese (Brazil)' >>> len(name) 19 >>> str(name) <-- works when chars fit with default encoding 'Portuguese (Brazil)' >>> name[3] u't' >>> name[12:18] >>> name[12:18] = 'the country of Brasil' >>> name >>> name += ' oh joy' >>> name ### error reporting The C++ ICU library does not use C++ exceptions to report errors. ICU C++ APIs return errors via a ``UErrorCode`` reference argument. All such APIs are wrapped by Python APIs that omit this argument and throw an ``ICUError`` Python exception instead. The same is true for ICU APIs taking both a ``ParseError`` and a ``UErrorCode``, they are both to be omitted. For example, the ``'UnicodeString &DateFormat::format(const Formattable &, UnicodeString &, UErrorCode &)'`` API, documented at http://icu-project.org/apiref/icu4c/classDateFormat.html is invoked from Python with: >>> from icu import DateFormat, Formattable >>> df = DateFormat.createInstance() >>> df >>> f = Formattable(940284258.0, Formattable.kIsDate) >>> df.format(f) u'10/18/99 3:04 PM' Of course, the simpler ``'UnicodeString &DateFormat::format(UDate, UnicodeString &)'`` documented here: http://icu-project.org/apiref/icu4c/classDateFormat.html can be used too: >>> from icu import DateFormat >>> df = DateFormat.createInstance() >>> df >>> df.format(940284258.0) u'10/18/99 3:04 PM' ### dates ICU uses a double floating point type called ``UDate`` that represents the number of milliseconds elapsed since 1970-jan-01 UTC for dates. In Python, the value returned by the ``time`` module's ``time()`` function is the number of seconds since 1970-jan-01 UTC. Because of this difference, floating point values are multiplied by 1000 when passed to APIs taking ``UDate`` and divided by 1000 when returned as ``UDate``. Python's ``datetime`` objects, with or without timezone information, can also be used with APIs taking ``UDate`` arguments. The ``datetime`` objects get converted to ``UDate`` when crossing into the C++ layer. ### arrays Many ICU API take array arguments. A list of elements of the array element types is to be passed from Python. ### StringEnumeration An ICU ``StringEnumeration`` has three ``next`` methods: ``next()`` which returns a ``str`` objects, ``unext()`` which returns ``unicode`` objects and ``snext()`` which returns ``UnicodeString`` objects. Any of these methods can be used as an iterator, using the Python built-in ``iter`` function. For example, let ``e`` be a ``StringEnumeration`` instance:: ```python [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:: ```python tz = ICUtzinfo(TimeZone.createTimeZone('US/Mountain')) datetime.now(tz) ``` or, even simpler:: ```python tz = ICUtzinfo.getInstance('Pacific/Fiji') datetime.now(tz) ``` To get the default time zone use:: ```python defaultTZ = ICUtzinfo.getDefault() ``` To get the time zone's id, use the ``tzid`` attribute or coerce the time zone to a string:: ```python ICUtzinfo.getInstance('Pacific/Fiji').tzid -> 'Pacific/Fiji' str(ICUtzinfo.getInstance('Pacific/Fiji')) -> 'Pacific/Fiji' ``` Platform: UNKNOWN Classifier: Development Status :: 5 - Production/Stable Classifier: Environment :: Console Classifier: Intended Audience :: Developers Classifier: License :: OSI Approved Classifier: Operating System :: OS Independent Classifier: Programming Language :: C++ Classifier: Programming Language :: Python Classifier: Programming Language :: Python :: 2 Classifier: Programming Language :: Python :: 3 Classifier: Programming Language :: Python :: Implementation :: CPython Classifier: Programming Language :: Python :: Implementation :: PyPy Classifier: Topic :: Software Development :: Localization Classifier: Topic :: Software Development :: Internationalization Description-Content-Type: text/markdown ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1573605241.0 PyICU-2.4.2/PyICU.egg-info/SOURCES.txt0000644000076500000000000000264400000000000017171 0ustar00vajdawheel00000000000000CHANGES CREDITS LICENSE MANIFEST.in PyICU.py README.md _icu.cpp bases.cpp bases.h calendar.cpp calendar.h casemap.cpp casemap.h char.cpp char.h charset.cpp charset.h collator.cpp collator.h common.cpp common.h dateformat.cpp dateformat.h errors.cpp errors.h format.cpp format.h gender.cpp gender.h idna.cpp idna.h iterators.cpp iterators.h layoutengine.cpp layoutengine.h locale.cpp locale.h macros.h measureunit.cpp measureunit.h normalizer.cpp normalizer.h numberformat.cpp numberformat.h regex.cpp regex.h script.cpp script.h search.cpp search.h setup.cfg setup.py shape.cpp shape.h spoof.cpp spoof.h transliterator.cpp transliterator.h tries.cpp tries.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 icu/__init__.py samples/break.py samples/strsrch.py test/__init__.py test/lohit_hi.ttf test/noms.txt test/test_BreakIterator.py test/test_BytesTrie.py test/test_Charset.py test/test_Collator.py test/test_DateTimeParserGenerator.py test/test_LayoutEngine.py test/test_ListFormatter.py test/test_Locale.py test/test_LocaleData.py test/test_LocaleMatcher.py test/test_MessageFormat.py test/test_Normalizer.py test/test_NumberFormatter.py test/test_PythonReplaceable.py test/test_Script.py test/test_SimpleFormatter.py test/test_Spoof.py test/test_Transliterator.py test/test_UCS4.py test/test_UCharsTrie.py test/test_UDate.py././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1573605241.0 PyICU-2.4.2/PyICU.egg-info/dependency_links.txt0000644000076500000000000000000100000000000021345 0ustar00vajdawheel00000000000000 ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1573605241.0 PyICU-2.4.2/PyICU.egg-info/top_level.txt0000644000076500000000000000001700000000000020027 0ustar00vajdawheel00000000000000PyICU _icu icu ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1454974200.0 PyICU-2.4.2/PyICU.py0000644000076500000000000000266700000000000014172 0ustar00vajdawheel00000000000000 # ==================================================================== # 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 * ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1516145785.0 PyICU-2.4.2/README.md0000644000076500000000000001731400000000000014141 0ustar00vajdawheel00000000000000# README file for PyICU ## Welcome Welcome to PyICU, a Python extension wrapping the ICU C++ libraries. ICU stands for "International Components for Unicode". These are the i18n libraries of the Unicode Consortium. They implement much of the Unicode Standard, many of its companion Unicode Technical Standards, and much of Unicode CLDR. The PyICU source code is hosted on GitHub at https://github.com/ovalhub/pyicu. The ICU homepage is http://site.icu-project.org/ See also the CLDR homepage at http://cldr.unicode.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 icu-config program is available or that the ``INCLUDES``, ``LFLAGS``, ``CFLAGS`` and ``LIBRARIES`` dictionaries in ``setup.py`` contain correct values for your platform. Starting with ICU 60, -std=c++11 must appear in your CFLAGS. - ``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, the ``utf-8`` encoding is assumed when converting them to ``UnicodeString`` objects. To convert a Python ``str`` encoded in an encoding other than ``utf-8`` to an ICU ``UnicodeString`` use the ``UnicodeString(str, encodingName)`` constructor. ICU's C++ APIs accept and return ``UnicodeString`` arguments in several ways: by value, by pointer or by reference. When an ICU C++ API is documented to accept a ``UnicodeString`` reference parameter, it is safe to assume that there are several corresponding PyICU python APIs making it accessible in simpler ways: For example, the ``'UnicodeString &Locale::getDisplayName(UnicodeString &)'`` API, documented at http://icu-project.org/apiref/icu4c/classLocale.html can be invoked from Python in several ways: 1. The ICU way >>> from icu import UnicodeString, Locale >>> locale = Locale('pt_BR') >>> string = UnicodeString() >>> name = locale.getDisplayName(string) >>> name >>> name is string True <-- string arg was returned, modified in place 2. The Python way >>> from icu import Locale >>> locale = Locale('pt_BR') >>> name = locale.getDisplayName() >>> name u'Portuguese (Brazil)' A ``UnicodeString`` object was allocated and converted to a Python ``unicode`` object. A UnicodeString can be coerced to a Python unicode string with Python's ``unicode()`` constructor. The usual ``len()``, ``str()``, comparison, ``[]`` and ``[:]`` operators are all available, with the additional twists that slicing is not read-only and that ``+=`` is also available since a UnicodeString is mutable. For example: >>> name = locale.getDisplayName() u'Portuguese (Brazil)' >>> name = UnicodeString(name) >>> name >>> unicode(name) u'Portuguese (Brazil)' >>> len(name) 19 >>> str(name) <-- works when chars fit with default encoding 'Portuguese (Brazil)' >>> name[3] u't' >>> name[12:18] >>> name[12:18] = 'the country of Brasil' >>> name >>> name += ' oh joy' >>> name ### error reporting The C++ ICU library does not use C++ exceptions to report errors. ICU C++ APIs return errors via a ``UErrorCode`` reference argument. All such APIs are wrapped by Python APIs that omit this argument and throw an ``ICUError`` Python exception instead. The same is true for ICU APIs taking both a ``ParseError`` and a ``UErrorCode``, they are both to be omitted. For example, the ``'UnicodeString &DateFormat::format(const Formattable &, UnicodeString &, UErrorCode &)'`` API, documented at http://icu-project.org/apiref/icu4c/classDateFormat.html is invoked from Python with: >>> from icu import DateFormat, Formattable >>> df = DateFormat.createInstance() >>> df >>> f = Formattable(940284258.0, Formattable.kIsDate) >>> df.format(f) u'10/18/99 3:04 PM' Of course, the simpler ``'UnicodeString &DateFormat::format(UDate, UnicodeString &)'`` documented here: http://icu-project.org/apiref/icu4c/classDateFormat.html can be used too: >>> from icu import DateFormat >>> df = DateFormat.createInstance() >>> df >>> df.format(940284258.0) u'10/18/99 3:04 PM' ### dates ICU uses a double floating point type called ``UDate`` that represents the number of milliseconds elapsed since 1970-jan-01 UTC for dates. In Python, the value returned by the ``time`` module's ``time()`` function is the number of seconds since 1970-jan-01 UTC. Because of this difference, floating point values are multiplied by 1000 when passed to APIs taking ``UDate`` and divided by 1000 when returned as ``UDate``. Python's ``datetime`` objects, with or without timezone information, can also be used with APIs taking ``UDate`` arguments. The ``datetime`` objects get converted to ``UDate`` when crossing into the C++ layer. ### arrays Many ICU API take array arguments. A list of elements of the array element types is to be passed from Python. ### StringEnumeration An ICU ``StringEnumeration`` has three ``next`` methods: ``next()`` which returns a ``str`` objects, ``unext()`` which returns ``unicode`` objects and ``snext()`` which returns ``UnicodeString`` objects. Any of these methods can be used as an iterator, using the Python built-in ``iter`` function. For example, let ``e`` be a ``StringEnumeration`` instance:: ```python [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:: ```python tz = ICUtzinfo(TimeZone.createTimeZone('US/Mountain')) datetime.now(tz) ``` or, even simpler:: ```python tz = ICUtzinfo.getInstance('Pacific/Fiji') datetime.now(tz) ``` To get the default time zone use:: ```python defaultTZ = ICUtzinfo.getDefault() ``` To get the time zone's id, use the ``tzid`` attribute or coerce the time zone to a string:: ```python ICUtzinfo.getInstance('Pacific/Fiji').tzid -> 'Pacific/Fiji' str(ICUtzinfo.getInstance('Pacific/Fiji')) -> 'Pacific/Fiji' ``` ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1571427709.0 PyICU-2.4.2/_icu.cpp0000644000076500000000000002124500000000000014303 0ustar00vajdawheel00000000000000/* ==================================================================== * Copyright (c) 2004-2019 Open Source Applications Foundation. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. * ==================================================================== */ #include #include "structmember.h" #include "common.h" #include "errors.h" #include "bases.h" #include "locale.h" #include "transliterator.h" #include "iterators.h" #include "format.h" #include "dateformat.h" #include "numberformat.h" #include "calendar.h" #include "collator.h" #include "charset.h" #include "tzinfo.h" #include "unicodeset.h" #include "regex.h" #include "normalizer.h" #include "search.h" #if U_ICU_VERSION_HEX < VERSION_HEX(58, 0, 0) #include "layoutengine.h" #endif #include "script.h" #include "spoof.h" #include "idna.h" #include "char.h" #include "shape.h" #include "measureunit.h" #include "casemap.h" #include "tries.h" #include "gender.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 PyMethodDef _icu_funcs[] = { { 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); ver = PyString_FromString(PY_VERSION); PyObject_SetAttrString(m, "PY_VERSION", ver); Py_DECREF(ver); #ifdef PYPY_VERSION ver = PyString_FromString(PYPY_VERSION); PyObject_SetAttrString(m, "PYPY_VERSION", ver); Py_DECREF(ver); #endif PyObject *module = PyImport_ImportModule("icu"); if (!module) { if (!PyErr_Occurred()) PyErr_SetString(PyExc_ImportError, "icu"); return NULL; } PyExc_ICUError = PyObject_GetAttrString(module, "ICUError"); PyExc_InvalidArgsError = PyObject_GetAttrString(module, "InvalidArgsError"); Py_DECREF(module); _init_common(m); _init_errors(m); _init_bases(m); _init_locale(m); _init_transliterator(m); _init_iterators(m); _init_format(m); _init_dateformat(m); _init_numberformat(m); _init_calendar(m); _init_collator(m); _init_charset(m); _init_tzinfo(m); _init_unicodeset(m); _init_regex(m); _init_normalizer(m); _init_search(m); #if U_ICU_VERSION_HEX < VERSION_HEX(58, 0, 0) _init_layoutengine(m); #endif _init_script(m); _init_spoof(m); _init_idna(m); _init_char(m); _init_shape(m); _init_measureunit(m); _init_casemap(m); _init_tries(m); _init_gender(m); 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 ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1573514656.0 PyICU-2.4.2/bases.cpp0000644000076500000000000022346100000000000014465 0ustar00vajdawheel00000000000000/* ==================================================================== * Copyright (c) 2004-2019 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" /* UMemory */ static PyObject *t_umemory_new(PyTypeObject *type, PyObject *args, PyObject *kwds); static PyObject *t_umemory_str(t_umemory *self); static PyObject *t_umemory_repr(t_umemory *self); static PyMethodDef t_umemory_methods[] = { { NULL, NULL, 0, NULL } }; static PyMemberDef t_umemory_members[] = { { NULL, 0, 0, 0, NULL } }; static PyObject *t_umemory__getOwned(t_umemory *self, void *data); static PyGetSetDef t_umemory_properties[] = { { (char *) "owned", (getter) t_umemory__getOwned, NULL, (char *) "", NULL }, { NULL, NULL, NULL, NULL, NULL } }; PyTypeObject UMemoryType_ = { PyVarObject_HEAD_INIT(NULL, 0) "icu.UMemory", /* tp_name */ sizeof(t_umemory), /* tp_basicsize */ 0, /* tp_itemsize */ (destructor)t_umemory_dealloc, /* tp_dealloc */ 0, /* tp_print */ 0, /* tp_getattr */ 0, /* tp_setattr */ 0, /* tp_compare */ (reprfunc)t_umemory_repr, /* tp_repr */ 0, /* tp_as_number */ 0, /* tp_as_sequence */ 0, /* tp_as_mapping */ 0, /* tp_hash */ 0, /* tp_call */ (reprfunc)t_umemory_str, /* tp_str */ 0, /* tp_getattro */ 0, /* tp_setattro */ 0, /* tp_as_buffer */ (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE), /* tp_flags */ "t_umemory objects", /* tp_doc */ 0, /* tp_traverse */ 0, /* tp_clear */ 0, /* tp_richcompare */ 0, /* tp_weaklistoffset */ 0, /* tp_iter */ 0, /* tp_iternext */ t_umemory_methods, /* tp_methods */ t_umemory_members, /* tp_members */ t_umemory_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_umemory_new, /* tp_new */ }; /* UObject */ static PyObject *t_uobject_richcmp(t_uobject *, PyObject *o2, int op); static PyObject *t_uobject_str(t_uobject *self); static PyObject *t_uobject_getDynamicClassID(t_uobject *self); static PyMethodDef t_uobject_methods[] = { DECLARE_METHOD(t_uobject, getDynamicClassID, METH_NOARGS), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(UObject, t_uobject, UMemory, UObject, abstract_init, t_uobject_dealloc); /* 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); /* PythonReplaceable */ class t_python_replaceable : public _wrapper { public: PythonReplaceable *object; }; static int t_python_replaceable_init(t_python_replaceable *self, PyObject *args, PyObject *kwds); static PyObject *t_python_replaceable_extractBetween(t_python_replaceable *self, PyObject *args); static PyObject *t_python_replaceable_handleReplaceBetween(t_python_replaceable *self, PyObject *args); static PyObject *t_python_replaceable_copy(t_python_replaceable *self, PyObject *args); static PyObject *t_python_replaceable_hasMetaData(t_python_replaceable *self); static PyMethodDef t_python_replaceable_methods[] = { DECLARE_METHOD(t_python_replaceable, hasMetaData, METH_NOARGS), DECLARE_METHOD(t_python_replaceable, extractBetween, METH_VARARGS), DECLARE_METHOD(t_python_replaceable, handleReplaceBetween, METH_VARARGS), DECLARE_METHOD(t_python_replaceable, copy, METH_VARARGS), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(PythonReplaceable, t_python_replaceable, Replaceable, PythonReplaceable, t_python_replaceable_init, NULL); PythonReplaceable::PythonReplaceable(PyObject *self) : self_(self) { Py_INCREF(self_); } PythonReplaceable::~PythonReplaceable() { Py_DECREF(self_); } int32_t PythonReplaceable::getLength() const { PyObject *result = PyObject_CallMethod(self_, (char *) "getLength", NULL); if (result == NULL) return -1; #if PY_MAJOR_VERSION < 3 if (PyInt_Check(result)) { int n = PyInt_AsLong(result); Py_DECREF(result); if (!PyErr_Occurred()) return n; return -1; } #endif if (PyLong_Check(result)) { int n = PyLong_AsLong(result); Py_DECREF(result); if (!PyErr_Occurred()) return n; return -1; } PyErr_SetObject(PyExc_TypeError, result); Py_DECREF(result); return -1; } #if U_ICU_VERSION_HEX < VERSION_HEX(59, 1, 0) UChar PythonReplaceable::getCharAt(int32_t offset) const #else char16_t PythonReplaceable::getCharAt(int32_t offset) const #endif { PyObject *result = PyObject_CallMethod( self_, (char *) "getCharAt", (char *) "i", offset); if (result == NULL) return -1; #if PY_MAJOR_VERSION < 3 if (PyInt_Check(result)) { int n = PyInt_AsLong(result); Py_DECREF(result); if (PyErr_Occurred()) return -1; #if U_ICU_VERSION_HEX < VERSION_HEX(59, 1, 0) return (UChar) n; #else return (char16_t) n; #endif } #endif if (PyLong_Check(result)) { int n = PyLong_AsLong(result); Py_DECREF(result); if (PyErr_Occurred()) return -1; #if U_ICU_VERSION_HEX < VERSION_HEX(59, 1, 0) return (UChar) n; #else return (char16_t) n; #endif } UnicodeString *u, _u; if (!parseArg(result, "S", &u, &_u) && u->length() == 1) { Py_DECREF(result); return u->charAt(0); } PyErr_SetObject(PyExc_TypeError, result); Py_DECREF(result); return -1; } UChar32 PythonReplaceable::getChar32At(int32_t offset) const { PyObject *result = PyObject_CallMethod( self_, (char *) "getChar32At", (char *) "i", offset); if (result == NULL) return -1; #if PY_MAJOR_VERSION < 3 if (PyInt_Check(result)) { int n = PyInt_AsLong(result); Py_DECREF(result); if (PyErr_Occurred()) return -1; return (UChar32) n; } #endif if (PyLong_Check(result)) { int n = PyLong_AsLong(result); Py_DECREF(result); if (PyErr_Occurred()) return -1; return (UChar32) n; } UnicodeString *u, _u; if (!parseArg(result, "S", &u, &_u) && u->countChar32() == 1) { Py_DECREF(result); return u->char32At(0); } PyErr_SetObject(PyExc_TypeError, result); Py_DECREF(result); return -1; } void PythonReplaceable::extractBetween( int32_t start, int32_t limit, UnicodeString &target) const { PyObject *result = PyObject_CallMethod( self_, (char *) "extractBetween", (char *) "ii", start, limit); UnicodeString *u, _u; if (result != NULL && !parseArg(result, "S", &u, &_u)) { target.setTo(*u); Py_DECREF(result); } } void PythonReplaceable::handleReplaceBetween( int32_t start, int32_t limit, const UnicodeString &text) { PyObject *obj = PyUnicode_FromUnicodeString(&text); PyObject *result = PyObject_CallMethod( self_, (char *) "handleReplaceBetween", (char *) "iiO", start, limit, obj); Py_DECREF(obj); Py_XDECREF(result); } void PythonReplaceable::copy(int32_t start, int32_t limit, int32_t dest) { PyObject *result = PyObject_CallMethod( self_, (char *) "copy", (char *) "iii", start, limit, dest); Py_XDECREF(result); } UBool PythonReplaceable::hasMetaData() const { PyObject *result = PyObject_CallMethod(self_, (char *) "hasMetaData", NULL); UBool b = PyObject_IsTrue(result); Py_XDECREF(result); return b; } /* UnicodeString */ class t_unicodestring : public _wrapper { public: UnicodeString *object; }; static int t_unicodestring_init(t_unicodestring *self, PyObject *args, PyObject *kwds); static PyObject *t_unicodestring_getAvailableStandards(PyTypeObject *type); static PyObject *t_unicodestring_getAvailableEncodings(PyTypeObject *type, PyObject *args); static PyObject *t_unicodestring_getStandardEncoding(PyTypeObject *type, PyObject *args); static PyObject *t_unicodestring_append(t_unicodestring *self, PyObject *args); static PyObject *t_unicodestring_compare(t_unicodestring *self, PyObject *args); static PyObject *t_unicodestring_compareBetween(t_unicodestring *self, PyObject *args); static PyObject *t_unicodestring_compareCodePointOrder(t_unicodestring *self, PyObject *args); static PyObject *t_unicodestring_compareCodePointOrderBetween(t_unicodestring *self, PyObject *args); static PyObject *t_unicodestring_caseCompare(t_unicodestring *self, PyObject *args); static PyObject *t_unicodestring_caseCompareBetween(t_unicodestring *self, PyObject *args); static PyObject *t_unicodestring_startsWith(t_unicodestring *self, PyObject *args); static PyObject *t_unicodestring_endsWith(t_unicodestring *self, PyObject *args); #define t_unicodestring_startswith t_unicodestring_startsWith #define t_unicodestring_endswith t_unicodestring_endsWith static PyObject *t_unicodestring_indexOf(t_unicodestring *self, PyObject *args); static PyObject *t_unicodestring_lastIndexOf(t_unicodestring *self, PyObject *args); static PyObject *t_unicodestring_trim(t_unicodestring *self); static PyObject *t_unicodestring_reverse(t_unicodestring *self); static PyObject *t_unicodestring_toUpper(t_unicodestring *self, PyObject *args); static PyObject *t_unicodestring_toLower(t_unicodestring *self, PyObject *args); static PyObject *t_unicodestring_toTitle(t_unicodestring *self, PyObject *args); static PyObject *t_unicodestring_foldCase(t_unicodestring *self, PyObject *args); static PyObject *t_unicodestring_isBogus(t_unicodestring *self); static PyObject *t_unicodestring_encode(t_unicodestring *self, PyObject *arg); static PyObject *t_unicodestring_countChar32(t_unicodestring *self, PyObject *args); #if U_ICU_VERSION_HEX < VERSION_HEX(55, 1, 0) static PyObject *t_unicodestring_idna_toASCII(t_unicodestring *self, PyObject *args); static PyObject *t_unicodestring_idna_toUnicode(t_unicodestring *self, PyObject *args); static PyObject *t_unicodestring_idna_IDNtoASCII(t_unicodestring *self, PyObject *args); static PyObject *t_unicodestring_idna_IDNtoUnicode(t_unicodestring *self, PyObject *args); static PyObject *t_unicodestring_idna_compare(t_unicodestring *self, PyObject *args); #endif static PyMethodDef t_unicodestring_methods[] = { DECLARE_METHOD(t_unicodestring, getAvailableStandards, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_unicodestring, getAvailableEncodings, METH_VARARGS | METH_CLASS), DECLARE_METHOD(t_unicodestring, getStandardEncoding, METH_VARARGS | METH_CLASS), DECLARE_METHOD(t_unicodestring, append, METH_VARARGS), DECLARE_METHOD(t_unicodestring, compare, METH_VARARGS), DECLARE_METHOD(t_unicodestring, compareBetween, METH_VARARGS), DECLARE_METHOD(t_unicodestring, compareCodePointOrder, METH_VARARGS), DECLARE_METHOD(t_unicodestring, compareCodePointOrderBetween, METH_VARARGS), DECLARE_METHOD(t_unicodestring, caseCompare, METH_VARARGS), DECLARE_METHOD(t_unicodestring, caseCompareBetween, METH_VARARGS), DECLARE_METHOD(t_unicodestring, startsWith, METH_VARARGS), DECLARE_METHOD(t_unicodestring, endsWith, METH_VARARGS), DECLARE_METHOD(t_unicodestring, startswith, METH_VARARGS), DECLARE_METHOD(t_unicodestring, endswith, METH_VARARGS), DECLARE_METHOD(t_unicodestring, indexOf, METH_VARARGS), DECLARE_METHOD(t_unicodestring, lastIndexOf, METH_VARARGS), DECLARE_METHOD(t_unicodestring, trim, METH_NOARGS), DECLARE_METHOD(t_unicodestring, reverse, METH_NOARGS), DECLARE_METHOD(t_unicodestring, toUpper, METH_VARARGS), DECLARE_METHOD(t_unicodestring, toLower, METH_VARARGS), DECLARE_METHOD(t_unicodestring, toTitle, METH_VARARGS), DECLARE_METHOD(t_unicodestring, foldCase, METH_VARARGS), DECLARE_METHOD(t_unicodestring, isBogus, METH_NOARGS), DECLARE_METHOD(t_unicodestring, encode, METH_O), DECLARE_METHOD(t_unicodestring, countChar32, METH_VARARGS), #if U_ICU_VERSION_HEX < VERSION_HEX(55, 1, 0) DECLARE_METHOD(t_unicodestring, idna_toASCII, METH_VARARGS), DECLARE_METHOD(t_unicodestring, idna_toUnicode, METH_VARARGS), DECLARE_METHOD(t_unicodestring, idna_IDNtoASCII, METH_VARARGS), DECLARE_METHOD(t_unicodestring, idna_IDNtoUnicode, METH_VARARGS), DECLARE_METHOD(t_unicodestring, idna_compare, METH_VARARGS), #endif { NULL, NULL, 0, NULL } }; DECLARE_TYPE(UnicodeString, t_unicodestring, Replaceable, UnicodeString, t_unicodestring_init, NULL); /* Formattable */ class t_formattable : public _wrapper { public: Formattable *object; }; static int t_formattable_init(t_formattable *self, PyObject *args, PyObject *kwds); static PyObject *t_formattable_isNumeric(t_formattable *self); static PyObject *t_formattable_getType(t_formattable *self); static PyObject *t_formattable_getDouble(t_formattable *self); static PyObject *t_formattable_getLong(t_formattable *self); static PyObject *t_formattable_getInt64(t_formattable *self); static PyObject *t_formattable_getDate(t_formattable *self); static PyObject *t_formattable_getString(t_formattable *self, PyObject *args); static PyObject *t_formattable_setDouble(t_formattable *self, PyObject *arg); static PyObject *t_formattable_setLong(t_formattable *self, PyObject *arg); static PyObject *t_formattable_setInt64(t_formattable *self, PyObject *arg); static PyObject *t_formattable_setDate(t_formattable *self, PyObject *arg); static PyObject *t_formattable_setString(t_formattable *self, PyObject *arg); static PyMethodDef t_formattable_methods[] = { DECLARE_METHOD(t_formattable, isNumeric, METH_NOARGS), DECLARE_METHOD(t_formattable, getType, METH_NOARGS), DECLARE_METHOD(t_formattable, getDouble, METH_NOARGS), DECLARE_METHOD(t_formattable, getLong, METH_NOARGS), DECLARE_METHOD(t_formattable, getInt64, METH_NOARGS), DECLARE_METHOD(t_formattable, getDate, METH_NOARGS), DECLARE_METHOD(t_formattable, getString, METH_VARARGS), DECLARE_METHOD(t_formattable, setDouble, METH_O), DECLARE_METHOD(t_formattable, setLong, METH_O), DECLARE_METHOD(t_formattable, setInt64, METH_O), DECLARE_METHOD(t_formattable, setDate, METH_O), DECLARE_METHOD(t_formattable, setString, METH_O), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(Formattable, t_formattable, UObject, Formattable, t_formattable_init, NULL); PyObject *wrap_Formattable(Formattable &formattable) { return wrap_Formattable(new Formattable(formattable), T_OWNED); } /* 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); /* UMemory */ static PyObject *t_umemory_new(PyTypeObject *type, PyObject *args, PyObject *kwds) { t_umemory *self = (t_umemory *) type->tp_alloc(type, 0); if (self) { self->object = NULL; self->flags = 0; } return (PyObject *) self; } void t_umemory_dealloc(t_umemory *self) { if (self->flags & T_OWNED) delete self->object; self->object = NULL; Py_TYPE(self)->tp_free((PyObject *) self); } static PyObject *t_umemory__getOwned(t_umemory *self, void *data) { int b = self->flags & T_OWNED; Py_RETURN_BOOL(b); } static PyObject *t_umemory_str(t_umemory *self) { if (self->object) { char buf[32]; sprintf(buf, "0x%llx", (unsigned long long) (intptr_t) self->object); return PyString_FromString(buf); } return PyString_FromString(""); } static PyObject *t_umemory_repr(t_umemory *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; } /* 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_richcmp(t_uobject *self, PyObject *arg, int op) { int b = 0; switch (op) { case Py_EQ: case Py_NE: if (PyObject_TypeCheck(arg, &UObjectType_)) b = self->object == ((t_uobject *) arg)->object; if (op == Py_EQ) Py_RETURN_BOOL(b); Py_RETURN_BOOL(!b); case Py_LT: PyErr_SetString(PyExc_NotImplementedError, "<"); return NULL; case Py_LE: PyErr_SetString(PyExc_NotImplementedError, "<="); return NULL; case Py_GT: PyErr_SetString(PyExc_NotImplementedError, ">"); return NULL; case Py_GE: PyErr_SetString(PyExc_NotImplementedError, ">="); return NULL; } return NULL; } static PyObject *t_uobject_str(t_uobject *self) { if (self->object) { char buf[32]; #if U_ICU_VERSION_HEX < 0x04060000 sprintf(buf, "0x%lx", (unsigned long) self->object->getDynamicClassID()); #else sprintf(buf, "0x%llx", (unsigned long long) (intptr_t) self->object); #endif return PyString_FromString(buf); } return PyString_FromString(""); } static PyObject *t_uobject_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); } /* PythonReplaceable */ static int t_python_replaceable_init( t_python_replaceable *self, PyObject *args, PyObject *kwds) { PyObject *object; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "K", &object)) { self->object = new PythonReplaceable(object); self->flags = T_OWNED; } else PyErr_SetArgsError((PyObject *) self, "__init__", args); break; default: PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; } if (self->object) return 0; return -1; } static PyObject *t_python_replaceable_extractBetween( t_python_replaceable *self, PyObject *args) { int start, limit; switch (PyTuple_Size(args)) { case 2: if (!parseArgs(args, "ii", &start, &limit)) { UnicodeString result; self->object->extractBetween(start, limit, result); return PyUnicode_FromUnicodeString(&result); } break; } return PyErr_SetArgsError((PyObject *) self, "extractBetween", args); } static PyObject *t_python_replaceable_handleReplaceBetween( t_python_replaceable *self, PyObject *args) { int start, limit; UnicodeString *u, _u; switch (PyTuple_Size(args)) { case 3: if (!parseArgs(args, "iiS", &start, &limit, &u, &_u)) { self->object->handleReplaceBetween(start, limit, *u); Py_RETURN_NONE; } break; } return PyErr_SetArgsError((PyObject *) self, "handleReplaceBetween", args); } static PyObject *t_python_replaceable_copy( t_python_replaceable *self, PyObject *args) { int start, limit, dest; switch (PyTuple_Size(args)) { case 3: if (!parseArgs(args, "iii", &start, &limit, &dest)) { self->object->copy(start, limit, dest); Py_RETURN_NONE; } break; } return PyErr_SetArgsError((PyObject *) self, "copy", args); } static PyObject *t_python_replaceable_hasMetaData(t_python_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, _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, _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, _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, _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, _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, _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, _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, _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, _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, _u; int c, start, len, srcStart, srcLen; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "S", &u, &_u)) { int i = self->object->lastIndexOf(*u); return PyInt_FromLong(i); } if (!parseArgs(args, "i", &c)) { int i; if (sizeof(Py_UNICODE) == sizeof(UChar)) i = self->object->lastIndexOf((UChar) c); else i = self->object->lastIndexOf((UChar32) c); return PyInt_FromLong(i); } break; case 2: if (!parseArgs(args, "Si", &u, &_u, &start)) { if (!verifyStart(start, u->length())) { int i = self->object->lastIndexOf(*u, start); return PyInt_FromLong(i); } PyErr_SetObject(PyExc_IndexError, args); return NULL; } if (!parseArgs(args, "ii", &c, &start)) { if (!verifyStart(start, self->object->length())) { int i; if (sizeof(Py_UNICODE) == sizeof(UChar)) i = self->object->lastIndexOf((UChar) c, start); else i = self->object->lastIndexOf((UChar32) c, start); return PyInt_FromLong(i); } PyErr_SetObject(PyExc_IndexError, args); return NULL; } break; case 3: if (!parseArgs(args, "Sii", &u, &_u, &start, &len)) { if (!verifyStartLen(start, len, u->length())) { int i = self->object->lastIndexOf(*u, start, len); return PyInt_FromLong(i); } PyErr_SetObject(PyExc_IndexError, args); return NULL; } if (!parseArgs(args, "iii", &c, &start, &len)) { if (!verifyStartLen(start, len, self->object->length())) { int i; if (sizeof(Py_UNICODE) == sizeof(UChar)) i = self->object->lastIndexOf((UChar) c, start, len); else i = self->object->lastIndexOf((UChar32) c, start, len); return PyInt_FromLong(i); } PyErr_SetObject(PyExc_IndexError, args); return NULL; } break; case 5: if (!parseArgs(args, "Siiii", &u, &_u, &srcStart, &srcLen, &start, &len)) { if (!verifyStartLen(srcStart, srcLen, u->length()) && !verifyStartLen(start, len, self->object->length())) { int i = self->object->lastIndexOf(*u, srcStart, srcLen, start, len); return PyInt_FromLong(i); } PyErr_SetObject(PyExc_IndexError, args); return NULL; } } return PyErr_SetArgsError((PyObject *) self, "lastIndexOf", args); } static PyObject *t_unicodestring_trim(t_unicodestring *self) { self->object->trim(); Py_RETURN_SELF(); } static PyObject *t_unicodestring_reverse(t_unicodestring *self) { self->object->reverse(); Py_RETURN_SELF(); } static PyObject *t_unicodestring_toUpper(t_unicodestring *self, PyObject *args) { Locale *locale; switch (PyTuple_Size(args)) { case 0: self->object->toUpper(); Py_RETURN_SELF(); case 1: if (!parseArgs(args, "P", TYPE_CLASSID(Locale), &locale)) { self->object->toUpper(*locale); Py_RETURN_SELF(); } break; } return PyErr_SetArgsError((PyObject *) self, "toUpper", args); } static PyObject *t_unicodestring_toLower(t_unicodestring *self, PyObject *args) { Locale *locale; switch (PyTuple_Size(args)) { case 0: self->object->toLower(); Py_RETURN_SELF(); case 1: if (!parseArgs(args, "P", TYPE_CLASSID(Locale), &locale)) { self->object->toLower(*locale); Py_RETURN_SELF(); } break; } return PyErr_SetArgsError((PyObject *) self, "toLower", args); } static PyObject *t_unicodestring_toTitle(t_unicodestring *self, PyObject *args) { BreakIterator *iterator; Locale *locale; switch (PyTuple_Size(args)) { case 0: self->object->toTitle(NULL); Py_RETURN_SELF(); case 1: if (!parseArgs(args, "P", TYPE_CLASSID(Locale), &locale)) { self->object->toTitle(NULL, *locale); Py_RETURN_SELF(); } if (!parseArg(args, "P", TYPE_ID(BreakIterator), &iterator)) { self->object->toTitle(iterator); Py_RETURN_SELF(); } break; case 2: if (!parseArgs(args, "PP", TYPE_ID(BreakIterator), TYPE_CLASSID(Locale), &iterator, &locale)) { self->object->toTitle(iterator, *locale); Py_RETURN_SELF(); } break; } return PyErr_SetArgsError((PyObject *) self, "toTitle", args); } static PyObject *t_unicodestring_foldCase(t_unicodestring *self, PyObject *args) { int i; switch (PyTuple_Size(args)) { case 0: self->object->foldCase(0); Py_RETURN_SELF(); case 1: if (!parseArgs(args, "i", &i)) { self->object->foldCase(i); Py_RETURN_SELF(); } break; } return PyErr_SetArgsError((PyObject *) self, "foldCase", args); } static PyObject *t_unicodestring_isBogus(t_unicodestring *self) { int b = self->object->isBogus(); Py_RETURN_BOOL(b); } static PyObject *t_unicodestring_str(t_unicodestring *self) { return PyUnicode_FromUnicodeString(self->object); } static PyObject *t_unicodestring_repr(t_unicodestring *self) { PyObject *name = PyObject_GetAttrString((PyObject *) Py_TYPE(self), "__name__"); PyObject *str = PyUnicode_FromUnicodeString(self->object); if (str) { PyObject *repr = str->ob_type->tp_repr(str); Py_DECREF(str); str = repr; } if (!str) return NULL; #if PY_VERSION_HEX < 0x02040000 PyObject *args = Py_BuildValue("(OO)", name, str); #else PyObject *args = PyTuple_Pack(2, name, str); #endif PyObject *format = PyString_FromString("<%s: %s>"); PyObject *repr = PyString_Format(format, args); Py_DECREF(name); Py_DECREF(str); Py_DECREF(args); Py_DECREF(format); return repr; } static long t_unicodestring_hash(t_unicodestring *self) { return (long) self->object->hashCode(); } static PyObject *t_unicodestring_encode(t_unicodestring *self, PyObject *arg) { charsArg encoding; if (!parseArg(arg, "n", &encoding)) { int srcLen = self->object->length(); int dstLen = srcLen * 4, _dstLen; UErrorCode status = U_ZERO_ERROR; UConverter *conv = ucnv_open(encoding, &status); PyObject *string; if (U_FAILURE(status)) return ICUException(status).reportError(); string = PyBytes_FromStringAndSize(NULL, dstLen); retry: if (!string) { ucnv_close(conv); return NULL; } _dstLen = ucnv_fromUChars(conv, PyBytes_AS_STRING(string), dstLen, self->object->getBuffer(), srcLen, &status); if (status == U_BUFFER_OVERFLOW_ERROR && _dstLen > dstLen) { _PyBytes_Resize(&string, _dstLen); dstLen = _dstLen; status = U_ZERO_ERROR; goto retry; } ucnv_close(conv); if (U_FAILURE(status)) { Py_DECREF(string); return ICUException(status).reportError(); } if (_dstLen != dstLen) _PyBytes_Resize(&string, _dstLen); return string; } return PyErr_SetArgsError((PyObject *) self, "encode", arg); } static PyObject *t_unicodestring_countChar32(t_unicodestring *self, PyObject *args) { int32_t start = 0, length = INT32_MAX; int32_t len; switch (PyTuple_Size(args)) { case 0: len = self->object->countChar32(); return PyInt_FromLong(len); case 1: if (!parseArgs(args, "i", &start)) { len = self->object->countChar32(start); return PyInt_FromLong(len); } break; case 2: if (!parseArgs(args, "ii", &start, &length)) { len = self->object->countChar32(start, length); return PyInt_FromLong(len); } break; } return PyErr_SetArgsError((PyObject *) self, "countChar32", args); } #if U_ICU_VERSION_HEX < VERSION_HEX(55, 1, 0) static PyObject *t_unicodestring_idna_toASCII(t_unicodestring *self, PyObject *args) { UErrorCode status = U_ZERO_ERROR; UParseError parseError; int options = UIDNA_DEFAULT; int len = self->object->length(); UnicodeString *u; UChar *dest; if (!PyArg_ParseTuple(args, "|i", &options)) return NULL; dest = new UChar[len * 4 + 32]; if (!dest) { PyErr_SetNone(PyExc_MemoryError); return NULL; } len = uidna_toASCII(self->object->getBuffer(), len, dest, len * 4 + 32, options, &parseError, &status); if (U_FAILURE(status)) { delete dest; return ICUException(parseError, status).reportError(); } u = new UnicodeString(dest, len); delete dest; return wrap_UnicodeString(u, T_OWNED); } static PyObject *t_unicodestring_idna_toUnicode(t_unicodestring *self, PyObject *args) { UErrorCode status = U_ZERO_ERROR; UParseError parseError; int options = UIDNA_DEFAULT; int len = self->object->length(); UnicodeString *u; UChar *dest; if (!PyArg_ParseTuple(args, "|i", &options)) return NULL; dest = new UChar[len]; if (!dest) { PyErr_SetNone(PyExc_MemoryError); return NULL; } len = uidna_toUnicode(self->object->getBuffer(), len, dest, len, options, &parseError, &status); if (U_FAILURE(status)) { delete dest; return ICUException(parseError, status).reportError(); } u = new UnicodeString(dest, len); delete dest; return wrap_UnicodeString(u, T_OWNED); } static PyObject *t_unicodestring_idna_IDNtoASCII(t_unicodestring *self, PyObject *args) { UErrorCode status = U_ZERO_ERROR; UParseError parseError; int options = UIDNA_DEFAULT; int len = self->object->length(); UnicodeString *u; UChar *dest; if (!PyArg_ParseTuple(args, "|i", &options)) return NULL; dest = new UChar[len * 4 + 32]; if (!dest) { PyErr_SetNone(PyExc_MemoryError); return NULL; } len = uidna_IDNToASCII(self->object->getBuffer(), len, dest, len * 4 + 32, options, &parseError, &status); if (U_FAILURE(status)) { delete dest; return ICUException(parseError, status).reportError(); } u = new UnicodeString(dest, len); delete dest; return wrap_UnicodeString(u, T_OWNED); } static PyObject *t_unicodestring_idna_IDNtoUnicode(t_unicodestring *self, PyObject *args) { UErrorCode status = U_ZERO_ERROR; UParseError parseError; int options = UIDNA_DEFAULT; int len = self->object->length(); UnicodeString *u; UChar *dest; if (!PyArg_ParseTuple(args, "|i", &options)) return NULL; dest = new UChar[len]; if (!dest) { PyErr_SetNone(PyExc_MemoryError); return NULL; } len = uidna_IDNToUnicode(self->object->getBuffer(), len, dest, len, options, &parseError, &status); if (U_FAILURE(status)) { delete dest; return ICUException(parseError, status).reportError(); } u = new UnicodeString(dest, len); delete dest; return wrap_UnicodeString(u, T_OWNED); } static PyObject *t_unicodestring_idna_compare(t_unicodestring *self, PyObject *args) { int options = UIDNA_DEFAULT; UnicodeString *u; UnicodeString _u; int n; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "S", &u, &_u)) { STATUS_CALL(n = uidna_compare(self->object->getBuffer(), self->object->length(), u->getBuffer(), u->length(), options, &status)); return PyInt_FromLong(n); } break; case 2: if (!parseArgs(args, "Si", &u, &_u, &options)) { STATUS_CALL(n = uidna_compare(self->object->getBuffer(), self->object->length(), u->getBuffer(), u->length(), options, &status)); return PyInt_FromLong(n); } break; } return PyErr_SetArgsError((PyObject *) self, "idna_compare", args); } #endif static PyObject *t_unicodestring_richcmp(t_unicodestring *self, PyObject *arg, int op) { UnicodeString *u; UnicodeString _u; int b = 0; if (isUnicodeString(arg)) u = (UnicodeString *) ((t_uobject *) arg)->object; else try { PyObject_AsUnicodeString(arg, _u); u = &_u; } catch (ICUException e) { return e.reportError(); } switch (op) { case Py_EQ: b = *self->object == *u; break; case Py_NE: b = *self->object != *u; break; case Py_LT: b = *self->object < *u; break; case Py_LE: b = *self->object <= *u; break; case Py_GT: b = *self->object > *u; break; case Py_GE: b = *self->object >= *u; break; default: PyErr_SetNone(PyExc_NotImplementedError); return NULL; } Py_RETURN_BOOL(b); } // unicodestring as sequence of UChar, not codepoints 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); 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() * (int32_t) 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) { // unicodestring as sequence of UChar, not codepoints Py_UNICODE c = (Py_UNICODE) u->charAt(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((int32_t) l, (int32_t) (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)) { // unicodestring as sequence of UChar, not codepoints u->replace((int32_t) n, 1, (UChar) i); return 0; } UnicodeString *v; UnicodeString _v; if (!parseArg(arg, "S", &v, &_v)) { if (v->length() == 1) { // unicodestring as sequence of UChar, not codepoints u->setCharAt((int32_t) 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((int32_t) l, (int32_t) 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)) { 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; } // unicodestring as sequence of UChar, not codepoints 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); } DEFINE_RICHCMP(Formattable, t_formattable); 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; } /* 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) { UObjectType_.tp_str = (reprfunc) t_uobject_str; UObjectType_.tp_richcompare = (richcmpfunc) t_uobject_richcmp; 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; StringEnumerationType_.tp_iter = (getiterfunc) t_stringenumeration_iter; StringEnumerationType_.tp_iternext = (iternextfunc) t_stringenumeration_next; INSTALL_STRUCT(UMemory, m); // no typeid() INSTALL_TYPE(UObject, m); INSTALL_TYPE(Replaceable, m); INSTALL_TYPE(PythonReplaceable, m); REGISTER_TYPE(UnicodeString, m); REGISTER_TYPE(Formattable, 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_COMPARE_IGNORE_CASE); INSTALL_MODULE_INT(m, U_FOLD_CASE_EXCLUDE_SPECIAL_I); INSTALL_MODULE_INT(m, U_TITLECASE_NO_BREAK_ADJUSTMENT); INSTALL_MODULE_INT(m, U_TITLECASE_NO_LOWERCASE); INSTALL_MODULE_INT(m, UNORM_INPUT_IS_FCD); #if U_ICU_VERSION_HEX >= VERSION_HEX(60, 0, 0) INSTALL_MODULE_INT(m, U_EDITS_NO_RESET); INSTALL_MODULE_INT(m, U_OMIT_UNCHANGED_TEXT); INSTALL_MODULE_INT(m, U_TITLECASE_ADJUST_TO_CASED); INSTALL_MODULE_INT(m, U_TITLECASE_SENTENCES); INSTALL_MODULE_INT(m, U_TITLECASE_WHOLE_STRING); #endif #if U_ICU_VERSION_HEX < VERSION_HEX(55, 1, 0) INSTALL_MODULE_INT(m, UIDNA_DEFAULT); INSTALL_MODULE_INT(m, UIDNA_ALLOW_UNASSIGNED); INSTALL_MODULE_INT(m, UIDNA_USE_STD3_RULES); #endif INSTALL_STATIC_INT(Formattable, kIsDate); INSTALL_STATIC_INT(Formattable, kDate); INSTALL_STATIC_INT(Formattable, kDouble); INSTALL_STATIC_INT(Formattable, kLong); INSTALL_STATIC_INT(Formattable, kString); INSTALL_STATIC_INT(Formattable, kArray); INSTALL_STATIC_INT(Formattable, kInt64); INSTALL_STATIC_INT(Formattable, kObject); } ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1573514475.0 PyICU-2.4.2/bases.h0000644000076500000000000000545500000000000014133 0ustar00vajdawheel00000000000000/* ==================================================================== * 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_umemory : public _wrapper { public: UMemory *object; }; class t_uobject : public _wrapper { public: UObject *object; }; class PythonReplaceable : public Replaceable { public: explicit PythonReplaceable(PyObject *self); ~PythonReplaceable(); int32_t getLength() const override; #if U_ICU_VERSION_HEX < VERSION_HEX(59, 1, 0) UChar getCharAt(int32_t offset) const override; #else char16_t getCharAt(int32_t offset) const override; #endif UChar32 getChar32At(int32_t offset) const override; void extractBetween( int32_t start, int32_t limit, UnicodeString &target) const override; void handleReplaceBetween( int32_t start, int32_t limit, const UnicodeString &text) override; void copy(int32_t start, int32_t limit, int32_t dest) override; UBool hasMetaData() const override; private: PyObject *self_; }; struct UNone; typedef struct UNone UNone; void t_umemory_dealloc(t_umemory *self); void t_uobject_dealloc(t_uobject *self); extern PyTypeObject UMemoryType_; extern PyTypeObject UObjectType_; extern PyTypeObject FormattableType_; extern PyTypeObject PythonReplaceableType_; 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 */ ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1569878426.0 PyICU-2.4.2/calendar.cpp0000644000076500000000000015157200000000000015144 0ustar00vajdawheel00000000000000/* ==================================================================== * Copyright (c) 2004-2019 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" /* apparently a macro defined by some versions of the MSVC compiler */ #ifdef daylight #undef daylight #endif DECLARE_CONSTANTS_TYPE(UCalendarDateFields); DECLARE_CONSTANTS_TYPE(UCalendarDaysOfWeek); DECLARE_CONSTANTS_TYPE(UCalendarMonths); DECLARE_CONSTANTS_TYPE(UCalendarAMPMs); /* TimeZone */ static PyObject *t_timezone_getOffset(t_timezone *self, PyObject *args); static PyObject *t_timezone_getRawOffset(t_timezone *self); static PyObject *t_timezone_setRawOffset(t_timezone *self, PyObject *arg); static PyObject *t_timezone_getID(t_timezone *self, PyObject *args); static PyObject *t_timezone_setID(t_timezone *self, PyObject *arg); static PyObject *t_timezone_getDisplayName(t_timezone *self, PyObject *args); static PyObject *t_timezone_useDaylightTime(t_timezone *self); static PyObject *t_timezone_inDaylightTime(t_timezone *self, PyObject *arg); static PyObject *t_timezone_hasSameRules(t_timezone *self, PyObject *arg); static PyObject *t_timezone_getDSTSavings(t_timezone *self); static PyObject *t_timezone_getGMT(PyTypeObject *type); static PyObject *t_timezone_createEnumeration(PyTypeObject *type, PyObject *args); static PyObject *t_timezone_countEquivalentIDs(PyTypeObject *type, PyObject *arg); static PyObject *t_timezone_getEquivalentID(PyTypeObject *type, PyObject *args); #if U_ICU_VERSION_HEX >= VERSION_HEX(52, 0, 0) static PyObject *t_timezone_getIDForWindowsID(PyTypeObject *type, PyObject *args); static PyObject *t_timezone_getWindowsID(PyTypeObject *type, PyObject *arg); #endif static PyObject *t_timezone_createDefault(PyTypeObject *type); static PyObject *t_timezone_setDefault(PyTypeObject *type, PyObject *arg); static PyMethodDef t_timezone_methods[] = { DECLARE_METHOD(t_timezone, getOffset, METH_VARARGS), DECLARE_METHOD(t_timezone, getRawOffset, METH_NOARGS), DECLARE_METHOD(t_timezone, setRawOffset, METH_O), DECLARE_METHOD(t_timezone, getID, METH_VARARGS), DECLARE_METHOD(t_timezone, setID, METH_O), DECLARE_METHOD(t_timezone, getDisplayName, METH_VARARGS), DECLARE_METHOD(t_timezone, useDaylightTime, METH_NOARGS), DECLARE_METHOD(t_timezone, inDaylightTime, METH_O), DECLARE_METHOD(t_timezone, hasSameRules, METH_O), DECLARE_METHOD(t_timezone, getDSTSavings, METH_NOARGS), DECLARE_METHOD(t_timezone, getGMT, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_timezone, createTimeZone, METH_O | METH_CLASS), DECLARE_METHOD(t_timezone, createEnumeration, METH_VARARGS | METH_CLASS), DECLARE_METHOD(t_timezone, countEquivalentIDs, METH_O | METH_CLASS), DECLARE_METHOD(t_timezone, getEquivalentID, METH_VARARGS | METH_CLASS), #if U_ICU_VERSION_HEX >= VERSION_HEX(52, 0, 0) DECLARE_METHOD(t_timezone, getIDForWindowsID, METH_VARARGS | METH_CLASS), DECLARE_METHOD(t_timezone, getWindowsID, METH_O | METH_CLASS), #endif DECLARE_METHOD(t_timezone, createDefault, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_timezone, setDefault, METH_O | METH_CLASS), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(TimeZone, t_timezone, UObject, TimeZone, abstract_init, NULL); /* SimpleTimeZone */ class t_simpletimezone : public _wrapper { public: SimpleTimeZone *object; }; static int t_simpletimezone_init(t_simpletimezone *self, PyObject *args, PyObject *kwds); static PyObject *t_simpletimezone_setStartYear(t_simpletimezone *self, PyObject *arg); static PyObject *t_simpletimezone_setStartRule(t_simpletimezone *self, PyObject *args); static PyObject *t_simpletimezone_setEndRule(t_simpletimezone *self, PyObject *args); static PyObject *t_simpletimezone_getOffset(t_simpletimezone *self, PyObject *args); static PyObject *t_simpletimezone_setDSTSavings(t_simpletimezone *self, PyObject *arg); static PyMethodDef t_simpletimezone_methods[] = { DECLARE_METHOD(t_simpletimezone, setStartYear, METH_O), DECLARE_METHOD(t_simpletimezone, setStartRule, METH_VARARGS), DECLARE_METHOD(t_simpletimezone, setEndRule, METH_VARARGS), DECLARE_METHOD(t_simpletimezone, getOffset, METH_VARARGS), DECLARE_METHOD(t_simpletimezone, setDSTSavings, METH_O), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(SimpleTimeZone, t_simpletimezone, TimeZone, SimpleTimeZone, t_simpletimezone_init, NULL); /* Calendar */ class t_calendar : public _wrapper { public: Calendar *object; }; static PyObject *t_calendar_getTime(t_calendar *self); static PyObject *t_calendar_setTime(t_calendar *self, PyObject *arg); static PyObject *t_calendar_isEquivalentTo(t_calendar *self, PyObject *arg); static PyObject *t_calendar_equals(t_calendar *self, PyObject *arg); static PyObject *t_calendar_before(t_calendar *self, PyObject *arg); static PyObject *t_calendar_after(t_calendar *self, PyObject *arg); static PyObject *t_calendar_add(t_calendar *self, PyObject *args); static PyObject *t_calendar_roll(t_calendar *self, PyObject *args); static PyObject *t_calendar_fieldDifference(t_calendar *self, PyObject *args); static PyObject *t_calendar_getTimeZone(t_calendar *self); static PyObject *t_calendar_setTimeZone(t_calendar *self, PyObject *arg); static PyObject *t_calendar_inDaylightTime(t_calendar *self); static PyObject *t_calendar_isLenient(t_calendar *self); static PyObject *t_calendar_setLenient(t_calendar *self, PyObject *arg); static PyObject *t_calendar_getType(t_calendar *self); static PyObject *t_calendar_getFirstDayOfWeek(t_calendar *self); static PyObject *t_calendar_setFirstDayOfWeek(t_calendar *self, PyObject *arg); static PyObject *t_calendar_getMinimalDaysInFirstWeek(t_calendar *self); static PyObject *t_calendar_setMinimalDaysInFirstWeek(t_calendar *self, PyObject *arg); static PyObject *t_calendar_getMinimum(t_calendar *self, PyObject *arg); static PyObject *t_calendar_getMaximum(t_calendar *self, PyObject *arg); static PyObject *t_calendar_getGreatestMinimum(t_calendar *self, PyObject *arg); static PyObject *t_calendar_getActualMinimum(t_calendar *self, PyObject *arg); static PyObject *t_calendar_getLeastMaximum(t_calendar *self, PyObject *arg); static PyObject *t_calendar_getActualMaximum(t_calendar *self, PyObject *arg); static PyObject *t_calendar_get(t_calendar *self, PyObject *arg); static PyObject *t_calendar_isSet(t_calendar *self, PyObject *arg); static PyObject *t_calendar_set(t_calendar *self, PyObject *args); static PyObject *t_calendar_clear(t_calendar *self, PyObject *args); static PyObject *t_calendar_haveDefaultCentury(t_calendar *self); static PyObject *t_calendar_defaultCenturyStart(t_calendar *self); static PyObject *t_calendar_defaultCenturyStartYear(t_calendar *self); static PyObject *t_calendar_getLocale(t_calendar *self, PyObject *args); static PyObject *t_calendar_getLocaleID(t_calendar *self, PyObject *args); static PyObject *t_calendar_createInstance(PyTypeObject *type, PyObject *args); static PyObject *t_calendar_getAvailableLocales(PyTypeObject *type); static PyObject *t_calendar_getNow(PyTypeObject *type); static PyMethodDef t_calendar_methods[] = { DECLARE_METHOD(t_calendar, getTime, METH_NOARGS), DECLARE_METHOD(t_calendar, setTime, METH_O), DECLARE_METHOD(t_calendar, isEquivalentTo, METH_O), DECLARE_METHOD(t_calendar, equals, METH_O), DECLARE_METHOD(t_calendar, before, METH_O), DECLARE_METHOD(t_calendar, after, METH_O), DECLARE_METHOD(t_calendar, add, METH_VARARGS), DECLARE_METHOD(t_calendar, roll, METH_VARARGS), DECLARE_METHOD(t_calendar, fieldDifference, METH_VARARGS), DECLARE_METHOD(t_calendar, getTimeZone, METH_NOARGS), DECLARE_METHOD(t_calendar, setTimeZone, METH_O), DECLARE_METHOD(t_calendar, inDaylightTime, METH_NOARGS), DECLARE_METHOD(t_calendar, isLenient, METH_NOARGS), DECLARE_METHOD(t_calendar, setLenient, METH_O), DECLARE_METHOD(t_calendar, getType, METH_NOARGS), DECLARE_METHOD(t_calendar, getFirstDayOfWeek, METH_NOARGS), DECLARE_METHOD(t_calendar, setFirstDayOfWeek, METH_O), DECLARE_METHOD(t_calendar, getMinimalDaysInFirstWeek, METH_NOARGS), DECLARE_METHOD(t_calendar, setMinimalDaysInFirstWeek, METH_O), DECLARE_METHOD(t_calendar, getMinimum, METH_O), DECLARE_METHOD(t_calendar, getMaximum, METH_O), DECLARE_METHOD(t_calendar, getGreatestMinimum, METH_O), DECLARE_METHOD(t_calendar, getActualMinimum, METH_O), DECLARE_METHOD(t_calendar, getLeastMaximum, METH_O), DECLARE_METHOD(t_calendar, getActualMaximum, METH_O), DECLARE_METHOD(t_calendar, get, METH_O), DECLARE_METHOD(t_calendar, isSet, METH_O), DECLARE_METHOD(t_calendar, set, METH_VARARGS), DECLARE_METHOD(t_calendar, clear, METH_VARARGS), DECLARE_METHOD(t_calendar, haveDefaultCentury, METH_NOARGS), DECLARE_METHOD(t_calendar, defaultCenturyStart, METH_NOARGS), DECLARE_METHOD(t_calendar, defaultCenturyStartYear, METH_NOARGS), DECLARE_METHOD(t_calendar, getLocale, METH_VARARGS), DECLARE_METHOD(t_calendar, getLocaleID, METH_VARARGS), DECLARE_METHOD(t_calendar, createInstance, METH_VARARGS | METH_CLASS), DECLARE_METHOD(t_calendar, getAvailableLocales, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_calendar, getNow, METH_NOARGS | METH_CLASS), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(Calendar, t_calendar, UObject, Calendar, abstract_init, NULL); /* GregorianCalendar */ class t_gregoriancalendar : public _wrapper { public: GregorianCalendar *object; }; static int t_gregoriancalendar_init(t_gregoriancalendar *self, PyObject *args, PyObject *kwds); static PyObject *t_gregoriancalendar_getGregorianChange(t_gregoriancalendar *self); static PyObject *t_gregoriancalendar_setGregorianChange(t_gregoriancalendar *self, PyObject *arg); static PyObject *t_gregoriancalendar_isLeapYear(t_gregoriancalendar *self, PyObject *arg); static PyMethodDef t_gregoriancalendar_methods[] = { DECLARE_METHOD(t_gregoriancalendar, getGregorianChange, METH_NOARGS), DECLARE_METHOD(t_gregoriancalendar, setGregorianChange, METH_O), DECLARE_METHOD(t_gregoriancalendar, isLeapYear, METH_O), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(GregorianCalendar, t_gregoriancalendar, Calendar, GregorianCalendar, t_gregoriancalendar_init, NULL); /* TimeZone */ PyObject *wrap_TimeZone(TimeZone *tz) { RETURN_WRAPPED_IF_ISINSTANCE(tz, SimpleTimeZone); return wrap_TimeZone(tz, T_OWNED); } PyObject *wrap_TimeZone(const TimeZone &tz) { return wrap_TimeZone(tz.clone()); } static PyObject *t_timezone_getOffset(t_timezone *self, PyObject *args) { UDate date; int local, rawOffset, dstOffset, offset; int era, year, month, day, dayOfWeek, millis, monthLength; switch (PyTuple_Size(args)) { case 2: if (!parseArgs(args, "Db", &date, &local)) { STATUS_CALL(self->object->getOffset(date, (UBool) local, rawOffset, dstOffset, status)); return Py_BuildValue("(ii)", rawOffset, dstOffset); } break; case 6: if (!parseArgs(args, "iiiiii", &era, &year, &month, &day, &dayOfWeek, &millis)) { STATUS_CALL(offset = self->object->getOffset((uint8_t) era, year, month, day, dayOfWeek, millis, status)); return PyInt_FromLong(offset); } break; case 7: if (!parseArgs(args, "iiiiiii", &era, &year, &month, &day, &dayOfWeek, &millis, &monthLength)) { STATUS_CALL(offset = self->object->getOffset((uint8_t) era, year, month, day, dayOfWeek, millis, monthLength, status)); return PyInt_FromLong(offset); } break; } return PyErr_SetArgsError((PyObject *) self, "getOffset", args); } static PyObject *t_timezone_getRawOffset(t_timezone *self) { return PyInt_FromLong(self->object->getRawOffset()); } static PyObject *t_timezone_setRawOffset(t_timezone *self, PyObject *arg) { int offset; if (!parseArg(arg, "i", &offset)) { self->object->setRawOffset(offset); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setRawOffset", arg); } static PyObject *t_timezone_getID(t_timezone *self, PyObject *args) { UnicodeString *u; UnicodeString _u; switch (PyTuple_Size(args)) { case 0: self->object->getID(_u); return PyUnicode_FromUnicodeString(&_u); case 1: if (!parseArgs(args, "U", &u)) { self->object->getID(*u); Py_RETURN_ARG(args, 0); } break; } return PyErr_SetArgsError((PyObject *) self, "getID", args); } static PyObject *t_timezone_setID(t_timezone *self, PyObject *arg) { UnicodeString *u, _u; if (!parseArg(arg, "S", &u, &_u)) { self->object->setID(*u); /* copied */ Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setID", arg); } static PyObject *t_timezone_getDisplayName(t_timezone *self, PyObject *args) { UnicodeString *u, _u; int daylight; Locale *locale; TimeZone::EDisplayType type; switch (PyTuple_Size(args)) { case 0: self->object->getDisplayName(_u); return PyUnicode_FromUnicodeString(&_u); case 1: if (!parseArgs(args, "P", TYPE_CLASSID(Locale), &locale)) { self->object->getDisplayName(*locale, _u); return PyUnicode_FromUnicodeString(&_u); } if (!parseArgs(args, "U", &u)) { self->object->getDisplayName(*u); Py_RETURN_ARG(args, 0); } break; case 2: if (!parseArgs(args, "bi", &daylight, &type)) { self->object->getDisplayName((UBool) daylight, type, _u); return PyUnicode_FromUnicodeString(&_u); } if (!parseArgs(args, "PU", TYPE_CLASSID(Locale), &locale, &u)) { self->object->getDisplayName(*locale, *u); Py_RETURN_ARG(args, 1); } break; case 3: if (!parseArgs(args, "biP", TYPE_CLASSID(Locale), &daylight, &type, &locale)) { self->object->getDisplayName((UBool) daylight, type, *locale, _u); return PyUnicode_FromUnicodeString(&_u); } if (!parseArgs(args, "biU", &daylight, &type, &u)) { self->object->getDisplayName((UBool) daylight, type, *u); Py_RETURN_ARG(args, 2); } break; case 4: if (!parseArgs(args, "biPU", TYPE_CLASSID(Locale), &daylight, &type, &locale, &u)) { self->object->getDisplayName((UBool) daylight, type, *locale, *u); Py_RETURN_ARG(args, 3); } break; } return PyErr_SetArgsError((PyObject *) self, "getDisplayName", args); } static PyObject *t_timezone_useDaylightTime(t_timezone *self) { UBool b = self->object->useDaylightTime(); Py_RETURN_BOOL(b); } static PyObject *t_timezone_inDaylightTime(t_timezone *self, PyObject *arg) { UDate date; UBool b; if (!parseArg(arg, "D", &date)) { STATUS_CALL(b = self->object->inDaylightTime(date, status)); Py_RETURN_BOOL(b); } return PyErr_SetArgsError((PyObject *) self, "inDaylightTime", arg); } static PyObject *t_timezone_hasSameRules(t_timezone *self, PyObject *arg) { TimeZone *tz; UBool b; if (!parseArg(arg, "P", TYPE_CLASSID(TimeZone), &tz)) { b = self->object->hasSameRules(*tz); Py_RETURN_BOOL(b); } return PyErr_SetArgsError((PyObject *) self, "hasSameRules", arg); } static PyObject *t_timezone_getDSTSavings(t_timezone *self) { return PyInt_FromLong(self->object->getDSTSavings()); } static PyObject *t_timezone_getGMT(PyTypeObject *type) { return wrap_TimeZone((TimeZone *) TimeZone::getGMT(), 0); } PyObject *t_timezone_createTimeZone(PyTypeObject *type, PyObject *arg) { UnicodeString *u; UnicodeString _u; if (!parseArg(arg, "S", &u, &_u)) { TimeZone *tz = TimeZone::createTimeZone(*u); const TimeZone *gmt = TimeZone::getGMT(); UnicodeString tzid, GMT; /* PyICU bug 8180 and ICU bug 5612: * https://bugzilla.osafoundation.org/show_bug.cgi?id=8180 * http://bugs.icu-project.org/trac/ticket/5612 * Only an Olson ID can be used with createTimeZone(). * If GMT is returned, it means the requested id was incorrect. * Matching it with the default timezone increases the likelihood of * returning a sensible timezone with the intended raw offset as the * non-Olson requested id is likely to have come from the OS's default * timezone id in the first place. */ tz->getID(tzid); gmt->getID(GMT); if (tzid == GMT && *u != GMT) { TimeZone *deflt = TimeZone::createDefault(); deflt->getID(tzid); if (tzid == *u) { delete tz; tz = deflt; } else delete deflt; } return wrap_TimeZone(tz); } return PyErr_SetArgsError(type, "createTimeZone", arg); } static PyObject *t_timezone_createEnumeration(PyTypeObject *type, PyObject *args) { int offset; charsArg country; switch (PyTuple_Size(args)) { case 0: return wrap_StringEnumeration(TimeZone::createEnumeration(), T_OWNED); case 1: if (!parseArgs(args, "i", &offset)) return wrap_StringEnumeration(TimeZone::createEnumeration(offset), T_OWNED); if (!parseArgs(args, "n", &country)) return wrap_StringEnumeration(TimeZone::createEnumeration(country), T_OWNED); break; } return PyErr_SetArgsError(type, "createEnumeration", args); } static PyObject *t_timezone_countEquivalentIDs(PyTypeObject *type, PyObject *arg) { UnicodeString *u; UnicodeString _u; if (!parseArg(arg, "S", &u, &_u)) return PyInt_FromLong(TimeZone::countEquivalentIDs(*u)); return PyErr_SetArgsError(type, "countEquivalentIDs", arg); } static PyObject *t_timezone_getEquivalentID(PyTypeObject *type, PyObject *args) { UnicodeString *u; UnicodeString _u; int index; if (!parseArgs(args, "Si", &u, &_u, &index)) { UnicodeString v = TimeZone::getEquivalentID(*u, index); return PyUnicode_FromUnicodeString(&v); } return PyErr_SetArgsError(type, "getEquivalentID", args); } #if U_ICU_VERSION_HEX >= VERSION_HEX(52, 0, 0) static PyObject *t_timezone_getIDForWindowsID(PyTypeObject *type, PyObject *args) { UnicodeString *winId; UnicodeString _winId; charsArg region; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "S", &winId, &_winId)) { UnicodeString id; STATUS_CALL(TimeZone::getIDForWindowsID(*winId, NULL, id, status)); return PyUnicode_FromUnicodeString(&id); } break; case 2: if (!parseArgs(args, "Sn", &winId, &_winId, ®ion)) { UnicodeString id; STATUS_CALL(TimeZone::getIDForWindowsID(*winId, region, id, status)); return PyUnicode_FromUnicodeString(&id); } break; } return PyErr_SetArgsError(type, "getIDForWindowsID", args); } static PyObject *t_timezone_getWindowsID(PyTypeObject *type, PyObject *arg) { UnicodeString *id; UnicodeString _id; if (!parseArg(arg, "S", &id, &_id)) { UnicodeString winId; STATUS_CALL(TimeZone::getWindowsID(*id, winId, status)); return PyUnicode_FromUnicodeString(&winId); } return PyErr_SetArgsError(type, "getWindowsID", arg); } #endif static PyObject *t_timezone_createDefault(PyTypeObject *type) { return wrap_TimeZone(TimeZone::createDefault()); } static PyObject *t_timezone_setDefault(PyTypeObject *type, PyObject *arg) { TimeZone *tz; if (!parseArg(arg, "P", TYPE_CLASSID(TimeZone), &tz)) { TimeZone::setDefault(*tz); /* copied */ PyObject *m = PyImport_ImportModule("icu"); PyObject *cls = PyObject_GetAttrString(m, "ICUtzinfo"); PyObject *result = PyObject_CallMethod( cls, (char *) "_resetDefault", (char *) "", NULL); Py_DECREF(m); Py_DECREF(cls); return result; } return PyErr_SetArgsError(type, "setDefault", arg); } static PyObject *t_timezone_str(t_timezone *self) { UnicodeString u; self->object->getID(u); return PyUnicode_FromUnicodeString(&u); } DEFINE_RICHCMP(TimeZone, t_timezone); /* 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); } DEFINE_RICHCMP(Calendar, t_calendar); /* 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); } ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1430285491.0 PyICU-2.4.2/calendar.h0000644000076500000000000000335400000000000014603 0ustar00vajdawheel00000000000000/* ==================================================================== * 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 */ ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1539913953.0 PyICU-2.4.2/casemap.cpp0000644000076500000000000013434300000000000015001 0ustar00vajdawheel00000000000000/* ==================================================================== * Copyright (c) 2004-2018 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 "casemap.h" #include "iterators.h" #include "locale.h" #include "macros.h" /* CaseMap */ #if U_ICU_VERSION_HEX >= VERSION_HEX(59, 0, 0) using EditsIterator = Edits::Iterator; class t_casemap : public _wrapper { public: UNone *object; }; static PyObject *t_casemap_toLower(PyTypeObject *type, PyObject *args); static PyObject *t_casemap_toUpper(PyTypeObject *type, PyObject *args); static PyObject *t_casemap_toTitle(PyTypeObject *type, PyObject *args); static PyObject *t_casemap_fold(PyTypeObject *type, PyObject *args); static PyMethodDef t_casemap_methods[] = { DECLARE_METHOD(t_casemap, toLower, METH_CLASS | METH_VARARGS), DECLARE_METHOD(t_casemap, toUpper, METH_CLASS | METH_VARARGS), DECLARE_METHOD(t_casemap, toTitle, METH_CLASS | METH_VARARGS), DECLARE_METHOD(t_casemap, fold, METH_CLASS | METH_VARARGS), { NULL, NULL, 0, NULL } }; DECLARE_STRUCT(CaseMap, t_casemap, UNone, abstract_init, NULL); /* Edits */ class t_edits : public _wrapper { public: Edits *object; }; static int t_edits_init(t_edits *self, PyObject *args, PyObject *kwds); static PyObject *t_edits_reset(t_edits *self); static PyObject *t_edits_addUnchanged(t_edits *self, PyObject *arg); static PyObject *t_edits_addReplace(t_edits *self, PyObject *args); static PyObject *t_edits_lengthDelta(t_edits *self); static PyObject *t_edits_hasChanges(t_edits *self); static PyObject *t_edits_numberOfChanges(t_edits *self); static PyObject *t_edits_getCoarseChangesIterator(t_edits *self); static PyObject *t_edits_getCoarseIterator(t_edits *self); static PyObject *t_edits_getFineChangesIterator(t_edits *self); static PyObject *t_edits_getFineIterator(t_edits *self); #if U_ICU_VERSION_HEX >= VERSION_HEX(60, 0, 0) static PyObject *t_edits_mergeAndAppend(t_edits *self, PyObject *args); #endif static PyMethodDef t_edits_methods[] = { DECLARE_METHOD(t_edits, reset, METH_NOARGS), DECLARE_METHOD(t_edits, addUnchanged, METH_O), DECLARE_METHOD(t_edits, addReplace, METH_VARARGS), DECLARE_METHOD(t_edits, lengthDelta, METH_NOARGS), DECLARE_METHOD(t_edits, hasChanges, METH_NOARGS), DECLARE_METHOD(t_edits, numberOfChanges, METH_NOARGS), DECLARE_METHOD(t_edits, getCoarseChangesIterator, METH_NOARGS), DECLARE_METHOD(t_edits, getCoarseIterator, METH_NOARGS), DECLARE_METHOD(t_edits, getFineChangesIterator, METH_NOARGS), DECLARE_METHOD(t_edits, getFineIterator, METH_NOARGS), #if U_ICU_VERSION_HEX >= VERSION_HEX(60, 0, 0) DECLARE_METHOD(t_edits, mergeAndAppend, METH_VARARGS), #endif { NULL, NULL, 0, NULL } }; DECLARE_STRUCT(Edits, t_edits, Edits, t_edits_init, NULL); /* EditsIterator */ class t_editsiterator : public _wrapper { public: EditsIterator *object; }; static int t_editsiterator_init(t_editsiterator *self, PyObject *args, PyObject *kwds); static PyObject *t_editsiterator_findSourceIndex( t_editsiterator *self, PyObject *arg); static PyObject *t_editsiterator_findDestinationIndex( t_editsiterator *self, PyObject *arg); static PyObject *t_editsiterator_destinationIndexFromSourceIndex( t_editsiterator *self, PyObject *arg); static PyObject *t_editsiterator_sourceIndexFromdestinationIndex( t_editsiterator *self, PyObject *arg); static PyObject *t_editsiterator__hasChange( t_editsiterator *self, void *closure); static PyObject *t_editsiterator__newLength( t_editsiterator *self, void *closure); static PyObject *t_editsiterator__oldLength( t_editsiterator *self, void *closure); static PyObject *t_editsiterator__sourceIndex( t_editsiterator *self, void *closure); static PyObject *t_editsiterator__destinationIndex( t_editsiterator *self, void *closure); static PyObject *t_editsiterator__replacementIndex( t_editsiterator *self, void *closure); static PyGetSetDef t_editsiterator_properties[] = { { (char *) "hasChange", (getter) t_editsiterator__hasChange, NULL, (char *) "hasChange property", NULL }, { (char *) "oldLength", (getter) t_editsiterator__oldLength, NULL, (char *) "oldLength property", NULL }, { (char *) "newLength", (getter) t_editsiterator__newLength, NULL, (char *) "newLength property", NULL }, { (char *) "sourceIndex", (getter) t_editsiterator__sourceIndex, NULL, (char *) "sourceIndex property", NULL }, { (char *) "destinationIndex", (getter) t_editsiterator__destinationIndex, NULL, (char *) "destinationIndex property", NULL }, { (char *) "replacementIndex", (getter) t_editsiterator__replacementIndex, NULL, (char *) "replacementIndex property", NULL }, { NULL, NULL, NULL, NULL, NULL } }; static PyMethodDef t_editsiterator_methods[] = { DECLARE_METHOD(t_editsiterator, findSourceIndex, METH_O), DECLARE_METHOD(t_editsiterator, findDestinationIndex, METH_O), DECLARE_METHOD(t_editsiterator, destinationIndexFromSourceIndex, METH_O), DECLARE_METHOD(t_editsiterator, sourceIndexFromdestinationIndex, METH_O), { NULL, NULL, 0, NULL } }; DECLARE_STRUCT(EditsIterator, t_editsiterator, EditsIterator, t_editsiterator_init, NULL); PyObject *wrap_EditsIterator(const EditsIterator &iterator) { return wrap_EditsIterator(new EditsIterator(iterator), T_OWNED); } /* CaseMap */ static PyObject *t_casemap_toLower(PyTypeObject *type, PyObject *args) { Locale *locale; UnicodeString *u, _u; int32_t options; PyObject *edits; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "S", &u, &_u)) { Buffer dest(u->length() + 8); UErrorCode status = U_ZERO_ERROR; int32_t size = CaseMap::toLower( NULL, 0, u->getBuffer(), u->length(), dest.buffer, dest.size, NULL, status); if (U_SUCCESS(status)) return PyUnicode_FromUnicodeString(dest.buffer, size); if (status == U_BUFFER_OVERFLOW_ERROR) { Buffer dest(size); STATUS_CALL(CaseMap::toLower( NULL, 0, u->getBuffer(), u->length(), dest.buffer, size, NULL, status)); return PyUnicode_FromUnicodeString(dest.buffer, size); } return ICUException(status).reportError(); } break; case 2: if (!parseArgs(args, "SO", &EditsType_, &u, &_u, &edits)) { Buffer dest(u->length() + 8); UErrorCode status = U_ZERO_ERROR; int32_t size = CaseMap::toLower( NULL, 0, u->getBuffer(), u->length(), dest.buffer, dest.size, ((t_edits *) edits)->object, status); if (U_SUCCESS(status)) return PyUnicode_FromUnicodeString(dest.buffer, size); if (status == U_BUFFER_OVERFLOW_ERROR) { Buffer dest(size); STATUS_CALL(CaseMap::toLower( NULL, 0, u->getBuffer(), u->length(), dest.buffer, size, ((t_edits *) edits)->object, status)); return PyUnicode_FromUnicodeString(dest.buffer, size); } return ICUException(status).reportError(); } if (!parseArgs(args, "PS", TYPE_CLASSID(Locale), &locale, &u, &_u)) { Buffer dest(u->length() + 8); UErrorCode status = U_ZERO_ERROR; int32_t size = CaseMap::toLower( locale->getBaseName(), 0, u->getBuffer(), u->length(), dest.buffer, dest.size, NULL, status); if (U_SUCCESS(status)) return PyUnicode_FromUnicodeString(dest.buffer, size); if (status == U_BUFFER_OVERFLOW_ERROR) { Buffer dest(size); STATUS_CALL(CaseMap::toLower( locale->getBaseName(), 0, u->getBuffer(), u->length(), dest.buffer, size, NULL, status)); return PyUnicode_FromUnicodeString(dest.buffer, size); } return ICUException(status).reportError(); } if (!parseArgs(args, "iS", &options, &u, &_u)) { Buffer dest(u->length() + 8); UErrorCode status = U_ZERO_ERROR; int32_t size = CaseMap::toLower( NULL, options, u->getBuffer(), u->length(), dest.buffer, dest.size, NULL, status); if (U_SUCCESS(status)) return PyUnicode_FromUnicodeString(dest.buffer, size); if (status == U_BUFFER_OVERFLOW_ERROR) { Buffer dest(size); STATUS_CALL(CaseMap::toLower( NULL, options, u->getBuffer(), u->length(), dest.buffer, size, NULL, status)); return PyUnicode_FromUnicodeString(dest.buffer, size); } return ICUException(status).reportError(); } break; case 3: if (!parseArgs(args, "PSO", TYPE_CLASSID(Locale), &EditsType_, &locale, &u, &_u, &edits)) { Buffer dest(u->length() + 8); UErrorCode status = U_ZERO_ERROR; int32_t size = CaseMap::toLower( locale->getBaseName(), 0, u->getBuffer(), u->length(), dest.buffer, dest.size, ((t_edits *) edits)->object, status); if (U_SUCCESS(status)) return PyUnicode_FromUnicodeString(dest.buffer, size); if (status == U_BUFFER_OVERFLOW_ERROR) { Buffer dest(size); STATUS_CALL(CaseMap::toLower( locale->getBaseName(), 0, u->getBuffer(), u->length(), dest.buffer, size, ((t_edits *) edits)->object, status)); return PyUnicode_FromUnicodeString(dest.buffer, size); } return ICUException(status).reportError(); } if (!parseArgs(args, "iSO", &EditsType_, &options, &u, &_u, &edits)) { Buffer dest(u->length() + 8); UErrorCode status = U_ZERO_ERROR; int32_t size = CaseMap::toLower( NULL, options, u->getBuffer(), u->length(), dest.buffer, dest.size, ((t_edits *) edits)->object, status); if (U_SUCCESS(status)) return PyUnicode_FromUnicodeString(dest.buffer, size); if (status == U_BUFFER_OVERFLOW_ERROR) { Buffer dest(size); STATUS_CALL(CaseMap::toLower( NULL, options, u->getBuffer(), u->length(), dest.buffer, size, ((t_edits *) edits)->object, status)); return PyUnicode_FromUnicodeString(dest.buffer, size); } return ICUException(status).reportError(); } if (!parseArgs(args, "PiS", TYPE_CLASSID(Locale), &locale, &options, &u, &_u)) { Buffer dest(u->length() + 8); UErrorCode status = U_ZERO_ERROR; int32_t size = CaseMap::toLower( locale->getBaseName(), options, u->getBuffer(), u->length(), dest.buffer, dest.size, NULL, status); if (U_SUCCESS(status)) return PyUnicode_FromUnicodeString(dest.buffer, size); if (status == U_BUFFER_OVERFLOW_ERROR) { Buffer dest(size); STATUS_CALL(CaseMap::toLower( locale->getBaseName(), options, u->getBuffer(), u->length(), dest.buffer, size, NULL, status)); return PyUnicode_FromUnicodeString(dest.buffer, size); } return ICUException(status).reportError(); } break; case 4: if (!parseArgs(args, "PiSO", TYPE_CLASSID(Locale), &EditsType_, &locale, &options, &u, &_u, &edits)) { Buffer dest(u->length() + 8); UErrorCode status = U_ZERO_ERROR; int32_t size = CaseMap::toLower( locale->getBaseName(), options, u->getBuffer(), u->length(), dest.buffer, dest.size, ((t_edits *) edits)->object, status); if (U_SUCCESS(status)) return PyUnicode_FromUnicodeString(dest.buffer, size); if (status == U_BUFFER_OVERFLOW_ERROR) { Buffer dest(size); STATUS_CALL(CaseMap::toLower( locale->getBaseName(), options, u->getBuffer(), u->length(), dest.buffer, size, ((t_edits *) edits)->object, status)); return PyUnicode_FromUnicodeString(dest.buffer, size); } return ICUException(status).reportError(); } break; } return PyErr_SetArgsError(type, "toLower", args); } static PyObject *t_casemap_toUpper(PyTypeObject *type, PyObject *args) { Locale *locale; UnicodeString *u, _u; int32_t options; PyObject *edits; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "S", &u, &_u)) { Buffer dest(u->length() + 8); UErrorCode status = U_ZERO_ERROR; int32_t size = CaseMap::toUpper( NULL, 0, u->getBuffer(), u->length(), dest.buffer, dest.size, NULL, status); if (U_SUCCESS(status)) return PyUnicode_FromUnicodeString(dest.buffer, size); if (status == U_BUFFER_OVERFLOW_ERROR) { Buffer dest(size); STATUS_CALL(CaseMap::toUpper( NULL, 0, u->getBuffer(), u->length(), dest.buffer, size, NULL, status)); return PyUnicode_FromUnicodeString(dest.buffer, size); } return ICUException(status).reportError(); } break; case 2: if (!parseArgs(args, "SO", &EditsType_, &u, &_u, &edits)) { Buffer dest(u->length() + 8); UErrorCode status = U_ZERO_ERROR; int32_t size = CaseMap::toUpper( NULL, 0, u->getBuffer(), u->length(), dest.buffer, dest.size, ((t_edits *) edits)->object, status); if (U_SUCCESS(status)) return PyUnicode_FromUnicodeString(dest.buffer, size); if (status == U_BUFFER_OVERFLOW_ERROR) { Buffer dest(size); STATUS_CALL(CaseMap::toUpper( NULL, 0, u->getBuffer(), u->length(), dest.buffer, size, ((t_edits *) edits)->object, status)); return PyUnicode_FromUnicodeString(dest.buffer, size); } return ICUException(status).reportError(); } if (!parseArgs(args, "PS", TYPE_CLASSID(Locale), &locale, &u, &_u)) { Buffer dest(u->length() + 8); UErrorCode status = U_ZERO_ERROR; int32_t size = CaseMap::toUpper( locale->getBaseName(), 0, u->getBuffer(), u->length(), dest.buffer, dest.size, NULL, status); if (U_SUCCESS(status)) return PyUnicode_FromUnicodeString(dest.buffer, size); if (status == U_BUFFER_OVERFLOW_ERROR) { Buffer dest(size); STATUS_CALL(CaseMap::toUpper( locale->getBaseName(), 0, u->getBuffer(), u->length(), dest.buffer, size, NULL, status)); return PyUnicode_FromUnicodeString(dest.buffer, size); } return ICUException(status).reportError(); } if (!parseArgs(args, "iS", &options, &u, &_u)) { Buffer dest(u->length() + 8); UErrorCode status = U_ZERO_ERROR; int32_t size = CaseMap::toUpper( NULL, options, u->getBuffer(), u->length(), dest.buffer, dest.size, NULL, status); if (U_SUCCESS(status)) return PyUnicode_FromUnicodeString(dest.buffer, size); if (status == U_BUFFER_OVERFLOW_ERROR) { Buffer dest(size); STATUS_CALL(CaseMap::toUpper( NULL, options, u->getBuffer(), u->length(), dest.buffer, size, NULL, status)); return PyUnicode_FromUnicodeString(dest.buffer, size); } return ICUException(status).reportError(); } break; case 3: if (!parseArgs(args, "PSO", TYPE_CLASSID(Locale), &EditsType_, &locale, &u, &_u, &edits)) { Buffer dest(u->length() + 8); UErrorCode status = U_ZERO_ERROR; int32_t size = CaseMap::toUpper( locale->getBaseName(), 0, u->getBuffer(), u->length(), dest.buffer, dest.size, ((t_edits *) edits)->object, status); if (U_SUCCESS(status)) return PyUnicode_FromUnicodeString(dest.buffer, size); if (status == U_BUFFER_OVERFLOW_ERROR) { Buffer dest(size); STATUS_CALL(CaseMap::toUpper( locale->getBaseName(), 0, u->getBuffer(), u->length(), dest.buffer, size, ((t_edits *) edits)->object, status)); return PyUnicode_FromUnicodeString(dest.buffer, size); } return ICUException(status).reportError(); } if (!parseArgs(args, "iSO", &EditsType_, &options, &u, &_u, &edits)) { Buffer dest(u->length() + 8); UErrorCode status = U_ZERO_ERROR; int32_t size = CaseMap::toUpper( NULL, options, u->getBuffer(), u->length(), dest.buffer, dest.size, ((t_edits *) edits)->object, status); if (U_SUCCESS(status)) return PyUnicode_FromUnicodeString(dest.buffer, size); if (status == U_BUFFER_OVERFLOW_ERROR) { Buffer dest(size); STATUS_CALL(CaseMap::toUpper( NULL, options, u->getBuffer(), u->length(), dest.buffer, size, ((t_edits *) edits)->object, status)); return PyUnicode_FromUnicodeString(dest.buffer, size); } return ICUException(status).reportError(); } if (!parseArgs(args, "PiS", TYPE_CLASSID(Locale), &locale, &options, &u, &_u)) { Buffer dest(u->length() + 8); UErrorCode status = U_ZERO_ERROR; int32_t size = CaseMap::toUpper( locale->getBaseName(), options, u->getBuffer(), u->length(), dest.buffer, dest.size, NULL, status); if (U_SUCCESS(status)) return PyUnicode_FromUnicodeString(dest.buffer, size); if (status == U_BUFFER_OVERFLOW_ERROR) { Buffer dest(size); STATUS_CALL(CaseMap::toUpper( locale->getBaseName(), options, u->getBuffer(), u->length(), dest.buffer, size, NULL, status)); return PyUnicode_FromUnicodeString(dest.buffer, size); } return ICUException(status).reportError(); } break; case 4: if (!parseArgs(args, "PiSO", TYPE_CLASSID(Locale), &EditsType_, &locale, &options, &u, &_u, &edits)) { Buffer dest(u->length() + 8); UErrorCode status = U_ZERO_ERROR; int32_t size = CaseMap::toUpper( locale->getBaseName(), options, u->getBuffer(), u->length(), dest.buffer, dest.size, ((t_edits *) edits)->object, status); if (U_SUCCESS(status)) return PyUnicode_FromUnicodeString(dest.buffer, size); if (status == U_BUFFER_OVERFLOW_ERROR) { Buffer dest(size); STATUS_CALL(CaseMap::toUpper( locale->getBaseName(), options, u->getBuffer(), u->length(), dest.buffer, size, ((t_edits *) edits)->object, status)); return PyUnicode_FromUnicodeString(dest.buffer, size); } return ICUException(status).reportError(); } break; } return PyErr_SetArgsError(type, "toUpper", args); } static PyObject *t_casemap_toTitle(PyTypeObject *type, PyObject *args) { Locale *locale; BreakIterator *iter; UnicodeString *u, _u; int32_t options; PyObject *edits; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "S", &u, &_u)) { Buffer dest(u->length() + 8); UErrorCode status = U_ZERO_ERROR; int32_t size = CaseMap::toTitle( NULL, 0, NULL, u->getBuffer(), u->length(), dest.buffer, dest.size, NULL, status); if (U_SUCCESS(status)) return PyUnicode_FromUnicodeString(dest.buffer, size); if (status == U_BUFFER_OVERFLOW_ERROR) { Buffer dest(size); STATUS_CALL(CaseMap::toTitle( NULL, 0, NULL, u->getBuffer(), u->length(), dest.buffer, size, NULL, status)); return PyUnicode_FromUnicodeString(dest.buffer, size); } return ICUException(status).reportError(); } break; case 2: if (!parseArgs(args, "SO", &EditsType_, &u, &_u, &edits)) { Buffer dest(u->length() + 8); UErrorCode status = U_ZERO_ERROR; int32_t size = CaseMap::toTitle( NULL, 0, NULL, u->getBuffer(), u->length(), dest.buffer, dest.size, ((t_edits *) edits)->object, status); if (U_SUCCESS(status)) return PyUnicode_FromUnicodeString(dest.buffer, size); if (status == U_BUFFER_OVERFLOW_ERROR) { Buffer dest(size); STATUS_CALL(CaseMap::toTitle( NULL, 0, NULL, u->getBuffer(), u->length(), dest.buffer, size, ((t_edits *) edits)->object, status)); return PyUnicode_FromUnicodeString(dest.buffer, size); } return ICUException(status).reportError(); } if (!parseArgs(args, "PS", TYPE_CLASSID(Locale), &locale, &u, &_u)) { Buffer dest(u->length() + 8); UErrorCode status = U_ZERO_ERROR; int32_t size = CaseMap::toTitle( locale->getBaseName(), 0, NULL, u->getBuffer(), u->length(), dest.buffer, dest.size, NULL, status); if (U_SUCCESS(status)) return PyUnicode_FromUnicodeString(dest.buffer, size); if (status == U_BUFFER_OVERFLOW_ERROR) { Buffer dest(size); STATUS_CALL(CaseMap::toTitle( locale->getBaseName(), 0, NULL, u->getBuffer(), u->length(), dest.buffer, size, NULL, status)); return PyUnicode_FromUnicodeString(dest.buffer, size); } return ICUException(status).reportError(); } if (!parseArgs(args, "PS", TYPE_CLASSID(BreakIterator), &iter, &u, &_u)) { Buffer dest(u->length() + 8); UErrorCode status = U_ZERO_ERROR; int32_t size = CaseMap::toTitle( NULL, 0, iter, u->getBuffer(), u->length(), dest.buffer, dest.size, NULL, status); if (U_SUCCESS(status)) return PyUnicode_FromUnicodeString(dest.buffer, size); if (status == U_BUFFER_OVERFLOW_ERROR) { Buffer dest(size); STATUS_CALL(CaseMap::toTitle( NULL, 0, iter, u->getBuffer(), u->length(), dest.buffer, size, NULL, status)); return PyUnicode_FromUnicodeString(dest.buffer, size); } return ICUException(status).reportError(); } if (!parseArgs(args, "iS", &options, &u, &_u)) { Buffer dest(u->length() + 8); UErrorCode status = U_ZERO_ERROR; int32_t size = CaseMap::toTitle( NULL, options, NULL, u->getBuffer(), u->length(), dest.buffer, dest.size, NULL, status); if (U_SUCCESS(status)) return PyUnicode_FromUnicodeString(dest.buffer, size); if (status == U_BUFFER_OVERFLOW_ERROR) { Buffer dest(size); STATUS_CALL(CaseMap::toTitle( NULL, options, NULL, u->getBuffer(), u->length(), dest.buffer, size, NULL, status)); return PyUnicode_FromUnicodeString(dest.buffer, size); } return ICUException(status).reportError(); } break; case 3: if (!parseArgs(args, "PSO", TYPE_CLASSID(Locale), &EditsType_, &locale, &u, &_u, &edits)) { Buffer dest(u->length() + 8); UErrorCode status = U_ZERO_ERROR; int32_t size = CaseMap::toTitle( locale->getBaseName(), 0, NULL, u->getBuffer(), u->length(), dest.buffer, dest.size, ((t_edits *) edits)->object, status); if (U_SUCCESS(status)) return PyUnicode_FromUnicodeString(dest.buffer, size); if (status == U_BUFFER_OVERFLOW_ERROR) { Buffer dest(size); STATUS_CALL(CaseMap::toTitle( locale->getBaseName(), 0, NULL, u->getBuffer(), u->length(), dest.buffer, size, ((t_edits *) edits)->object, status)); return PyUnicode_FromUnicodeString(dest.buffer, size); } return ICUException(status).reportError(); } if (!parseArgs(args, "PSO", TYPE_CLASSID(BreakIterator), &EditsType_, &iter, &u, &_u, &edits)) { Buffer dest(u->length() + 8); UErrorCode status = U_ZERO_ERROR; int32_t size = CaseMap::toTitle( NULL, 0, iter, u->getBuffer(), u->length(), dest.buffer, dest.size, ((t_edits *) edits)->object, status); if (U_SUCCESS(status)) return PyUnicode_FromUnicodeString(dest.buffer, size); if (status == U_BUFFER_OVERFLOW_ERROR) { Buffer dest(size); STATUS_CALL(CaseMap::toTitle( NULL, 0, iter, u->getBuffer(), u->length(), dest.buffer, size, ((t_edits *) edits)->object, status)); return PyUnicode_FromUnicodeString(dest.buffer, size); } return ICUException(status).reportError(); } if (!parseArgs(args, "iSO", &EditsType_, &options, &u, &_u, &edits)) { Buffer dest(u->length() + 8); UErrorCode status = U_ZERO_ERROR; int32_t size = CaseMap::toTitle( NULL, options, NULL, u->getBuffer(), u->length(), dest.buffer, dest.size, ((t_edits *) edits)->object, status); if (U_SUCCESS(status)) return PyUnicode_FromUnicodeString(dest.buffer, size); if (status == U_BUFFER_OVERFLOW_ERROR) { Buffer dest(size); STATUS_CALL(CaseMap::toTitle( NULL, options, NULL, u->getBuffer(), u->length(), dest.buffer, size, ((t_edits *) edits)->object, status)); return PyUnicode_FromUnicodeString(dest.buffer, size); } return ICUException(status).reportError(); } if (!parseArgs(args, "PPS", TYPE_CLASSID(Locale), TYPE_CLASSID(BreakIterator), &locale, &iter, &u, &_u)) { Buffer dest(u->length() + 8); UErrorCode status = U_ZERO_ERROR; int32_t size = CaseMap::toTitle( locale->getBaseName(), 0, iter, u->getBuffer(), u->length(), dest.buffer, dest.size, NULL, status); if (U_SUCCESS(status)) return PyUnicode_FromUnicodeString(dest.buffer, size); if (status == U_BUFFER_OVERFLOW_ERROR) { Buffer dest(size); STATUS_CALL(CaseMap::toTitle( locale->getBaseName(), 0, iter, u->getBuffer(), u->length(), dest.buffer, size, NULL, status)); return PyUnicode_FromUnicodeString(dest.buffer, size); } return ICUException(status).reportError(); } if (!parseArgs(args, "PiS", TYPE_CLASSID(Locale), &locale, &options, &u, &_u)) { Buffer dest(u->length() + 8); UErrorCode status = U_ZERO_ERROR; int32_t size = CaseMap::toTitle( locale->getBaseName(), options, NULL, u->getBuffer(), u->length(), dest.buffer, dest.size, NULL, status); if (U_SUCCESS(status)) return PyUnicode_FromUnicodeString(dest.buffer, size); if (status == U_BUFFER_OVERFLOW_ERROR) { Buffer dest(size); STATUS_CALL(CaseMap::toTitle( locale->getBaseName(), options, NULL, u->getBuffer(), u->length(), dest.buffer, size, NULL, status)); return PyUnicode_FromUnicodeString(dest.buffer, size); } return ICUException(status).reportError(); } if (!parseArgs(args, "iPS", TYPE_CLASSID(BreakIterator), &options, &iter, &u, &_u)) { Buffer dest(u->length() + 8); UErrorCode status = U_ZERO_ERROR; int32_t size = CaseMap::toTitle( NULL, options, iter, u->getBuffer(), u->length(), dest.buffer, dest.size, NULL, status); if (U_SUCCESS(status)) return PyUnicode_FromUnicodeString(dest.buffer, size); if (status == U_BUFFER_OVERFLOW_ERROR) { Buffer dest(size); STATUS_CALL(CaseMap::toTitle( NULL, options, iter, u->getBuffer(), u->length(), dest.buffer, size, NULL, status)); return PyUnicode_FromUnicodeString(dest.buffer, size); } return ICUException(status).reportError(); } break; case 4: if (!parseArgs(args, "PPSO", TYPE_CLASSID(Locale), TYPE_CLASSID(BreakIterator), &EditsType_, &locale, &iter, &u, &_u, &edits)) { Buffer dest(u->length() + 8); UErrorCode status = U_ZERO_ERROR; int32_t size = CaseMap::toTitle( locale->getBaseName(), 0, iter, u->getBuffer(), u->length(), dest.buffer, dest.size, ((t_edits *) edits)->object, status); if (U_SUCCESS(status)) return PyUnicode_FromUnicodeString(dest.buffer, size); if (status == U_BUFFER_OVERFLOW_ERROR) { Buffer dest(size); STATUS_CALL(CaseMap::toTitle( locale->getBaseName(), 0, iter, u->getBuffer(), u->length(), dest.buffer, size, ((t_edits *) edits)->object, status)); return PyUnicode_FromUnicodeString(dest.buffer, size); } return ICUException(status).reportError(); } if (!parseArgs(args, "PiSO", TYPE_CLASSID(Locale), &EditsType_, &locale, &options, &u, &_u, &edits)) { Buffer dest(u->length() + 8); UErrorCode status = U_ZERO_ERROR; int32_t size = CaseMap::toTitle( locale->getBaseName(), options, NULL, u->getBuffer(), u->length(), dest.buffer, dest.size, ((t_edits *) edits)->object, status); if (U_SUCCESS(status)) return PyUnicode_FromUnicodeString(dest.buffer, size); if (status == U_BUFFER_OVERFLOW_ERROR) { Buffer dest(size); STATUS_CALL(CaseMap::toTitle( locale->getBaseName(), options, NULL, u->getBuffer(), u->length(), dest.buffer, size, ((t_edits *) edits)->object, status)); return PyUnicode_FromUnicodeString(dest.buffer, size); } return ICUException(status).reportError(); } if (!parseArgs(args, "iPSO", TYPE_CLASSID(BreakIterator), &EditsType_, &options, &iter, &u, &_u, &edits)) { Buffer dest(u->length() + 8); UErrorCode status = U_ZERO_ERROR; int32_t size = CaseMap::toTitle( NULL, options, iter, u->getBuffer(), u->length(), dest.buffer, dest.size, ((t_edits *) edits)->object, status); if (U_SUCCESS(status)) return PyUnicode_FromUnicodeString(dest.buffer, size); if (status == U_BUFFER_OVERFLOW_ERROR) { Buffer dest(size); STATUS_CALL(CaseMap::toTitle( NULL, options, iter, u->getBuffer(), u->length(), dest.buffer, size, ((t_edits *) edits)->object, status)); return PyUnicode_FromUnicodeString(dest.buffer, size); } return ICUException(status).reportError(); } if (!parseArgs(args, "PiPS", TYPE_CLASSID(Locale), TYPE_CLASSID(BreakIterator), &locale, &options, &iter, &u, &_u)) { Buffer dest(u->length() + 8); UErrorCode status = U_ZERO_ERROR; int32_t size = CaseMap::toTitle( locale->getBaseName(), options, iter, u->getBuffer(), u->length(), dest.buffer, dest.size, NULL, status); if (U_SUCCESS(status)) return PyUnicode_FromUnicodeString(dest.buffer, size); if (status == U_BUFFER_OVERFLOW_ERROR) { Buffer dest(size); STATUS_CALL(CaseMap::toTitle( locale->getBaseName(), options, iter, u->getBuffer(), u->length(), dest.buffer, size, NULL, status)); return PyUnicode_FromUnicodeString(dest.buffer, size); } return ICUException(status).reportError(); } break; case 5: if (!parseArgs(args, "PiPSO", TYPE_CLASSID(Locale), TYPE_CLASSID(BreakIterator), &EditsType_, &locale, &options, &iter, &u, &_u, &edits)) { Buffer dest(u->length() + 8); UErrorCode status = U_ZERO_ERROR; int32_t size = CaseMap::toTitle( locale->getBaseName(), options, iter, u->getBuffer(), u->length(), dest.buffer, dest.size, ((t_edits *) edits)->object, status); if (U_SUCCESS(status)) return PyUnicode_FromUnicodeString(dest.buffer, size); if (status == U_BUFFER_OVERFLOW_ERROR) { Buffer dest(size); STATUS_CALL(CaseMap::toTitle( locale->getBaseName(), options, iter, u->getBuffer(), u->length(), dest.buffer, size, ((t_edits *) edits)->object, status)); return PyUnicode_FromUnicodeString(dest.buffer, size); } return ICUException(status).reportError(); } break; } return PyErr_SetArgsError(type, "toTitle", args); } static PyObject *t_casemap_fold(PyTypeObject *type, PyObject *args) { UnicodeString *u, _u; int32_t options; PyObject *edits; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "S", &u, &_u)) { Buffer dest(u->length() + 8); UErrorCode status = U_ZERO_ERROR; int32_t size = CaseMap::fold( 0, u->getBuffer(), u->length(), dest.buffer, dest.size, NULL, status); if (U_SUCCESS(status)) return PyUnicode_FromUnicodeString(dest.buffer, size); if (status == U_BUFFER_OVERFLOW_ERROR) { Buffer dest(size); STATUS_CALL(CaseMap::fold( 0, u->getBuffer(), u->length(), dest.buffer, size, NULL, status)); return PyUnicode_FromUnicodeString(dest.buffer, size); } return ICUException(status).reportError(); } break; case 2: if (!parseArgs(args, "SO", &EditsType_, &u, &_u, &edits)) { Buffer dest(u->length() + 8); UErrorCode status = U_ZERO_ERROR; int32_t size = CaseMap::fold( 0, u->getBuffer(), u->length(), dest.buffer, dest.size, ((t_edits *) edits)->object, status); if (U_SUCCESS(status)) return PyUnicode_FromUnicodeString(dest.buffer, size); if (status == U_BUFFER_OVERFLOW_ERROR) { Buffer dest(size); STATUS_CALL(CaseMap::fold( 0, u->getBuffer(), u->length(), dest.buffer, size, ((t_edits *) edits)->object, status)); return PyUnicode_FromUnicodeString(dest.buffer, size); } return ICUException(status).reportError(); } if (!parseArgs(args, "iS", &options, &u, &_u)) { Buffer dest(u->length() + 8); UErrorCode status = U_ZERO_ERROR; int32_t size = CaseMap::fold( options, u->getBuffer(), u->length(), dest.buffer, dest.size, NULL, status); if (U_SUCCESS(status)) return PyUnicode_FromUnicodeString(dest.buffer, size); if (status == U_BUFFER_OVERFLOW_ERROR) { Buffer dest(size); STATUS_CALL(CaseMap::fold( options, u->getBuffer(), u->length(), dest.buffer, size, NULL, status)); return PyUnicode_FromUnicodeString(dest.buffer, size); } return ICUException(status).reportError(); } break; case 3: if (!parseArgs(args, "iSO", &EditsType_, &options, &u, &_u, &edits)) { Buffer dest(u->length() + 8); UErrorCode status = U_ZERO_ERROR; int32_t size = CaseMap::fold( options, u->getBuffer(), u->length(), dest.buffer, dest.size, ((t_edits *) edits)->object, status); if (U_SUCCESS(status)) return PyUnicode_FromUnicodeString(dest.buffer, size); if (status == U_BUFFER_OVERFLOW_ERROR) { Buffer dest(size); STATUS_CALL(CaseMap::fold( options, u->getBuffer(), u->length(), dest.buffer, size, ((t_edits *) edits)->object, status)); return PyUnicode_FromUnicodeString(dest.buffer, size); } return ICUException(status).reportError(); } break; } return PyErr_SetArgsError(type, "fold", args); } /* Edits */ static int t_edits_init(t_edits *self, PyObject *args, PyObject *kwds) { switch (PyTuple_Size(args)) { case 0: self->object = new Edits(); self->flags = T_OWNED; break; default: PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; } if (self->object) return 0; return -1; } static PyObject *t_edits_reset(t_edits *self) { self->object->reset(); Py_RETURN_NONE; } static PyObject *t_edits_addUnchanged(t_edits *self, PyObject *arg) { int length; if (!parseArg(arg, "i", &length)) { self->object->addUnchanged(length); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "addUnchanged", arg); } static PyObject *t_edits_addReplace(t_edits *self, PyObject *args) { int oldLength, newLength; if (!parseArgs(args, "ii", &oldLength, &newLength)) { self->object->addReplace(oldLength, newLength); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "addReplace", args); } static PyObject *t_edits_lengthDelta(t_edits *self) { return PyInt_FromLong(self->object->lengthDelta()); } static PyObject *t_edits_hasChanges(t_edits *self) { Py_RETURN_BOOL(self->object->hasChanges()); } static PyObject *t_edits_numberOfChanges(t_edits *self) { return PyInt_FromLong(self->object->numberOfChanges()); } static PyObject *t_edits_getCoarseChangesIterator(t_edits *self) { return wrap_EditsIterator(self->object->getCoarseChangesIterator()); } static PyObject *t_edits_getCoarseIterator(t_edits *self) { return wrap_EditsIterator(self->object->getCoarseIterator()); } static PyObject *t_edits_getFineChangesIterator(t_edits *self) { return wrap_EditsIterator(self->object->getFineChangesIterator()); } static PyObject *t_edits_getFineIterator(t_edits *self) { return wrap_EditsIterator(self->object->getFineIterator()); } #if U_ICU_VERSION_HEX >= VERSION_HEX(60, 0, 0) static PyObject *t_edits_mergeAndAppend(t_edits *self, PyObject *args) { PyObject *ab, *bc; switch (PyTuple_Size(args)) { case 2: if (!parseArgs(args, "OO", &EditsType_, &EditsType_, &ab, &bc)) { STATUS_CALL(self->object->mergeAndAppend( *((t_edits *) ab)->object, *((t_edits *) bc)->object, status)); Py_RETURN_NONE; } } return PyErr_SetArgsError((PyObject *) self, "mergeAndAppend", args); } #endif /* EditsIterator */ static int t_editsiterator_init(t_editsiterator *self, PyObject *args, PyObject *kwds) { switch (PyTuple_Size(args)) { case 0: self->object = new EditsIterator(); self->flags = T_OWNED; break; default: PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; } if (self->object) return 0; return -1; } static PyObject *t_editsiterator_findSourceIndex( t_editsiterator *self, PyObject *arg) { int index; if (!parseArg(arg, "i", &index)) { bool found; STATUS_CALL(found = self->object->findSourceIndex(index, status)); Py_RETURN_BOOL(found); } return PyErr_SetArgsError((PyObject *) self, "findSourceIndex", arg); } static PyObject *t_editsiterator_findDestinationIndex( t_editsiterator *self, PyObject *arg) { int index; if (!parseArg(arg, "i", &index)) { bool found; STATUS_CALL(found = self->object->findDestinationIndex(index, status)); Py_RETURN_BOOL(found); } return PyErr_SetArgsError((PyObject *) self, "findDestinationIndex", arg); } static PyObject *t_editsiterator_destinationIndexFromSourceIndex( t_editsiterator *self, PyObject *arg) { int index; if (!parseArg(arg, "i", &index)) { STATUS_CALL(index = self->object->destinationIndexFromSourceIndex( index, status)); return PyInt_FromLong(index); } return PyErr_SetArgsError( (PyObject *) self, "destinationIndexFromSourceIndex", arg); } static PyObject *t_editsiterator_sourceIndexFromdestinationIndex( t_editsiterator *self, PyObject *arg) { int index; if (!parseArg(arg, "i", &index)) { STATUS_CALL(index = self->object->sourceIndexFromDestinationIndex( index, status)); return PyInt_FromLong(index); } return PyErr_SetArgsError( (PyObject *) self, "sourceIndexFromDestinationIndex", arg); } static PyObject *t_editsiterator__hasChange( t_editsiterator *self, void *closure) { Py_RETURN_BOOL(self->object->hasChange()); } static PyObject *t_editsiterator__newLength( t_editsiterator *self, void *closure) { return PyInt_FromLong(self->object->newLength()); } static PyObject *t_editsiterator__oldLength( t_editsiterator *self, void *closure) { return PyInt_FromLong(self->object->oldLength()); } static PyObject *t_editsiterator__sourceIndex( t_editsiterator *self, void *closure) { return PyInt_FromLong(self->object->sourceIndex()); } static PyObject *t_editsiterator__destinationIndex( t_editsiterator *self, void *closure) { return PyInt_FromLong(self->object->destinationIndex()); } static PyObject *t_editsiterator__replacementIndex( t_editsiterator *self, void *closure) { return PyInt_FromLong(self->object->replacementIndex()); } static PyObject *t_editsiterator_iter_next(t_editsiterator *self) { UBool more; STATUS_CALL(more = self->object->next(status)); if (!more) { PyErr_SetNone(PyExc_StopIteration); return NULL; } return Py_BuildValue( "Oiiiii", self->object->hasChange() ? Py_True : Py_False, (int) self->object->oldLength(), (int) self->object->newLength(), (int) self->object->sourceIndex(), (int) self->object->destinationIndex(), (int) self->object->replacementIndex()); } #endif void _init_casemap(PyObject *m) { #if U_ICU_VERSION_HEX >= VERSION_HEX(59, 0, 0) EditsIteratorType_.tp_getset = t_editsiterator_properties; EditsIteratorType_.tp_iter = (getiterfunc) PyObject_SelfIter; EditsIteratorType_.tp_iternext = (iternextfunc) t_editsiterator_iter_next; INSTALL_STRUCT(CaseMap, m); INSTALL_STRUCT(Edits, m); INSTALL_STRUCT(EditsIterator, m); #endif } ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1530564121.0 PyICU-2.4.2/casemap.h0000644000076500000000000000255100000000000014441 0ustar00vajdawheel00000000000000/* ==================================================================== * Copyright (c) 2004-2018 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 _casemap_h #define _casemap_h void _init_casemap(PyObject *m); #endif /* _casemap_h */ ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1553763196.0 PyICU-2.4.2/char.cpp0000644000076500000000000023551500000000000014310 0ustar00vajdawheel00000000000000/* ==================================================================== * Copyright (c) 2004-2015 Open Source Applications Foundation. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. * ==================================================================== */ #include #include #include "common.h" #include "structmember.h" #include "bases.h" #include "char.h" #include "macros.h" #include "unicodeset.h" DECLARE_CONSTANTS_TYPE(UProperty); DECLARE_CONSTANTS_TYPE(UCharDirection); DECLARE_CONSTANTS_TYPE(UCharCategory); DECLARE_CONSTANTS_TYPE(UBlockCode); DECLARE_CONSTANTS_TYPE(UCharNameChoice); DECLARE_CONSTANTS_TYPE(UPropertyNameChoice); DECLARE_CONSTANTS_TYPE(UWordBreakValues); DECLARE_CONSTANTS_TYPE(UJoiningGroup); DECLARE_CONSTANTS_TYPE(ULineBreak); DECLARE_CONSTANTS_TYPE(UGraphemeClusterBreak); DECLARE_CONSTANTS_TYPE(UHangulSyllableType); #if U_ICU_VERSION_HEX >= VERSION_HEX(52, 0, 0) DECLARE_CONSTANTS_TYPE(UBidiPairedBracketType); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(63, 0, 0) DECLARE_CONSTANTS_TYPE(UIndicPositionalCategory); DECLARE_CONSTANTS_TYPE(UIndicSyllabicCategory); DECLARE_CONSTANTS_TYPE(UVerticalOrientation); #endif /* Char */ class t_char : public _wrapper { public: UNone *object; }; typedef UBool (*bool_char_fn)(UChar32 c); typedef UChar32 (*uchar32_char_fn)(UChar32 c); static int t_char_init(t_char *self, PyObject *args, PyObject *kwds); static PyObject *t_char_hasBinaryProperty(PyTypeObject *type, PyObject *args); #if U_ICU_VERSION_HEX >= VERSION_HEX(63, 0, 0) static PyObject *t_char_getBinaryPropertySet(PyTypeObject *type, PyObject *arg); #endif static PyObject *t_char_getIntPropertyValue(PyTypeObject *type, PyObject *args); static PyObject *t_char_getIntPropertyMinValue(PyTypeObject *type, PyObject *arg); static PyObject *t_char_getIntPropertyMaxValue(PyTypeObject *type, PyObject *arg); static PyObject *t_char_getNumericValue(PyTypeObject *type, PyObject *arg); static PyObject *t_char_isUAlphabetic(PyTypeObject *type, PyObject *arg); static PyObject *t_char_isULowercase(PyTypeObject *type, PyObject *arg); static PyObject *t_char_isUUppercase(PyTypeObject *type, PyObject *arg); static PyObject *t_char_isUWhiteSpace(PyTypeObject *type, PyObject *arg); static PyObject *t_char_islower(PyTypeObject *type, PyObject *arg); static PyObject *t_char_isupper(PyTypeObject *type, PyObject *arg); static PyObject *t_char_istitle(PyTypeObject *type, PyObject *arg); static PyObject *t_char_isdigit(PyTypeObject *type, PyObject *arg); static PyObject *t_char_isalpha(PyTypeObject *type, PyObject *arg); static PyObject *t_char_isalnum(PyTypeObject *type, PyObject *arg); static PyObject *t_char_isxdigit(PyTypeObject *type, PyObject *arg); static PyObject *t_char_ispunct(PyTypeObject *type, PyObject *arg); static PyObject *t_char_isgraph(PyTypeObject *type, PyObject *arg); static PyObject *t_char_isblank(PyTypeObject *type, PyObject *arg); static PyObject *t_char_isdefined(PyTypeObject *type, PyObject *arg); static PyObject *t_char_isspace(PyTypeObject *type, PyObject *arg); static PyObject *t_char_isJavaSpaceChar(PyTypeObject *type, PyObject *arg); static PyObject *t_char_isWhitespace(PyTypeObject *type, PyObject *arg); static PyObject *t_char_iscntrl(PyTypeObject *type, PyObject *arg); static PyObject *t_char_isISOControl(PyTypeObject *type, PyObject *arg); static PyObject *t_char_isprint(PyTypeObject *type, PyObject *arg); static PyObject *t_char_isbase(PyTypeObject *type, PyObject *arg); static PyObject *t_char_charDirection(PyTypeObject *type, PyObject *arg); static PyObject *t_char_isMirrored(PyTypeObject *type, PyObject *arg); static PyObject *t_char_charMirror(PyTypeObject *type, PyObject *arg); #if U_ICU_VERSION_HEX >= VERSION_HEX(52, 0, 0) static PyObject *t_char_getBidiPairedBracket(PyTypeObject *type, PyObject *arg); #endif static PyObject *t_char_charType(PyTypeObject *type, PyObject *arg); static PyObject *t_char_enumCharTypes(PyTypeObject *type, PyObject *arg); static PyObject *t_char_getCombiningClass(PyTypeObject *type, PyObject *arg); static PyObject *t_char_charDigitValue(PyTypeObject *type, PyObject *arg); static PyObject *t_char_ublock_getCode(PyTypeObject *type, PyObject *arg); static PyObject *t_char_charName(PyTypeObject *type, PyObject *args); static PyObject *t_char_charFromName(PyTypeObject *type, PyObject *args); static PyObject *t_char_enumCharNames(PyTypeObject *type, PyObject *args); static PyObject *t_char_getPropertyName(PyTypeObject *type, PyObject *args); static PyObject *t_char_getPropertyEnum(PyTypeObject *type, PyObject *arg); static PyObject *t_char_isIDStart(PyTypeObject *type, PyObject *arg); static PyObject *t_char_isIDPart(PyTypeObject *type, PyObject *arg); static PyObject *t_char_isIDIgnorable(PyTypeObject *type, PyObject *arg); static PyObject *t_char_isJavaIDStart(PyTypeObject *type, PyObject *arg); static PyObject *t_char_isJavaIDPart(PyTypeObject *type, PyObject *arg); static PyObject *t_char_tolower(PyTypeObject *type, PyObject *arg); static PyObject *t_char_toupper(PyTypeObject *type, PyObject *arg); static PyObject *t_char_totitle(PyTypeObject *type, PyObject *arg); static PyObject *t_char_foldCase(PyTypeObject *type, PyObject *args); static PyObject *t_char_digit(PyTypeObject *type, PyObject *args); static PyObject *t_char_forDigit(PyTypeObject *type, PyObject *args); static PyObject *t_char_charAge(PyTypeObject *type, PyObject *arg); static PyObject *t_char_getUnicodeVersion(PyTypeObject *type); static PyObject *t_char_getFC_NFKC_Closure(PyTypeObject *type, PyObject *arg); static PyMethodDef t_char_methods[] = { DECLARE_METHOD(t_char, hasBinaryProperty, METH_VARARGS | METH_CLASS), #if U_ICU_VERSION_HEX >= VERSION_HEX(63, 0, 0) DECLARE_METHOD(t_char, getBinaryPropertySet, METH_O | METH_CLASS), #endif DECLARE_METHOD(t_char, getIntPropertyValue, METH_VARARGS | METH_CLASS), DECLARE_METHOD(t_char, getIntPropertyMinValue, METH_O | METH_CLASS), DECLARE_METHOD(t_char, getIntPropertyMaxValue, METH_O | METH_CLASS), DECLARE_METHOD(t_char, getNumericValue, METH_O | METH_CLASS), DECLARE_METHOD(t_char, isUAlphabetic, METH_O | METH_CLASS), DECLARE_METHOD(t_char, isULowercase, METH_O | METH_CLASS), DECLARE_METHOD(t_char, isUUppercase, METH_O | METH_CLASS), DECLARE_METHOD(t_char, isUWhiteSpace, METH_O | METH_CLASS), DECLARE_METHOD(t_char, islower, METH_O | METH_CLASS), DECLARE_METHOD(t_char, isupper, METH_O | METH_CLASS), DECLARE_METHOD(t_char, istitle, METH_O | METH_CLASS), DECLARE_METHOD(t_char, isdigit, METH_O | METH_CLASS), DECLARE_METHOD(t_char, isalpha, METH_O | METH_CLASS), DECLARE_METHOD(t_char, isalnum, METH_O | METH_CLASS), DECLARE_METHOD(t_char, isxdigit, METH_O | METH_CLASS), DECLARE_METHOD(t_char, ispunct, METH_O | METH_CLASS), DECLARE_METHOD(t_char, isgraph, METH_O | METH_CLASS), DECLARE_METHOD(t_char, isblank, METH_O | METH_CLASS), DECLARE_METHOD(t_char, isdefined, METH_O | METH_CLASS), DECLARE_METHOD(t_char, isspace, METH_O | METH_CLASS), DECLARE_METHOD(t_char, isJavaSpaceChar, METH_O | METH_CLASS), DECLARE_METHOD(t_char, isWhitespace, METH_O | METH_CLASS), DECLARE_METHOD(t_char, iscntrl, METH_O | METH_CLASS), DECLARE_METHOD(t_char, isISOControl, METH_O | METH_CLASS), DECLARE_METHOD(t_char, isprint, METH_O | METH_CLASS), DECLARE_METHOD(t_char, isbase, METH_O | METH_CLASS), DECLARE_METHOD(t_char, charDirection, METH_O | METH_CLASS), DECLARE_METHOD(t_char, isMirrored, METH_O | METH_CLASS), DECLARE_METHOD(t_char, charMirror, METH_O | METH_CLASS), #if U_ICU_VERSION_HEX >= VERSION_HEX(52, 0, 0) DECLARE_METHOD(t_char, getBidiPairedBracket, METH_O | METH_CLASS), #endif DECLARE_METHOD(t_char, charType, METH_O | METH_CLASS), DECLARE_METHOD(t_char, enumCharTypes, METH_O | METH_CLASS), DECLARE_METHOD(t_char, getCombiningClass, METH_O | METH_CLASS), DECLARE_METHOD(t_char, charDigitValue, METH_O | METH_CLASS), DECLARE_METHOD(t_char, ublock_getCode, METH_O | METH_CLASS), DECLARE_METHOD(t_char, charName, METH_VARARGS | METH_CLASS), DECLARE_METHOD(t_char, charFromName, METH_VARARGS | METH_CLASS), DECLARE_METHOD(t_char, enumCharNames, METH_VARARGS | METH_CLASS), DECLARE_METHOD(t_char, getPropertyName, METH_VARARGS | METH_CLASS), DECLARE_METHOD(t_char, getPropertyEnum, METH_O | METH_CLASS), DECLARE_METHOD(t_char, isIDStart, METH_O | METH_CLASS), DECLARE_METHOD(t_char, isIDPart, METH_O | METH_CLASS), DECLARE_METHOD(t_char, isIDIgnorable, METH_O | METH_CLASS), DECLARE_METHOD(t_char, isJavaIDStart, METH_O | METH_CLASS), DECLARE_METHOD(t_char, isJavaIDPart, METH_O | METH_CLASS), DECLARE_METHOD(t_char, tolower, METH_O | METH_CLASS), DECLARE_METHOD(t_char, toupper, METH_O | METH_CLASS), DECLARE_METHOD(t_char, totitle, METH_O | METH_CLASS), DECLARE_METHOD(t_char, foldCase, METH_VARARGS | METH_CLASS), DECLARE_METHOD(t_char, digit, METH_VARARGS | METH_CLASS), DECLARE_METHOD(t_char, forDigit, METH_VARARGS | METH_CLASS), DECLARE_METHOD(t_char, charAge, METH_O | METH_CLASS), DECLARE_METHOD(t_char, getUnicodeVersion, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_char, getFC_NFKC_Closure, METH_O | METH_CLASS), { NULL, NULL, 0, NULL } }; static void t_char_dealloc(t_char *self) { Py_TYPE(self)->tp_free((PyObject *) self); } DECLARE_STRUCT(Char, t_char, UNone, t_char_init, t_char_dealloc); /* Char */ static int t_char_init(t_char *self, PyObject *args, PyObject *kwds) { switch (PyTuple_Size(args)) { case 0: self->object = NULL; /* there is no ICU struct for this */ self->flags = T_OWNED; return 0; default: PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; } } static PyObject *t_char_hasBinaryProperty(PyTypeObject *type, PyObject *args) { UnicodeString *u, _u; UProperty prop; UChar32 c; switch (PyTuple_Size(args)) { case 2: if (!parseArgs(args, "ii", &c, &prop)) Py_RETURN_BOOL(u_hasBinaryProperty(c, prop)); if (!parseArgs(args, "Si", &u, &_u, &prop) && u->length() >= 1) Py_RETURN_BOOL(u_hasBinaryProperty(u->char32At(0), prop)); break; } return PyErr_SetArgsError((PyObject *) type, "hasBinaryProperty", args); } #if U_ICU_VERSION_HEX >= VERSION_HEX(63, 0, 0) static PyObject *t_char_getBinaryPropertySet(PyTypeObject *type, PyObject *arg) { UProperty prop; if (!parseArg(arg, "i", &prop)) { const USet *set; STATUS_CALL(set = u_getBinaryPropertySet(prop, &status)); return wrap_UnicodeSet( const_cast(UnicodeSet::fromUSet(set)), 0); } return PyErr_SetArgsError((PyObject *) type, "getBinaryPropertySet", arg); } #endif static PyObject *t_char_getIntPropertyValue(PyTypeObject *type, PyObject *args) { UnicodeString *u, _u; UProperty prop; UChar32 c; switch (PyTuple_Size(args)) { case 2: if (!parseArgs(args, "ii", &c, &prop)) return PyInt_FromLong(u_getIntPropertyValue(c, prop)); if (!parseArgs(args, "Si", &u, &_u, &prop) && u->length() >= 1) return PyInt_FromLong(u_getIntPropertyValue(u->char32At(0), prop)); break; } return PyErr_SetArgsError((PyObject *) type, "getIntPropertyValue", args); } static PyObject *t_char_getIntPropertyMinValue(PyTypeObject *type, PyObject *arg) { UProperty prop; if (!parseArg(arg, "i", &prop)) return PyInt_FromLong(u_getIntPropertyMinValue(prop)); return PyErr_SetArgsError((PyObject *) type, "getIntPropertyMinValue", arg); } static PyObject *t_char_getIntPropertyMaxValue(PyTypeObject *type, PyObject *arg) { UProperty prop; if (!parseArg(arg, "i", &prop)) return PyInt_FromLong(u_getIntPropertyMaxValue(prop)); return PyErr_SetArgsError((PyObject *) type, "getIntPropertyMaxValue", arg); } static PyObject *t_char_getNumericValue(PyTypeObject *type, PyObject *arg) { UnicodeString *u, _u; UChar32 c; double value = U_NO_NUMERIC_VALUE; if (!parseArg(arg, "i", &c)) value = u_getNumericValue(c); else if (!parseArg(arg, "S", &u, &_u) && u->length() >= 1) value = u_getNumericValue(u->char32At(0)); else return PyErr_SetArgsError((PyObject *) type, "getNumericValue", arg); if (value == U_NO_NUMERIC_VALUE) Py_RETURN_NONE; return PyFloat_FromDouble(value); } static PyObject *t_char_fn(bool_char_fn fn, const char *name, PyTypeObject *type, PyObject *arg) { UnicodeString *u, _u; UChar32 c; if (!parseArg(arg, "i", &c)) Py_RETURN_BOOL((*fn)(c)); if (!parseArg(arg, "S", &u, &_u) && u->length() >= 1) Py_RETURN_BOOL((*fn)(u->char32At(0))); return PyErr_SetArgsError((PyObject *) type, name, arg); } static PyObject *t_char_isUAlphabetic(PyTypeObject *type, PyObject *arg) { return t_char_fn(u_isUAlphabetic, "isUAlphabetic", type, arg); } static PyObject *t_char_isULowercase(PyTypeObject *type, PyObject *arg) { return t_char_fn(u_isULowercase, "isULowercase", type, arg); } static PyObject *t_char_isUUppercase(PyTypeObject *type, PyObject *arg) { return t_char_fn(u_isUUppercase, "isUUpperCase", type, arg); } static PyObject *t_char_isUWhiteSpace(PyTypeObject *type, PyObject *arg) { return t_char_fn(u_isUWhiteSpace, "isUWhiteSpace", type, arg); } static PyObject *t_char_islower(PyTypeObject *type, PyObject *arg) { return t_char_fn(u_islower, "islower", type, arg); } static PyObject *t_char_isupper(PyTypeObject *type, PyObject *arg) { return t_char_fn(u_isupper, "isupper", type, arg); } static PyObject *t_char_istitle(PyTypeObject *type, PyObject *arg) { return t_char_fn(u_istitle, "istitle", type, arg); } static PyObject *t_char_isdigit(PyTypeObject *type, PyObject *arg) { return t_char_fn(u_isdigit, "isdigit", type, arg); } static PyObject *t_char_isalpha(PyTypeObject *type, PyObject *arg) { return t_char_fn(u_isalpha, "isalpha", type, arg); } static PyObject *t_char_isalnum(PyTypeObject *type, PyObject *arg) { return t_char_fn(u_isalnum, "isalnum", type, arg); } static PyObject *t_char_isxdigit(PyTypeObject *type, PyObject *arg) { return t_char_fn(u_isxdigit, "isxdigit", type, arg); } static PyObject *t_char_ispunct(PyTypeObject *type, PyObject *arg) { return t_char_fn(u_ispunct, "ispunct", type, arg); } static PyObject *t_char_isgraph(PyTypeObject *type, PyObject *arg) { return t_char_fn(u_isgraph, "isgraph", type, arg); } static PyObject *t_char_isblank(PyTypeObject *type, PyObject *arg) { return t_char_fn(u_isblank, "isblank", type, arg); } static PyObject *t_char_isdefined(PyTypeObject *type, PyObject *arg) { return t_char_fn(u_isdefined, "isdefined", type, arg); } static PyObject *t_char_isspace(PyTypeObject *type, PyObject *arg) { return t_char_fn(u_isspace, "isspace", type, arg); } static PyObject *t_char_isJavaSpaceChar(PyTypeObject *type, PyObject *arg) { return t_char_fn(u_isJavaSpaceChar, "isJavaSpaceChar", type, arg); } static PyObject *t_char_isWhitespace(PyTypeObject *type, PyObject *arg) { return t_char_fn(u_isWhitespace, "isWhitespace", type, arg); } static PyObject *t_char_iscntrl(PyTypeObject *type, PyObject *arg) { return t_char_fn(u_iscntrl, "iscntrl", type, arg); } static PyObject *t_char_isISOControl(PyTypeObject *type, PyObject *arg) { return t_char_fn(u_isISOControl, "isISOControl", type, arg); } static PyObject *t_char_isprint(PyTypeObject *type, PyObject *arg) { return t_char_fn(u_isprint, "isprint", type, arg); } static PyObject *t_char_isbase(PyTypeObject *type, PyObject *arg) { return t_char_fn(u_isbase, "isbase", type, arg); } static PyObject *t_char_isMirrored(PyTypeObject *type, PyObject *arg) { return t_char_fn(u_isMirrored, "isMirrored", type, arg); } static PyObject *t_char_isIDStart(PyTypeObject *type, PyObject *arg) { return t_char_fn(u_isIDStart, "isIDStart", type, arg); } static PyObject *t_char_isIDPart(PyTypeObject *type, PyObject *arg) { return t_char_fn(u_isIDPart, "isIDPart", type, arg); } static PyObject *t_char_isIDIgnorable(PyTypeObject *type, PyObject *arg) { return t_char_fn(u_isIDIgnorable, "isIDIgnorable", type, arg); } static PyObject *t_char_isJavaIDStart(PyTypeObject *type, PyObject *arg) { return t_char_fn(u_isJavaIDStart, "isJavaIDStart", type, arg); } static PyObject *t_char_isJavaIDPart(PyTypeObject *type, PyObject *arg) { return t_char_fn(u_isJavaIDPart, "isJavaIDPart", type, arg); } static PyObject *t_char_charDirection(PyTypeObject *type, PyObject *arg) { UnicodeString *u, _u; UChar32 c; if (!parseArg(arg, "i", &c)) return PyInt_FromLong(u_charDirection(c)); if (!parseArg(arg, "S", &u, &_u) && u->length() >= 1) return PyInt_FromLong(u_charDirection(u->char32At(0))); return PyErr_SetArgsError((PyObject *) type, "charDirection", arg); } static PyObject *t_char_charType(PyTypeObject *type, PyObject *arg) { UnicodeString *u, _u; UChar32 c; if (!parseArg(arg, "i", &c)) return PyInt_FromLong((int) u_charType(c)); if (!parseArg(arg, "S", &u, &_u) && u->length() >= 1) return PyInt_FromLong((int) u_charType(u->char32At(0))); return PyErr_SetArgsError((PyObject *) type, "charType", arg); } static UBool t_char_enum_types_cb( const void *context, UChar32 start, UChar32 limit, UCharCategory type) { PyObject *obj = PyObject_CallFunction( (PyObject *) context, (char *) "iii", start, limit, type); if (obj == NULL) return false; bool result = PyObject_IsTrue(obj); Py_DECREF(obj); return result; } static PyObject *t_char_enumCharTypes(PyTypeObject *type, PyObject *arg) { if (PyCallable_Check(arg)) { u_enumCharTypes(t_char_enum_types_cb, arg); if (PyErr_Occurred()) return NULL; Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) type, "enumCharTypes", arg); } static PyObject *t_char_getCombiningClass(PyTypeObject *type, PyObject *arg) { UnicodeString *u, _u; UChar32 c; if (!parseArg(arg, "i", &c)) return PyInt_FromLong((unsigned int) u_getCombiningClass(c)); if (!parseArg(arg, "S", &u, &_u) && u->length() >= 1) return PyInt_FromLong( (unsigned int) u_getCombiningClass(u->char32At(0))); return PyErr_SetArgsError((PyObject *) type, "getCombiningClass", arg); } static PyObject *t_char_charDigitValue(PyTypeObject *type, PyObject *arg) { UnicodeString *u, _u; UChar32 c; if (!parseArg(arg, "i", &c)) return PyInt_FromLong((int) u_charDigitValue(c)); if (!parseArg(arg, "S", &u, &_u) && u->length() >= 1) return PyInt_FromLong((int) u_charDigitValue(u->char32At(0))); return PyErr_SetArgsError((PyObject *) type, "charDigitValue", arg); } static PyObject *t_char_ublock_getCode(PyTypeObject *type, PyObject *arg) { UnicodeString *u, _u; UChar32 c; if (!parseArg(arg, "i", &c)) return PyInt_FromLong((int) ublock_getCode(c)); if (!parseArg(arg, "S", &u, &_u) && u->length() >= 1) return PyInt_FromLong((int) ublock_getCode(u->char32At(0))); return PyErr_SetArgsError((PyObject *) type, "ublock_getCode", arg); } static PyObject *t_char_charName(PyTypeObject *type, PyObject *args) { UnicodeString *u, _u; UCharNameChoice choice = U_UNICODE_CHAR_NAME; char buffer[128]; int32_t size; UChar32 c; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "i", &c)) { STATUS_CALL(size = u_charName(c, choice, buffer, sizeof(buffer), &status)); return PyString_FromString(buffer); } if (!parseArgs(args, "S", &u, &_u) && u->length() >= 1) { STATUS_CALL(size = u_charName(u->char32At(0), choice, buffer, sizeof(buffer), &status)); return PyString_FromStringAndSize(buffer, size); } break; case 2: if (!parseArgs(args, "ii", &c, &choice)) { STATUS_CALL(size = u_charName(c, choice, buffer, sizeof(buffer), &status)); return PyString_FromStringAndSize(buffer, size); } if (!parseArgs(args, "Si", &u, &_u, &choice) && u->length() >= 1) { STATUS_CALL(size = u_charName(u->char32At(0), choice, buffer, sizeof(buffer), &status)); return PyString_FromStringAndSize(buffer, size); } break; } return PyErr_SetArgsError((PyObject *) type, "charName", args); } static PyObject *t_char_charFromName(PyTypeObject *type, PyObject *args) { char *name; UCharNameChoice choice = U_UNICODE_CHAR_NAME; UChar32 c; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "c", &name)) { STATUS_CALL(c = u_charFromName(choice, name, &status)); return PyInt_FromLong(c); } break; case 2: if (!parseArgs(args, "ci", &name, &choice)) { STATUS_CALL(c = u_charFromName(choice, name, &status)); return PyInt_FromLong(c); } break; } return PyErr_SetArgsError((PyObject *) type, "charFromName", args); } static UBool t_char_enum_names_cb( void *context, UChar32 code, UCharNameChoice choice, const char *name, int32_t length) { PyObject *obj = PyObject_CallFunction( (PyObject *) context, (char *) "is#i", code, name, (int) length, choice); if (obj == NULL) return false; bool result = PyObject_IsTrue(obj); Py_DECREF(obj); return result; } static PyObject *t_char_enumCharNames(PyTypeObject *type, PyObject *args) { PyObject *callable; UCharNameChoice choice = U_UNICODE_CHAR_NAME; UnicodeString *u, _u, *v, _v; UChar32 start, limit; switch (PyTuple_Size(args)) { case 3: if (!parseArgs(args, "iiM", &start, &limit, &callable)) { STATUS_CALL(u_enumCharNames( start, limit, t_char_enum_names_cb, callable, choice, &status)); if (PyErr_Occurred()) return NULL; Py_RETURN_NONE; } if (!parseArgs(args, "SSM", &u, &_u, &v, &_v, &callable) && u->length() >= 1 && v->length() >= 1) { STATUS_CALL(u_enumCharNames( u->char32At(0), v->char32At(0), t_char_enum_names_cb, callable, choice, &status)); if (PyErr_Occurred()) return NULL; Py_RETURN_NONE; } break; case 4: if (!parseArgs(args, "iiMi", &start, &limit, &callable, &choice)) { STATUS_CALL(u_enumCharNames( start, limit, t_char_enum_names_cb, callable, choice, &status)); if (PyErr_Occurred()) return NULL; Py_RETURN_NONE; } if (!parseArgs(args, "SSMi", &u, &_u, &v, &_v, &callable, &choice) && u->length() >= 1 && v->length() >= 1) { STATUS_CALL(u_enumCharNames( u->char32At(0), v->char32At(0), t_char_enum_names_cb, callable, choice, &status)); if (PyErr_Occurred()) return NULL; Py_RETURN_NONE; } break; } return PyErr_SetArgsError((PyObject *) type, "enumCharNames", args); } static PyObject *t_char_getPropertyName(PyTypeObject *type, PyObject *args) { UPropertyNameChoice choice = U_SHORT_PROPERTY_NAME; UProperty prop; const char *result; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "i", &prop)) { result = u_getPropertyName(prop, choice); if (result != NULL) return PyString_FromString(result); Py_RETURN_NONE; } break; case 2: if (!parseArgs(args, "ii", &prop, &choice)) { result = u_getPropertyName(prop, choice); if (result != NULL) return PyString_FromString(result); Py_RETURN_NONE; } break; } return PyErr_SetArgsError((PyObject *) type, "getPropertyName", args); } static PyObject *t_char_getPropertyEnum(PyTypeObject *type, PyObject *arg) { char *alias; if (!parseArg(arg, "c", &alias)) return PyInt_FromLong(u_getPropertyEnum(alias)); return PyErr_SetArgsError((PyObject *) type, "getPropertyEnum", arg); } static PyObject *t_char_fn(uchar32_char_fn fn, const char *name, PyTypeObject *type, PyObject *arg) { UnicodeString *u, _u; UChar32 c; if (!parseArg(arg, "i", &c)) return PyInt_FromLong((*fn)(c)); if (!parseArg(arg, "S", &u, &_u) && u->length() >= 1) { UnicodeString result; result += (*fn)(u->char32At(0)); return PyUnicode_FromUnicodeString(&result); } return PyErr_SetArgsError((PyObject *) type, name, arg); } static PyObject *t_char_charMirror(PyTypeObject *type, PyObject *arg) { return t_char_fn(u_charMirror, "charMirror", type, arg); } #if U_ICU_VERSION_HEX >= VERSION_HEX(52, 0, 0) static PyObject *t_char_getBidiPairedBracket(PyTypeObject *type, PyObject *arg) { return t_char_fn(u_getBidiPairedBracket, "getBidiPairedBracket", type, arg); } #endif static PyObject *t_char_tolower(PyTypeObject *type, PyObject *arg) { return t_char_fn(u_tolower, "tolower", type, arg); } static PyObject *t_char_toupper(PyTypeObject *type, PyObject *arg) { return t_char_fn(u_toupper, "toupper", type, arg); } static PyObject *t_char_totitle(PyTypeObject *type, PyObject *arg) { return t_char_fn(u_totitle, "totitle", type, arg); } static PyObject *t_char_foldCase(PyTypeObject *type, PyObject *args) { UnicodeString *u, _u; UChar32 c; uint32_t options; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "i", &c)) return PyInt_FromLong(u_foldCase(c, U_FOLD_CASE_DEFAULT)); if (!parseArgs(args, "S", &u, &_u) && u->length() >= 1) { UnicodeString result; result += u_foldCase(u->char32At(0), U_FOLD_CASE_DEFAULT); return PyUnicode_FromUnicodeString(&result); } break; case 2: if (!parseArgs(args, "ii", &c, &options)) return PyInt_FromLong(u_foldCase(c, options)); if (!parseArgs(args, "Si", &u, &_u, &options) && u->length() >= 1) { UnicodeString result; result += u_foldCase(u->char32At(0), options); return PyUnicode_FromUnicodeString(&result); } break; } return PyErr_SetArgsError((PyObject *) type, "foldCase", args); } static PyObject *t_char_digit(PyTypeObject *type, PyObject *args) { UnicodeString *u, _u; UChar32 c; int radix; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "i", &c)) return PyInt_FromLong(u_digit(c, (int8_t) 10)); if (!parseArgs(args, "S", &u, &_u) && u->length() >= 1) return PyInt_FromLong(u_digit(u->char32At(0), (int8_t) 10)); break; case 2: if (!parseArgs(args, "ii", &c, &radix)) return PyInt_FromLong(u_digit(c, (int8_t) radix)); if (!parseArgs(args, "Si", &u, &_u, &radix) && u->length() >= 1) return PyInt_FromLong(u_digit(u->char32At(0), (int8_t) radix)); break; } return PyErr_SetArgsError((PyObject *) type, "digit", args); } static PyObject *t_char_forDigit(PyTypeObject *type, PyObject *args) { UChar32 c; int radix; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "i", &c)) return PyInt_FromLong(u_forDigit(c, (int8_t) 10)); break; case 2: if (!parseArgs(args, "ii", &c, &radix)) return PyInt_FromLong(u_forDigit(c, (int8_t) radix)); break; } return PyErr_SetArgsError((PyObject *) type, "forDigit", args); } static PyObject *t_char_charAge(PyTypeObject *type, PyObject *arg) { char buffer[U_MAX_VERSION_STRING_LENGTH + 1]; UVersionInfo versionInfo; UnicodeString *u, _u; UChar32 c; if (!parseArg(arg, "i", &c)) u_charAge(c, versionInfo); else if (!parseArg(arg, "S", &u, &_u) && u->length() >= 1) u_charAge(u->char32At(0), versionInfo); else return PyErr_SetArgsError((PyObject *) type, "charAge", arg); u_versionToString(versionInfo, buffer); return PyString_FromString(buffer); } static PyObject *t_char_getUnicodeVersion(PyTypeObject *type) { UVersionInfo versionInfo; char buffer[U_MAX_VERSION_STRING_LENGTH + 1]; u_getUnicodeVersion(versionInfo); u_versionToString(versionInfo, buffer); return PyString_FromString(buffer); } static PyObject *t_char_getFC_NFKC_Closure(PyTypeObject *type, PyObject *arg) { UChar buffer[128]; UnicodeString *u, _u; UChar32 c; int32_t size; if (!parseArg(arg, "i", &c)) { STATUS_CALL(size = u_getFC_NFKC_Closure(c, buffer, 128, &status)); } else if (!parseArg(arg, "S", &u, &_u) && u->length() >= 1) { STATUS_CALL(size = u_getFC_NFKC_Closure(u->char32At(0), buffer, 128, &status)); } else return PyErr_SetArgsError((PyObject *) type, "getFC_NFKC_Closure", arg); return PyUnicode_FromUnicodeString(buffer, size); } void _init_char(PyObject *m) { INSTALL_CONSTANTS_TYPE(UProperty, m); INSTALL_CONSTANTS_TYPE(UCharDirection, m); INSTALL_CONSTANTS_TYPE(UCharCategory, m); INSTALL_CONSTANTS_TYPE(UBlockCode, m); INSTALL_CONSTANTS_TYPE(UCharNameChoice, m); INSTALL_CONSTANTS_TYPE(UPropertyNameChoice, m); INSTALL_CONSTANTS_TYPE(UWordBreakValues, m); INSTALL_CONSTANTS_TYPE(UJoiningGroup, m); INSTALL_CONSTANTS_TYPE(ULineBreak, m); INSTALL_CONSTANTS_TYPE(UGraphemeClusterBreak, m); INSTALL_CONSTANTS_TYPE(UHangulSyllableType, m); #if U_ICU_VERSION_HEX >= VERSION_HEX(52, 0, 0) INSTALL_CONSTANTS_TYPE(UBidiPairedBracketType, m); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(63, 0, 0) INSTALL_CONSTANTS_TYPE(UIndicPositionalCategory, m); INSTALL_CONSTANTS_TYPE(UIndicSyllabicCategory, m); INSTALL_CONSTANTS_TYPE(UVerticalOrientation, m); #endif INSTALL_STRUCT(Char, m); INSTALL_ENUM(Char, "FOLD_CASE_DEFAULT", U_FOLD_CASE_DEFAULT); INSTALL_ENUM(Char, "FOLD_CASE_EXCLUDE_SPECIAL_I", U_FOLD_CASE_EXCLUDE_SPECIAL_I); INSTALL_ENUM(UProperty, "ALPHABETIC", UCHAR_ALPHABETIC); INSTALL_ENUM(UProperty, "ASCII_HEX_DIGIT", UCHAR_ASCII_HEX_DIGIT); INSTALL_ENUM(UProperty, "BIDI_CONTROL", UCHAR_BIDI_CONTROL); INSTALL_ENUM(UProperty, "BIDI_MIRRORED", UCHAR_BIDI_MIRRORED); INSTALL_ENUM(UProperty, "DASH", UCHAR_DASH); INSTALL_ENUM(UProperty, "DEFAULT_IGNORABLE_CODE_POINT", UCHAR_DEFAULT_IGNORABLE_CODE_POINT); INSTALL_ENUM(UProperty, "DIACRITIC", UCHAR_DIACRITIC); INSTALL_ENUM(UProperty, "EXTENDER", UCHAR_EXTENDER); INSTALL_ENUM(UProperty, "FULL_COMPOSITION_EXCLUSION", UCHAR_FULL_COMPOSITION_EXCLUSION); INSTALL_ENUM(UProperty, "GRAPHEME_BASE", UCHAR_GRAPHEME_BASE); INSTALL_ENUM(UProperty, "GRAPHEME_EXTEND", UCHAR_GRAPHEME_EXTEND); INSTALL_ENUM(UProperty, "GRAPHEME_LINK", UCHAR_GRAPHEME_LINK); INSTALL_ENUM(UProperty, "HEX_DIGIT", UCHAR_HEX_DIGIT); INSTALL_ENUM(UProperty, "HYPHEN", UCHAR_HYPHEN); INSTALL_ENUM(UProperty, "ID_CONTINUE", UCHAR_ID_CONTINUE); INSTALL_ENUM(UProperty, "ID_START", UCHAR_ID_START); INSTALL_ENUM(UProperty, "IDEOGRAPHIC", UCHAR_IDEOGRAPHIC); INSTALL_ENUM(UProperty, "IDS_BINARY_OPERATOR", UCHAR_IDS_BINARY_OPERATOR); INSTALL_ENUM(UProperty, "IDS_TRINARY_OPERATOR", UCHAR_IDS_TRINARY_OPERATOR); INSTALL_ENUM(UProperty, "JOIN_CONTROL", UCHAR_JOIN_CONTROL); INSTALL_ENUM(UProperty, "LOGICAL_ORDER_EXCEPTION", UCHAR_LOGICAL_ORDER_EXCEPTION); INSTALL_ENUM(UProperty, "LOWERCASE", UCHAR_LOWERCASE); INSTALL_ENUM(UProperty, "MATH", UCHAR_MATH); INSTALL_ENUM(UProperty, "NONCHARACTER_CODE_POINT", UCHAR_NONCHARACTER_CODE_POINT); INSTALL_ENUM(UProperty, "QUOTATION_MARK", UCHAR_QUOTATION_MARK); INSTALL_ENUM(UProperty, "RADICAL", UCHAR_RADICAL); INSTALL_ENUM(UProperty, "SOFT_DOTTED", UCHAR_SOFT_DOTTED); INSTALL_ENUM(UProperty, "TERMINAL_PUNCTUATION", UCHAR_TERMINAL_PUNCTUATION); INSTALL_ENUM(UProperty, "UNIFIED_IDEOGRAPH", UCHAR_UNIFIED_IDEOGRAPH); INSTALL_ENUM(UProperty, "UPPERCASE", UCHAR_UPPERCASE); INSTALL_ENUM(UProperty, "WHITE_SPACE", UCHAR_WHITE_SPACE); INSTALL_ENUM(UProperty, "XID_CONTINUE", UCHAR_XID_CONTINUE); INSTALL_ENUM(UProperty, "XID_START", UCHAR_XID_START); INSTALL_ENUM(UProperty, "CASE_SENSITIVE", UCHAR_CASE_SENSITIVE); INSTALL_ENUM(UProperty, "S_TERM", UCHAR_S_TERM); INSTALL_ENUM(UProperty, "VARIATION_SELECTOR", UCHAR_VARIATION_SELECTOR); INSTALL_ENUM(UProperty, "NFD_INERT", UCHAR_NFD_INERT); INSTALL_ENUM(UProperty, "NFKD_INERT", UCHAR_NFKD_INERT); INSTALL_ENUM(UProperty, "NFC_INERT", UCHAR_NFC_INERT); INSTALL_ENUM(UProperty, "NFKC_INERT", UCHAR_NFKC_INERT); INSTALL_ENUM(UProperty, "SEGMENT_STARTER", UCHAR_SEGMENT_STARTER); INSTALL_ENUM(UProperty, "PATTERN_SYNTAX", UCHAR_PATTERN_SYNTAX); INSTALL_ENUM(UProperty, "PATTERN_WHITE_SPACE", UCHAR_PATTERN_WHITE_SPACE); INSTALL_ENUM(UProperty, "POSIX_ALNUM", UCHAR_POSIX_ALNUM); INSTALL_ENUM(UProperty, "POSIX_BLANK", UCHAR_POSIX_BLANK); INSTALL_ENUM(UProperty, "POSIX_GRAPH", UCHAR_POSIX_GRAPH); INSTALL_ENUM(UProperty, "POSIX_PRINT", UCHAR_POSIX_PRINT); INSTALL_ENUM(UProperty, "POSIX_XDIGIT", UCHAR_POSIX_XDIGIT); #if U_ICU_VERSION_HEX >= 0x04040000 INSTALL_ENUM(UProperty, "CASED", UCHAR_CASED); INSTALL_ENUM(UProperty, "CASE_IGNORABLE", UCHAR_CASE_IGNORABLE); INSTALL_ENUM(UProperty, "CHANGES_WHEN_LOWERCASED", UCHAR_CHANGES_WHEN_LOWERCASED); INSTALL_ENUM(UProperty, "CHANGES_WHEN_UPPERCASED", UCHAR_CHANGES_WHEN_UPPERCASED); INSTALL_ENUM(UProperty, "CHANGES_WHEN_TITLECASED", UCHAR_CHANGES_WHEN_TITLECASED); INSTALL_ENUM(UProperty, "CHANGES_WHEN_CASEFOLDED", UCHAR_CHANGES_WHEN_CASEFOLDED); INSTALL_ENUM(UProperty, "CHANGES_WHEN_CASEMAPPED", UCHAR_CHANGES_WHEN_CASEMAPPED); INSTALL_ENUM(UProperty, "CHANGES_WHEN_NFKC_CASEFOLDED", UCHAR_CHANGES_WHEN_NFKC_CASEFOLDED); #endif INSTALL_ENUM(UProperty, "BIDI_CLASS", UCHAR_BIDI_CLASS); INSTALL_ENUM(UProperty, "INT_START", UCHAR_INT_START); INSTALL_ENUM(UProperty, "BLOCK", UCHAR_BLOCK); INSTALL_ENUM(UProperty, "CANONICAL_COMBINING_CLASS", UCHAR_CANONICAL_COMBINING_CLASS); INSTALL_ENUM(UProperty, "DECOMPOSITION_TYPE", UCHAR_DECOMPOSITION_TYPE); INSTALL_ENUM(UProperty, "EAST_ASIAN_WIDTH", UCHAR_EAST_ASIAN_WIDTH); INSTALL_ENUM(UProperty, "GENERAL_CATEGORY", UCHAR_GENERAL_CATEGORY); INSTALL_ENUM(UProperty, "JOINING_GROUP", UCHAR_JOINING_GROUP); INSTALL_ENUM(UProperty, "JOINING_TYPE", UCHAR_JOINING_TYPE); INSTALL_ENUM(UProperty, "LINE_BREAK", UCHAR_LINE_BREAK); INSTALL_ENUM(UProperty, "NUMERIC_TYPE", UCHAR_NUMERIC_TYPE); INSTALL_ENUM(UProperty, "SCRIPT", UCHAR_SCRIPT); INSTALL_ENUM(UProperty, "HANGUL_SYLLABLE_TYPE", UCHAR_HANGUL_SYLLABLE_TYPE); INSTALL_ENUM(UProperty, "NFD_QUICK_CHECK", UCHAR_NFD_QUICK_CHECK); INSTALL_ENUM(UProperty, "NFKD_QUICK_CHECK", UCHAR_NFKD_QUICK_CHECK); INSTALL_ENUM(UProperty, "NFC_QUICK_CHECK", UCHAR_NFC_QUICK_CHECK); INSTALL_ENUM(UProperty, "NFKC_QUICK_CHECK", UCHAR_NFKC_QUICK_CHECK); INSTALL_ENUM(UProperty, "LEAD_CANONICAL_COMBINING_CLASS", UCHAR_LEAD_CANONICAL_COMBINING_CLASS); INSTALL_ENUM(UProperty, "TRAIL_CANONICAL_COMBINING_CLASS", UCHAR_TRAIL_CANONICAL_COMBINING_CLASS); INSTALL_ENUM(UProperty, "GRAPHEME_CLUSTER_BREAK", UCHAR_GRAPHEME_CLUSTER_BREAK); INSTALL_ENUM(UProperty, "SENTENCE_BREAK", UCHAR_SENTENCE_BREAK); INSTALL_ENUM(UProperty, "WORD_BREAK", UCHAR_WORD_BREAK); #if U_ICU_VERSION_HEX >= VERSION_HEX(52, 0, 0) INSTALL_ENUM(UProperty, "BIDI_PAIRED_BRACKET_TYPE", UCHAR_BIDI_PAIRED_BRACKET_TYPE); #endif INSTALL_ENUM(UProperty, "GENERAL_CATEGORY_MASK", UCHAR_GENERAL_CATEGORY_MASK); INSTALL_ENUM(UProperty, "MASK_START", UCHAR_MASK_START); INSTALL_ENUM(UProperty, "NUMERIC_VALUE", UCHAR_NUMERIC_VALUE); INSTALL_ENUM(UProperty, "DOUBLE_START", UCHAR_DOUBLE_START); INSTALL_ENUM(UProperty, "AGE", UCHAR_AGE); INSTALL_ENUM(UProperty, "STRING_START", UCHAR_STRING_START); INSTALL_ENUM(UProperty, "BIDI_MIRRORING_GLYPH", UCHAR_BIDI_MIRRORING_GLYPH); INSTALL_ENUM(UProperty, "CASE_FOLDING", UCHAR_CASE_FOLDING); INSTALL_ENUM(UProperty, "LOWERCASE_MAPPING", UCHAR_LOWERCASE_MAPPING); INSTALL_ENUM(UProperty, "NAME", UCHAR_NAME); INSTALL_ENUM(UProperty, "SIMPLE_CASE_FOLDING", UCHAR_SIMPLE_CASE_FOLDING); INSTALL_ENUM(UProperty, "SIMPLE_LOWERCASE_MAPPING", UCHAR_SIMPLE_LOWERCASE_MAPPING); INSTALL_ENUM(UProperty, "SIMPLE_TITLECASE_MAPPING", UCHAR_SIMPLE_TITLECASE_MAPPING); INSTALL_ENUM(UProperty, "SIMPLE_UPPERCASE_MAPPING", UCHAR_SIMPLE_UPPERCASE_MAPPING); INSTALL_ENUM(UProperty, "TITLECASE_MAPPING", UCHAR_TITLECASE_MAPPING); INSTALL_ENUM(UProperty, "UPPERCASE_MAPPING", UCHAR_UPPERCASE_MAPPING); #if U_ICU_VERSION_HEX >= VERSION_HEX(52, 0, 0) INSTALL_ENUM(UProperty, "BIDI_PAIRED_BRACKET", UCHAR_BIDI_PAIRED_BRACKET); #endif #if U_ICU_VERSION_HEX >= 0x04060000 INSTALL_ENUM(UProperty, "SCRIPT_EXTENSIONS", UCHAR_SCRIPT_EXTENSIONS); INSTALL_ENUM(UProperty, "OTHER_PROPERTY_START", UCHAR_OTHER_PROPERTY_START); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(57, 0, 0) INSTALL_ENUM(UProperty, "EMOJI", UCHAR_EMOJI); INSTALL_ENUM(UProperty, "EMOJI_PRESENTATION", UCHAR_EMOJI_PRESENTATION); INSTALL_ENUM(UProperty, "EMOJI_MODIFIER", UCHAR_EMOJI_MODIFIER); INSTALL_ENUM(UProperty, "EMOJI_MODIFIER_BASE", UCHAR_EMOJI_MODIFIER_BASE); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(60, 0, 0) INSTALL_ENUM(UProperty, "EMOJI_COMPONENT", UCHAR_EMOJI_COMPONENT); INSTALL_ENUM(UProperty, "REGIONAL_INDICATOR", UCHAR_REGIONAL_INDICATOR); INSTALL_ENUM(UProperty, "PREPENDED_CONCATENATION_MARK", UCHAR_PREPENDED_CONCATENATION_MARK); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(62, 0, 0) INSTALL_ENUM(UProperty, "EXTENDED_PICTOGRAPHIC", UCHAR_EXTENDED_PICTOGRAPHIC); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(63, 0, 0) INSTALL_ENUM(UProperty, "INDIC_POSITIONAL_CATEGORY", UCHAR_INDIC_POSITIONAL_CATEGORY); INSTALL_ENUM(UProperty, "INDIC_SYLLABIC_CATEGORY", UCHAR_INDIC_SYLLABIC_CATEGORY); INSTALL_ENUM(UProperty, "VERTICAL_ORIENTATION", UCHAR_VERTICAL_ORIENTATION); #endif INSTALL_ENUM(UProperty, "INVALID_CODE ", UCHAR_INVALID_CODE ); INSTALL_ENUM(UCharDirection, "LEFT_TO_RIGHT", U_LEFT_TO_RIGHT); INSTALL_ENUM(UCharDirection, "RIGHT_TO_LEFT", U_RIGHT_TO_LEFT); INSTALL_ENUM(UCharDirection, "EUROPEAN_NUMBER", U_EUROPEAN_NUMBER); INSTALL_ENUM(UCharDirection, "EUROPEAN_NUMBER_SEPARATOR", U_EUROPEAN_NUMBER_SEPARATOR); INSTALL_ENUM(UCharDirection, "EUROPEAN_NUMBER_TERMINATOR", U_EUROPEAN_NUMBER_TERMINATOR); INSTALL_ENUM(UCharDirection, "ARABIC_NUMBER", U_ARABIC_NUMBER); INSTALL_ENUM(UCharDirection, "COMMON_NUMBER_SEPARATOR", U_COMMON_NUMBER_SEPARATOR); INSTALL_ENUM(UCharDirection, "BLOCK_SEPARATOR", U_BLOCK_SEPARATOR); INSTALL_ENUM(UCharDirection, "SEGMENT_SEPARATOR", U_SEGMENT_SEPARATOR); INSTALL_ENUM(UCharDirection, "WHITE_SPACE_NEUTRAL", U_WHITE_SPACE_NEUTRAL); INSTALL_ENUM(UCharDirection, "OTHER_NEUTRAL", U_OTHER_NEUTRAL); INSTALL_ENUM(UCharDirection, "LEFT_TO_RIGHT_EMBEDDING", U_LEFT_TO_RIGHT_EMBEDDING); INSTALL_ENUM(UCharDirection, "LEFT_TO_RIGHT_OVERRIDE", U_LEFT_TO_RIGHT_OVERRIDE); INSTALL_ENUM(UCharDirection, "RIGHT_TO_LEFT_ARABIC", U_RIGHT_TO_LEFT_ARABIC); INSTALL_ENUM(UCharDirection, "RIGHT_TO_LEFT_EMBEDDING", U_RIGHT_TO_LEFT_EMBEDDING); INSTALL_ENUM(UCharDirection, "RIGHT_TO_LEFT_OVERRIDE", U_RIGHT_TO_LEFT_OVERRIDE); INSTALL_ENUM(UCharDirection, "POP_DIRECTIONAL_FORMAT", U_POP_DIRECTIONAL_FORMAT); INSTALL_ENUM(UCharDirection, "DIR_NON_SPACING_MARK", U_DIR_NON_SPACING_MARK); INSTALL_ENUM(UCharDirection, "BOUNDARY_NEUTRAL", U_BOUNDARY_NEUTRAL); #if U_ICU_VERSION_HEX >= VERSION_HEX(52, 0, 0) INSTALL_ENUM(UCharDirection, "FIRST_STRONG_ISOLATE", U_FIRST_STRONG_ISOLATE); INSTALL_ENUM(UCharDirection, "LEFT_TO_RIGHT_ISOLATE", U_LEFT_TO_RIGHT_ISOLATE); INSTALL_ENUM(UCharDirection, "RIGHT_TO_LEFT_ISOLATE", U_RIGHT_TO_LEFT_ISOLATE); INSTALL_ENUM(UCharDirection, "POP_DIRECTIONAL_ISOLATE", U_POP_DIRECTIONAL_ISOLATE); #endif INSTALL_ENUM(UCharCategory, "UNASSIGNED", U_UNASSIGNED); INSTALL_ENUM(UCharCategory, "GENERAL_OTHER_TYPES", U_GENERAL_OTHER_TYPES); INSTALL_ENUM(UCharCategory, "UPPERCASE_LETTER", U_UPPERCASE_LETTER); INSTALL_ENUM(UCharCategory, "LOWERCASE_LETTER", U_LOWERCASE_LETTER); INSTALL_ENUM(UCharCategory, "TITLECASE_LETTER", U_TITLECASE_LETTER); INSTALL_ENUM(UCharCategory, "MODIFIER_LETTER", U_MODIFIER_LETTER); INSTALL_ENUM(UCharCategory, "OTHER_LETTER", U_OTHER_LETTER); INSTALL_ENUM(UCharCategory, "NON_SPACING_MARK", U_NON_SPACING_MARK); INSTALL_ENUM(UCharCategory, "ENCLOSING_MARK", U_ENCLOSING_MARK); INSTALL_ENUM(UCharCategory, "COMBINING_SPACING_MARK", U_COMBINING_SPACING_MARK); INSTALL_ENUM(UCharCategory, "DECIMAL_DIGIT_NUMBER", U_DECIMAL_DIGIT_NUMBER); INSTALL_ENUM(UCharCategory, "LETTER_NUMBER", U_LETTER_NUMBER); INSTALL_ENUM(UCharCategory, "OTHER_NUMBER", U_OTHER_NUMBER); INSTALL_ENUM(UCharCategory, "SPACE_SEPARATOR", U_SPACE_SEPARATOR); INSTALL_ENUM(UCharCategory, "LINE_SEPARATOR", U_LINE_SEPARATOR); INSTALL_ENUM(UCharCategory, "PARAGRAPH_SEPARATOR", U_PARAGRAPH_SEPARATOR); INSTALL_ENUM(UCharCategory, "CONTROL_CHAR", U_CONTROL_CHAR); INSTALL_ENUM(UCharCategory, "FORMAT_CHAR", U_FORMAT_CHAR); INSTALL_ENUM(UCharCategory, "PRIVATE_USE_CHAR", U_PRIVATE_USE_CHAR); INSTALL_ENUM(UCharCategory, "SURROGATE", U_SURROGATE); INSTALL_ENUM(UCharCategory, "DASH_PUNCTUATION", U_DASH_PUNCTUATION); INSTALL_ENUM(UCharCategory, "START_PUNCTUATION", U_START_PUNCTUATION); INSTALL_ENUM(UCharCategory, "END_PUNCTUATION", U_END_PUNCTUATION); INSTALL_ENUM(UCharCategory, "CONNECTOR_PUNCTUATION", U_CONNECTOR_PUNCTUATION); INSTALL_ENUM(UCharCategory, "OTHER_PUNCTUATION", U_OTHER_PUNCTUATION); INSTALL_ENUM(UCharCategory, "MATH_SYMBOL", U_MATH_SYMBOL); INSTALL_ENUM(UCharCategory, "CURRENCY_SYMBOL", U_CURRENCY_SYMBOL); INSTALL_ENUM(UCharCategory, "MODIFIER_SYMBOL", U_MODIFIER_SYMBOL); INSTALL_ENUM(UCharCategory, "OTHER_SYMBOL", U_OTHER_SYMBOL); INSTALL_ENUM(UCharCategory, "INITIAL_PUNCTUATION", U_INITIAL_PUNCTUATION); INSTALL_ENUM(UCharCategory, "FINAL_PUNCTUATION", U_FINAL_PUNCTUATION); INSTALL_ENUM(UBlockCode, "NO_BLOCK", UBLOCK_NO_BLOCK); INSTALL_ENUM(UBlockCode, "BASIC_LATIN", UBLOCK_BASIC_LATIN); INSTALL_ENUM(UBlockCode, "LATIN_1_SUPPLEMENT,", UBLOCK_LATIN_1_SUPPLEMENT); INSTALL_ENUM(UBlockCode, "LATIN_EXTENDED_A", UBLOCK_LATIN_EXTENDED_A); INSTALL_ENUM(UBlockCode, "LATIN_EXTENDED_B", UBLOCK_LATIN_EXTENDED_B); INSTALL_ENUM(UBlockCode, "IPA_EXTENSIONS", UBLOCK_IPA_EXTENSIONS); INSTALL_ENUM(UBlockCode, "SPACING_MODIFIER_LETTERS", UBLOCK_SPACING_MODIFIER_LETTERS); INSTALL_ENUM(UBlockCode, "COMBINING_DIACRITICAL_MARKS", UBLOCK_COMBINING_DIACRITICAL_MARKS); INSTALL_ENUM(UBlockCode, "GREEK", UBLOCK_GREEK); INSTALL_ENUM(UBlockCode, "CYRILLIC", UBLOCK_CYRILLIC); INSTALL_ENUM(UBlockCode, "ARMENIAN", UBLOCK_ARMENIAN); INSTALL_ENUM(UBlockCode, "HEBREW", UBLOCK_HEBREW); INSTALL_ENUM(UBlockCode, "ARABIC", UBLOCK_ARABIC); INSTALL_ENUM(UBlockCode, "SYRIAC", UBLOCK_SYRIAC); INSTALL_ENUM(UBlockCode, "THAANA", UBLOCK_THAANA); INSTALL_ENUM(UBlockCode, "DEVANAGARI", UBLOCK_DEVANAGARI); INSTALL_ENUM(UBlockCode, "BENGALI", UBLOCK_BENGALI); INSTALL_ENUM(UBlockCode, "GURMUKHI", UBLOCK_GURMUKHI); INSTALL_ENUM(UBlockCode, "GUJARATI", UBLOCK_GUJARATI); INSTALL_ENUM(UBlockCode, "ORIYA", UBLOCK_ORIYA); INSTALL_ENUM(UBlockCode, "TAMIL", UBLOCK_TAMIL); INSTALL_ENUM(UBlockCode, "TELUGU", UBLOCK_TELUGU); INSTALL_ENUM(UBlockCode, "KANNADA", UBLOCK_KANNADA); INSTALL_ENUM(UBlockCode, "MALAYALAM", UBLOCK_MALAYALAM); INSTALL_ENUM(UBlockCode, "SINHALA", UBLOCK_SINHALA); INSTALL_ENUM(UBlockCode, "THAI", UBLOCK_THAI); INSTALL_ENUM(UBlockCode, "LAO", UBLOCK_LAO); INSTALL_ENUM(UBlockCode, "TIBETAN", UBLOCK_TIBETAN); INSTALL_ENUM(UBlockCode, "MYANMAR", UBLOCK_MYANMAR); INSTALL_ENUM(UBlockCode, "GEORGIAN", UBLOCK_GEORGIAN); INSTALL_ENUM(UBlockCode, "HANGUL_JAMO", UBLOCK_HANGUL_JAMO); INSTALL_ENUM(UBlockCode, "ETHIOPIC", UBLOCK_ETHIOPIC); INSTALL_ENUM(UBlockCode, "CHEROKEE", UBLOCK_CHEROKEE); INSTALL_ENUM(UBlockCode, "UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS", UBLOCK_UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS); INSTALL_ENUM(UBlockCode, "OGHAM", UBLOCK_OGHAM); INSTALL_ENUM(UBlockCode, "RUNIC", UBLOCK_RUNIC); INSTALL_ENUM(UBlockCode, "KHMER", UBLOCK_KHMER); INSTALL_ENUM(UBlockCode, "MONGOLIAN", UBLOCK_MONGOLIAN); INSTALL_ENUM(UBlockCode, "LATIN_EXTENDED_ADDITIONAL", UBLOCK_LATIN_EXTENDED_ADDITIONAL); INSTALL_ENUM(UBlockCode, "GREEK_EXTENDED", UBLOCK_GREEK_EXTENDED); INSTALL_ENUM(UBlockCode, "GENERAL_PUNCTUATION", UBLOCK_GENERAL_PUNCTUATION); INSTALL_ENUM(UBlockCode, "SUPERSCRIPTS_AND_SUBSCRIPTS", UBLOCK_SUPERSCRIPTS_AND_SUBSCRIPTS); INSTALL_ENUM(UBlockCode, "CURRENCY_SYMBOLS", UBLOCK_CURRENCY_SYMBOLS); INSTALL_ENUM(UBlockCode, "COMBINING_MARKS_FOR_SYMBOLS", UBLOCK_COMBINING_MARKS_FOR_SYMBOLS); INSTALL_ENUM(UBlockCode, "LETTERLIKE_SYMBOLS", UBLOCK_LETTERLIKE_SYMBOLS); INSTALL_ENUM(UBlockCode, "NUMBER_FORMS", UBLOCK_NUMBER_FORMS); INSTALL_ENUM(UBlockCode, "ARROWS", UBLOCK_ARROWS); INSTALL_ENUM(UBlockCode, "MATHEMATICAL_OPERATORS", UBLOCK_MATHEMATICAL_OPERATORS); INSTALL_ENUM(UBlockCode, "MISCELLANEOUS_TECHNICAL", UBLOCK_MISCELLANEOUS_TECHNICAL); INSTALL_ENUM(UBlockCode, "CONTROL_PICTURES", UBLOCK_CONTROL_PICTURES); INSTALL_ENUM(UBlockCode, "OPTICAL_CHARACTER_RECOGNITION", UBLOCK_OPTICAL_CHARACTER_RECOGNITION); INSTALL_ENUM(UBlockCode, "ENCLOSED_ALPHANUMERICS", UBLOCK_ENCLOSED_ALPHANUMERICS); INSTALL_ENUM(UBlockCode, "BOX_DRAWING", UBLOCK_BOX_DRAWING); INSTALL_ENUM(UBlockCode, "BLOCK_ELEMENTS", UBLOCK_BLOCK_ELEMENTS); INSTALL_ENUM(UBlockCode, "GEOMETRIC_SHAPES", UBLOCK_GEOMETRIC_SHAPES); INSTALL_ENUM(UBlockCode, "MISCELLANEOUS_SYMBOLS", UBLOCK_MISCELLANEOUS_SYMBOLS); INSTALL_ENUM(UBlockCode, "DINGBATS", UBLOCK_DINGBATS); INSTALL_ENUM(UBlockCode, "BRAILLE_PATTERNS", UBLOCK_BRAILLE_PATTERNS); INSTALL_ENUM(UBlockCode, "CJK_RADICALS_SUPPLEMENT", UBLOCK_CJK_RADICALS_SUPPLEMENT); INSTALL_ENUM(UBlockCode, "KANGXI_RADICALS", UBLOCK_KANGXI_RADICALS); INSTALL_ENUM(UBlockCode, "IDEOGRAPHIC_DESCRIPTION_CHARACTERS", UBLOCK_IDEOGRAPHIC_DESCRIPTION_CHARACTERS); INSTALL_ENUM(UBlockCode, "CJK_SYMBOLS_AND_PUNCTUATION", UBLOCK_CJK_SYMBOLS_AND_PUNCTUATION); INSTALL_ENUM(UBlockCode, "HIRAGANA", UBLOCK_HIRAGANA); INSTALL_ENUM(UBlockCode, "KATAKANA", UBLOCK_KATAKANA); INSTALL_ENUM(UBlockCode, "BOPOMOFO", UBLOCK_BOPOMOFO); INSTALL_ENUM(UBlockCode, "HANGUL_COMPATIBILITY_JAMO", UBLOCK_HANGUL_COMPATIBILITY_JAMO); INSTALL_ENUM(UBlockCode, "KANBUN", UBLOCK_KANBUN); INSTALL_ENUM(UBlockCode, "BOPOMOFO_EXTENDED", UBLOCK_BOPOMOFO_EXTENDED); INSTALL_ENUM(UBlockCode, "ENCLOSED_CJK_LETTERS_AND_MONTHS", UBLOCK_ENCLOSED_CJK_LETTERS_AND_MONTHS); INSTALL_ENUM(UBlockCode, "CJK_COMPATIBILITY", UBLOCK_CJK_COMPATIBILITY); INSTALL_ENUM(UBlockCode, "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A", UBLOCK_CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A); INSTALL_ENUM(UBlockCode, "CJK_UNIFIED_IDEOGRAPHS", UBLOCK_CJK_UNIFIED_IDEOGRAPHS); INSTALL_ENUM(UBlockCode, "YI_SYLLABLES", UBLOCK_YI_SYLLABLES); INSTALL_ENUM(UBlockCode, "YI_RADICALS", UBLOCK_YI_RADICALS); INSTALL_ENUM(UBlockCode, "HANGUL_SYLLABLES", UBLOCK_HANGUL_SYLLABLES); INSTALL_ENUM(UBlockCode, "HIGH_SURROGATES", UBLOCK_HIGH_SURROGATES); INSTALL_ENUM(UBlockCode, "HIGH_PRIVATE_USE_SURROGATES", UBLOCK_HIGH_PRIVATE_USE_SURROGATES); INSTALL_ENUM(UBlockCode, "LOW_SURROGATES", UBLOCK_LOW_SURROGATES); INSTALL_ENUM(UBlockCode, "PRIVATE_USE_AREA", UBLOCK_PRIVATE_USE_AREA); INSTALL_ENUM(UBlockCode, "PRIVATE_USE", UBLOCK_PRIVATE_USE); INSTALL_ENUM(UBlockCode, "CJK_COMPATIBILITY_IDEOGRAPHS", UBLOCK_CJK_COMPATIBILITY_IDEOGRAPHS); INSTALL_ENUM(UBlockCode, "ALPHABETIC_PRESENTATION_FORMS", UBLOCK_ALPHABETIC_PRESENTATION_FORMS); INSTALL_ENUM(UBlockCode, "ARABIC_PRESENTATION_FORMS_A", UBLOCK_ARABIC_PRESENTATION_FORMS_A); INSTALL_ENUM(UBlockCode, "COMBINING_HALF_MARKS", UBLOCK_COMBINING_HALF_MARKS); INSTALL_ENUM(UBlockCode, "CJK_COMPATIBILITY_FORMS", UBLOCK_CJK_COMPATIBILITY_FORMS); INSTALL_ENUM(UBlockCode, "SMALL_FORM_VARIANTS", UBLOCK_SMALL_FORM_VARIANTS); INSTALL_ENUM(UBlockCode, "ARABIC_PRESENTATION_FORMS_B", UBLOCK_ARABIC_PRESENTATION_FORMS_B); INSTALL_ENUM(UBlockCode, "SPECIALS", UBLOCK_SPECIALS); INSTALL_ENUM(UBlockCode, "HALFWIDTH_AND_FULLWIDTH_FORMS", UBLOCK_HALFWIDTH_AND_FULLWIDTH_FORMS); INSTALL_ENUM(UBlockCode, "OLD_ITALIC", UBLOCK_OLD_ITALIC); INSTALL_ENUM(UBlockCode, "GOTHIC", UBLOCK_GOTHIC); INSTALL_ENUM(UBlockCode, "DESERET", UBLOCK_DESERET); INSTALL_ENUM(UBlockCode, "BYZANTINE_MUSICAL_SYMBOLS", UBLOCK_BYZANTINE_MUSICAL_SYMBOLS); INSTALL_ENUM(UBlockCode, "MUSICAL_SYMBOLS", UBLOCK_MUSICAL_SYMBOLS); INSTALL_ENUM(UBlockCode, "MATHEMATICAL_ALPHANUMERIC_SYMBOLS", UBLOCK_MATHEMATICAL_ALPHANUMERIC_SYMBOLS); INSTALL_ENUM(UBlockCode, "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B", UBLOCK_CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B); INSTALL_ENUM(UBlockCode, "CJK_COMPATIBILITY_IDEOGRAPHS_SUPPLEMENT", UBLOCK_CJK_COMPATIBILITY_IDEOGRAPHS_SUPPLEMENT); INSTALL_ENUM(UBlockCode, "TAGS", UBLOCK_TAGS); INSTALL_ENUM(UBlockCode, "CYRILLIC_SUPPLEMENT", UBLOCK_CYRILLIC_SUPPLEMENT); INSTALL_ENUM(UBlockCode, "CYRILLIC_SUPPLEMENTARY", UBLOCK_CYRILLIC_SUPPLEMENTARY); INSTALL_ENUM(UBlockCode, "TAGALOG", UBLOCK_TAGALOG); INSTALL_ENUM(UBlockCode, "HANUNOO", UBLOCK_HANUNOO); INSTALL_ENUM(UBlockCode, "BUHID", UBLOCK_BUHID); INSTALL_ENUM(UBlockCode, "TAGBANWA", UBLOCK_TAGBANWA); INSTALL_ENUM(UBlockCode, "MISCELLANEOUS_MATHEMATICAL_SYMBOLS_A", UBLOCK_MISCELLANEOUS_MATHEMATICAL_SYMBOLS_A); INSTALL_ENUM(UBlockCode, "SUPPLEMENTAL_ARROWS_A", UBLOCK_SUPPLEMENTAL_ARROWS_A); INSTALL_ENUM(UBlockCode, "SUPPLEMENTAL_ARROWS_B", UBLOCK_SUPPLEMENTAL_ARROWS_B); INSTALL_ENUM(UBlockCode, "MISCELLANEOUS_MATHEMATICAL_SYMBOLS_B", UBLOCK_MISCELLANEOUS_MATHEMATICAL_SYMBOLS_B); INSTALL_ENUM(UBlockCode, "SUPPLEMENTAL_MATHEMATICAL_OPERATORS", UBLOCK_SUPPLEMENTAL_MATHEMATICAL_OPERATORS); INSTALL_ENUM(UBlockCode, "KATAKANA_PHONETIC_EXTENSIONS", UBLOCK_KATAKANA_PHONETIC_EXTENSIONS); INSTALL_ENUM(UBlockCode, "VARIATION_SELECTORS", UBLOCK_VARIATION_SELECTORS); INSTALL_ENUM(UBlockCode, "SUPPLEMENTARY_PRIVATE_USE_AREA_A", UBLOCK_SUPPLEMENTARY_PRIVATE_USE_AREA_A); INSTALL_ENUM(UBlockCode, "SUPPLEMENTARY_PRIVATE_USE_AREA_B", UBLOCK_SUPPLEMENTARY_PRIVATE_USE_AREA_B); INSTALL_ENUM(UBlockCode, "LIMBU", UBLOCK_LIMBU); INSTALL_ENUM(UBlockCode, "TAI_LE", UBLOCK_TAI_LE); INSTALL_ENUM(UBlockCode, "KHMER_SYMBOLS", UBLOCK_KHMER_SYMBOLS); INSTALL_ENUM(UBlockCode, "PHONETIC_EXTENSIONS", UBLOCK_PHONETIC_EXTENSIONS); INSTALL_ENUM(UBlockCode, "MISCELLANEOUS_SYMBOLS_AND_ARROWS", UBLOCK_MISCELLANEOUS_SYMBOLS_AND_ARROWS); INSTALL_ENUM(UBlockCode, "YIJING_HEXAGRAM_SYMBOLS", UBLOCK_YIJING_HEXAGRAM_SYMBOLS); INSTALL_ENUM(UBlockCode, "LINEAR_B_SYLLABARY", UBLOCK_LINEAR_B_SYLLABARY); INSTALL_ENUM(UBlockCode, "LINEAR_B_IDEOGRAMS", UBLOCK_LINEAR_B_IDEOGRAMS); INSTALL_ENUM(UBlockCode, "AEGEAN_NUMBERS", UBLOCK_AEGEAN_NUMBERS); INSTALL_ENUM(UBlockCode, "UGARITIC", UBLOCK_UGARITIC); INSTALL_ENUM(UBlockCode, "SHAVIAN", UBLOCK_SHAVIAN); INSTALL_ENUM(UBlockCode, "OSMANYA", UBLOCK_OSMANYA); INSTALL_ENUM(UBlockCode, "CYPRIOT_SYLLABARY", UBLOCK_CYPRIOT_SYLLABARY); INSTALL_ENUM(UBlockCode, "TAI_XUAN_JING_SYMBOLS", UBLOCK_TAI_XUAN_JING_SYMBOLS); INSTALL_ENUM(UBlockCode, "VARIATION_SELECTORS_SUPPLEMENT", UBLOCK_VARIATION_SELECTORS_SUPPLEMENT); INSTALL_ENUM(UBlockCode, "ANCIENT_GREEK_MUSICAL_NOTATION", UBLOCK_ANCIENT_GREEK_MUSICAL_NOTATION); INSTALL_ENUM(UBlockCode, "ANCIENT_GREEK_NUMBERS", UBLOCK_ANCIENT_GREEK_NUMBERS); INSTALL_ENUM(UBlockCode, "ARABIC_SUPPLEMENT", UBLOCK_ARABIC_SUPPLEMENT); INSTALL_ENUM(UBlockCode, "BUGINESE", UBLOCK_BUGINESE); INSTALL_ENUM(UBlockCode, "CJK_STROKES", UBLOCK_CJK_STROKES); INSTALL_ENUM(UBlockCode, "COMBINING_DIACRITICAL_MARKS_SUPPLEMENT", UBLOCK_COMBINING_DIACRITICAL_MARKS_SUPPLEMENT); INSTALL_ENUM(UBlockCode, "COPTIC", UBLOCK_COPTIC); INSTALL_ENUM(UBlockCode, "ETHIOPIC_EXTENDED", UBLOCK_ETHIOPIC_EXTENDED); INSTALL_ENUM(UBlockCode, "ETHIOPIC_SUPPLEMENT", UBLOCK_ETHIOPIC_SUPPLEMENT); INSTALL_ENUM(UBlockCode, "GEORGIAN_SUPPLEMENT", UBLOCK_GEORGIAN_SUPPLEMENT); INSTALL_ENUM(UBlockCode, "GLAGOLITIC", UBLOCK_GLAGOLITIC); INSTALL_ENUM(UBlockCode, "KHAROSHTHI", UBLOCK_KHAROSHTHI); INSTALL_ENUM(UBlockCode, "MODIFIER_TONE_LETTERS", UBLOCK_MODIFIER_TONE_LETTERS); INSTALL_ENUM(UBlockCode, "NEW_TAI_LUE", UBLOCK_NEW_TAI_LUE); INSTALL_ENUM(UBlockCode, "OLD_PERSIAN", UBLOCK_OLD_PERSIAN); INSTALL_ENUM(UBlockCode, "PHONETIC_EXTENSIONS_SUPPLEMENT", UBLOCK_PHONETIC_EXTENSIONS_SUPPLEMENT); INSTALL_ENUM(UBlockCode, "SUPPLEMENTAL_PUNCTUATION", UBLOCK_SUPPLEMENTAL_PUNCTUATION); INSTALL_ENUM(UBlockCode, "SYLOTI_NAGRI", UBLOCK_SYLOTI_NAGRI); INSTALL_ENUM(UBlockCode, "TIFINAGH", UBLOCK_TIFINAGH); INSTALL_ENUM(UBlockCode, "VERTICAL_FORMS", UBLOCK_VERTICAL_FORMS); INSTALL_ENUM(UBlockCode, "NKO", UBLOCK_NKO); INSTALL_ENUM(UBlockCode, "BALINESE", UBLOCK_BALINESE); INSTALL_ENUM(UBlockCode, "LATIN_EXTENDED_C", UBLOCK_LATIN_EXTENDED_C); INSTALL_ENUM(UBlockCode, "LATIN_EXTENDED_D", UBLOCK_LATIN_EXTENDED_D); INSTALL_ENUM(UBlockCode, "PHAGS_PA", UBLOCK_PHAGS_PA); INSTALL_ENUM(UBlockCode, "PHOENICIAN", UBLOCK_PHOENICIAN); INSTALL_ENUM(UBlockCode, "CUNEIFORM", UBLOCK_CUNEIFORM); INSTALL_ENUM(UBlockCode, "CUNEIFORM_NUMBERS_AND_PUNCTUATION", UBLOCK_CUNEIFORM_NUMBERS_AND_PUNCTUATION); INSTALL_ENUM(UBlockCode, "COUNTING_ROD_NUMERALS", UBLOCK_COUNTING_ROD_NUMERALS); #if U_ICU_VERSION_HEX >= 0x04000000 INSTALL_ENUM(UBlockCode, "SUNDANESE", UBLOCK_SUNDANESE); INSTALL_ENUM(UBlockCode, "LEPCHA", UBLOCK_LEPCHA); INSTALL_ENUM(UBlockCode, "OL_CHIKI", UBLOCK_OL_CHIKI); INSTALL_ENUM(UBlockCode, "CYRILLIC_EXTENDED_A", UBLOCK_CYRILLIC_EXTENDED_A); INSTALL_ENUM(UBlockCode, "VAI", UBLOCK_VAI); INSTALL_ENUM(UBlockCode, "CYRILLIC_EXTENDED_B", UBLOCK_CYRILLIC_EXTENDED_B); INSTALL_ENUM(UBlockCode, "SAURASHTRA", UBLOCK_SAURASHTRA); INSTALL_ENUM(UBlockCode, "KAYAH_LI", UBLOCK_KAYAH_LI); INSTALL_ENUM(UBlockCode, "REJANG", UBLOCK_REJANG); INSTALL_ENUM(UBlockCode, "CHAM", UBLOCK_CHAM); INSTALL_ENUM(UBlockCode, "ANCIENT_SYMBOLS", UBLOCK_ANCIENT_SYMBOLS); INSTALL_ENUM(UBlockCode, "PHAISTOS_DISC", UBLOCK_PHAISTOS_DISC); INSTALL_ENUM(UBlockCode, "LYCIAN", UBLOCK_LYCIAN); INSTALL_ENUM(UBlockCode, "CARIAN", UBLOCK_CARIAN); INSTALL_ENUM(UBlockCode, "LYDIAN", UBLOCK_LYDIAN); INSTALL_ENUM(UBlockCode, "MAHJONG_TILES", UBLOCK_MAHJONG_TILES); INSTALL_ENUM(UBlockCode, "DOMINO_TILES", UBLOCK_DOMINO_TILES); #endif #if U_ICU_VERSION_HEX >= 0x04040000 INSTALL_ENUM(UBlockCode, "SAMARITAN", UBLOCK_SAMARITAN); INSTALL_ENUM(UBlockCode, "UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS_EXTENDED", UBLOCK_UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS_EXTENDED); INSTALL_ENUM(UBlockCode, "TAI_THAM", UBLOCK_TAI_THAM); INSTALL_ENUM(UBlockCode, "VEDIC_EXTENSIONS", UBLOCK_VEDIC_EXTENSIONS); INSTALL_ENUM(UBlockCode, "LISU", UBLOCK_LISU); INSTALL_ENUM(UBlockCode, "BAMUM", UBLOCK_BAMUM); INSTALL_ENUM(UBlockCode, "COMMON_INDIC_NUMBER_FORMS", UBLOCK_COMMON_INDIC_NUMBER_FORMS); INSTALL_ENUM(UBlockCode, "DEVANAGARI_EXTENDED", UBLOCK_DEVANAGARI_EXTENDED); INSTALL_ENUM(UBlockCode, "HANGUL_JAMO_EXTENDED_A", UBLOCK_HANGUL_JAMO_EXTENDED_A); INSTALL_ENUM(UBlockCode, "JAVANESE", UBLOCK_JAVANESE); INSTALL_ENUM(UBlockCode, "MYANMAR_EXTENDED_A", UBLOCK_MYANMAR_EXTENDED_A); INSTALL_ENUM(UBlockCode, "TAI_VIET", UBLOCK_TAI_VIET); INSTALL_ENUM(UBlockCode, "MEETEI_MAYEK", UBLOCK_MEETEI_MAYEK); INSTALL_ENUM(UBlockCode, "HANGUL_JAMO_EXTENDED_B", UBLOCK_HANGUL_JAMO_EXTENDED_B); INSTALL_ENUM(UBlockCode, "IMPERIAL_ARAMAIC", UBLOCK_IMPERIAL_ARAMAIC); INSTALL_ENUM(UBlockCode, "OLD_SOUTH_ARABIAN", UBLOCK_OLD_SOUTH_ARABIAN); INSTALL_ENUM(UBlockCode, "AVESTAN", UBLOCK_AVESTAN); INSTALL_ENUM(UBlockCode, "INSCRIPTIONAL_PARTHIAN", UBLOCK_INSCRIPTIONAL_PARTHIAN); INSTALL_ENUM(UBlockCode, "INSCRIPTIONAL_PAHLAVI", UBLOCK_INSCRIPTIONAL_PAHLAVI); INSTALL_ENUM(UBlockCode, "OLD_TURKIC", UBLOCK_OLD_TURKIC); INSTALL_ENUM(UBlockCode, "RUMI_NUMERAL_SYMBOLS", UBLOCK_RUMI_NUMERAL_SYMBOLS); INSTALL_ENUM(UBlockCode, "KAITHI", UBLOCK_KAITHI); INSTALL_ENUM(UBlockCode, "EGYPTIAN_HIEROGLYPHS", UBLOCK_EGYPTIAN_HIEROGLYPHS); INSTALL_ENUM(UBlockCode, "ENCLOSED_ALPHANUMERIC_SUPPLEMENT", UBLOCK_ENCLOSED_ALPHANUMERIC_SUPPLEMENT); INSTALL_ENUM(UBlockCode, "ENCLOSED_IDEOGRAPHIC_SUPPLEMENT", UBLOCK_ENCLOSED_IDEOGRAPHIC_SUPPLEMENT); INSTALL_ENUM(UBlockCode, "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_C", UBLOCK_CJK_UNIFIED_IDEOGRAPHS_EXTENSION_C); #endif #if U_ICU_VERSION_HEX >= 0x04060000 INSTALL_ENUM(UBlockCode, "MANDAIC", UBLOCK_MANDAIC); INSTALL_ENUM(UBlockCode, "BATAK", UBLOCK_BATAK); INSTALL_ENUM(UBlockCode, "ETHIOPIC_EXTENDED_A", UBLOCK_ETHIOPIC_EXTENDED_A); INSTALL_ENUM(UBlockCode, "BRAHMI", UBLOCK_BRAHMI); INSTALL_ENUM(UBlockCode, "BAMUM_SUPPLEMENT", UBLOCK_BAMUM_SUPPLEMENT); INSTALL_ENUM(UBlockCode, "KANA_SUPPLEMENT", UBLOCK_KANA_SUPPLEMENT); INSTALL_ENUM(UBlockCode, "PLAYING_CARDS", UBLOCK_PLAYING_CARDS); INSTALL_ENUM(UBlockCode, "MISCELLANEOUS_SYMBOLS_AND_PICTOGRAPHS", UBLOCK_MISCELLANEOUS_SYMBOLS_AND_PICTOGRAPHS); INSTALL_ENUM(UBlockCode, "EMOTICONS", UBLOCK_EMOTICONS); INSTALL_ENUM(UBlockCode, "TRANSPORT_AND_MAP_SYMBOLS", UBLOCK_TRANSPORT_AND_MAP_SYMBOLS); INSTALL_ENUM(UBlockCode, "ALCHEMICAL_SYMBOLS", UBLOCK_ALCHEMICAL_SYMBOLS); INSTALL_ENUM(UBlockCode, "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_D", UBLOCK_CJK_UNIFIED_IDEOGRAPHS_EXTENSION_D); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(49, 0, 0) INSTALL_ENUM(UBlockCode, "ARABIC_EXTENDED_A", UBLOCK_ARABIC_EXTENDED_A); INSTALL_ENUM(UBlockCode, "ARABIC_MATHEMATICAL_ALPHABETIC_SYMBOLS", UBLOCK_ARABIC_MATHEMATICAL_ALPHABETIC_SYMBOLS); INSTALL_ENUM(UBlockCode, "CHAKMA", UBLOCK_CHAKMA); INSTALL_ENUM(UBlockCode, "MEETEI_MAYEK_EXTENSIONS", UBLOCK_MEETEI_MAYEK_EXTENSIONS); INSTALL_ENUM(UBlockCode, "MEROITIC_CURSIVE", UBLOCK_MEROITIC_CURSIVE); INSTALL_ENUM(UBlockCode, "MEROITIC_HIEROGLYPHS", UBLOCK_MEROITIC_HIEROGLYPHS); INSTALL_ENUM(UBlockCode, "MIAO", UBLOCK_MIAO); INSTALL_ENUM(UBlockCode, "SHARADA", UBLOCK_SHARADA); INSTALL_ENUM(UBlockCode, "SORA_SOMPENG", UBLOCK_SORA_SOMPENG); INSTALL_ENUM(UBlockCode, "SUNDANESE_SUPPLEMENT", UBLOCK_SUNDANESE_SUPPLEMENT); INSTALL_ENUM(UBlockCode, "TAKRI", UBLOCK_TAKRI); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(54, 0, 0) INSTALL_ENUM(UBlockCode, "BASSA_VAH", UBLOCK_BASSA_VAH); INSTALL_ENUM(UBlockCode, "CAUCASIAN_ALBANIAN", UBLOCK_CAUCASIAN_ALBANIAN); INSTALL_ENUM(UBlockCode, "COPTIC_EPACT_NUMBERS", UBLOCK_COPTIC_EPACT_NUMBERS); INSTALL_ENUM(UBlockCode, "COMBINING_DIACRITICAL_MARKS_EXTENDED", UBLOCK_COMBINING_DIACRITICAL_MARKS_EXTENDED); INSTALL_ENUM(UBlockCode, "DUPLOYAN", UBLOCK_DUPLOYAN); INSTALL_ENUM(UBlockCode, "ELBASAN", UBLOCK_ELBASAN); INSTALL_ENUM(UBlockCode, "GEOMETRIC_SHAPES_EXTENDED", UBLOCK_GEOMETRIC_SHAPES_EXTENDED); INSTALL_ENUM(UBlockCode, "GRANTHA", UBLOCK_GRANTHA); INSTALL_ENUM(UBlockCode, "KHOJKI", UBLOCK_KHOJKI); INSTALL_ENUM(UBlockCode, "KHUDAWADI", UBLOCK_KHUDAWADI); INSTALL_ENUM(UBlockCode, "LATIN_EXTENDED_E", UBLOCK_LATIN_EXTENDED_E); INSTALL_ENUM(UBlockCode, "LINEAR_A", UBLOCK_LINEAR_A); INSTALL_ENUM(UBlockCode, "MAHAJANI", UBLOCK_MAHAJANI); INSTALL_ENUM(UBlockCode, "MANICHAEAN", UBLOCK_MANICHAEAN); INSTALL_ENUM(UBlockCode, "MENDE_KIKAKUI", UBLOCK_MENDE_KIKAKUI); INSTALL_ENUM(UBlockCode, "MODI", UBLOCK_MODI); INSTALL_ENUM(UBlockCode, "MRO", UBLOCK_MRO); INSTALL_ENUM(UBlockCode, "MYANMAR_EXTENDED_B", UBLOCK_MYANMAR_EXTENDED_B); INSTALL_ENUM(UBlockCode, "NABATAEAN", UBLOCK_NABATAEAN); INSTALL_ENUM(UBlockCode, "OLD_NORTH_ARABIAN", UBLOCK_OLD_NORTH_ARABIAN); INSTALL_ENUM(UBlockCode, "OLD_PERMIC", UBLOCK_OLD_PERMIC); INSTALL_ENUM(UBlockCode, "ORNAMENTAL_DINGBATS", UBLOCK_ORNAMENTAL_DINGBATS); INSTALL_ENUM(UBlockCode, "PAHAWH_HMONG", UBLOCK_PAHAWH_HMONG); INSTALL_ENUM(UBlockCode, "PALMYRENE", UBLOCK_PALMYRENE); INSTALL_ENUM(UBlockCode, "PAU_CIN_HAU", UBLOCK_PAU_CIN_HAU); INSTALL_ENUM(UBlockCode, "PSALTER_PAHLAVI", UBLOCK_PSALTER_PAHLAVI); INSTALL_ENUM(UBlockCode, "SHORTHAND_FORMAT_CONTROLS", UBLOCK_SHORTHAND_FORMAT_CONTROLS); INSTALL_ENUM(UBlockCode, "SIDDHAM", UBLOCK_SIDDHAM); INSTALL_ENUM(UBlockCode, "SINHALA_ARCHAIC_NUMBERS", UBLOCK_SINHALA_ARCHAIC_NUMBERS); INSTALL_ENUM(UBlockCode, "SUPPLEMENTAL_ARROWS_C", UBLOCK_SUPPLEMENTAL_ARROWS_C); INSTALL_ENUM(UBlockCode, "TIRHUTA", UBLOCK_TIRHUTA); INSTALL_ENUM(UBlockCode, "WARANG_CITI", UBLOCK_WARANG_CITI); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(56, 0, 0) INSTALL_ENUM(UBlockCode, "AHOM", UBLOCK_AHOM); INSTALL_ENUM(UBlockCode, "ANATOLIAN_HIEROGLYPHS", UBLOCK_ANATOLIAN_HIEROGLYPHS); INSTALL_ENUM(UBlockCode, "CHEROKEE_SUPPLEMENT", UBLOCK_CHEROKEE_SUPPLEMENT); INSTALL_ENUM(UBlockCode, "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_E", UBLOCK_CJK_UNIFIED_IDEOGRAPHS_EXTENSION_E); INSTALL_ENUM(UBlockCode, "EARLY_DYNASTIC_CUNEIFORM", UBLOCK_EARLY_DYNASTIC_CUNEIFORM); INSTALL_ENUM(UBlockCode, "HATRAN", UBLOCK_HATRAN); INSTALL_ENUM(UBlockCode, "MULTANI", UBLOCK_MULTANI); INSTALL_ENUM(UBlockCode, "OLD_HUNGARIAN", UBLOCK_OLD_HUNGARIAN); INSTALL_ENUM(UBlockCode, "SUPPLEMENTAL_SYMBOLS_AND_PICTOGRAPHS", UBLOCK_SUPPLEMENTAL_SYMBOLS_AND_PICTOGRAPHS); INSTALL_ENUM(UBlockCode, "SUTTON_SIGNWRITING", UBLOCK_SUTTON_SIGNWRITING); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(58, 0, 0) INSTALL_ENUM(UBlockCode, "ADLAM", UBLOCK_ADLAM); INSTALL_ENUM(UBlockCode, "BHAIKSUKI", UBLOCK_BHAIKSUKI); INSTALL_ENUM(UBlockCode, "CYRILLIC_EXTENDED_C", UBLOCK_CYRILLIC_EXTENDED_C); INSTALL_ENUM(UBlockCode, "GLAGOLITIC_SUPPLEMENT", UBLOCK_GLAGOLITIC_SUPPLEMENT); INSTALL_ENUM(UBlockCode, "IDEOGRAPHIC_SYMBOLS_AND_PUNCTUATION", UBLOCK_IDEOGRAPHIC_SYMBOLS_AND_PUNCTUATION); INSTALL_ENUM(UBlockCode, "MARCHEN", UBLOCK_MARCHEN); INSTALL_ENUM(UBlockCode, "MONGOLIAN_SUPPLEMENT", UBLOCK_MONGOLIAN_SUPPLEMENT); INSTALL_ENUM(UBlockCode, "NEWA", UBLOCK_NEWA); INSTALL_ENUM(UBlockCode, "OSAGE", UBLOCK_OSAGE); INSTALL_ENUM(UBlockCode, "TANGUT", UBLOCK_TANGUT); INSTALL_ENUM(UBlockCode, "TANGUT_COMPONENTS", UBLOCK_TANGUT_COMPONENTS); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(60, 0, 0) INSTALL_ENUM(UBlockCode, "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_F", UBLOCK_CJK_UNIFIED_IDEOGRAPHS_EXTENSION_F); INSTALL_ENUM(UBlockCode, "KANA_EXTENDED_A", UBLOCK_KANA_EXTENDED_A); INSTALL_ENUM(UBlockCode, "MASARAM_GONDI", UBLOCK_MASARAM_GONDI); INSTALL_ENUM(UBlockCode, "NUSHU", UBLOCK_NUSHU); INSTALL_ENUM(UBlockCode, "SOYOMBO", UBLOCK_SOYOMBO); INSTALL_ENUM(UBlockCode, "SYRIAC_SUPPLEMENT", UBLOCK_SYRIAC_SUPPLEMENT); INSTALL_ENUM(UBlockCode, "ZANABAZAR_SQUARE", UBLOCK_ZANABAZAR_SQUARE); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(62, 0, 0) INSTALL_ENUM(UBlockCode, "CHESS_SYMBOLS", UBLOCK_CHESS_SYMBOLS); INSTALL_ENUM(UBlockCode, "DOGRA", UBLOCK_DOGRA); INSTALL_ENUM(UBlockCode, "GEORGIAN_EXTENDED", UBLOCK_GEORGIAN_EXTENDED); INSTALL_ENUM(UBlockCode, "GUNJALA_GONDI", UBLOCK_GUNJALA_GONDI); INSTALL_ENUM(UBlockCode, "HANIFI_ROHINGYA", UBLOCK_HANIFI_ROHINGYA); INSTALL_ENUM(UBlockCode, "INDIC_SIYAQ_NUMBERS", UBLOCK_INDIC_SIYAQ_NUMBERS); INSTALL_ENUM(UBlockCode, "MAKASAR", UBLOCK_MAKASAR); INSTALL_ENUM(UBlockCode, "MAYAN_NUMERALS", UBLOCK_MAYAN_NUMERALS); INSTALL_ENUM(UBlockCode, "MEDEFAIDRIN", UBLOCK_MEDEFAIDRIN); INSTALL_ENUM(UBlockCode, "OLD_SOGDIAN", UBLOCK_OLD_SOGDIAN); INSTALL_ENUM(UBlockCode, "SOGDIAN", UBLOCK_SOGDIAN); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(64, 0, 0) INSTALL_ENUM(UBlockCode, "EGYPTIAN_HIEROGLYPH_FORMAT_CONTROLS", UBLOCK_EGYPTIAN_HIEROGLYPH_FORMAT_CONTROLS); INSTALL_ENUM(UBlockCode, "ELYMAIC", UBLOCK_ELYMAIC); INSTALL_ENUM(UBlockCode, "NANDINAGARI", UBLOCK_NANDINAGARI); INSTALL_ENUM(UBlockCode, "NYIAKENG_PUACHUE_HMONG", UBLOCK_NYIAKENG_PUACHUE_HMONG); INSTALL_ENUM(UBlockCode, "OTTOMAN_SIYAQ_NUMBERS", UBLOCK_OTTOMAN_SIYAQ_NUMBERS); INSTALL_ENUM(UBlockCode, "SMALL_KANA_EXTENSION", UBLOCK_SMALL_KANA_EXTENSION); INSTALL_ENUM(UBlockCode, "SYMBOLS_AND_PICTOGRAPHS_EXTENDED_A", UBLOCK_SYMBOLS_AND_PICTOGRAPHS_EXTENDED_A); INSTALL_ENUM(UBlockCode, "TAMIL_SUPPLEMENT", UBLOCK_TAMIL_SUPPLEMENT); INSTALL_ENUM(UBlockCode, "WANCHO", UBLOCK_WANCHO); #endif INSTALL_ENUM(UBlockCode, "INVALID_CODE", UBLOCK_INVALID_CODE); INSTALL_ENUM(UCharNameChoice, "UNICODE_CHAR_NAME", U_UNICODE_CHAR_NAME); INSTALL_ENUM(UCharNameChoice, "EXTENDED_CHAR_NAME", U_EXTENDED_CHAR_NAME); #if U_ICU_VERSION_HEX >= 0x04040000 INSTALL_ENUM(UCharNameChoice, "CHAR_NAME_ALIAS", U_CHAR_NAME_ALIAS); #endif INSTALL_ENUM(UPropertyNameChoice, "SHORT_PROPERTY_NAME", U_SHORT_PROPERTY_NAME); INSTALL_ENUM(UPropertyNameChoice, "LONG_PROPERTY_NAME", U_LONG_PROPERTY_NAME); #if U_ICU_VERSION_HEX >= VERSION_HEX(52, 0, 0) INSTALL_ENUM(UBidiPairedBracketType, "NONE", U_BPT_NONE); INSTALL_ENUM(UBidiPairedBracketType, "OPEN", U_BPT_OPEN); INSTALL_ENUM(UBidiPairedBracketType, "CLOSE", U_BPT_CLOSE); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(63, 0, 0) INSTALL_ENUM(UIndicPositionalCategory, "NA", U_INPC_NA); INSTALL_ENUM(UIndicPositionalCategory, "BOTTOM", U_INPC_BOTTOM); INSTALL_ENUM(UIndicPositionalCategory, "BOTTOM_AND_LEFT", U_INPC_BOTTOM_AND_LEFT); INSTALL_ENUM(UIndicPositionalCategory, "BOTTOM_AND_RIGHT", U_INPC_BOTTOM_AND_RIGHT); INSTALL_ENUM(UIndicPositionalCategory, "LEFT", U_INPC_LEFT); INSTALL_ENUM(UIndicPositionalCategory, "LEFT_AND_RIGHT", U_INPC_LEFT_AND_RIGHT); INSTALL_ENUM(UIndicPositionalCategory, "OVERSTRUCK", U_INPC_OVERSTRUCK); INSTALL_ENUM(UIndicPositionalCategory, "RIGHT", U_INPC_RIGHT); INSTALL_ENUM(UIndicPositionalCategory, "TOP", U_INPC_TOP); INSTALL_ENUM(UIndicPositionalCategory, "TOP_AND_BOTTOM", U_INPC_TOP_AND_BOTTOM); INSTALL_ENUM(UIndicPositionalCategory, "TOP_AND_BOTTOM_AND_RIGHT", U_INPC_TOP_AND_BOTTOM_AND_RIGHT); INSTALL_ENUM(UIndicPositionalCategory, "TOP_AND_LEFT", U_INPC_TOP_AND_LEFT); INSTALL_ENUM(UIndicPositionalCategory, "TOP_AND_LEFT_AND_RIGHT", U_INPC_TOP_AND_LEFT_AND_RIGHT); INSTALL_ENUM(UIndicPositionalCategory, "TOP_AND_RIGHT", U_INPC_TOP_AND_RIGHT); INSTALL_ENUM(UIndicPositionalCategory, "VISUAL_ORDER_LEFT", U_INPC_VISUAL_ORDER_LEFT); INSTALL_ENUM(UIndicSyllabicCategory, "OTHER", U_INSC_OTHER); INSTALL_ENUM(UIndicSyllabicCategory, "AVAGRAHA", U_INSC_AVAGRAHA); INSTALL_ENUM(UIndicSyllabicCategory, "BINDU", U_INSC_BINDU); INSTALL_ENUM(UIndicSyllabicCategory, "BRAHMI_JOINING_NUMBER", U_INSC_BRAHMI_JOINING_NUMBER); INSTALL_ENUM(UIndicSyllabicCategory, "CANTILLATION_MARK", U_INSC_CANTILLATION_MARK); INSTALL_ENUM(UIndicSyllabicCategory, "CONSONANT", U_INSC_CONSONANT); INSTALL_ENUM(UIndicSyllabicCategory, "CONSONANT_DEAD", U_INSC_CONSONANT_DEAD); INSTALL_ENUM(UIndicSyllabicCategory, "CONSONANT_FINAL", U_INSC_CONSONANT_FINAL); INSTALL_ENUM(UIndicSyllabicCategory, "CONSONANT_HEAD_LETTER", U_INSC_CONSONANT_HEAD_LETTER); INSTALL_ENUM(UIndicSyllabicCategory, "CONSONANT_INITIAL_POSTFIXED", U_INSC_CONSONANT_INITIAL_POSTFIXED); INSTALL_ENUM(UIndicSyllabicCategory, "CONSONANT_KILLER", U_INSC_CONSONANT_KILLER); INSTALL_ENUM(UIndicSyllabicCategory, "CONSONANT_MEDIAL", U_INSC_CONSONANT_MEDIAL); INSTALL_ENUM(UIndicSyllabicCategory, "CONSONANT_PLACEHOLDER", U_INSC_CONSONANT_PLACEHOLDER); INSTALL_ENUM(UIndicSyllabicCategory, "CONSONANT_PRECEDING_REPHA", U_INSC_CONSONANT_PRECEDING_REPHA); INSTALL_ENUM(UIndicSyllabicCategory, "CONSONANT_PREFIXED", U_INSC_CONSONANT_PREFIXED); INSTALL_ENUM(UIndicSyllabicCategory, "CONSONANT_SUBJOINED", U_INSC_CONSONANT_SUBJOINED); INSTALL_ENUM(UIndicSyllabicCategory, "CONSONANT_SUCCEEDING_REPHA", U_INSC_CONSONANT_SUCCEEDING_REPHA); INSTALL_ENUM(UIndicSyllabicCategory, "CONSONANT_WITH_STACKER", U_INSC_CONSONANT_WITH_STACKER); INSTALL_ENUM(UIndicSyllabicCategory, "GEMINATION_MARK", U_INSC_GEMINATION_MARK); INSTALL_ENUM(UIndicSyllabicCategory, "INVISIBLE_STACKER", U_INSC_INVISIBLE_STACKER); INSTALL_ENUM(UIndicSyllabicCategory, "JOINER", U_INSC_JOINER); INSTALL_ENUM(UIndicSyllabicCategory, "MODIFYING_LETTER", U_INSC_MODIFYING_LETTER); INSTALL_ENUM(UIndicSyllabicCategory, "NON_JOINER", U_INSC_NON_JOINER); INSTALL_ENUM(UIndicSyllabicCategory, "NUKTA", U_INSC_NUKTA); INSTALL_ENUM(UIndicSyllabicCategory, "NUMBER", U_INSC_NUMBER); INSTALL_ENUM(UIndicSyllabicCategory, "NUMBER_JOINER", U_INSC_NUMBER_JOINER); INSTALL_ENUM(UIndicSyllabicCategory, "PURE_KILLER", U_INSC_PURE_KILLER); INSTALL_ENUM(UIndicSyllabicCategory, "REGISTER_SHIFTER", U_INSC_REGISTER_SHIFTER); INSTALL_ENUM(UIndicSyllabicCategory, "SYLLABLE_MODIFIER", U_INSC_SYLLABLE_MODIFIER); INSTALL_ENUM(UIndicSyllabicCategory, "TONE_LETTER", U_INSC_TONE_LETTER); INSTALL_ENUM(UIndicSyllabicCategory, "TONE_MARK", U_INSC_TONE_MARK); INSTALL_ENUM(UIndicSyllabicCategory, "VIRAMA", U_INSC_VIRAMA); INSTALL_ENUM(UIndicSyllabicCategory, "VISARGA", U_INSC_VISARGA); INSTALL_ENUM(UIndicSyllabicCategory, "VOWEL", U_INSC_VOWEL); INSTALL_ENUM(UIndicSyllabicCategory, "VOWEL_DEPENDENT", U_INSC_VOWEL_DEPENDENT); INSTALL_ENUM(UIndicSyllabicCategory, "VOWEL_INDEPENDENT", U_INSC_VOWEL_INDEPENDENT); INSTALL_ENUM(UVerticalOrientation, "ROTATED", U_VO_ROTATED); INSTALL_ENUM(UVerticalOrientation, "TRANSFORMED_ROTATED", U_VO_TRANSFORMED_ROTATED); INSTALL_ENUM(UVerticalOrientation, "TRANSFORMED_UPRIGHT", U_VO_TRANSFORMED_UPRIGHT); INSTALL_ENUM(UVerticalOrientation, "UPRIGHT", U_VO_UPRIGHT); #endif #if U_ICU_VERSION_HEX >= 0x04000000 INSTALL_ENUM(UWordBreakValues, "CR", U_WB_CR); INSTALL_ENUM(UWordBreakValues, "EXTEND", U_WB_EXTEND); INSTALL_ENUM(UWordBreakValues, "LF", U_WB_LF); INSTALL_ENUM(UWordBreakValues, "MIDNUMLET", U_WB_MIDNUMLET); INSTALL_ENUM(UWordBreakValues, "NEWLINE", U_WB_NEWLINE); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(50, 0, 0) INSTALL_ENUM(UWordBreakValues, "REGIONAL_INDICATOR", U_WB_REGIONAL_INDICATOR); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(52, 0, 0) INSTALL_ENUM(UWordBreakValues, "HEBREW_LETTER", U_WB_HEBREW_LETTER); INSTALL_ENUM(UWordBreakValues, "SINGLE_QUOTE", U_WB_SINGLE_QUOTE); INSTALL_ENUM(UWordBreakValues, "DOUBLE_QUOTE", U_WB_DOUBLE_QUOTE); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(58, 0, 0) INSTALL_ENUM(UWordBreakValues, "E_BASE", U_WB_E_BASE); INSTALL_ENUM(UWordBreakValues, "E_BASE_GAZ", U_WB_E_BASE_GAZ); INSTALL_ENUM(UWordBreakValues, "E_MODIFIER", U_WB_E_MODIFIER); INSTALL_ENUM(UWordBreakValues, "ZWJ", U_WB_ZWJ); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(62, 0, 0) INSTALL_ENUM(UWordBreakValues, "WSEGSPACE", U_WB_WSEGSPACE); #endif #if U_ICU_VERSION_HEX >= 0x04060000 INSTALL_ENUM(UJoiningGroup, "TEH_MARBUTA_GOAL", U_JG_TEH_MARBUTA_GOAL); #endif INSTALL_ENUM(UJoiningGroup, "FE", U_JG_FE); INSTALL_ENUM(UJoiningGroup, "KHAPH", U_JG_KHAPH); INSTALL_ENUM(UJoiningGroup, "ZHAIN", U_JG_ZHAIN); #if U_ICU_VERSION_HEX >= 0x04000000 INSTALL_ENUM(UJoiningGroup, "BURUSHASKI_YEH_BARREE", U_JG_BURUSHASKI_YEH_BARREE); #endif #if U_ICU_VERSION_HEX >= 0x04040000 INSTALL_ENUM(UJoiningGroup, "FARSI_YEH", U_JG_FARSI_YEH); INSTALL_ENUM(UJoiningGroup, "NYA", U_JG_NYA); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(49, 0, 0) INSTALL_ENUM(UJoiningGroup, "ROHINGYA_YEH", U_JG_ROHINGYA_YEH); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(54, 0, 0) INSTALL_ENUM(UJoiningGroup, "MANICHAEAN_ALEPH", U_JG_MANICHAEAN_ALEPH); INSTALL_ENUM(UJoiningGroup, "MANICHAEAN_AYIN", U_JG_MANICHAEAN_AYIN); INSTALL_ENUM(UJoiningGroup, "MANICHAEAN_BETH", U_JG_MANICHAEAN_BETH); INSTALL_ENUM(UJoiningGroup, "MANICHAEAN_DALETH", U_JG_MANICHAEAN_DALETH); INSTALL_ENUM(UJoiningGroup, "MANICHAEAN_DHAMEDH", U_JG_MANICHAEAN_DHAMEDH); INSTALL_ENUM(UJoiningGroup, "MANICHAEAN_FIVE", U_JG_MANICHAEAN_FIVE); INSTALL_ENUM(UJoiningGroup, "MANICHAEAN_GIMEL", U_JG_MANICHAEAN_GIMEL); INSTALL_ENUM(UJoiningGroup, "MANICHAEAN_HETH", U_JG_MANICHAEAN_HETH); INSTALL_ENUM(UJoiningGroup, "MANICHAEAN_HUNDRED", U_JG_MANICHAEAN_HUNDRED); INSTALL_ENUM(UJoiningGroup, "MANICHAEAN_KAPH", U_JG_MANICHAEAN_KAPH); INSTALL_ENUM(UJoiningGroup, "MANICHAEAN_LAMEDH", U_JG_MANICHAEAN_LAMEDH); INSTALL_ENUM(UJoiningGroup, "MANICHAEAN_MEM", U_JG_MANICHAEAN_MEM); INSTALL_ENUM(UJoiningGroup, "MANICHAEAN_NUN", U_JG_MANICHAEAN_NUN); INSTALL_ENUM(UJoiningGroup, "MANICHAEAN_ONE", U_JG_MANICHAEAN_ONE); INSTALL_ENUM(UJoiningGroup, "MANICHAEAN_PE", U_JG_MANICHAEAN_PE); INSTALL_ENUM(UJoiningGroup, "MANICHAEAN_QOPH", U_JG_MANICHAEAN_QOPH); INSTALL_ENUM(UJoiningGroup, "MANICHAEAN_RESH", U_JG_MANICHAEAN_RESH); INSTALL_ENUM(UJoiningGroup, "MANICHAEAN_SADHE", U_JG_MANICHAEAN_SADHE); INSTALL_ENUM(UJoiningGroup, "MANICHAEAN_SAMEKH", U_JG_MANICHAEAN_SAMEKH); INSTALL_ENUM(UJoiningGroup, "MANICHAEAN_TAW", U_JG_MANICHAEAN_TAW); INSTALL_ENUM(UJoiningGroup, "MANICHAEAN_TEN", U_JG_MANICHAEAN_TEN); INSTALL_ENUM(UJoiningGroup, "MANICHAEAN_TETH", U_JG_MANICHAEAN_TETH); INSTALL_ENUM(UJoiningGroup, "MANICHAEAN_THAMEDH", U_JG_MANICHAEAN_THAMEDH); INSTALL_ENUM(UJoiningGroup, "MANICHAEAN_TWENTY", U_JG_MANICHAEAN_TWENTY); INSTALL_ENUM(UJoiningGroup, "MANICHAEAN_WAW", U_JG_MANICHAEAN_WAW); INSTALL_ENUM(UJoiningGroup, "MANICHAEAN_YODH", U_JG_MANICHAEAN_YODH); INSTALL_ENUM(UJoiningGroup, "MANICHAEAN_ZAYIN", U_JG_MANICHAEAN_ZAYIN); INSTALL_ENUM(UJoiningGroup, "STRAIGHT_WAW", U_JG_STRAIGHT_WAW); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(58, 0, 0) INSTALL_ENUM(UJoiningGroup, "AFRICAN_FEH", U_JG_AFRICAN_FEH); INSTALL_ENUM(UJoiningGroup, "AFRICAN_NOON", U_JG_AFRICAN_NOON); INSTALL_ENUM(UJoiningGroup, "AFRICAN_QAF", U_JG_AFRICAN_QAF); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(60, 0, 0) INSTALL_ENUM(UJoiningGroup, "MALAYALAM_BHA", U_JG_MALAYALAM_BHA); INSTALL_ENUM(UJoiningGroup, "MALAYALAM_JA", U_JG_MALAYALAM_JA); INSTALL_ENUM(UJoiningGroup, "MALAYALAM_LLA", U_JG_MALAYALAM_LLA); INSTALL_ENUM(UJoiningGroup, "MALAYALAM_LLLA", U_JG_MALAYALAM_LLLA); INSTALL_ENUM(UJoiningGroup, "MALAYALAM_NGA", U_JG_MALAYALAM_NGA); INSTALL_ENUM(UJoiningGroup, "MALAYALAM_NNA", U_JG_MALAYALAM_NNA); INSTALL_ENUM(UJoiningGroup, "MALAYALAM_NNNA", U_JG_MALAYALAM_NNNA); INSTALL_ENUM(UJoiningGroup, "MALAYALAM_NYA", U_JG_MALAYALAM_NYA); INSTALL_ENUM(UJoiningGroup, "MALAYALAM_RA", U_JG_MALAYALAM_RA); INSTALL_ENUM(UJoiningGroup, "MALAYALAM_SSA", U_JG_MALAYALAM_SSA); INSTALL_ENUM(UJoiningGroup, "MALAYALAM_TTA", U_JG_MALAYALAM_TTA); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(62, 0, 0) INSTALL_ENUM(UJoiningGroup, "HANIFI_ROHINGYA_KINNA_YA", U_JG_HANIFI_ROHINGYA_KINNA_YA); INSTALL_ENUM(UJoiningGroup, "HANIFI_ROHINGYA_PA", U_JG_HANIFI_ROHINGYA_PA); #endif INSTALL_ENUM(ULineBreak, "INSEPARABLE", U_LB_INSEPARABLE); INSTALL_ENUM(ULineBreak, "NEXT_LINE", U_LB_NEXT_LINE); INSTALL_ENUM(ULineBreak, "WORD_JOINER", U_LB_WORD_JOINER); INSTALL_ENUM(ULineBreak, "H2", U_LB_H2); INSTALL_ENUM(ULineBreak, "H3", U_LB_H3); INSTALL_ENUM(ULineBreak, "JL", U_LB_JL); INSTALL_ENUM(ULineBreak, "JT", U_LB_JT); INSTALL_ENUM(UGraphemeClusterBreak, "OTHER", U_GCB_OTHER); INSTALL_ENUM(UGraphemeClusterBreak, "CONTROL", U_GCB_CONTROL); INSTALL_ENUM(UGraphemeClusterBreak, "CR", U_GCB_CR); INSTALL_ENUM(UGraphemeClusterBreak, "EXTEND", U_GCB_EXTEND); INSTALL_ENUM(UGraphemeClusterBreak, "L", U_GCB_L); INSTALL_ENUM(UGraphemeClusterBreak, "LF", U_GCB_LF); INSTALL_ENUM(UGraphemeClusterBreak, "LV", U_GCB_LV); INSTALL_ENUM(UGraphemeClusterBreak, "LVT", U_GCB_LVT); INSTALL_ENUM(UGraphemeClusterBreak, "T", U_GCB_T); INSTALL_ENUM(UGraphemeClusterBreak, "V", U_GCB_V); #if U_ICU_VERSION_HEX >= 0x04000000 INSTALL_ENUM(UGraphemeClusterBreak, "SPACING_MARK", U_GCB_SPACING_MARK); INSTALL_ENUM(UGraphemeClusterBreak, "PREPEND", U_GCB_PREPEND); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(50, 0, 0) INSTALL_ENUM(UGraphemeClusterBreak, "REGIONAL_INDICATOR", U_GCB_REGIONAL_INDICATOR); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(58, 0, 0) INSTALL_ENUM(UGraphemeClusterBreak, "E_BASE", U_GCB_E_BASE); INSTALL_ENUM(UGraphemeClusterBreak, "E_BASE_GAZ", U_GCB_E_BASE_GAZ); INSTALL_ENUM(UGraphemeClusterBreak, "GLUE_AFTER_ZWJ", U_GCB_GLUE_AFTER_ZWJ); INSTALL_ENUM(UGraphemeClusterBreak, "ZWJ", U_GCB_ZWJ); #endif INSTALL_ENUM(UHangulSyllableType, "NOT_APPLICABLE", U_HST_NOT_APPLICABLE); INSTALL_ENUM(UHangulSyllableType, "LEADING_JAMO", U_HST_LEADING_JAMO); INSTALL_ENUM(UHangulSyllableType, "VOWEL_JAMO", U_HST_VOWEL_JAMO); INSTALL_ENUM(UHangulSyllableType, "TRAILING_JAMO", U_HST_TRAILING_JAMO); INSTALL_ENUM(UHangulSyllableType, "LV_SYLLABLE", U_HST_LV_SYLLABLE); INSTALL_ENUM(UHangulSyllableType, "LVT_SYLLABLE", U_HST_LVT_SYLLABLE); #if U_ICU_VERSION_HEX >= 0x04040000 INSTALL_ENUM(ULineBreak, "CLOSE_PARENTHESIS", U_LB_CLOSE_PARENTHESIS); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(49, 0, 0) INSTALL_ENUM(ULineBreak, "CONDITIONAL_JAPANESE_STARTER", U_LB_CONDITIONAL_JAPANESE_STARTER); INSTALL_ENUM(ULineBreak, "HEBREW_LETTER", U_LB_HEBREW_LETTER); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(50, 0, 0) INSTALL_ENUM(ULineBreak, "REGIONAL_INDICATOR", U_LB_REGIONAL_INDICATOR); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(58, 0, 0) INSTALL_ENUM(ULineBreak, "E_BASE", U_LB_E_BASE); INSTALL_ENUM(ULineBreak, "E_MODIFIER", U_LB_E_MODIFIER); INSTALL_ENUM(ULineBreak, "ZWJ", U_LB_ZWJ); #endif } ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1430255100.0 PyICU-2.4.2/char.h0000644000076500000000000000253700000000000013751 0ustar00vajdawheel00000000000000/* ==================================================================== * Copyright (c) 2004-2015 Open Source Applications Foundation. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. * ==================================================================== */ #ifndef _char_h #define _char_h void _init_char(PyObject *m); #endif /* _char_h */ ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1482176353.0 PyICU-2.4.2/charset.cpp0000644000076500000000000002425400000000000015020 0ustar00vajdawheel00000000000000/* ==================================================================== * 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 = (int) 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); } ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1263422165.0 PyICU-2.4.2/charset.h0000644000076500000000000000255400000000000014464 0ustar00vajdawheel00000000000000/* ==================================================================== * 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 */ ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1549422494.0 PyICU-2.4.2/collator.cpp0000644000076500000000000012624100000000000015205 0ustar00vajdawheel00000000000000/* ==================================================================== * Copyright (c) 2004-2018 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); #if U_ICU_VERSION_HEX >= 0x04080000 DECLARE_CONSTANTS_TYPE(UAlphabeticIndexLabelType); #endif /* 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); #if U_ICU_VERSION_HEX >= 0x04080000 /* AlphabeticIndex */ class t_alphabeticindex : public _wrapper { public: AlphabeticIndex *object; PyObject *records; }; static PyObject *t_alphabeticindex_addLabels(t_alphabeticindex *self, PyObject *arg); static PyObject *t_alphabeticindex_addRecord(t_alphabeticindex *self, PyObject *args); static PyObject *t_alphabeticindex_clearRecords(t_alphabeticindex *self); static PyObject *t_alphabeticindex_getBucketIndex(t_alphabeticindex *self, PyObject *arg); static PyObject *t_alphabeticindex_nextBucket(t_alphabeticindex *self); static PyObject *t_alphabeticindex_nextRecord(t_alphabeticindex *self); static PyObject *t_alphabeticindex_resetBucketIterator(t_alphabeticindex *self); static PyObject *t_alphabeticindex_resetRecordIterator(t_alphabeticindex *self); #if U_ICU_VERSION_HEX >= VERSION_HEX(51, 0, 0) static PyObject *t_alphabeticindex_buildImmutableIndex(t_alphabeticindex *self); #endif static PyObject *t_alphabeticindex__getCollator( t_alphabeticindex *self, void *closure); static PyObject *t_alphabeticindex__getInflowLabel( t_alphabeticindex *self, void *closure); static int t_alphabeticindex__setInflowLabel( t_alphabeticindex *self, PyObject *value, void *closure); static PyObject *t_alphabeticindex__getOverflowLabel( t_alphabeticindex *self, void *closure); static int t_alphabeticindex__setOverflowLabel( t_alphabeticindex *self, PyObject *value, void *closure); static PyObject *t_alphabeticindex__getUnderflowLabel( t_alphabeticindex *self, void *closure); static int t_alphabeticindex__setUnderflowLabel( t_alphabeticindex *self, PyObject *value, void *closure); static PyObject *t_alphabeticindex__getMaxLabelCount( t_alphabeticindex *self, void *closure); static int t_alphabeticindex__setMaxLabelCount( t_alphabeticindex *self, PyObject *value, void *closure); static PyObject *t_alphabeticindex__getBucketIndex( t_alphabeticindex *self, void *closure); static PyObject *t_alphabeticindex__getBucketLabel( t_alphabeticindex *self, void *closure); static PyObject *t_alphabeticindex__getBucketLabelType( t_alphabeticindex *self, void *closure); static PyObject *t_alphabeticindex__getBucketCount( t_alphabeticindex *self, void *closure); static PyObject *t_alphabeticindex__getBucketRecordCount( t_alphabeticindex *self, void *closure); static PyObject *t_alphabeticindex__getRecordCount( t_alphabeticindex *self, void *closure); static PyObject *t_alphabeticindex__getRecordName( t_alphabeticindex *self, void *closure); static PyObject *t_alphabeticindex__getRecordData( t_alphabeticindex *self, void *closure); static int t_alphabeticindex_init(t_alphabeticindex *self, PyObject *args, PyObject *kwds); static PyGetSetDef t_alphabeticindex_properties[] = { { (char *) "collator", (getter) t_alphabeticindex__getCollator, NULL, (char *) "collator property", NULL }, { (char *) "inflowLabel", (getter) t_alphabeticindex__getInflowLabel, (setter) t_alphabeticindex__setInflowLabel, (char *) "inflowLabel property", NULL }, { (char *) "overflowLabel", (getter) t_alphabeticindex__getOverflowLabel, (setter) t_alphabeticindex__setOverflowLabel, (char *) "overflowLabel property", NULL }, { (char *) "underflowLabel", (getter) t_alphabeticindex__getUnderflowLabel, (setter) t_alphabeticindex__setUnderflowLabel, (char *) "underflowLabel property", NULL }, { (char *) "maxLabelCount", (getter) t_alphabeticindex__getMaxLabelCount, (setter) t_alphabeticindex__setMaxLabelCount, (char *) "maxLabelCount property", NULL }, { (char *) "bucketIndex", (getter) t_alphabeticindex__getBucketIndex, (setter) NULL, (char *) "bucketIndex property", NULL }, { (char *) "bucketLabel", (getter) t_alphabeticindex__getBucketLabel, (setter) NULL, (char *) "bucketLabel property", NULL }, { (char *) "bucketLabelType", (getter) t_alphabeticindex__getBucketLabelType, (setter) NULL, (char *) "bucketLabelType property", NULL }, { (char *) "bucketCount", (getter) t_alphabeticindex__getBucketCount, (setter) NULL, (char *) "bucketCount property", NULL }, { (char *) "bucketRecordCount", (getter) t_alphabeticindex__getBucketRecordCount, (setter) NULL, (char *) "bucketRecordCount property", NULL }, { (char *) "recordCount", (getter) t_alphabeticindex__getRecordCount, (setter) NULL, (char *) "recordCount property", NULL }, { (char *) "recordName", (getter) t_alphabeticindex__getRecordName, (setter) NULL, (char *) "recordName property", NULL }, { (char *) "recordData", (getter) t_alphabeticindex__getRecordData, (setter) NULL, (char *) "recordData property", NULL }, { NULL, NULL, NULL, NULL, NULL } }; static PyMethodDef t_alphabeticindex_methods[] = { DECLARE_METHOD(t_alphabeticindex, addLabels, METH_O), DECLARE_METHOD(t_alphabeticindex, addRecord, METH_VARARGS), DECLARE_METHOD(t_alphabeticindex, clearRecords, METH_NOARGS), DECLARE_METHOD(t_alphabeticindex, getBucketIndex, METH_O), DECLARE_METHOD(t_alphabeticindex, nextBucket, METH_NOARGS), DECLARE_METHOD(t_alphabeticindex, nextRecord, METH_NOARGS), DECLARE_METHOD(t_alphabeticindex, resetBucketIterator, METH_NOARGS), DECLARE_METHOD(t_alphabeticindex, resetRecordIterator, METH_NOARGS), #if U_ICU_VERSION_HEX >= VERSION_HEX(51, 0, 0) DECLARE_METHOD(t_alphabeticindex, buildImmutableIndex, METH_NOARGS), #endif { NULL, NULL, 0, NULL } }; static void t_alphabeticindex_dealloc(t_alphabeticindex *self) { if (self->flags & T_OWNED) delete self->object; self->object = NULL; Py_CLEAR(self->records); Py_TYPE(self)->tp_free((PyObject *) self); } DECLARE_TYPE(AlphabeticIndex, t_alphabeticindex, UObject, AlphabeticIndex, t_alphabeticindex_init, t_alphabeticindex_dealloc); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(51, 0, 0) /* ImmutableIndex */ typedef AlphabeticIndex::ImmutableIndex ImmutableIndex; class t_immutableindex : public _wrapper { public: ImmutableIndex *object; }; static PyObject *t_immutableindex_getBucketIndex(t_immutableindex *self, PyObject *arg); static PyObject *t_immutableindex_getBucket(t_immutableindex *self, PyObject *arg); static Py_ssize_t t_immutableindex_length(t_immutableindex *self); static PyObject *t_immutableindex_item(t_immutableindex *self, int n); static int t_immutableindex_contains(t_immutableindex *self, PyObject *arg); static PyObject *t_immutableindex__getBucketCount(t_immutableindex *self, void *closure); static PySequenceMethods t_immutableindex_as_sequence = { (lenfunc) t_immutableindex_length, /* sq_length */ (binaryfunc) NULL, /* sq_concat */ (ssizeargfunc) NULL, /* sq_repeat */ (ssizeargfunc) t_immutableindex_item, /* sq_item */ #if PY_MAJOR_VERSION >= 3 NULL, NULL, /* sq_ass_item */ NULL, #else (ssizessizeargfunc) NULL, /* sq_slice */ (ssizeobjargproc) NULL, /* sq_ass_item */ (ssizessizeobjargproc) NULL, /* sq_ass_slice */ #endif (objobjproc) t_immutableindex_contains, /* sq_contains */ (binaryfunc) NULL, /* sq_inplace_concat */ (ssizeargfunc) NULL, /* sq_inplace_repeat */ }; static PyGetSetDef t_immutableindex_properties[] = { { (char *) "bucketCount", (getter) t_immutableindex__getBucketCount, NULL, (char *) "bucketCount property", NULL }, { NULL, NULL, NULL, NULL, NULL } }; static PyMethodDef t_immutableindex_methods[] = { DECLARE_METHOD(t_immutableindex, getBucketIndex, METH_O), DECLARE_METHOD(t_immutableindex, getBucket, METH_O), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(ImmutableIndex, t_immutableindex, UObject, ImmutableIndex, abstract_init, NULL); #endif /* 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)); PyObject *py_locale = wrap_Locale(result); PyObject *py_result = Py_BuildValue("(OO)", py_locale, isAvailable ? Py_True : Py_False); Py_DECREF(py_locale); return py_result; } return PyErr_SetArgsError(type, "getFunctionalEquivalent", args); } static PyObject *t_collator_getAttribute(t_collator *self, PyObject *arg) { UColAttribute attribute; if (!parseArg(arg, "i", &attribute)) { UColAttributeValue value; STATUS_CALL(value = self->object->getAttribute(attribute, status)); return PyInt_FromLong(value); } return PyErr_SetArgsError((PyObject *) self, "getAttribute", arg); } static PyObject *t_collator_setAttribute(t_collator *self, PyObject *args) { UColAttribute attribute; UColAttributeValue value; if (!parseArgs(args, "ii", &attribute, &value)) { STATUS_CALL(self->object->setAttribute(attribute, value, status)); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setAttribute", args); } static PyObject *t_collator_getTailoredSet(t_collator *self) { UnicodeSet *set; STATUS_CALL(set = self->object->getTailoredSet(status)); return wrap_UnicodeSet(set, T_OWNED); } static PyObject *t_collator_getVariableTop(t_collator *self) { uint32_t top; STATUS_CALL(top = self->object->getVariableTop(status)); return PyInt_FromLong(top >> 16); } static PyObject *t_collator_setVariableTop(t_collator *self, PyObject *arg) { UnicodeString *u, _u; uint32_t top; if (!parseArg(arg, "i", &top)) { STATUS_CALL(self->object->setVariableTop(top << 16, status)); Py_RETURN_NONE; } else if (!parseArg(arg, "S", &u, &_u)) { STATUS_CALL(self->object->setVariableTop(*u, status)); /* transient */ Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setVariableTop", arg); } static long t_collator_hash(t_collator *self) { return (long) self->object->hashCode(); } /* RuleBasedCollator */ static int t_rulebasedcollator_init(t_rulebasedcollator *self, PyObject *args, PyObject *kwds) { UnicodeString *u; UnicodeString _u; RuleBasedCollator *collator; Collator::ECollationStrength strength; UColAttributeValue decompositionMode; PyObject *buf, *base; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "S", &u, &_u)) { INT_STATUS_CALL(collator = new RuleBasedCollator(*u, status)); self->object = collator; self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; case 2: if (!parseArgs(args, "CO", &RuleBasedCollatorType_, &buf, &base)) { INT_STATUS_CALL(collator = new RuleBasedCollator((uint8_t *) PyBytes_AS_STRING(buf), (int32_t) 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); #if U_ICU_VERSION_HEX >= 0x04080000 static int t_alphabeticindex_init(t_alphabeticindex *self, PyObject *args, PyObject *kwds) { Locale *locale; #if U_ICU_VERSION_HEX >= VERSION_HEX(51, 0, 0) RuleBasedCollator *collator; #endif switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "P", TYPE_CLASSID(Locale), &locale)) { INT_STATUS_CALL(self->object = new AlphabeticIndex( *locale, status)); self->flags = T_OWNED; break; } #if U_ICU_VERSION_HEX >= VERSION_HEX(51, 0, 0) if (!parseArgs(args, "P", TYPE_CLASSID(RuleBasedCollator), &collator)) { INT_STATUS_CALL(self->object = new AlphabeticIndex( new RuleBasedCollator(*collator), status)); self->flags = T_OWNED; break; } #endif default: PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; } if (self->object) { self->records = PyList_New(0); return 0; } return -1; } static PyObject *t_alphabeticindex_addLabels(t_alphabeticindex *self, PyObject *arg) { UnicodeSet *set; Locale *locale; if (!parseArg(arg, "P", TYPE_CLASSID(UnicodeSet), &set)) { STATUS_CALL(self->object->addLabels(*set, status)); Py_RETURN_SELF(); } if (!parseArg(arg, "P", TYPE_CLASSID(Locale), &locale)) { STATUS_CALL(self->object->addLabels(*locale, status)); Py_RETURN_SELF(); } return PyErr_SetArgsError((PyObject *) self, "addLabels", arg); } static PyObject *t_alphabeticindex_addRecord(t_alphabeticindex *self, PyObject *args) { UnicodeString *u, _u; PyObject *record; if (!parseArgs(args, "SK", &u, &_u, &record)) { STATUS_CALL(self->object->addRecord(*u, record, status)); PyList_Append(self->records, record); Py_RETURN_SELF(); } return PyErr_SetArgsError((PyObject *) self, "addRecord", args); } static PyObject *t_alphabeticindex_clearRecords(t_alphabeticindex *self) { STATUS_CALL(self->object->clearRecords(status)); PyList_SetSlice(self->records, 0, PyList_GET_SIZE(self->records), NULL); Py_RETURN_SELF(); } static PyObject *t_alphabeticindex_getBucketIndex(t_alphabeticindex *self, PyObject *arg) { UnicodeString *u, _u; if (!parseArg(arg, "S", &u, &_u)) { int index; STATUS_CALL(index = self->object->getBucketIndex(*u, status)); return PyInt_FromLong(index); } return PyErr_SetArgsError((PyObject *) self, "getBucketIndex", arg); } static PyObject *t_alphabeticindex_nextBucket(t_alphabeticindex *self) { UBool more; STATUS_CALL(more = self->object->nextBucket(status)); Py_RETURN_BOOL(more); } static PyObject *t_alphabeticindex_nextRecord(t_alphabeticindex *self) { UBool more; STATUS_CALL(more = self->object->nextRecord(status)); Py_RETURN_BOOL(more); } static PyObject *t_alphabeticindex_resetBucketIterator(t_alphabeticindex *self) { STATUS_CALL(self->object->resetBucketIterator(status)); Py_RETURN_SELF(); } static PyObject *t_alphabeticindex_resetRecordIterator(t_alphabeticindex *self) { self->object->resetRecordIterator(); Py_RETURN_SELF(); } static PyObject *t_alphabeticindex__getCollator(t_alphabeticindex *self, void *closure) { const RuleBasedCollator &collator = self->object->getCollator(); return wrap_RuleBasedCollator( const_cast(&collator), 0); // not owned by wrapper } static PyObject *t_alphabeticindex__getInflowLabel( t_alphabeticindex *self, void *closure) { return PyUnicode_FromUnicodeString(&self->object->getInflowLabel()); } static int t_alphabeticindex__setInflowLabel( t_alphabeticindex *self, PyObject *value, void *closure) { if (value == NULL) { PyErr_SetString(PyExc_TypeError, "cannot delete property"); return -1; } UnicodeString *u, _u; if (!parseArg(value, "S", &u, &_u)) { INT_STATUS_CALL(self->object->setInflowLabel(*u, status)); return 0; } PyErr_SetArgsError((PyObject *) self, "inflowLabel", value); return -1; } static PyObject *t_alphabeticindex__getOverflowLabel( t_alphabeticindex *self, void *closure) { return PyUnicode_FromUnicodeString(&self->object->getOverflowLabel()); } static int t_alphabeticindex__setOverflowLabel( t_alphabeticindex *self, PyObject *value, void *closure) { if (value == NULL) { PyErr_SetString(PyExc_TypeError, "cannot delete property"); return -1; } UnicodeString *u, _u; if (!parseArg(value, "S", &u, &_u)) { INT_STATUS_CALL(self->object->setOverflowLabel(*u, status)); return 0; } PyErr_SetArgsError((PyObject *) self, "overflowLabel", value); return -1; } static PyObject *t_alphabeticindex__getUnderflowLabel( t_alphabeticindex *self, void *closure) { return PyUnicode_FromUnicodeString(&self->object->getUnderflowLabel()); } static int t_alphabeticindex__setUnderflowLabel( t_alphabeticindex *self, PyObject *value, void *closure) { if (value == NULL) { PyErr_SetString(PyExc_TypeError, "cannot delete property"); return -1; } UnicodeString *u, _u; if (!parseArg(value, "S", &u, &_u)) { INT_STATUS_CALL(self->object->setUnderflowLabel(*u, status)); return 0; } PyErr_SetArgsError((PyObject *) self, "underflowLabel", value); return -1; } static PyObject *t_alphabeticindex__getMaxLabelCount( t_alphabeticindex *self, void *closure) { return PyInt_FromLong(self->object->getMaxLabelCount()); } static int t_alphabeticindex__setMaxLabelCount( t_alphabeticindex *self, PyObject *value, void *closure) { if (value == NULL) { PyErr_SetString(PyExc_TypeError, "cannot delete property"); return -1; } int count; if (!parseArg(value, "i", &count)) { INT_STATUS_CALL(self->object->setMaxLabelCount(count, status)); return 0; } PyErr_SetArgsError((PyObject *) self, "maxLabelCount", value); return -1; } static PyObject *t_alphabeticindex__getBucketIndex( t_alphabeticindex *self, void *closure) { return PyInt_FromLong(self->object->getBucketIndex()); } static PyObject *t_alphabeticindex__getBucketLabel( t_alphabeticindex *self, void *closure) { return PyUnicode_FromUnicodeString(&self->object->getBucketLabel()); } static PyObject *t_alphabeticindex__getBucketLabelType( t_alphabeticindex *self, void *closure) { return PyInt_FromLong(self->object->getBucketLabelType()); } static PyObject *t_alphabeticindex__getBucketCount( t_alphabeticindex *self, void *closure) { int count; STATUS_CALL(count = self->object->getBucketCount(status)); return PyInt_FromLong(count); } static PyObject *t_alphabeticindex__getBucketRecordCount( t_alphabeticindex *self, void *closure) { return PyInt_FromLong(self->object->getBucketRecordCount()); } static PyObject *t_alphabeticindex__getRecordCount( t_alphabeticindex *self, void *closure) { int count; STATUS_CALL(count = self->object->getRecordCount(status)); return PyInt_FromLong(count); } static PyObject *t_alphabeticindex__getRecordName( t_alphabeticindex *self, void *closure) { return PyUnicode_FromUnicodeString(&self->object->getRecordName()); } static PyObject *t_alphabeticindex__getRecordData( t_alphabeticindex *self, void *closure) { PyObject *data = (PyObject *) self->object->getRecordData(); if (data == NULL) Py_RETURN_NONE; Py_INCREF(data); return data; } static PyObject *t_alphabeticindex_iter(t_alphabeticindex *self) { STATUS_CALL(self->object->resetBucketIterator(status)); Py_RETURN_SELF(); } static PyObject *t_alphabeticindex_iter_next(t_alphabeticindex *self) { UBool more; STATUS_CALL(more = self->object->nextBucket(status)); if (!more) { PyErr_SetNone(PyExc_StopIteration); return NULL; } PyObject *result = PyTuple_New(2); PyTuple_SET_ITEM(result, 0, PyUnicode_FromUnicodeString( &self->object->getBucketLabel())); PyTuple_SET_ITEM(result, 1, PyInt_FromLong( self->object->getBucketLabelType())); return result; } #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(51, 0, 0) static PyObject *t_alphabeticindex_buildImmutableIndex(t_alphabeticindex *self) { ImmutableIndex *index; STATUS_CALL(index = self->object->buildImmutableIndex(status)); return wrap_ImmutableIndex(index, T_OWNED); } /* ImmutableIndex */ static PyObject *t_immutableindex_getBucketIndex(t_immutableindex *self, PyObject *arg) { UnicodeString *u, _u; if (!parseArg(arg, "S", &u, &_u)) { int index; STATUS_CALL(index = self->object->getBucketIndex(*u, status)); return PyInt_FromLong(index); } return PyErr_SetArgsError((PyObject *) self, "getBucketIndex", arg); } static PyObject *t_immutableindex_getBucket(t_immutableindex *self, PyObject *arg) { int index; if (!parseArg(arg, "i", &index)) { const AlphabeticIndex::Bucket *bucket = self->object->getBucket(index); if (bucket == NULL) Py_RETURN_NONE; PyObject *result = PyTuple_New(2); PyTuple_SET_ITEM(result, 0, PyUnicode_FromUnicodeString( &bucket->getLabel())); PyTuple_SET_ITEM(result, 1, PyInt_FromLong(bucket->getLabelType())); return result; } return PyErr_SetArgsError((PyObject *) self, "getBucket", arg); } static PyObject *t_immutableindex__getBucketCount(t_immutableindex *self, void *closure) { return PyInt_FromLong(self->object->getBucketCount()); } static Py_ssize_t t_immutableindex_length(t_immutableindex *self) { return self->object->getBucketCount(); } static PyObject *t_immutableindex_item(t_immutableindex *self, int n) { int len = self->object->getBucketCount(); if (n < 0) n += len; if (n >= 0 && n < len) { const AlphabeticIndex::Bucket *bucket = self->object->getBucket(n); if (bucket == NULL) Py_RETURN_NONE; PyObject *result = PyTuple_New(2); PyTuple_SET_ITEM(result, 0, PyUnicode_FromUnicodeString( &bucket->getLabel())); PyTuple_SET_ITEM(result, 1, PyInt_FromLong(bucket->getLabelType())); return result; } PyErr_SetNone(PyExc_IndexError); return NULL; } static int t_immutableindex_contains(t_immutableindex *self, PyObject *arg) { UnicodeString *u, _u; if (!parseArg(arg, "S", &u, &_u)) { UErrorCode status = U_ZERO_ERROR; self->object->getBucketIndex(*u, status); return U_SUCCESS(status); } PyErr_SetObject(PyExc_TypeError, arg); return -1; } #endif 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; #if U_ICU_VERSION_HEX >= 0x04080000 AlphabeticIndexType_.tp_getset = t_alphabeticindex_properties; AlphabeticIndexType_.tp_iter = (getiterfunc) t_alphabeticindex_iter; AlphabeticIndexType_.tp_iternext = (iternextfunc) t_alphabeticindex_iter_next; #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(51, 0, 0) ImmutableIndexType_.tp_getset = t_immutableindex_properties; ImmutableIndexType_.tp_as_sequence = &t_immutableindex_as_sequence; #endif 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); #if U_ICU_VERSION_HEX >= 0x04080000 INSTALL_CONSTANTS_TYPE(UAlphabeticIndexLabelType, m); INSTALL_TYPE(AlphabeticIndex, m); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(51, 0, 0) INSTALL_TYPE(ImmutableIndex, m); #endif 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); #if U_ICU_VERSION_HEX >= 0x04080000 INSTALL_ENUM(UAlphabeticIndexLabelType, "NORMAL", U_ALPHAINDEX_NORMAL); INSTALL_ENUM(UAlphabeticIndexLabelType, "UNDERFLOW", U_ALPHAINDEX_UNDERFLOW); INSTALL_ENUM(UAlphabeticIndexLabelType, "INFLOW", U_ALPHAINDEX_INFLOW); INSTALL_ENUM(UAlphabeticIndexLabelType, "OVERFLOW", U_ALPHAINDEX_OVERFLOW); #endif 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); } ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1430285695.0 PyICU-2.4.2/collator.h0000644000076500000000000000274700000000000014656 0ustar00vajdawheel00000000000000/* ==================================================================== * 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 */ ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1569966762.0 PyICU-2.4.2/common.cpp0000644000076500000000000012327000000000000014655 0ustar00vajdawheel00000000000000/* ==================================================================== * Copyright (c) 2005-2019 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 #include "bases.h" #include "macros.h" static PyObject *utcoffset_NAME; static PyObject *toordinal_NAME; static PyObject *getDefault_NAME; typedef struct { UConverterCallbackReason reason; const char *src; int32_t src_length; char chars[8]; int32_t length; int32_t error_position; } _STOPReason; U_STABLE void U_EXPORT2 _stopDecode(const void *context, UConverterToUnicodeArgs *args, const char *chars, int32_t length, UConverterCallbackReason reason, UErrorCode *err) { _STOPReason *stop = (_STOPReason *) context; stop->reason = reason; stop->length = length; if (chars && length) { const int size = stop->src_length - length + 1; const size_t len = (size_t) length < sizeof(stop->chars) - 1 ? (size_t) length : sizeof(stop->chars) - 1; strncpy(stop->chars, chars, len); stop->chars[len] = '\0'; stop->error_position = -1; for (int i = 0; i < size; ++i) { if (!memcmp(stop->src + i, chars, length)) { stop->error_position = i; break; } } } } PyObject *PyExc_ICUError; PyObject *PyExc_InvalidArgsError; EXPORT ICUException::ICUException() { code = NULL; msg = NULL; } EXPORT ICUException::ICUException(const ICUException &e) : code(e.code), msg(e.msg) { Py_XINCREF(code); Py_XINCREF(msg); } EXPORT ICUException::ICUException(UErrorCode status) { PyObject *messages = PyObject_GetAttrString(PyExc_ICUError, "messages"); code = PyInt_FromLong((long) status); msg = PyObject_GetItem(messages, code); Py_DECREF(messages); } EXPORT ICUException::ICUException(UErrorCode status, char *format, ...) { ICUException::code = PyInt_FromLong((long) status); va_list ap; va_start(ap, format); ICUException::msg = PyString_FromFormatV(format, ap); va_end(ap); } EXPORT ICUException::ICUException(UParseError &pe, UErrorCode status) { PyObject *messages = PyObject_GetAttrString(PyExc_ICUError, "messages"); UnicodeString pre((const UChar *) pe.preContext, U_PARSE_CONTEXT_LEN); UnicodeString post((const UChar *) pe.postContext, U_PARSE_CONTEXT_LEN); PyObject *tuple = PyTuple_New(5); ICUException::code = PyInt_FromLong((long) status); PyTuple_SET_ITEM(tuple, 0, PyObject_GetItem(messages, code)); PyTuple_SET_ITEM(tuple, 1, PyInt_FromLong(pe.line)); PyTuple_SET_ITEM(tuple, 2, PyInt_FromLong(pe.offset)); PyTuple_SET_ITEM(tuple, 3, PyUnicode_FromUnicodeString(&pre)); PyTuple_SET_ITEM(tuple, 4, PyUnicode_FromUnicodeString(&post)); ICUException::msg = tuple; Py_DECREF(messages); } EXPORT ICUException::~ICUException() { Py_XDECREF(ICUException::code); Py_XDECREF(ICUException::msg); } EXPORT PyObject *ICUException::reportError() { if (ICUException::code) { PyObject *tuple = Py_BuildValue("(OO)", ICUException::code, ICUException::msg ? ICUException::msg : Py_None); PyErr_SetObject(PyExc_ICUError, tuple); Py_DECREF(tuple); } return NULL; } EXPORT PyObject *PyUnicode_FromUnicodeString(const UnicodeString *string) { if (!string) { Py_INCREF(Py_None); return Py_None; } return PyUnicode_FromUnicodeString(string->getBuffer(), string->length()); } EXPORT PyObject *PyUnicode_FromUnicodeString(const UChar *utf16, int len16) { if (!utf16) { Py_INCREF(Py_None); return Py_None; } #if PY_VERSION_HEX < 0x03030000 || defined(PYPY_VERSION) else if (sizeof(Py_UNICODE) == sizeof(UChar)) return PyUnicode_FromUnicode((const Py_UNICODE *) utf16, len16); else { int32_t len32 = u_countChar32(utf16, len16); PyObject *u = PyUnicode_FromUnicode(NULL, len32); if (u) { Py_UNICODE *pchars = PyUnicode_AS_UNICODE(u); UErrorCode status = U_ZERO_ERROR; u_strToUTF32((UChar32 *) pchars, len32, NULL, utf16, len16, &status); if (U_FAILURE(status)) { Py_DECREF(u); return ICUException(status).reportError(); } } return u; } #else { int32_t len32 = 0; UChar32 max_char = 0; for (int32_t i = 0; i < len16;) { UChar32 cp; U16_NEXT(utf16, i, len16, cp); max_char |= cp; // we only care about the leftmost bit len32 += 1; } PyObject *result = PyUnicode_New(len32, max_char); if (result == NULL) return NULL; switch (PyUnicode_KIND(result)) { case PyUnicode_1BYTE_KIND: // note: len16 == len32 for (int32_t i = 0; i < len32; ++i) PyUnicode_1BYTE_DATA(result)[i] = (Py_UCS1) (utf16[i]); break; case PyUnicode_2BYTE_KIND: // note: len16 == len32 u_memcpy((UChar *) PyUnicode_2BYTE_DATA(result), utf16, len16); break; case PyUnicode_4BYTE_KIND: { UErrorCode status = U_ZERO_ERROR; // note: len16 > len32 (len32 is at least half of len16) u_strToUTF32((UChar32 *) PyUnicode_4BYTE_DATA(result), len32, NULL, utf16, len16, &status); if (U_FAILURE(status)) { Py_DECREF(result); return ICUException(status).reportError(); } break; } default: Py_DECREF(result); return NULL; } return result; } #endif } EXPORT UnicodeString &PyBytes_AsUnicodeString(PyObject *object, const char *encoding, const char *mode, UnicodeString &string) { UErrorCode status = U_ZERO_ERROR; UConverter *conv = ucnv_open(encoding, &status); if (U_FAILURE(status)) throw ICUException(status); _STOPReason stop; char *src; Py_ssize_t len; UChar *buffer, *target; memset(&stop, 0, sizeof(stop)); if (!strcmp(mode, "strict")) { ucnv_setToUCallBack(conv, _stopDecode, &stop, NULL, NULL, &status); if (U_FAILURE(status)) { ucnv_close(conv); throw ICUException(status); } } PyBytes_AsStringAndSize(object, &src, &len); stop.src = src; stop.src_length = (int) len; buffer = target = new UChar[(int) len]; if (buffer == NULL) { ucnv_close(conv); PyErr_NoMemory(); throw ICUException(); } ucnv_toUnicode(conv, &target, target + (int) len, (const char **) &src, src + len, NULL, true, &status); if (U_FAILURE(status)) { const char *reasonName; switch (stop.reason) { case UCNV_UNASSIGNED: reasonName = "the code point is unassigned"; break; case UCNV_ILLEGAL: reasonName = "the code point is illegal"; break; case UCNV_IRREGULAR: reasonName = "the code point is not a regular sequence in the encoding"; break; default: reasonName = "unexpected reason code"; break; } status = U_ZERO_ERROR; PyErr_Format(PyExc_ValueError, "'%s' codec can't decode byte 0x%x in position %d: reason code %d (%s)", ucnv_getName(conv, &status), (int) (unsigned char) stop.chars[0], stop.error_position, stop.reason, reasonName); delete[] buffer; ucnv_close(conv); throw ICUException(); } string.setTo(buffer, (int32_t) (target - buffer)); delete[] buffer; ucnv_close(conv); return string; } EXPORT UnicodeString &PyObject_AsUnicodeString(PyObject *object, const char *encoding, const char *mode, UnicodeString &string) { if (PyUnicode_Check(object)) { #if PY_VERSION_HEX < 0x03030000 if (sizeof(Py_UNICODE) == sizeof(UChar)) string.setTo((const UChar *) PyUnicode_AS_UNICODE(object), (int32_t) PyUnicode_GET_SIZE(object)); else { int32_t len = (int32_t) PyUnicode_GET_SIZE(object); Py_UNICODE *pchars = PyUnicode_AS_UNICODE(object); string = UnicodeString::fromUTF32((const UChar32 *) pchars, len); } #else PyUnicode_READY(object); switch (PyUnicode_KIND(object)) { case PyUnicode_WCHAR_KIND: { // this code path should be deprecated if (sizeof(Py_UNICODE) == sizeof(UChar)) { Py_ssize_t len; Py_UNICODE *pchars = PyUnicode_AsUnicodeAndSize(object, &len); string.setTo((const UChar *) pchars, len); } else { Py_ssize_t len; Py_UNICODE *pchars = PyUnicode_AsUnicodeAndSize(object, &len); string = UnicodeString::fromUTF32( (const UChar32 *) pchars, len); } break; } case PyUnicode_1BYTE_KIND: { Py_ssize_t len = PyUnicode_GET_LENGTH(object); Py_UCS1 *pchars = PyUnicode_1BYTE_DATA(object); UChar *chars = string.getBuffer(len); if (chars != NULL) { for (int i = 0; i < len; ++i) chars[i] = (UChar) pchars[i]; string.releaseBuffer(len); } break; } case PyUnicode_2BYTE_KIND: { Py_ssize_t len = PyUnicode_GET_LENGTH(object); Py_UCS2 *pchars = PyUnicode_2BYTE_DATA(object); string.setTo((const UChar *) pchars, len); break; } case PyUnicode_4BYTE_KIND: { Py_ssize_t len = PyUnicode_GET_LENGTH(object); Py_UCS4 *pchars = PyUnicode_4BYTE_DATA(object); string = UnicodeString::fromUTF32((const UChar32 *) pchars, len); break; } } #endif } else if (PyBytes_Check(object)) PyBytes_AsUnicodeString(object, encoding, mode, string); else { PyErr_SetObject(PyExc_TypeError, object); throw ICUException(); } return string; } EXPORT UnicodeString &PyObject_AsUnicodeString(PyObject *object, UnicodeString &string) { return PyObject_AsUnicodeString(object, "utf-8", "strict", string); } EXPORT UnicodeString *PyObject_AsUnicodeString(PyObject *object) { if (object == Py_None) return NULL; else { UnicodeString string; try { PyObject_AsUnicodeString(object, string); } catch (ICUException e) { throw e; } return new UnicodeString(string); } } #if PY_VERSION_HEX < 0x02040000 /* Replace some _CheckExact macros for Python < 2.4 since the actual * datetime types are private until then. This is ugly, but allows * support for datetime objects in Python 2.3. */ #include #undef PyDateTime_CheckExact #define PyDateTime_CheckExact(op) \ (!strcmp(Py_TYPE(op)->tp_name, "datetime.datetime")) #undef PyDelta_CheckExact #define PyDelta_CheckExact(op) \ (!strcmp(Py_TYPE(op)->tp_name, "datetime.timedelta")) #endif int isDate(PyObject *object) { if (PyFloat_CheckExact(object)) return 1; return PyDateTime_CheckExact(object); } int isDateExact(PyObject *object) { return PyDateTime_CheckExact(object); } EXPORT UDate PyObject_AsUDate(PyObject *object) { if (PyFloat_CheckExact(object)) return (UDate) (PyFloat_AsDouble(object) * 1000.0); else { if (PyDateTime_CheckExact(object)) { PyObject *tzinfo = PyObject_GetAttrString(object, "tzinfo"); PyObject *utcoffset, *ordinal; if (tzinfo == Py_None) { PyObject *m = PyImport_ImportModule("icu"); PyObject *cls = PyObject_GetAttrString(m, "ICUtzinfo"); tzinfo = PyObject_CallMethodObjArgs(cls, getDefault_NAME, NULL); Py_DECREF(cls); Py_DECREF(m); utcoffset = PyObject_CallMethodObjArgs(tzinfo, utcoffset_NAME, object, NULL); Py_DECREF(tzinfo); } else { utcoffset = PyObject_CallMethodObjArgs(object, utcoffset_NAME, NULL); Py_DECREF(tzinfo); } ordinal = PyObject_CallMethodObjArgs(object, toordinal_NAME, NULL); if (utcoffset != NULL && PyDelta_CheckExact(utcoffset) && ordinal != NULL && PyInt_CheckExact(ordinal)) { #if PY_MAJOR_VERSION >= 3 double ordinalValue = PyLong_AsDouble(ordinal); #else long ordinalValue = PyInt_AsLong(ordinal); #endif double timestamp = (ordinalValue - 719163) * 86400.0 + PyDateTime_DATE_GET_HOUR(object) * 3600.0 + PyDateTime_DATE_GET_MINUTE(object) * 60.0 + (double) PyDateTime_DATE_GET_SECOND(object) + PyDateTime_DATE_GET_MICROSECOND(object) / 1e6 - #ifndef PYPY_VERSION (((PyDateTime_Delta *) utcoffset)->days * 86400.0 + (double) ((PyDateTime_Delta *) utcoffset)->seconds); #else (PyDateTime_DELTA_GET_DAYS( (PyDateTime_Delta *) utcoffset) * 86400.0 + (double) PyDateTime_DELTA_GET_SECONDS( (PyDateTime_Delta *) utcoffset)); #endif Py_DECREF(utcoffset); Py_DECREF(ordinal); return (UDate) (timestamp * 1000.0); } Py_XDECREF(utcoffset); Py_XDECREF(ordinal); } } PyErr_SetObject(PyExc_TypeError, object); throw ICUException(); } int abstract_init(PyObject *self, PyObject *args, PyObject *kwds) { PyObject *err = Py_BuildValue("(sO)", "instantiating class", self->ob_type); PyErr_SetObject(PyExc_NotImplementedError, err); Py_DECREF(err); return -1; } PyObject *abstract_method(PyObject *self, PyObject *args) { PyObject *err = Py_BuildValue("(sO)", "calling abstract method on", self->ob_type); PyErr_SetObject(PyExc_NotImplementedError, err); Py_DECREF(err); return NULL; } 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 = (int) 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 = (int) 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 = (int) 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 int *toIntArray(PyObject *arg, int *len) { if (PySequence_Check(arg)) { *len = (int) PySequence_Size(arg); int *array = new int[*len + 1]; for (int i = 0; i < *len; i++) { PyObject *obj = PySequence_GetItem(arg, i); #if PY_MAJOR_VERSION < 3 if (PyInt_Check(obj)) { array[i] = PyInt_AsLong(obj); Py_DECREF(obj); if (!PyErr_Occurred()) continue; } else if (PyLong_Check(obj)) { array[i] = PyLong_AsLong(obj); Py_DECREF(obj); if (!PyErr_Occurred()) continue; } #else if (PyLong_Check(obj)) { array[i] = PyLong_AsLong(obj); Py_DECREF(obj); if (!PyErr_Occurred()) continue; } #endif Py_DECREF(obj); delete[] array; return NULL; } return array; } return NULL; } static double *toDoubleArray(PyObject *arg, int *len) { if (PySequence_Check(arg)) { *len = (int) 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 = (int) PySequence_Size(arg); UBool *array = new UBool[*len + 1]; for (int i = 0; i < *len; i++) { PyObject *obj = PySequence_GetItem(arg, i); array[i] = (UBool) PyObject_IsTrue(obj); Py_DECREF(obj); } return array; } return NULL; } #if defined(_MSC_VER) || defined(PYPY_VERSION) int __parseArgs(PyObject *args, const char *types, ...) { int count = PyObject_Size(args); va_list list; va_start(list, types); #ifdef PYPY_VERSION return _parseArgs(args, count, types, list); #else return _parseArgs(((PyTupleObject *)(args))->ob_item, count, types, list); #endif } int __parseArg(PyObject *arg, const char *types, ...) { va_list list; va_start(list, types); #ifdef PYPY_VERSION { struct arg_tuple { PyObject *tuple; arg_tuple(PyObject *arg) { tuple = PyTuple_Pack(1, arg); } ~arg_tuple() { Py_DECREF(tuple); } } tuple_arg(arg); return _parseArgs(tuple_arg.tuple, 1, types, list); } #else return _parseArgs(&arg, 1, types, list); #endif } #ifdef PYPY_VERSION int _parseArgs(PyObject *args, int count, const char *types, va_list list) #else int _parseArgs(PyObject **args, int count, const char *types, va_list list) #endif { if (count != strlen(types)) return -1; #else int _parseArgs(PyObject **args, int count, const char *types, ...) { va_list list; if (count != (int) strlen(types)) return -1; va_start(list, types); #endif if (PyErr_Occurred()) return -1; for (int i = 0; i < count; i++) { #ifdef PYPY_VERSION PyObject *arg = PyTuple_GetItem(args, i); #else PyObject *arg = args[i]; #endif switch (types[i]) { case 'c': /* string */ case 'k': /* string and size */ case 'C': /* string, not to be unpacked */ if (PyBytes_Check(arg)) break; return -1; case 's': /* string or unicode, to UnicodeString ref */ case 'u': /* string or unicode, to new UnicodeString ptr */ case 'n': /* string or unicode, to utf8 charsArg */ case 'f': /* string or unicode filename, to charsArg */ if (PyBytes_Check(arg) || PyUnicode_Check(arg)) break; return -1; case 'S': /* string, unicode or UnicodeString */ case 'W': /* string, unicode or UnicodeString, to save */ if (PyBytes_Check(arg) || PyUnicode_Check(arg) || isUnicodeString(arg)) break; return -1; case 'T': /* array of string, unicode or UnicodeString */ if (PySequence_Check(arg)) { if (PySequence_Length(arg) > 0) { PyObject *obj = PySequence_GetItem(arg, 0); int ok = (PyBytes_Check(obj) || PyUnicode_Check(obj) || isUnicodeString(obj)); Py_DECREF(obj); if (ok) break; } else break; } return -1; case 'U': /* UnicodeString */ case 'V': /* UnicodeString and raw arg object */ if (isUnicodeString(arg)) break; return -1; case 'K': /* python object of any type */ break; case 'M': /* python callable */ { if (PyCallable_Check(arg)) break; return -1; } case 'O': /* python object of given type */ { PyTypeObject *type = va_arg(list, PyTypeObject *); if (PyObject_TypeCheck(arg, type)) break; return -1; } case 'P': /* wrapped ICU object */ case 'p': /* wrapped ICU object, to save */ { classid id = va_arg(list, classid); PyTypeObject *type = va_arg(list, PyTypeObject *); if (isInstance(arg, id, type)) break; return -1; } case 'Q': /* array of wrapped ICU object pointers */ case 'R': /* array of wrapped ICU objects */ { classid id = va_arg(list, classid); PyTypeObject *type = va_arg(list, PyTypeObject *); if (PySequence_Check(arg)) { if (PySequence_Length(arg) > 0) { PyObject *obj = PySequence_GetItem(arg, 0); int ok = isInstance(obj, id, type); Py_DECREF(obj); if (ok) break; } else break; } return -1; } case 'D': /* date as UDate float or datetime */ if (isDate(arg)) break; return -1; case 'E': /* date as datetime */ if (isDateExact(arg)) break; return -1; case 'a': /* byte */ if (PyBytes_Check(arg) && (PyBytes_Size(arg) == 1)) break; return -1; case 'B': /* boolean, strict */ if (arg == Py_True || arg == Py_False) break; return -1; case 'b': /* boolean */ break; case 'i': /* int */ if (PyInt_Check(arg)) break; return -1; case 'd': /* double */ if (PyFloat_Check(arg) || PyInt_Check(arg) || PyLong_Check(arg)) break; return -1; case 'F': /* array of double */ if (PySequence_Check(arg)) { if (PySequence_Length(arg) > 0) { PyObject *obj = PySequence_GetItem(arg, 0); int ok = (PyFloat_Check(obj) || PyInt_Check(obj) || PyLong_Check(obj)); Py_DECREF(obj); if (ok) break; } else break; } return -1; case 'G': /* array of bool */ if (PySequence_Check(arg)) break; return -1; case 'H': /* array of int */ if (PySequence_Check(arg)) { if (PySequence_Length(arg) > 0) { PyObject *obj = PySequence_GetItem(arg, 0); int ok = (PyInt_Check(obj) || PyLong_Check(obj)); Py_DECREF(obj); if (ok) break; } else break; } return -1; case 'L': /* PY_LONG_LONG */ if (PyLong_Check(arg) || PyInt_Check(arg)) break; return -1; default: return -1; } } for (int j = 0; j < count; j++) { #ifdef PYPY_VERSION PyObject *arg = PyTuple_GetItem(args, j); #else PyObject *arg = args[j]; #endif switch (types[j]) { case 'A': /* previous Python arg object */ { PyObject **obj = va_arg(list, PyObject **); #ifdef PYPY_VERSION *obj = PyTuple_GetItem(args, j - 1); #else *obj = args[j - 1]; #endif break; } case 'c': /* string */ { char **c = va_arg(list, char **); *c = PyBytes_AS_STRING(arg); break; } case 'k': /* string and size */ { char **c = va_arg(list, char **); int *l = va_arg(list, int *); *c = PyBytes_AS_STRING(arg); *l = (int) PyBytes_GET_SIZE(arg); break; } case 'C': /* string, not to be unpacked */ { PyObject **obj = va_arg(list, PyObject **); *obj = arg; break; } case 's': /* string or unicode, to UnicodeString ref */ { UnicodeString *u = va_arg(list, UnicodeString *); try { PyObject_AsUnicodeString(arg, *u); } catch (ICUException e) { e.reportError(); return -1; } break; } case 'u': /* string or unicode, to new UnicodeString ptr */ { UnicodeString **u = va_arg(list, UnicodeString **); try { *u = PyObject_AsUnicodeString(arg); } catch (ICUException e) { e.reportError(); return -1; } break; } case 'n': /* string or unicode, to utf8 charsArg */ { charsArg *p = va_arg(list, charsArg *); if (PyUnicode_Check(arg)) { PyObject *bytes = PyUnicode_AsUTF8String(arg); if (bytes == NULL) return -1; p->own(bytes); } else { p->borrow(arg); } break; } case 'f': /* string or unicode filename, to charsArg */ { charsArg *p = va_arg(list, charsArg *); if (PyUnicode_Check(arg)) { #if PY_MAJOR_VERSION >= 3 PyObject *bytes = PyUnicode_EncodeFSDefault(arg); #else // TODO: Figure out fs encoding in a reasonable way PyObject *bytes = PyUnicode_AsUTF8String(arg); #endif if (bytes == NULL) return -1; p->own(bytes); } else { p->borrow(arg); } break; } case 'S': /* string, unicode or UnicodeString */ { UnicodeString **u = va_arg(list, UnicodeString **); UnicodeString *_u = va_arg(list, UnicodeString *); if (PyObject_TypeCheck(arg, &UObjectType_)) *u = (UnicodeString *) ((t_uobject *) arg)->object; else { try { PyObject_AsUnicodeString(arg, *_u); *u = _u; } catch (ICUException e) { e.reportError(); return -1; } } break; } case 'W': /* string, unicode or UnicodeString, to save */ { UnicodeString **u = va_arg(list, UnicodeString **); PyObject **obj = va_arg(list, PyObject **); if (PyObject_TypeCheck(arg, &UObjectType_)) { *u = (UnicodeString *) ((t_uobject *) arg)->object; Py_INCREF(arg); Py_XDECREF(*obj); *obj = arg; } else { try { *u = PyObject_AsUnicodeString(arg); Py_XDECREF(*obj); *obj = wrap_UnicodeString(*u, T_OWNED); } catch (ICUException e) { e.reportError(); return -1; } } break; } case 'T': /* array of string, unicode or UnicodeString */ { UnicodeString **array = va_arg(list, UnicodeString **); int *len = va_arg(list, int *); *array = toUnicodeStringArray(arg, len); if (!*array) return -1; break; } case 'U': /* UnicodeString */ { UnicodeString **u = va_arg(list, UnicodeString **); *u = (UnicodeString *) ((t_uobject *) arg)->object; break; } case 'V': /* UnicodeString and raw arg object */ { UnicodeString **u = va_arg(list, UnicodeString **); PyObject **obj = va_arg(list, PyObject **); *u = (UnicodeString *) ((t_uobject *) arg)->object; *obj = arg; break; } case 'K': /* python object of any type */ case 'M': /* python callable */ case 'O': /* python object of given type */ { PyObject **obj = va_arg(list, PyObject **); *obj = arg; break; } case 'P': /* wrapped ICU object */ { UObject **obj = va_arg(list, UObject **); *obj = ((t_uobject *) arg)->object; break; } case 'p': /* wrapped ICU object, to save */ { UObject **obj = va_arg(list, UObject **); PyObject **pyobj = va_arg(list, PyObject **); *obj = ((t_uobject *) arg)->object; Py_INCREF(arg); Py_XDECREF(*pyobj); *pyobj = arg; break; } case 'Q': /* array of wrapped ICU object pointers */ { UObject ***array = va_arg(list, UObject ***); int *len = va_arg(list, int *); classid id = va_arg(list, classid); PyTypeObject *type = va_arg(list, PyTypeObject *); *array = pl2cpa(arg, len, id, type); if (!*array) return -1; break; } case 'R': /* array of wrapped ICU objects */ { typedef UObject *(*convFn)(PyObject *, int *, classid, PyTypeObject *); UObject **array = va_arg(list, UObject **); int *len = va_arg(list, int *); classid id = va_arg(list, classid); PyTypeObject *type = va_arg(list, PyTypeObject *); convFn fn = va_arg(list, convFn); *array = fn(arg, len, id, type); if (!*array) return -1; break; } case 'D': /* date as UDate float or datetime */ case 'E': /* date as datetime */ { UDate *d = va_arg(list, UDate *); *d = PyObject_AsUDate(arg); break; } case 'a': /* byte */ { unsigned char *a = va_arg(list, unsigned char *); *a = (unsigned char) PyBytes_AS_STRING(arg)[0]; break; } case 'B': /* boolean, strict */ case 'b': /* boolean */ { int *b = va_arg(list, int *); *b = PyObject_IsTrue(arg); break; } case 'i': /* int */ { int *n = va_arg(list, int *); #if PY_MAJOR_VERSION >= 3 if ((*n = PyLong_AsLong(arg)) == -1 && PyErr_Occurred()) return -1; #else *n = (int) 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 'H': /* array of int */ { int **array = va_arg(list, int **); int *len = va_arg(list, int *); *array = toIntArray(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"); } ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1573596711.0 PyICU-2.4.2/common.h0000644000076500000000000003141700000000000014323 0ustar00vajdawheel00000000000000/* ==================================================================== * Copyright (c) 2005-2019 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 #ifdef __GNUG__ #define GCC_VERSION \ (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) #if GCC_VERSION < 40800 // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=54249 namespace std { typedef decltype(nullptr) nullptr_t; } #endif #endif #include #if !defined(PYPY_VERSION) && defined(PYPY_VERSION_NUM) #define PYPY_VERSION #endif #if PY_VERSION_HEX < 0x02040000 #define Py_RETURN_NONE return Py_INCREF(Py_None), Py_None #define Py_RETURN_TRUE return Py_INCREF(Py_True), Py_True #define Py_RETURN_FALSE return Py_INCREF(Py_False), Py_False #endif #if PY_VERSION_HEX < 0x02050000 typedef int Py_ssize_t; typedef inquiry lenfunc; typedef intargfunc ssizeargfunc; typedef intobjargproc ssizeobjargproc; typedef intintargfunc ssizessizeargfunc; typedef intintobjargproc ssizessizeobjargproc; #endif /* Python 2 uses String and Unicode, Python 3 Bytes and Unicode. * In PyICU, we use Bytes for everything that should be 8 bit in both * environments, i.e. String in Python 2 and Bytes in Python 3. We use * String for everything that should be a String in Python 2 and a * Unicode in Python 3. The assumption is that the argument will * always be ASCII only, and that we want the result to be represented * as a simple string literal without b or u modifier no matter the * environment. The definitions below establish these three flavours. */ #if PY_MAJOR_VERSION >= 3 # define Py_TPFLAGS_CHECKTYPES 0 # define PyInt_FromLong PyLong_FromLong # define PyInt_CheckExact PyLong_CheckExact # define PyInt_Check PyLong_Check # define PyInt_AsLong PyLong_AsLong # define PyString_FromString PyUnicode_FromString # define PyString_FromStringAndSize PyUnicode_FromStringAndSize # define PyString_FromFormatV PyUnicode_FromFormatV # define PyString_FromFormat PyUnicode_FromFormat # define PyString_Format PyUnicode_Format #else # define PyBytes_FromStringAndSize PyString_FromStringAndSize # define PyBytes_Check PyString_Check # define PyBytes_Size PyString_Size # define PyBytes_AsStringAndSize PyString_AsStringAndSize # define PyBytes_AS_STRING PyString_AS_STRING # define PyBytes_GET_SIZE PyString_GET_SIZE # define _PyBytes_Resize _PyString_Resize # ifndef PyVarObject_HEAD_INIT # define PyVarObject_HEAD_INIT(type, size) PyObject_HEAD_INIT(type) size, # endif # ifndef Py_TYPE # define Py_TYPE(ob) (((PyObject*)(ob))->ob_type) # endif #endif /* apparently a macro defined by some versions of the MSVC compiler */ #ifdef daylight #undef daylight #endif #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #define VERSION_HEX(major, minor, patch) \ (((major) << 24) | ((minor) << 16) | ((patch) << 8)) #define U_ICU_VERSION_HEX ((U_ICU_VERSION_MAJOR_NUM << 24) + \ (U_ICU_VERSION_MINOR_NUM << 16) + \ (U_ICU_VERSION_PATCHLEVEL_NUM << 8)) #if U_ICU_VERSION_HEX >= 0x04000000 #include #include #include #include #include #endif #if U_ICU_VERSION_HEX >= 0x04020000 #include #include #include #include #include #include #endif #if U_ICU_VERSION_HEX >= 0x04040000 #include #include #endif #if U_ICU_VERSION_HEX >= 0x04060000 #include #endif #if U_ICU_VERSION_HEX >= 0x04080000 #include #include #include #include #include #include #include #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(50, 0, 0) #include #include #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(51, 0, 0) #include #include #include #include #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(53, 0, 0) #include #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(57, 0, 0) #include #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(59, 0, 0) #include #include #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(60, 0, 0) #include #include #include #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(64, 0, 0) #include #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(65, 0, 0) #include #endif #if U_ICU_VERSION_HEX < 0x04060000 typedef UClassID classid; enum { UObject_ID, Replaceable_ID, MeasureUnit_ID, Measure_ID, StringEnumeration_ID, ForwardCharacterIterator_ID, CharacterIterator_ID, BreakIterator_ID, Format_ID, MeasureFormat_ID, DateFormat_ID, Calendar_ID, Collator_ID, UnicodeMatcher_ID, SearchIterator_ID, ListFormatter_ID, CaseMap_ID, }; #else typedef const char *classid; #endif U_NAMESPACE_USE /* lifted from common/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 Buffer { public: explicit Buffer(int32_t len) : size(len), buffer(u.getBuffer(len)) {} ~Buffer() { u.releaseBuffer(0); } UnicodeString u; int32_t size; UChar *buffer; }; class ICUException { private: PyObject *code; PyObject *msg; public: EXPORT ICUException(); EXPORT ICUException(const ICUException &e); EXPORT ICUException(UErrorCode status); EXPORT ICUException(UErrorCode status, char *format, ...); EXPORT ICUException(UParseError &pe, UErrorCode status); EXPORT ~ICUException(); EXPORT PyObject *reportError(); }; EXPORT PyObject *PyUnicode_FromUnicodeString(const UnicodeString *string); EXPORT PyObject *PyUnicode_FromUnicodeString(const UChar *chars, int size); EXPORT UnicodeString &PyBytes_AsUnicodeString(PyObject *object, const char *encoding, const char *mode, UnicodeString &string); EXPORT UnicodeString &PyObject_AsUnicodeString(PyObject *object, const char *encoding, const char *mode, UnicodeString &string); EXPORT UnicodeString &PyObject_AsUnicodeString(PyObject *object, UnicodeString &string); EXPORT UnicodeString *PyObject_AsUnicodeString(PyObject *object); EXPORT UDate PyObject_AsUDate(PyObject *object); int abstract_init(PyObject *self, PyObject *args, PyObject *kwds); PyObject *abstract_method(PyObject *self, PyObject *args); // helper class, to allow argument parsing with proper cleanup class charsArg { private: const char *str; PyObject *obj; void clear() { Py_XDECREF(obj); } public: charsArg() : str(NULL), obj(NULL) {} ~charsArg() { clear(); } const char *c_str() const { return str; } size_t size() const { return strlen(str); } #if PY_VERSION_HEX >= 0x02070000 // Allow using this class wherever a const char * is statically expected operator const char *() const { return str; } #else // Old python APIs were extremely unclean about constness of char strings operator char *() const { return const_cast(str); } #endif // Point to an existing bytes object. We don't own the buffer. void borrow(PyObject *bytes) { clear(); obj = NULL; str = PyBytes_AS_STRING(bytes); } // Point to a newly created bytes object, which we own and will clean. void own(PyObject *bytes) { clear(); obj = bytes; str = PyBytes_AS_STRING(bytes); } }; #if defined(_MSC_VER) || defined(PYPY_VERSION) #define parseArgs __parseArgs #define parseArg __parseArg int __parseArgs(PyObject *args, const char *types, ...); int __parseArg(PyObject *arg, const char *types, ...); #ifdef PYPY_VERSION int _parseArgs(PyObject *args, int count, const char *types, va_list list); #else int _parseArgs(PyObject **args, int count, const char *types, va_list list); #endif #else #define parseArgs(args, types, rest...) \ _parseArgs(((PyTupleObject *)(args))->ob_item, \ (int) 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 */ ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1491850614.0 PyICU-2.4.2/dateformat.cpp0000644000076500000000000023133200000000000015512 0ustar00vajdawheel00000000000000/* ==================================================================== * Copyright (c) 2004-2015 Open Source Applications Foundation. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. * ==================================================================== */ #include "common.h" #include "structmember.h" #include "bases.h" #include "locale.h" #include "format.h" #include "calendar.h" #include "numberformat.h" #include "dateformat.h" #include "macros.h" DECLARE_CONSTANTS_TYPE(UDateTimePatternConflict); DECLARE_CONSTANTS_TYPE(UDateTimePatternField); #if U_ICU_VERSION_HEX >= 0x04040000 DECLARE_CONSTANTS_TYPE(UDateTimePatternMatchOptions); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(54, 0, 0) DECLARE_CONSTANTS_TYPE(UDateRelativeDateTimeFormatterStyle); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(51, 0, 0) DECLARE_CONSTANTS_TYPE(UDisplayContext); DECLARE_CONSTANTS_TYPE(UDisplayContextType); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(53, 0, 0) DECLARE_CONSTANTS_TYPE(UDateDirection); DECLARE_CONSTANTS_TYPE(UDateAbsoluteUnit); DECLARE_CONSTANTS_TYPE(UDateRelativeUnit); DECLARE_CONSTANTS_TYPE(UDateFormatBooleanAttribute); #endif /* DateFormatSymbols */ class t_dateformatsymbols : public _wrapper { public: DateFormatSymbols *object; }; static int t_dateformatsymbols_init(t_dateformatsymbols *self, PyObject *args, PyObject *kwds); static PyObject *t_dateformatsymbols_getEras(t_dateformatsymbols *self); static PyObject *t_dateformatsymbols_setEras(t_dateformatsymbols *self, PyObject *arg); static PyObject *t_dateformatsymbols_getMonths(t_dateformatsymbols *self, PyObject *args); static PyObject *t_dateformatsymbols_setMonths(t_dateformatsymbols *self, PyObject *arg); static PyObject *t_dateformatsymbols_getShortMonths(t_dateformatsymbols *self); static PyObject *t_dateformatsymbols_setShortMonths(t_dateformatsymbols *self, PyObject *arg); static PyObject *t_dateformatsymbols_getWeekdays(t_dateformatsymbols *self, PyObject *args); static PyObject *t_dateformatsymbols_setWeekdays(t_dateformatsymbols *self, PyObject *arg); static PyObject *t_dateformatsymbols_getShortWeekdays(t_dateformatsymbols *self); static PyObject *t_dateformatsymbols_setShortWeekdays(t_dateformatsymbols *self, PyObject *arg); static PyObject *t_dateformatsymbols_getAmPmStrings(t_dateformatsymbols *self); static PyObject *t_dateformatsymbols_setAmPmStrings(t_dateformatsymbols *self, PyObject *arg); static PyObject *t_dateformatsymbols_getLocalPatternChars(t_dateformatsymbols *self, PyObject *args); static PyObject *t_dateformatsymbols_setLocalPatternChars(t_dateformatsymbols *self, PyObject *arg); static PyObject *t_dateformatsymbols_getLocale(t_dateformatsymbols *self, PyObject *args); static PyMethodDef t_dateformatsymbols_methods[] = { DECLARE_METHOD(t_dateformatsymbols, getEras, METH_NOARGS), DECLARE_METHOD(t_dateformatsymbols, setEras, METH_O), DECLARE_METHOD(t_dateformatsymbols, getMonths, METH_VARARGS), DECLARE_METHOD(t_dateformatsymbols, setMonths, METH_O), DECLARE_METHOD(t_dateformatsymbols, getShortMonths, METH_NOARGS), DECLARE_METHOD(t_dateformatsymbols, setShortMonths, METH_O), DECLARE_METHOD(t_dateformatsymbols, getWeekdays, METH_VARARGS), DECLARE_METHOD(t_dateformatsymbols, setWeekdays, METH_O), DECLARE_METHOD(t_dateformatsymbols, getShortWeekdays, METH_NOARGS), DECLARE_METHOD(t_dateformatsymbols, setShortWeekdays, METH_O), DECLARE_METHOD(t_dateformatsymbols, getAmPmStrings, METH_NOARGS), DECLARE_METHOD(t_dateformatsymbols, setAmPmStrings, METH_O), DECLARE_METHOD(t_dateformatsymbols, getLocalPatternChars, METH_VARARGS), DECLARE_METHOD(t_dateformatsymbols, setLocalPatternChars, METH_O), DECLARE_METHOD(t_dateformatsymbols, getLocale, METH_VARARGS), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(DateFormatSymbols, t_dateformatsymbols, UObject, DateFormatSymbols, t_dateformatsymbols_init, NULL); /* DateFormat */ class t_dateformat : public _wrapper { public: DateFormat *object; }; static PyObject *t_dateformat_isLenient(t_dateformat *self); static PyObject *t_dateformat_setLenient(t_dateformat *self, PyObject *arg); static PyObject *t_dateformat_format(t_dateformat *self, PyObject *args); static PyObject *t_dateformat_parse(t_dateformat *self, PyObject *args); static PyObject *t_dateformat_getCalendar(t_dateformat *self); static PyObject *t_dateformat_setCalendar(t_dateformat *self, PyObject *arg); static PyObject *t_dateformat_getNumberFormat(t_dateformat *self); static PyObject *t_dateformat_setNumberFormat(t_dateformat *self, PyObject *arg); static PyObject *t_dateformat_getTimeZone(t_dateformat *self); static PyObject *t_dateformat_setTimeZone(t_dateformat *self, PyObject *arg); static PyObject *t_dateformat_createInstance(PyTypeObject *type); static PyObject *t_dateformat_createTimeInstance(PyTypeObject *type, PyObject *args); static PyObject *t_dateformat_createDateInstance(PyTypeObject *type, PyObject *args); static PyObject *t_dateformat_createDateTimeInstance(PyTypeObject *type, PyObject *args); static PyObject *t_dateformat_getAvailableLocales(PyTypeObject *type); #if U_ICU_VERSION_HEX >= VERSION_HEX(53, 0, 0) static PyObject *t_dateformat_setContext(t_dateformat *self, PyObject *arg); static PyObject *t_dateformat_getContext(t_dateformat *self, PyObject *arg); static PyObject *t_dateformat_setBooleanAttribute(t_dateformat *self, PyObject *args); static PyObject *t_dateformat_getBooleanAttribute(t_dateformat *self, PyObject *arg); #endif static PyMethodDef t_dateformat_methods[] = { DECLARE_METHOD(t_dateformat, isLenient, METH_NOARGS), DECLARE_METHOD(t_dateformat, setLenient, METH_O), DECLARE_METHOD(t_dateformat, format, METH_VARARGS), DECLARE_METHOD(t_dateformat, parse, METH_VARARGS), DECLARE_METHOD(t_dateformat, getCalendar, METH_NOARGS), DECLARE_METHOD(t_dateformat, setCalendar, METH_O), DECLARE_METHOD(t_dateformat, getNumberFormat, METH_NOARGS), DECLARE_METHOD(t_dateformat, setNumberFormat, METH_O), DECLARE_METHOD(t_dateformat, getTimeZone, METH_NOARGS), DECLARE_METHOD(t_dateformat, setTimeZone, METH_O), DECLARE_METHOD(t_dateformat, createInstance, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_dateformat, createTimeInstance, METH_VARARGS | METH_CLASS), DECLARE_METHOD(t_dateformat, createDateInstance, METH_VARARGS | METH_CLASS), DECLARE_METHOD(t_dateformat, createDateTimeInstance, METH_VARARGS | METH_CLASS), DECLARE_METHOD(t_dateformat, getAvailableLocales, METH_NOARGS | METH_CLASS), #if U_ICU_VERSION_HEX >= VERSION_HEX(53, 0, 0) DECLARE_METHOD(t_dateformat, setContext, METH_O), DECLARE_METHOD(t_dateformat, getContext, METH_O), DECLARE_METHOD(t_dateformat, setBooleanAttribute, METH_VARARGS), DECLARE_METHOD(t_dateformat, getBooleanAttribute, METH_O), #endif { NULL, NULL, 0, NULL } }; DECLARE_TYPE(DateFormat, t_dateformat, Format, DateFormat, abstract_init, NULL); /* SimpleDateFormat */ class t_simpledateformat : public _wrapper { public: SimpleDateFormat *object; }; static int t_simpledateformat_init(t_simpledateformat *self, PyObject *args, PyObject *kwds); static PyObject *t_simpledateformat_toPattern(t_simpledateformat *self, PyObject *args); static PyObject *t_simpledateformat_toLocalizedPattern(t_simpledateformat *self, PyObject *args); static PyObject *t_simpledateformat_applyPattern(t_simpledateformat *self, PyObject *arg); static PyObject *t_simpledateformat_applyLocalizedPattern(t_simpledateformat *self, PyObject *arg); static PyObject *t_simpledateformat_get2DigitYearStart(t_simpledateformat *self); static PyObject *t_simpledateformat_set2DigitYearStart(t_simpledateformat *self, PyObject *arg); static PyObject *t_simpledateformat_getDateFormatSymbols(t_simpledateformat *self); static PyObject *t_simpledateformat_setDateFormatSymbols(t_simpledateformat *self, PyObject *arg); static PyMethodDef t_simpledateformat_methods[] = { DECLARE_METHOD(t_simpledateformat, toPattern, METH_VARARGS), DECLARE_METHOD(t_simpledateformat, toLocalizedPattern, METH_VARARGS), DECLARE_METHOD(t_simpledateformat, applyPattern, METH_O), DECLARE_METHOD(t_simpledateformat, applyLocalizedPattern, METH_O), DECLARE_METHOD(t_simpledateformat, get2DigitYearStart, METH_NOARGS), DECLARE_METHOD(t_simpledateformat, set2DigitYearStart, METH_O), DECLARE_METHOD(t_simpledateformat, getDateFormatSymbols, METH_NOARGS), DECLARE_METHOD(t_simpledateformat, setDateFormatSymbols, METH_O), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(SimpleDateFormat, t_simpledateformat, DateFormat, SimpleDateFormat, t_simpledateformat_init, NULL); PyObject *wrap_DateFormat(DateFormat *format) { RETURN_WRAPPED_IF_ISINSTANCE(format, SimpleDateFormat); return wrap_DateFormat(format, T_OWNED); } /* DateTimePatternGenerator */ class t_datetimepatterngenerator : public _wrapper { public: DateTimePatternGenerator *object; }; static PyObject *t_datetimepatterngenerator_createEmptyInstance( PyTypeObject *type); static PyObject *t_datetimepatterngenerator_createInstance( PyTypeObject *type, PyObject *args); static PyObject *t_datetimepatterngenerator_getSkeleton( t_datetimepatterngenerator *self, PyObject *arg); static PyObject *t_datetimepatterngenerator_getBaseSkeleton( t_datetimepatterngenerator *self, PyObject *arg); static PyObject *t_datetimepatterngenerator_addPattern( t_datetimepatterngenerator *self, PyObject *args); static PyObject *t_datetimepatterngenerator_getBestPattern( t_datetimepatterngenerator *self, PyObject *args); static PyObject *t_datetimepatterngenerator_setAppendItemFormat( t_datetimepatterngenerator *self, PyObject *args); static PyObject *t_datetimepatterngenerator_setAppendItemName( t_datetimepatterngenerator *self, PyObject *args); static PyObject *t_datetimepatterngenerator_getAppendItemFormat( t_datetimepatterngenerator *self, PyObject *arg); static PyObject *t_datetimepatterngenerator_getAppendItemName( t_datetimepatterngenerator *self, PyObject *arg); static PyObject *t_datetimepatterngenerator_replaceFieldTypes( t_datetimepatterngenerator *self, PyObject *args); static PyObject *t_datetimepatterngenerator_getSkeletons( t_datetimepatterngenerator *self); static PyObject *t_datetimepatterngenerator_getBaseSkeletons( t_datetimepatterngenerator *self); static PyObject *t_datetimepatterngenerator_getRedundants( t_datetimepatterngenerator *self); static PyObject *t_datetimepatterngenerator_getPatternForSkeleton( t_datetimepatterngenerator *self, PyObject *arg); static PyObject *t_datetimepatterngenerator_setDecimal( t_datetimepatterngenerator *self, PyObject *arg); static PyObject *t_datetimepatterngenerator_getDecimal( t_datetimepatterngenerator *self); #if U_ICU_VERSION_HEX >= VERSION_HEX(56, 0, 0) static PyObject *t_datetimepatterngenerator_staticGetSkeleton( PyTypeObject *type, PyObject *arg); static PyObject *t_datetimepatterngenerator_staticGetBaseSkeleton( PyTypeObject *type, PyObject *arg); #endif static PyMethodDef t_datetimepatterngenerator_methods[] = { DECLARE_METHOD(t_datetimepatterngenerator, createEmptyInstance, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_datetimepatterngenerator, createInstance, METH_VARARGS | METH_CLASS), DECLARE_METHOD(t_datetimepatterngenerator, getSkeleton, METH_O), DECLARE_METHOD(t_datetimepatterngenerator, getBaseSkeleton, METH_O), DECLARE_METHOD(t_datetimepatterngenerator, addPattern, METH_VARARGS), DECLARE_METHOD(t_datetimepatterngenerator, getBestPattern, METH_VARARGS), DECLARE_METHOD(t_datetimepatterngenerator, setAppendItemFormat, METH_VARARGS), DECLARE_METHOD(t_datetimepatterngenerator, setAppendItemName, METH_VARARGS), DECLARE_METHOD(t_datetimepatterngenerator, getAppendItemFormat, METH_O), DECLARE_METHOD(t_datetimepatterngenerator, getAppendItemName, METH_O), DECLARE_METHOD(t_datetimepatterngenerator, replaceFieldTypes, METH_VARARGS), DECLARE_METHOD(t_datetimepatterngenerator, getSkeletons, METH_NOARGS), DECLARE_METHOD(t_datetimepatterngenerator, getBaseSkeletons, METH_NOARGS), DECLARE_METHOD(t_datetimepatterngenerator, getRedundants, METH_NOARGS), DECLARE_METHOD(t_datetimepatterngenerator, getPatternForSkeleton, METH_O), DECLARE_METHOD(t_datetimepatterngenerator, setDecimal, METH_O), DECLARE_METHOD(t_datetimepatterngenerator, getDecimal, METH_NOARGS), #if U_ICU_VERSION_HEX >= VERSION_HEX(56, 0, 0) DECLARE_METHOD(t_datetimepatterngenerator, staticGetSkeleton, METH_O | METH_CLASS), DECLARE_METHOD(t_datetimepatterngenerator, staticGetBaseSkeleton, METH_O | METH_CLASS), #endif { NULL, NULL, 0, NULL } }; DECLARE_TYPE(DateTimePatternGenerator, t_datetimepatterngenerator, UObject, DateTimePatternGenerator, abstract_init, NULL); #if U_ICU_VERSION_HEX >= 0x04000000 /* DateInterval */ class t_dateinterval : public _wrapper { public: DateInterval *object; }; static int t_dateinterval_init(t_dateinterval *self, PyObject *args, PyObject *kwds); static PyObject *t_dateinterval_getFromDate(t_dateinterval *self); static PyObject *t_dateinterval_getToDate(t_dateinterval *self); static PyMethodDef t_dateinterval_methods[] = { DECLARE_METHOD(t_dateinterval, getFromDate, METH_NOARGS), DECLARE_METHOD(t_dateinterval, getToDate, METH_NOARGS), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(DateInterval, t_dateinterval, UObject, DateInterval, t_dateinterval_init, NULL); /* DateIntervalInfo */ class t_dateintervalinfo : public _wrapper { public: DateIntervalInfo *object; }; static int t_dateintervalinfo_init(t_dateintervalinfo *self, PyObject *args, PyObject *kwds); static PyObject *t_dateintervalinfo_getDefaultOrder(t_dateintervalinfo *self); static PyObject *t_dateintervalinfo_setIntervalPattern(t_dateintervalinfo *self, PyObject *args); static PyObject *t_dateintervalinfo_getIntervalPattern(t_dateintervalinfo *self, PyObject *args); static PyObject *t_dateintervalinfo_setFallbackIntervalPattern(t_dateintervalinfo *self, PyObject *arg); static PyObject *t_dateintervalinfo_getFallbackIntervalPattern(t_dateintervalinfo *self, PyObject *args); static PyMethodDef t_dateintervalinfo_methods[] = { DECLARE_METHOD(t_dateintervalinfo, getDefaultOrder, METH_NOARGS), DECLARE_METHOD(t_dateintervalinfo, setIntervalPattern, METH_VARARGS), DECLARE_METHOD(t_dateintervalinfo, getIntervalPattern, METH_VARARGS), DECLARE_METHOD(t_dateintervalinfo, setFallbackIntervalPattern, METH_O), DECLARE_METHOD(t_dateintervalinfo, getFallbackIntervalPattern, METH_VARARGS), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(DateIntervalInfo, t_dateintervalinfo, UObject, DateIntervalInfo, t_dateintervalinfo_init, NULL); /* DateIntervalFormat */ static DateIntervalFormat *DateInterval_format; class t_dateintervalformat : public _wrapper { public: DateIntervalFormat *object; }; static PyObject *t_dateintervalformat_format(t_dateintervalformat *self, PyObject *args); static PyObject *t_dateintervalformat_getDateIntervalInfo(t_dateintervalformat *self); static PyObject *t_dateintervalformat_setDateIntervalInfo(t_dateintervalformat *self, PyObject *arg); static PyObject *t_dateintervalformat_getDateFormat(t_dateintervalformat *self); static PyObject *t_dateintervalformat_parseObject(t_dateintervalformat *self, PyObject *args); static PyObject *t_dateintervalformat_createInstance(PyTypeObject *type, PyObject *args); static PyMethodDef t_dateintervalformat_methods[] = { DECLARE_METHOD(t_dateintervalformat, format, METH_VARARGS), DECLARE_METHOD(t_dateintervalformat, getDateIntervalInfo, METH_NOARGS), DECLARE_METHOD(t_dateintervalformat, setDateIntervalInfo, METH_O), DECLARE_METHOD(t_dateintervalformat, getDateFormat, METH_NOARGS), DECLARE_METHOD(t_dateintervalformat, parseObject, METH_VARARGS), DECLARE_METHOD(t_dateintervalformat, createInstance, METH_VARARGS | METH_CLASS), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(DateIntervalFormat, t_dateintervalformat, Format, DateIntervalFormat, abstract_init, NULL); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(53, 0, 0) /* RelativeDateTimeFormatter */ class t_relativedatetimeformatter : public _wrapper { public: RelativeDateTimeFormatter *object; }; static int t_relativedatetimeformatter_init(t_relativedatetimeformatter *self, PyObject *args, PyObject *kwds); static PyObject *t_relativedatetimeformatter_format( t_relativedatetimeformatter *self, PyObject *args); static PyObject *t_relativedatetimeformatter_combineDateAndTime( t_relativedatetimeformatter *self, PyObject *args); static PyObject *t_relativedatetimeformatter_getNumberFormat( t_relativedatetimeformatter *self); static PyObject *t_relativedatetimeformatter_getCapitalizationContext( t_relativedatetimeformatter *self); static PyObject *t_relativedatetimeformatter_getFormatStyle( t_relativedatetimeformatter *self); static PyMethodDef t_relativedatetimeformatter_methods[] = { DECLARE_METHOD(t_relativedatetimeformatter, format, METH_VARARGS), DECLARE_METHOD(t_relativedatetimeformatter, combineDateAndTime, METH_VARARGS), DECLARE_METHOD(t_relativedatetimeformatter, getNumberFormat, METH_NOARGS), DECLARE_METHOD(t_relativedatetimeformatter, getCapitalizationContext, METH_NOARGS), DECLARE_METHOD(t_relativedatetimeformatter, getFormatStyle, METH_NOARGS), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(RelativeDateTimeFormatter, t_relativedatetimeformatter, UObject, RelativeDateTimeFormatter, t_relativedatetimeformatter_init, NULL); #endif /* DateFormatSymbols */ static int t_dateformatsymbols_init(t_dateformatsymbols *self, PyObject *args, PyObject *kwds) { UnicodeString _u; Locale *locale; DateFormatSymbols *dfs; charsArg type; switch (PyTuple_Size(args)) { case 0: INT_STATUS_CALL(dfs = new DateFormatSymbols(status)); self->object = dfs; self->flags = T_OWNED; break; case 1: if (!parseArgs(args, "P", TYPE_CLASSID(Locale), &locale)) { INT_STATUS_CALL(dfs = new DateFormatSymbols(*locale, status)); self->object = dfs; self->flags = T_OWNED; break; } if (!parseArgs(args, "n", &type)) { INT_STATUS_CALL(dfs = new DateFormatSymbols(type, status)); self->object = dfs; self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; case 2: if (!parseArgs(args, "Pn", TYPE_CLASSID(Locale), &locale, &type)) { INT_STATUS_CALL(dfs = new DateFormatSymbols(*locale, type, status)); self->object = dfs; self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; default: PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; } if (self->object) return 0; return -1; } static PyObject *fromUnicodeStringArray(const UnicodeString *strings, int len, int dispose) { PyObject *list = PyList_New(len); for (int i = 0; i < len; i++) { UnicodeString *u = (UnicodeString *) (strings + i); PyList_SET_ITEM(list, i, PyUnicode_FromUnicodeString(u)); } if (dispose) delete strings; return list; } static PyObject *t_dateformatsymbols_getEras(t_dateformatsymbols *self) { int len; const UnicodeString *eras = self->object->getEras(len); return fromUnicodeStringArray(eras, len, 0); } static PyObject *t_dateformatsymbols_setEras(t_dateformatsymbols *self, PyObject *arg) { UnicodeString *eras; int len; if (!parseArg(arg, "T", &eras, &len)) { self->object->setEras(eras, len); /* copied */ delete[] eras; /* dtfmtsym.cpp code duplicates it */ Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setEras", arg); } static PyObject *t_dateformatsymbols_getMonths(t_dateformatsymbols *self, PyObject *args) { int len; const UnicodeString *months; DateFormatSymbols::DtContextType context; DateFormatSymbols::DtWidthType width; switch (PyTuple_Size(args)) { case 0: months = self->object->getMonths(len); return fromUnicodeStringArray(months, len, 0); case 2: if (!parseArgs(args, "ii", &context, &width)) { months = self->object->getMonths(len, context, width); return fromUnicodeStringArray(months, len, 0); } break; } return PyErr_SetArgsError((PyObject *) self, "getMonths", args); } static PyObject *t_dateformatsymbols_setMonths(t_dateformatsymbols *self, PyObject *arg) { UnicodeString *months; int len; if (!parseArg(arg, "T", &months, &len)) { self->object->setMonths(months, len); /* copied */ delete[] months; /* dtfmtsym.cpp code duplicates it */ Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setMonths", arg); } static PyObject *t_dateformatsymbols_getShortMonths(t_dateformatsymbols *self) { int len; const UnicodeString *months = self->object->getShortMonths(len); return fromUnicodeStringArray(months, len, 0); } static PyObject *t_dateformatsymbols_setShortMonths(t_dateformatsymbols *self, PyObject *arg) { UnicodeString *months; int len; if (!parseArg(arg, "T", &months, &len)) { self->object->setShortMonths(months, len); /* copied */ delete[] months; /* dtfmtsym.cpp code duplicates it */ Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setShortMonths", arg); } static PyObject *t_dateformatsymbols_getWeekdays(t_dateformatsymbols *self, PyObject *args) { int len; const UnicodeString *weekdays; DateFormatSymbols::DtContextType context; DateFormatSymbols::DtWidthType width; switch (PyTuple_Size(args)) { case 0: weekdays = self->object->getWeekdays(len); return fromUnicodeStringArray(weekdays, len, 0); case 2: if (!parseArgs(args, "ii", &context, &width)) { weekdays = self->object->getWeekdays(len, context, width); return fromUnicodeStringArray(weekdays, len, 0); } break; } return PyErr_SetArgsError((PyObject *) self, "getWeekdays", args); } static PyObject *t_dateformatsymbols_setWeekdays(t_dateformatsymbols *self, PyObject *arg) { UnicodeString *weekdays; int len; if (!parseArg(arg, "T", &weekdays, &len)) { self->object->setWeekdays(weekdays, len); /* copied */ delete[] weekdays; /* dtfmtsym.cpp code duplicates it */ Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setWeekdays", arg); } static PyObject *t_dateformatsymbols_getShortWeekdays(t_dateformatsymbols *self) { int len; const UnicodeString *months = self->object->getShortWeekdays(len); return fromUnicodeStringArray(months, len, 0); } static PyObject *t_dateformatsymbols_setShortWeekdays(t_dateformatsymbols *self, PyObject *arg) { UnicodeString *weekdays; int len; if (!parseArg(arg, "T", &weekdays, &len)) { self->object->setShortWeekdays(weekdays, len); /* copied */ delete[] weekdays; /* dtfmtsym.cpp code duplicates it */ Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setShortWeekdays", arg); } static PyObject *t_dateformatsymbols_getAmPmStrings(t_dateformatsymbols *self) { int len; const UnicodeString *strings = self->object->getAmPmStrings(len); return fromUnicodeStringArray(strings, len, 0); } static PyObject *t_dateformatsymbols_setAmPmStrings(t_dateformatsymbols *self, PyObject *arg) { UnicodeString *strings; int len; if (!parseArg(arg, "T", &strings, &len)) { self->object->setAmPmStrings(strings, len); /* copied */ delete[] strings; /* dtfmtsym.cpp code duplicates it */ Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setAmPmStrings", arg); } DEFINE_RICHCMP(DateFormatSymbols, t_dateformatsymbols); static PyObject *t_dateformatsymbols_getLocalPatternChars(t_dateformatsymbols *self, PyObject *args) { UnicodeString *u; UnicodeString _u; switch (PyTuple_Size(args)) { case 0: self->object->getLocalPatternChars(_u); return PyUnicode_FromUnicodeString(&_u); case 1: if (!parseArgs(args, "U", &u)) { self->object->getLocalPatternChars(*u); Py_RETURN_ARG(args, 0); } break; } return PyErr_SetArgsError((PyObject *) self, "getLocalPatternChars", args); } static PyObject *t_dateformatsymbols_setLocalPatternChars(t_dateformatsymbols *self, PyObject *arg) { UnicodeString *u, _u; if (!parseArg(arg, "S", &u, &_u)) { self->object->setLocalPatternChars(*u); /* copied */ Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setLocalPatternChars", arg); } static PyObject *t_dateformatsymbols_getLocale(t_dateformatsymbols *self, PyObject *args) { ULocDataLocaleType type; Locale locale; switch (PyTuple_Size(args)) { case 0: STATUS_CALL(locale = self->object->getLocale(ULOC_VALID_LOCALE, status)); return wrap_Locale(locale); case 1: if (!parseArgs(args, "i", &type)) { STATUS_CALL(locale = self->object->getLocale(type, status)); return wrap_Locale(locale); } break; } return PyErr_SetArgsError((PyObject *) self, "getLocale", args); } /* DateFormat */ static PyObject *t_dateformat_isLenient(t_dateformat *self) { int b = self->object->isLenient(); Py_RETURN_BOOL(b); } static PyObject *t_dateformat_setLenient(t_dateformat *self, PyObject *arg) { int b; if (!parseArg(arg, "b", &b)) { self->object->setLenient(b); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setLenient", arg); } static PyObject *t_dateformat_format(t_dateformat *self, PyObject *args) { UDate date; Calendar *calendar; UnicodeString *u; UnicodeString _u; FieldPosition *fp; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "D", &date)) { self->object->format(date, _u); return PyUnicode_FromUnicodeString(&_u); } if (!parseArgs(args, "P", TYPE_ID(Calendar), &calendar)) { FieldPosition fp0(0); self->object->format(*calendar, _u, fp0); return PyUnicode_FromUnicodeString(&_u); } break; case 2: if (!parseArgs(args, "DP", TYPE_CLASSID(FieldPosition), &date, &fp)) { self->object->format(date, _u, *fp); return PyUnicode_FromUnicodeString(&_u); } if (!parseArgs(args, "PP", TYPE_ID(Calendar), TYPE_CLASSID(FieldPosition), &calendar, &fp)) { self->object->format(*calendar, _u, *fp); return PyUnicode_FromUnicodeString(&_u); } if (!parseArgs(args, "DU", &date, &u)) { self->object->format(date, *u); Py_RETURN_ARG(args, 1); } break; case 3: if (!parseArgs(args, "DUP", TYPE_CLASSID(FieldPosition), &date, &u, &fp)) { self->object->format(date, *u, *fp); Py_RETURN_ARG(args, 1); } if (!parseArgs(args, "PUP", TYPE_ID(Calendar), TYPE_CLASSID(FieldPosition), &calendar, &u, &fp)) { self->object->format(*calendar, *u, *fp); Py_RETURN_ARG(args, 1); } break; } return t_format_format((t_format *) self, args); } static PyObject *t_dateformat_parse(t_dateformat *self, PyObject *args) { UnicodeString *u; UnicodeString _u; Calendar *calendar; ParsePosition *pp; UDate date; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "S", &u, &_u)) { STATUS_CALL(date = self->object->parse(*u, status)); return PyFloat_FromDouble(date / 1000.0); } break; case 2: if (!parseArgs(args, "SP", TYPE_CLASSID(ParsePosition), &u, &_u, &pp)) { pp->setErrorIndex(-1); STATUS_CALL(date = self->object->parse(*u, *pp)); if (pp->getErrorIndex() == -1) Py_RETURN_NONE; return PyFloat_FromDouble(date / 1000.0); } break; case 3: if (!parseArgs(args, "SPP", TYPE_ID(Calendar), TYPE_CLASSID(ParsePosition), &u, &_u, &calendar, &pp)) { pp->setErrorIndex(-1); STATUS_CALL(self->object->parse(*u, *calendar, *pp)); Py_RETURN_NONE; } break; } return PyErr_SetArgsError((PyObject *) self, "parse", args); } static PyObject *t_dateformat_getCalendar(t_dateformat *self) { return wrap_Calendar(self->object->getCalendar()->clone(), T_OWNED); } static PyObject *t_dateformat_setCalendar(t_dateformat *self, PyObject *arg) { Calendar *calendar; if (!parseArg(arg, "P", TYPE_ID(Calendar), &calendar)) { self->object->setCalendar(*calendar); /* copied */ Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setCalendar", arg); } static PyObject *t_dateformat_getNumberFormat(t_dateformat *self) { return wrap_NumberFormat((NumberFormat *) self->object->getNumberFormat()->clone(), T_OWNED); } static PyObject *t_dateformat_setNumberFormat(t_dateformat *self, PyObject *arg) { NumberFormat *format; if (!parseArg(arg, "P", TYPE_CLASSID(NumberFormat), &format)) { self->object->setNumberFormat(*format); /* copied */ Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setNumberFormat", arg); } static PyObject *t_dateformat_getTimeZone(t_dateformat *self) { return wrap_TimeZone(self->object->getTimeZone()); } static PyObject *t_dateformat_setTimeZone(t_dateformat *self, PyObject *arg) { TimeZone *tz; if (!parseArg(arg, "P", TYPE_CLASSID(TimeZone), &tz)) { self->object->setTimeZone(*tz); /* copied */ Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setTimeZone", arg); } static PyObject *t_dateformat_createInstance(PyTypeObject *type) { return wrap_DateFormat(DateFormat::createInstance()); } static PyObject *t_dateformat_createTimeInstance(PyTypeObject *type, PyObject *args) { DateFormat::EStyle style; Locale *locale; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "i", &style)) return wrap_DateFormat(DateFormat::createTimeInstance(style)); break; case 2: if (!parseArgs(args, "iP", TYPE_CLASSID(Locale), &style, &locale)) return wrap_DateFormat(DateFormat::createTimeInstance(style, *locale)); break; } return PyErr_SetArgsError(type, "createTimeInstance", args); } static PyObject *t_dateformat_createDateInstance(PyTypeObject *type, PyObject *args) { DateFormat::EStyle style; Locale *locale; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "i", &style)) return wrap_DateFormat(DateFormat::createDateInstance(style)); break; case 2: if (!parseArgs(args, "iP", TYPE_CLASSID(Locale), &style, &locale)) return wrap_DateFormat(DateFormat::createDateInstance(style, *locale)); break; } return PyErr_SetArgsError(type, "createDateInstance", args); } static PyObject *t_dateformat_createDateTimeInstance(PyTypeObject *type, PyObject *args) { DateFormat::EStyle dateStyle, timeStyle; Locale *locale; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "i", &dateStyle)) return wrap_DateFormat(DateFormat::createDateTimeInstance(dateStyle)); break; case 2: if (!parseArgs(args, "ii", &dateStyle, &timeStyle)) return wrap_DateFormat(DateFormat::createDateTimeInstance(dateStyle, timeStyle)); break; case 3: if (!parseArgs(args, "iiP", TYPE_CLASSID(Locale), &dateStyle, &timeStyle, &locale)) return wrap_DateFormat(DateFormat::createDateTimeInstance(dateStyle, timeStyle, *locale)); break; } return PyErr_SetArgsError(type, "createDateTimeInstance", args); } static PyObject *t_dateformat_getAvailableLocales(PyTypeObject *type) { int count; const Locale *locales = DateFormat::getAvailableLocales(count); PyObject *dict = PyDict_New(); for (int32_t i = 0; i < count; i++) { Locale *locale = (Locale *) locales + i; PyObject *obj = wrap_Locale(locale, 0); PyDict_SetItemString(dict, locale->getName(), obj); Py_DECREF(obj); } return dict; } #if U_ICU_VERSION_HEX >= VERSION_HEX(53, 0, 0) static PyObject *t_dateformat_setContext(t_dateformat *self, PyObject *arg) { int context; if (!parseArg(arg, "i", &context)) { STATUS_CALL(self->object->setContext( (UDisplayContext) context, status)); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setContext", arg); } static PyObject *t_dateformat_getContext(t_dateformat *self, PyObject *arg) { int context, type; if (!parseArg(arg, "i", &type)) { STATUS_CALL(context = self->object->getContext( (UDisplayContextType) type, status)); return PyInt_FromLong(context); } return PyErr_SetArgsError((PyObject *) self, "getContext", arg); } static PyObject *t_dateformat_setBooleanAttribute(t_dateformat *self, PyObject *args) { int attribute, value; if (!parseArgs(args, "ii", &attribute, &value)) { STATUS_CALL(self->object->setBooleanAttribute( (UDateFormatBooleanAttribute) attribute, (UBool) value, status)); Py_RETURN_SELF(); } return PyErr_SetArgsError((PyObject *) self, "setBooleanAttribute", args); } static PyObject *t_dateformat_getBooleanAttribute(t_dateformat *self, PyObject *arg) { int attribute; if (!parseArg(arg, "i", &attribute)) { UBool result; STATUS_CALL(result = self->object->getBooleanAttribute( (UDateFormatBooleanAttribute) attribute, status)); Py_RETURN_BOOL(result); } return PyErr_SetArgsError((PyObject *) self, "getBooleanAttribute", arg); } #endif /* SimpleDateFormat */ static int t_simpledateformat_init(t_simpledateformat *self, PyObject *args, PyObject *kwds) { UnicodeString *u; UnicodeString _u; Locale *locale; DateFormatSymbols *dfs; SimpleDateFormat *format; switch (PyTuple_Size(args)) { case 0: INT_STATUS_CALL(format = new SimpleDateFormat(status)); self->object = format; self->flags = T_OWNED; break; case 1: if (!parseArgs(args, "S", &u, &_u)) { INT_STATUS_CALL(format = new SimpleDateFormat(*u, status)); self->object = format; self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; case 2: if (!parseArgs(args, "SP", TYPE_CLASSID(Locale), &u, &_u, &locale)) { INT_STATUS_CALL(format = new SimpleDateFormat(*u, *locale, status)); self->object = format; self->flags = T_OWNED; break; } if (!parseArgs(args, "SP", TYPE_CLASSID(DateFormatSymbols), &u, &_u, &dfs)) { INT_STATUS_CALL(format = new SimpleDateFormat(*u, *dfs, status)); self->object = format; self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; default: PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; } if (self->object) return 0; return -1; } static PyObject *t_simpledateformat_toPattern(t_simpledateformat *self, PyObject *args) { UnicodeString *u; UnicodeString _u; switch (PyTuple_Size(args)) { case 0: self->object->toPattern(_u); return PyUnicode_FromUnicodeString(&_u); case 1: if (!parseArgs(args, "U", &u)) { self->object->toPattern(*u); Py_RETURN_ARG(args, 0); } break; } return PyErr_SetArgsError((PyObject *) self, "toPattern", args); } static PyObject *t_simpledateformat_toLocalizedPattern(t_simpledateformat *self, PyObject *args) { UnicodeString *u; UnicodeString _u; switch (PyTuple_Size(args)) { case 0: STATUS_CALL(self->object->toLocalizedPattern(_u, status)); return PyUnicode_FromUnicodeString(&_u); case 1: if (!parseArgs(args, "U", &u)) { STATUS_CALL(self->object->toLocalizedPattern(*u, status)); Py_RETURN_ARG(args, 0); } break; } return PyErr_SetArgsError((PyObject *) self, "toLocalizedPattern", args); } static PyObject *t_simpledateformat_applyPattern(t_simpledateformat *self, PyObject *arg) { UnicodeString *u; UnicodeString _u; if (!parseArg(arg, "S", &u, &_u)) { self->object->applyPattern(*u); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "applyPattern", arg); } static PyObject *t_simpledateformat_applyLocalizedPattern(t_simpledateformat *self, PyObject *arg) { UnicodeString *u; UnicodeString _u; if (!parseArg(arg, "S", &u, &_u)) { STATUS_CALL(self->object->applyLocalizedPattern(*u, status)); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "applyLocalizedPattern", arg); } static PyObject *t_simpledateformat_get2DigitYearStart(t_simpledateformat *self) { UDate date; STATUS_CALL(date = self->object->get2DigitYearStart(status)); return PyFloat_FromDouble(date / 1000.0); } static PyObject *t_simpledateformat_set2DigitYearStart(t_simpledateformat *self, PyObject *arg) { UDate date; if (!parseArg(arg, "D", &date)) { STATUS_CALL(self->object->set2DigitYearStart(date, status)); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "set2DigitYearStart", arg); } static PyObject *t_simpledateformat_getDateFormatSymbols(t_simpledateformat *self) { return wrap_DateFormatSymbols(new DateFormatSymbols(*self->object->getDateFormatSymbols()), T_OWNED); } static PyObject *t_simpledateformat_setDateFormatSymbols(t_simpledateformat *self, PyObject *arg) { DateFormatSymbols *dfs; if (!parseArg(arg, "P", TYPE_CLASSID(DateFormatSymbols), &dfs)) { self->object->setDateFormatSymbols(*dfs); /* copied */ Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setDateFormatSymbols", arg); } static PyObject *t_simpledateformat_str(t_simpledateformat *self) { UnicodeString u; self->object->toPattern(u); return PyUnicode_FromUnicodeString(&u); } /* DateTimePatternGenerator */ static PyObject *t_datetimepatterngenerator_createEmptyInstance( PyTypeObject *type) { DateTimePatternGenerator *dtpg; STATUS_CALL(dtpg = DateTimePatternGenerator::createEmptyInstance(status)); return wrap_DateTimePatternGenerator(dtpg, T_OWNED); } static PyObject *t_datetimepatterngenerator_createInstance(PyTypeObject *type, PyObject *args) { DateTimePatternGenerator *dtpg; Locale *locale; switch (PyTuple_Size(args)) { case 0: STATUS_CALL(dtpg = DateTimePatternGenerator::createInstance(status)); break; case 1: if (!parseArgs(args, "P", TYPE_CLASSID(Locale), &locale)) { STATUS_CALL(dtpg = DateTimePatternGenerator::createInstance( *locale, status)); break; } return PyErr_SetArgsError(type, "createInstance", args); default: return PyErr_SetArgsError(type, "createInstance", args); } return wrap_DateTimePatternGenerator(dtpg, T_OWNED); } #if U_ICU_VERSION_HEX >= VERSION_HEX(56, 0, 0) static PyObject *t_datetimepatterngenerator_staticGetSkeleton( PyTypeObject *type, PyObject *arg) { UnicodeString *u, _u; if (!parseArg(arg, "S", &u, &_u)) { UnicodeString result; STATUS_CALL(result = DateTimePatternGenerator::staticGetSkeleton( *u, status)); return PyUnicode_FromUnicodeString(&result); } return PyErr_SetArgsError(type, "staticGetSkeleton", arg); } static PyObject *t_datetimepatterngenerator_staticGetBaseSkeleton( PyTypeObject *type, PyObject *arg) { UnicodeString *u, _u; if (!parseArg(arg, "S", &u, &_u)) { UnicodeString result; STATUS_CALL(result = DateTimePatternGenerator::staticGetBaseSkeleton( *u, status)); return PyUnicode_FromUnicodeString(&result); } return PyErr_SetArgsError(type, "staticGetBaseSkeleton", arg); } #endif static PyObject *t_datetimepatterngenerator_getSkeleton( t_datetimepatterngenerator *self, PyObject *arg) { UnicodeString *u, _u; if (!parseArg(arg, "S", &u, &_u)) { UnicodeString result; STATUS_CALL(result = self->object->getSkeleton(*u, status)); return PyUnicode_FromUnicodeString(&result); } return PyErr_SetArgsError((PyObject *) self, "getSkeleton", arg); } static PyObject *t_datetimepatterngenerator_getBaseSkeleton( t_datetimepatterngenerator *self, PyObject *arg) { UnicodeString *u, _u; if (!parseArg(arg, "S", &u, &_u)) { UnicodeString result; STATUS_CALL(result = self->object->getBaseSkeleton(*u, status)); return PyUnicode_FromUnicodeString(&result); } return PyErr_SetArgsError((PyObject *) self, "staticGetBaseSkeleton", arg); } static PyObject *t_datetimepatterngenerator_addPattern( t_datetimepatterngenerator *self, PyObject *args) { UnicodeString *u, _u; int override; if (!parseArgs(args, "Sb", &u, &_u, &override)) { UDateTimePatternConflict conflict; UnicodeString conflictPattern; STATUS_CALL(conflict = self->object->addPattern( *u, override, conflictPattern, status)); PyObject *result = PyTuple_New(2); PyTuple_SET_ITEM(result, 0, PyInt_FromLong(conflict)); PyTuple_SET_ITEM(result, 1, PyUnicode_FromUnicodeString(&conflictPattern)); return result; } return PyErr_SetArgsError((PyObject *) self, "addPattern", args); } static PyObject *t_datetimepatterngenerator_getBestPattern( t_datetimepatterngenerator *self, PyObject *args) { UnicodeString *u, _u; #if U_ICU_VERSION_HEX >= 0x04040000 int options; #endif switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "S", &u, &_u)) { UnicodeString result; STATUS_CALL(result = self->object->getBestPattern(*u, status)); return PyUnicode_FromUnicodeString(&result); } break; #if U_ICU_VERSION_HEX >= 0x04040000 case 2: if (!parseArgs(args, "Si", &u, &_u, &options)) { UnicodeString result; STATUS_CALL(result = self->object->getBestPattern( *u, (UDateTimePatternMatchOptions) options, status)); return PyUnicode_FromUnicodeString(&result); } break; #endif } return PyErr_SetArgsError((PyObject *) self, "getBestPattern", args); } static PyObject *t_datetimepatterngenerator_setAppendItemFormat( t_datetimepatterngenerator *self, PyObject *args) { UnicodeString *u, _u; int field; if (!parseArgs(args, "iS", &field, &u, &_u)) { self->object->setAppendItemFormat((UDateTimePatternField) field, *u); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setAppendItemFormat", args); } static PyObject *t_datetimepatterngenerator_setAppendItemName( t_datetimepatterngenerator *self, PyObject *args) { UnicodeString *u, _u; int field; if (!parseArgs(args, "iS", &field, &u, &_u)) { self->object->setAppendItemName((UDateTimePatternField) field, *u); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setAppendItemName", args); } static PyObject *t_datetimepatterngenerator_getAppendItemFormat( t_datetimepatterngenerator *self, PyObject *arg) { int field; if (!parseArg(arg, "i", &field)) { const UnicodeString &result = self->object->getAppendItemFormat( (UDateTimePatternField) field); return PyUnicode_FromUnicodeString(&result); } return PyErr_SetArgsError((PyObject *) self, "getAppendItemFormat", arg); } static PyObject *t_datetimepatterngenerator_getAppendItemName( t_datetimepatterngenerator *self, PyObject *arg) { int field; if (!parseArg(arg, "i", &field)) { const UnicodeString &result = self->object->getAppendItemName( (UDateTimePatternField) field); return PyUnicode_FromUnicodeString(&result); } return PyErr_SetArgsError((PyObject *) self, "getAppendItemName", arg); } static PyObject *t_datetimepatterngenerator_replaceFieldTypes( t_datetimepatterngenerator *self, PyObject *args) { UnicodeString *u, _u, *v, _v;; #if U_ICU_VERSION_HEX >= 0x04040000 int options; #endif switch (PyTuple_Size(args)) { case 2: if (!parseArgs(args, "SS", &u, &_u, &v, &_v)) { UnicodeString result; STATUS_CALL(result = self->object->replaceFieldTypes( *u, *v, status)); return PyUnicode_FromUnicodeString(&result); } break; #if U_ICU_VERSION_HEX >= 0x04040000 case 3: if (!parseArgs(args, "SSi", &u, &_u, &v, &_v, &options)) { UnicodeString result; STATUS_CALL(result = self->object->replaceFieldTypes( *u, *v, (UDateTimePatternMatchOptions) options, status)); return PyUnicode_FromUnicodeString(&result); } break; #endif } return PyErr_SetArgsError((PyObject *) self, "replaceFieldTypes", args); } static PyObject *t_datetimepatterngenerator_getSkeletons( t_datetimepatterngenerator *self) { StringEnumeration *se; STATUS_CALL(se = self->object->getSkeletons(status)); return wrap_StringEnumeration(se, T_OWNED); } static PyObject *t_datetimepatterngenerator_getBaseSkeletons( t_datetimepatterngenerator *self) { StringEnumeration *se; STATUS_CALL(se = self->object->getBaseSkeletons(status)); return wrap_StringEnumeration(se, T_OWNED); } static PyObject *t_datetimepatterngenerator_getRedundants( t_datetimepatterngenerator *self) { StringEnumeration *se; STATUS_CALL(se = self->object->getRedundants(status)); return wrap_StringEnumeration(se, T_OWNED); } static PyObject *t_datetimepatterngenerator_getPatternForSkeleton( t_datetimepatterngenerator *self, PyObject *arg) { UnicodeString *u, _u;; if (!parseArg(arg, "S", &u, &_u)) { UnicodeString result; result = self->object->getPatternForSkeleton(*u); return PyUnicode_FromUnicodeString(&result); } return PyErr_SetArgsError((PyObject *) self, "getPatternForSkeleton", arg); } static PyObject *t_datetimepatterngenerator_setDecimal( t_datetimepatterngenerator *self, PyObject *arg) { UnicodeString *u, _u;; if (!parseArg(arg, "S", &u, &_u)) { self->object->setDecimal(*u); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setDecimal", arg); } static PyObject *t_datetimepatterngenerator_getDecimal( t_datetimepatterngenerator *self) { const UnicodeString &result = self->object->getDecimal(); return PyUnicode_FromUnicodeString(&result); } #if U_ICU_VERSION_HEX >= 0x04000000 /* DateInterval */ static int t_dateinterval_init(t_dateinterval *self, PyObject *args, PyObject *kwds) { UDate fromDate, toDate; if (!parseArgs(args, "DD", &fromDate, &toDate)) { self->object = new DateInterval(fromDate, toDate); self->flags = T_OWNED; return 0; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; } static PyObject *t_dateinterval_getFromDate(t_dateinterval *self) { UDate date = self->object->getFromDate(); return PyFloat_FromDouble(date / 1000.0); } static PyObject *t_dateinterval_getToDate(t_dateinterval *self) { UDate date = self->object->getToDate(); return PyFloat_FromDouble(date / 1000.0); } static PyObject *t_dateinterval_str(t_dateinterval *self) { UErrorCode status = U_ZERO_ERROR; UnicodeString u; FieldPosition _fp; DateInterval_format->format(self->object, u, _fp, status); if (U_FAILURE(status)) return ICUException(status).reportError(); return PyUnicode_FromUnicodeString(&u); } DEFINE_RICHCMP(DateInterval, t_dateinterval); /* DateIntervalInfo */ static int t_dateintervalinfo_init(t_dateintervalinfo *self, PyObject *args, PyObject *kwds) { DateIntervalInfo *dii; Locale *locale; switch (PyTuple_Size(args)) { case 0: INT_STATUS_CALL(dii = new DateIntervalInfo(status)); self->object = dii; self->flags = T_OWNED; break; case 1: if (!parseArgs(args, "P", TYPE_CLASSID(Locale), &locale)) { INT_STATUS_CALL(dii = new DateIntervalInfo(*locale, status)); self->object = dii; self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; default: PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; } if (self->object) return 0; return -1; } static PyObject *t_dateintervalinfo_getDefaultOrder(t_dateintervalinfo *self) { UBool b = self->object->getDefaultOrder(); Py_RETURN_BOOL(b); } static PyObject *t_dateintervalinfo_setIntervalPattern(t_dateintervalinfo *self, PyObject *args) { UnicodeString *u0, _u0; UnicodeString *u1, _u1; UCalendarDateFields ucdf; if (!parseArgs(args, "SiS", &u0, &_u0, &ucdf, &u1, &_u1)) { /* u0 transient, u1 copied */ STATUS_CALL(self->object->setIntervalPattern(*u0, ucdf, *u1, status)); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setIntervalPattern", args); } static PyObject *t_dateintervalinfo_getIntervalPattern(t_dateintervalinfo *self, PyObject *args) { UnicodeString *u0, _u0; UnicodeString *u1, _u1; UCalendarDateFields ucdf; switch (PyTuple_Size(args)) { case 2: if (!parseArgs(args, "Si", &u0, &_u0, &ucdf)) { STATUS_CALL(self->object->getIntervalPattern(*u0, ucdf, _u1, status)); return PyUnicode_FromUnicodeString(&_u1); } break; case 3: if (!parseArgs(args, "SiU", &u0, &_u0, &ucdf, &u1)) { STATUS_CALL(self->object->getIntervalPattern(*u0, ucdf, *u1, status)); Py_RETURN_ARG(args, 2); } break; } return PyErr_SetArgsError((PyObject *) self, "getIntervalPattern", args); } static PyObject *t_dateintervalinfo_setFallbackIntervalPattern(t_dateintervalinfo *self, PyObject *arg) { UnicodeString *u, _u; if (!parseArg(arg, "S", &u, &_u)) { /* copied */ STATUS_CALL(self->object->setFallbackIntervalPattern(*u, status)); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setFallbackIntervalPattern", arg); } static PyObject *t_dateintervalinfo_getFallbackIntervalPattern(t_dateintervalinfo *self, PyObject *args) { UnicodeString *u, _u; switch (PyTuple_Size(args)) { case 0: self->object->getFallbackIntervalPattern(_u); return PyUnicode_FromUnicodeString(&_u); case 1: if (!parseArgs(args, "U", &u)) { self->object->getFallbackIntervalPattern(*u); Py_RETURN_ARG(args, 0); } break; } return PyErr_SetArgsError((PyObject *) self, "getFallbackIntervalPattern", args); } DEFINE_RICHCMP(DateIntervalInfo, t_dateintervalinfo); /* DateIntervalFormat */ static PyObject *t_dateintervalformat_format(t_dateintervalformat *self, PyObject *args) { UnicodeString *u, _u; FieldPosition *fp, _fp; DateInterval *di; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "P", TYPE_CLASSID(DateInterval), &di)) { STATUS_CALL(self->object->format(di, _u, _fp, status)); return PyUnicode_FromUnicodeString(&_u); } break; case 2: if (!parseArgs(args, "PU", TYPE_CLASSID(DateInterval), &di, &u)) { STATUS_CALL(self->object->format(di, *u, _fp, status)); Py_RETURN_ARG(args, 1); } if (!parseArgs(args, "PP", TYPE_CLASSID(DateInterval), TYPE_CLASSID(FieldPosition), &di, &fp)) { STATUS_CALL(self->object->format(di, _u, *fp, status)); return PyUnicode_FromUnicodeString(&_u); } break; case 3: if (!parseArgs(args, "PUP", TYPE_CLASSID(DateInterval), TYPE_CLASSID(FieldPosition), &di, &u, &fp)) { STATUS_CALL(self->object->format(di, *u, *fp, status)); Py_RETURN_ARG(args, 1); } break; } return t_format_format((t_format *) self, args); } static PyObject *t_dateintervalformat_getDateIntervalInfo(t_dateintervalformat *self) { const DateIntervalInfo *dii = self->object->getDateIntervalInfo(); return wrap_DateIntervalInfo(new DateIntervalInfo(*dii), T_OWNED); } static PyObject *t_dateintervalformat_setDateIntervalInfo(t_dateintervalformat *self, PyObject *arg) { DateIntervalInfo *dii; if (!parseArg(arg, "P", TYPE_CLASSID(DateIntervalInfo), &dii)) { /* copied */ STATUS_CALL(self->object->setDateIntervalInfo(*dii, status)); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setDateIntervalInfo", arg); } static PyObject *t_dateintervalformat_getDateFormat(t_dateintervalformat *self) { DateFormat *format = (DateFormat *) self->object->getDateFormat()->clone(); return wrap_DateFormat(format); } static PyObject *t_dateintervalformat_parseObject(t_dateintervalformat *self, PyObject *args) { PyErr_SetString(PyExc_NotImplementedError, "DateIntervalFormat.parseObject()"); return NULL; } static PyObject *t_dateintervalformat_createInstance(PyTypeObject *type, PyObject *args) { UnicodeString *u, _u; Locale *locale; DateIntervalInfo *dii; DateIntervalFormat *dif; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "S", &u, &_u)) { STATUS_CALL(dif = DateIntervalFormat::createInstance(*u, status)); return wrap_DateIntervalFormat(dif, T_OWNED); } break; case 2: if (!parseArgs(args, "SP", TYPE_CLASSID(Locale), &u, &_u, &locale)) { STATUS_CALL(dif = DateIntervalFormat::createInstance(*u, *locale, status)); return wrap_DateIntervalFormat(dif, T_OWNED); } if (!parseArgs(args, "SP", TYPE_CLASSID(DateIntervalInfo), &u, &_u, &dii)) { STATUS_CALL(dif = DateIntervalFormat::createInstance(*u, *dii, status)); return wrap_DateIntervalFormat(dif, T_OWNED); } break; case 3: if (!parseArgs(args, "SPP", TYPE_CLASSID(Locale), TYPE_CLASSID(DateIntervalInfo), &u, &_u, &locale, &dii)) { STATUS_CALL(dif = DateIntervalFormat::createInstance(*u, *locale, *dii, status)); return wrap_DateIntervalFormat(dif, T_OWNED); } break; } return PyErr_SetArgsError(type, "createInstance", args); } DEFINE_RICHCMP(DateIntervalFormat, t_dateintervalformat); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(53, 0, 0) /* RelativeDateTimeFormatter */ static int t_relativedatetimeformatter_init(t_relativedatetimeformatter *self, PyObject *args, PyObject *kwds) { Locale *locale; RelativeDateTimeFormatter *fmt; NumberFormat *number_format; #if U_ICU_VERSION_HEX >= VERSION_HEX(54, 0, 0) UDateRelativeDateTimeFormatterStyle style; #endif UDisplayContext context; switch (PyTuple_Size(args)) { case 0: INT_STATUS_CALL(fmt = new RelativeDateTimeFormatter(status)); self->object = fmt; self->flags = T_OWNED; break; case 1: if (!parseArgs(args, "P", TYPE_CLASSID(Locale), &locale)) { INT_STATUS_CALL(fmt = new RelativeDateTimeFormatter(*locale, status)); self->object = fmt; self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; case 2: if (!parseArgs(args, "PP", TYPE_CLASSID(Locale), TYPE_CLASSID(NumberFormat), &locale, &number_format)) { INT_STATUS_CALL(fmt = new RelativeDateTimeFormatter( *locale, (NumberFormat *) number_format->clone(), status)); self->object = fmt; self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; #if U_ICU_VERSION_HEX >= VERSION_HEX(54, 0, 0) case 4: if (!parseArgs(args, "PPii", TYPE_CLASSID(Locale), TYPE_CLASSID(NumberFormat), &locale, &number_format, &style, &context)) { INT_STATUS_CALL(fmt = new RelativeDateTimeFormatter( *locale, (NumberFormat *) number_format->clone(), style, context, status)); self->object = fmt; self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; #endif default: PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; } if (self->object) return 0; return -1; } static PyObject *t_relativedatetimeformatter_format( t_relativedatetimeformatter *self, PyObject *args) { UDateDirection direction = UDAT_DIRECTION_PLAIN; UDateAbsoluteUnit abs_unit = UDAT_ABSOLUTE_NOW; UDateRelativeUnit rel_unit = UDAT_RELATIVE_SECONDS; UnicodeString *buffer; double value; switch (PyTuple_Size(args)) { case 0: { UnicodeString result; STATUS_CALL(self->object->format(direction, abs_unit, result, status)); return PyUnicode_FromUnicodeString(&result); } case 1: if (!parseArgs(args, "d", &value)) { UnicodeString result; STATUS_CALL(self->object->format( value, UDAT_DIRECTION_NEXT, rel_unit, result, status)); return PyUnicode_FromUnicodeString(&result); } break; case 2: if (!parseArgs(args, "ii", &direction, &abs_unit)) { UnicodeString result; STATUS_CALL(self->object->format( direction, abs_unit, result, status)); return PyUnicode_FromUnicodeString(&result); } break; case 3: if (!parseArgs(args, "iiU", &direction, &abs_unit, &buffer)) { STATUS_CALL(self->object->format( direction, abs_unit, *buffer, status)); Py_RETURN_ARG(args, 2); } if (!parseArgs(args, "dii", &value, &direction, &rel_unit)) { UnicodeString result; STATUS_CALL(self->object->format( value, direction, rel_unit, result, status)); return PyUnicode_FromUnicodeString(&result); } break; case 4: if (!parseArgs(args, "diiU", &value, &direction, &rel_unit, &buffer)) { STATUS_CALL(self->object->format( value, direction, rel_unit, *buffer, status)); Py_RETURN_ARG(args, 3); } break; } return PyErr_SetArgsError((PyObject *) self, "format", args); } static PyObject *t_relativedatetimeformatter_combineDateAndTime( t_relativedatetimeformatter *self, PyObject *args) { UnicodeString *u, _u, *v, _v; UnicodeString *buffer; switch (PyTuple_Size(args)) { case 2: if (!parseArgs(args, "SS", &u, &_u, &v, &_v)) { UnicodeString result; STATUS_CALL(self->object->combineDateAndTime( *u, *v, result, status)); return PyUnicode_FromUnicodeString(&result); } break; case 3: if (!parseArgs(args, "SSU", &u, &_u, &v, &_v, &buffer)) { STATUS_CALL(self->object->combineDateAndTime( *u, *v, *buffer, status)); Py_RETURN_ARG(args, 2); } break; } return PyErr_SetArgsError((PyObject *) self, "combineDateAndTime", args); } static PyObject *t_relativedatetimeformatter_getNumberFormat( t_relativedatetimeformatter *self) { const NumberFormat &format = self->object->getNumberFormat(); return wrap_NumberFormat(const_cast(&format), 0); } static PyObject *t_relativedatetimeformatter_getCapitalizationContext( t_relativedatetimeformatter *self) { return PyInt_FromLong(self->object->getCapitalizationContext()); } static PyObject *t_relativedatetimeformatter_getFormatStyle( t_relativedatetimeformatter *self) { return PyInt_FromLong(self->object->getFormatStyle()); } #endif void _init_dateformat(PyObject *m) { DateFormatSymbolsType_.tp_richcompare = (richcmpfunc) t_dateformatsymbols_richcmp; SimpleDateFormatType_.tp_str = (reprfunc) t_simpledateformat_str; #if U_ICU_VERSION_HEX >= 0x04000000 DateIntervalType_.tp_str = (reprfunc) t_dateinterval_str; DateIntervalType_.tp_richcompare = (richcmpfunc) t_dateinterval_richcmp; DateIntervalInfoType_.tp_richcompare = (richcmpfunc) t_dateintervalinfo_richcmp; DateIntervalFormatType_.tp_richcompare = (richcmpfunc) t_dateintervalformat_richcmp; #endif INSTALL_CONSTANTS_TYPE(UDateTimePatternConflict, m); INSTALL_CONSTANTS_TYPE(UDateTimePatternField, m); #if U_ICU_VERSION_HEX >= 0x04040000 INSTALL_CONSTANTS_TYPE(UDateTimePatternMatchOptions, m); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(54, 0, 0) INSTALL_CONSTANTS_TYPE(UDateRelativeDateTimeFormatterStyle, m); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(51, 0, 0) INSTALL_CONSTANTS_TYPE(UDisplayContext, m); INSTALL_CONSTANTS_TYPE(UDisplayContextType, m); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(53, 0, 0) INSTALL_CONSTANTS_TYPE(UDateDirection, m); INSTALL_CONSTANTS_TYPE(UDateAbsoluteUnit, m); INSTALL_CONSTANTS_TYPE(UDateRelativeUnit, m); INSTALL_CONSTANTS_TYPE(UDateFormatBooleanAttribute, m); #endif REGISTER_TYPE(DateFormatSymbols, m); INSTALL_TYPE(DateFormat, m); REGISTER_TYPE(SimpleDateFormat, m); REGISTER_TYPE(DateTimePatternGenerator, m); #if U_ICU_VERSION_HEX >= 0x04000000 REGISTER_TYPE(DateInterval, m); REGISTER_TYPE(DateIntervalInfo, m); REGISTER_TYPE(DateIntervalFormat, m); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(53, 0, 0) INSTALL_TYPE(RelativeDateTimeFormatter, m); #endif INSTALL_STATIC_INT(DateFormatSymbols, FORMAT); INSTALL_STATIC_INT(DateFormatSymbols, STANDALONE); INSTALL_STATIC_INT(DateFormatSymbols, WIDE); INSTALL_STATIC_INT(DateFormatSymbols, ABBREVIATED); INSTALL_STATIC_INT(DateFormatSymbols, NARROW); INSTALL_STATIC_INT(DateFormat, kNone); INSTALL_STATIC_INT(DateFormat, kFull); INSTALL_STATIC_INT(DateFormat, kLong); INSTALL_STATIC_INT(DateFormat, kMedium); INSTALL_STATIC_INT(DateFormat, kShort); INSTALL_STATIC_INT(DateFormat, kDateOffset); INSTALL_STATIC_INT(DateFormat, kDateTime); INSTALL_STATIC_INT(DateFormat, kDefault); INSTALL_STATIC_INT(DateFormat, FULL); INSTALL_STATIC_INT(DateFormat, LONG); INSTALL_STATIC_INT(DateFormat, MEDIUM); INSTALL_STATIC_INT(DateFormat, SHORT); INSTALL_STATIC_INT(DateFormat, DEFAULT); INSTALL_STATIC_INT(DateFormat, DATE_OFFSET); INSTALL_STATIC_INT(DateFormat, NONE); INSTALL_STATIC_INT(DateFormat, DATE_TIME); INSTALL_STATIC_INT(DateFormat, kEraField); INSTALL_STATIC_INT(DateFormat, kYearField); INSTALL_STATIC_INT(DateFormat, kMonthField); INSTALL_STATIC_INT(DateFormat, kDateField); INSTALL_STATIC_INT(DateFormat, kHourOfDay1Field); INSTALL_STATIC_INT(DateFormat, kHourOfDay0Field); INSTALL_STATIC_INT(DateFormat, kMinuteField); INSTALL_STATIC_INT(DateFormat, kSecondField); INSTALL_STATIC_INT(DateFormat, kMillisecondField); INSTALL_STATIC_INT(DateFormat, kDayOfWeekField); INSTALL_STATIC_INT(DateFormat, kDayOfYearField); INSTALL_STATIC_INT(DateFormat, kDayOfWeekInMonthField); INSTALL_STATIC_INT(DateFormat, kWeekOfYearField); INSTALL_STATIC_INT(DateFormat, kWeekOfMonthField); INSTALL_STATIC_INT(DateFormat, kAmPmField); INSTALL_STATIC_INT(DateFormat, kHour1Field); INSTALL_STATIC_INT(DateFormat, kHour0Field); INSTALL_STATIC_INT(DateFormat, kTimezoneField); INSTALL_STATIC_INT(DateFormat, kYearWOYField); INSTALL_STATIC_INT(DateFormat, kDOWLocalField); INSTALL_STATIC_INT(DateFormat, kExtendedYearField); INSTALL_STATIC_INT(DateFormat, kJulianDayField); INSTALL_STATIC_INT(DateFormat, kMillisecondsInDayField); INSTALL_STATIC_INT(DateFormat, ERA_FIELD); INSTALL_STATIC_INT(DateFormat, YEAR_FIELD); INSTALL_STATIC_INT(DateFormat, MONTH_FIELD); INSTALL_STATIC_INT(DateFormat, DATE_FIELD); INSTALL_STATIC_INT(DateFormat, HOUR_OF_DAY1_FIELD); INSTALL_STATIC_INT(DateFormat, HOUR_OF_DAY0_FIELD); INSTALL_STATIC_INT(DateFormat, MINUTE_FIELD); INSTALL_STATIC_INT(DateFormat, SECOND_FIELD); INSTALL_STATIC_INT(DateFormat, MILLISECOND_FIELD); INSTALL_STATIC_INT(DateFormat, DAY_OF_WEEK_FIELD); INSTALL_STATIC_INT(DateFormat, DAY_OF_YEAR_FIELD); INSTALL_STATIC_INT(DateFormat, DAY_OF_WEEK_IN_MONTH_FIELD); INSTALL_STATIC_INT(DateFormat, WEEK_OF_YEAR_FIELD); INSTALL_STATIC_INT(DateFormat, WEEK_OF_MONTH_FIELD); INSTALL_STATIC_INT(DateFormat, AM_PM_FIELD); INSTALL_STATIC_INT(DateFormat, HOUR1_FIELD); INSTALL_STATIC_INT(DateFormat, HOUR0_FIELD); INSTALL_STATIC_INT(DateFormat, TIMEZONE_FIELD); INSTALL_ENUM(UDateTimePatternConflict, "NO_CONFLICT", UDATPG_NO_CONFLICT); INSTALL_ENUM(UDateTimePatternConflict, "BASE_CONFLICT", UDATPG_BASE_CONFLICT); INSTALL_ENUM(UDateTimePatternConflict, "CONFLICT", UDATPG_CONFLICT); INSTALL_ENUM(UDateTimePatternConflict, "CONFLICT_COUNT", UDATPG_CONFLICT_COUNT); INSTALL_ENUM(UDateTimePatternField, "ERA_FIELD", UDATPG_ERA_FIELD); INSTALL_ENUM(UDateTimePatternField, "YEAR_FIELD", UDATPG_YEAR_FIELD); INSTALL_ENUM(UDateTimePatternField, "QUARTER_FIELD", UDATPG_QUARTER_FIELD); INSTALL_ENUM(UDateTimePatternField, "MONTH_FIELD", UDATPG_MONTH_FIELD); INSTALL_ENUM(UDateTimePatternField, "WEEK_OF_YEAR_FIELD", UDATPG_WEEK_OF_YEAR_FIELD); INSTALL_ENUM(UDateTimePatternField, "WEEK_OF_MONTH_FIELD", UDATPG_WEEK_OF_MONTH_FIELD); INSTALL_ENUM(UDateTimePatternField, "WEEKDAY_FIELD", UDATPG_WEEKDAY_FIELD); INSTALL_ENUM(UDateTimePatternField, "DAY_OF_YEAR_FIELD", UDATPG_DAY_OF_YEAR_FIELD); INSTALL_ENUM(UDateTimePatternField, "DAY_OF_WEEK_IN_MONTH_FIELD", UDATPG_DAY_OF_WEEK_IN_MONTH_FIELD); INSTALL_ENUM(UDateTimePatternField, "DAY_FIELD", UDATPG_DAY_FIELD); INSTALL_ENUM(UDateTimePatternField, "DAYPERIOD_FIELD", UDATPG_DAYPERIOD_FIELD); INSTALL_ENUM(UDateTimePatternField, "HOUR_FIELD", UDATPG_HOUR_FIELD); INSTALL_ENUM(UDateTimePatternField, "MINUTE_FIELD", UDATPG_MINUTE_FIELD); INSTALL_ENUM(UDateTimePatternField, "SECOND_FIELD", UDATPG_SECOND_FIELD); INSTALL_ENUM(UDateTimePatternField, "FRACTIONAL_SECOND_FIELD", UDATPG_FRACTIONAL_SECOND_FIELD); INSTALL_ENUM(UDateTimePatternField, "ZONE_FIELD", UDATPG_ZONE_FIELD); INSTALL_ENUM(UDateTimePatternField, "FIELD_COUNT", UDATPG_FIELD_COUNT); #if U_ICU_VERSION_HEX >= 0x04040000 INSTALL_ENUM(UDateTimePatternMatchOptions, "NO_OPTIONS", UDATPG_MATCH_NO_OPTIONS); INSTALL_ENUM(UDateTimePatternMatchOptions, "HOUR_FIELD_LENGTH", UDATPG_MATCH_HOUR_FIELD_LENGTH); INSTALL_ENUM(UDateTimePatternMatchOptions, "ALL_FIELDS_LENGTH", UDATPG_MATCH_ALL_FIELDS_LENGTH); INSTALL_STATIC_INT(DateIntervalInfo, kMaxIntervalPatternIndex); #endif #if U_ICU_VERSION_HEX >= 0x04000000 UErrorCode status = U_ZERO_ERROR; DateInterval_format = DateIntervalFormat::createInstance(UDAT_YEAR_ABBR_MONTH_DAY, status); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(54, 0, 0) INSTALL_ENUM(UDateRelativeDateTimeFormatterStyle, "LONG", UDAT_STYLE_LONG); INSTALL_ENUM(UDateRelativeDateTimeFormatterStyle, "SHORT", UDAT_STYLE_SHORT); INSTALL_ENUM(UDateRelativeDateTimeFormatterStyle, "NARROW", UDAT_STYLE_NARROW); INSTALL_ENUM(UDateRelativeDateTimeFormatterStyle, "COUNT", UDAT_STYLE_COUNT); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(51, 0, 0) INSTALL_ENUM(UDisplayContext, "STANDARD_NAMES", UDISPCTX_STANDARD_NAMES); INSTALL_ENUM(UDisplayContext, "DIALECT_NAMES", UDISPCTX_DIALECT_NAMES); INSTALL_ENUM(UDisplayContext, "CAPITALIZATION_NONE", UDISPCTX_CAPITALIZATION_NONE); INSTALL_ENUM(UDisplayContext, "CAPITALIZATION_FOR_MIDDLE_OF_SENTENCE", UDISPCTX_CAPITALIZATION_FOR_MIDDLE_OF_SENTENCE); INSTALL_ENUM(UDisplayContext, "CAPITALIZATION_FOR_BEGINNING_OF_SENTENCE", UDISPCTX_CAPITALIZATION_FOR_BEGINNING_OF_SENTENCE); INSTALL_ENUM(UDisplayContext, "CAPITALIZATION_FOR_UI_LIST_OR_MENU", UDISPCTX_CAPITALIZATION_FOR_UI_LIST_OR_MENU); INSTALL_ENUM(UDisplayContext, "CAPITALIZATION_FOR_STANDALONE", UDISPCTX_CAPITALIZATION_FOR_STANDALONE); INSTALL_ENUM(UDisplayContextType, "TYPE_DIALECT_HANDLING", UDISPCTX_TYPE_DIALECT_HANDLING); INSTALL_ENUM(UDisplayContextType, "TYPE_CAPITALIZATION", UDISPCTX_TYPE_CAPITALIZATION); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(54, 0, 0) INSTALL_ENUM(UDisplayContext, "LENGTH_FULL", UDISPCTX_LENGTH_FULL); INSTALL_ENUM(UDisplayContext, "LENGTH_SHORT", UDISPCTX_LENGTH_SHORT); INSTALL_ENUM(UDisplayContextType, "TYPE_DISPLAY_LENGTH", UDISPCTX_TYPE_DISPLAY_LENGTH); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(53, 0, 0) INSTALL_ENUM(UDateDirection, "LAST_2", UDAT_DIRECTION_LAST_2); INSTALL_ENUM(UDateDirection, "LAST", UDAT_DIRECTION_LAST); INSTALL_ENUM(UDateDirection, "THIS", UDAT_DIRECTION_THIS); INSTALL_ENUM(UDateDirection, "NEXT", UDAT_DIRECTION_NEXT); INSTALL_ENUM(UDateDirection, "NEXT_2", UDAT_DIRECTION_NEXT_2); INSTALL_ENUM(UDateDirection, "PLAIN", UDAT_DIRECTION_PLAIN); INSTALL_ENUM(UDateAbsoluteUnit, "SUNDAY", UDAT_ABSOLUTE_SUNDAY); INSTALL_ENUM(UDateAbsoluteUnit, "MONDAY", UDAT_ABSOLUTE_MONDAY); INSTALL_ENUM(UDateAbsoluteUnit, "TUESDAY", UDAT_ABSOLUTE_TUESDAY); INSTALL_ENUM(UDateAbsoluteUnit, "WEDNESDAY", UDAT_ABSOLUTE_WEDNESDAY); INSTALL_ENUM(UDateAbsoluteUnit, "THURSDAY", UDAT_ABSOLUTE_THURSDAY); INSTALL_ENUM(UDateAbsoluteUnit, "FRIDAY", UDAT_ABSOLUTE_FRIDAY); INSTALL_ENUM(UDateAbsoluteUnit, "SATURDAY", UDAT_ABSOLUTE_SATURDAY); INSTALL_ENUM(UDateAbsoluteUnit, "DAY", UDAT_ABSOLUTE_DAY); INSTALL_ENUM(UDateAbsoluteUnit, "WEEK", UDAT_ABSOLUTE_WEEK); INSTALL_ENUM(UDateAbsoluteUnit, "MONTH", UDAT_ABSOLUTE_MONTH); INSTALL_ENUM(UDateAbsoluteUnit, "YEAR", UDAT_ABSOLUTE_YEAR); INSTALL_ENUM(UDateAbsoluteUnit, "NOW", UDAT_ABSOLUTE_NOW); INSTALL_ENUM(UDateRelativeUnit, "SECONDS", UDAT_RELATIVE_SECONDS); INSTALL_ENUM(UDateRelativeUnit, "MINUTES", UDAT_RELATIVE_MINUTES); INSTALL_ENUM(UDateRelativeUnit, "HOURS", UDAT_RELATIVE_HOURS); INSTALL_ENUM(UDateRelativeUnit, "DAYS", UDAT_RELATIVE_DAYS); INSTALL_ENUM(UDateRelativeUnit, "WEEKS", UDAT_RELATIVE_WEEKS); INSTALL_ENUM(UDateRelativeUnit, "MONTHS", UDAT_RELATIVE_MONTHS); INSTALL_ENUM(UDateRelativeUnit, "YEARS", UDAT_RELATIVE_YEARS); INSTALL_ENUM(UDateFormatBooleanAttribute, "PARSE_ALLOW_WHITESPACE", UDAT_PARSE_ALLOW_WHITESPACE); INSTALL_ENUM(UDateFormatBooleanAttribute, "PARSE_ALLOW_NUMERIC", UDAT_PARSE_ALLOW_NUMERIC); INSTALL_ENUM(UDateFormatBooleanAttribute, "BOOLEAN_ATTRIBUTE_COUNT", UDAT_BOOLEAN_ATTRIBUTE_COUNT); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(56, 0, 0) INSTALL_ENUM(UDateFormatBooleanAttribute, "PARSE_PARTIAL_LITERAL_MATCH", UDAT_PARSE_PARTIAL_LITERAL_MATCH); INSTALL_ENUM(UDateFormatBooleanAttribute, "PARSE_MULTIPLE_PATTERNS_FOR_MATCH", UDAT_PARSE_MULTIPLE_PATTERNS_FOR_MATCH); #endif } ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1263422176.0 PyICU-2.4.2/dateformat.h0000644000076500000000000000266200000000000015161 0ustar00vajdawheel00000000000000/* ==================================================================== * 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 */ ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1553764292.0 PyICU-2.4.2/errors.cpp0000644000076500000000000003311600000000000014700 0ustar00vajdawheel00000000000000/* ==================================================================== * 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_ZERO_ERROR, "No error, no warning."); _setMsg(messages, U_ILLEGAL_ARGUMENT_ERROR, "Illegal argument"); _setMsg(messages, U_MISSING_RESOURCE_ERROR, "The requested resource cannot be found"); _setMsg(messages, U_INVALID_FORMAT_ERROR, "Data format is not what is expected"); _setMsg(messages, U_FILE_ACCESS_ERROR, "The requested file cannot be found"); _setMsg(messages, U_INTERNAL_PROGRAM_ERROR, "Indicates a bug in the library code"); _setMsg(messages, U_MESSAGE_PARSE_ERROR, "Unable to parse a message (message format)"); _setMsg(messages, U_MEMORY_ALLOCATION_ERROR, "Memory allocation error"); _setMsg(messages, U_INDEX_OUTOFBOUNDS_ERROR, "Trying to access the index that is out of bounds"); _setMsg(messages, U_PARSE_ERROR, "Equivalent to Java ParseException"); _setMsg(messages, U_INVALID_CHAR_FOUND, "Character conversion: Unmappable input sequence. In other APIs: Invalid character."); _setMsg(messages, U_TRUNCATED_CHAR_FOUND, "Character conversion: Incomplete input sequence."); _setMsg(messages, U_ILLEGAL_CHAR_FOUND, "Character conversion: Illegal input sequence/combination of input units.."); _setMsg(messages, U_INVALID_TABLE_FORMAT, "Conversion table file found, but corrupted"); _setMsg(messages, U_INVALID_TABLE_FILE, "Conversion table file not found"); _setMsg(messages, U_BUFFER_OVERFLOW_ERROR, "A result would not fit in the supplied buffer"); _setMsg(messages, U_UNSUPPORTED_ERROR, "Requested operation not supported in current context"); _setMsg(messages, U_RESOURCE_TYPE_MISMATCH, "an operation is requested over a resource that does not support it"); _setMsg(messages, U_ILLEGAL_ESCAPE_SEQUENCE, "ISO-2022 illegal escape sequence"); _setMsg(messages, U_UNSUPPORTED_ESCAPE_SEQUENCE, "ISO-2022 unsupported escape sequence"); _setMsg(messages, U_NO_SPACE_AVAILABLE, "No space available for in-buffer expansion for Arabic shaping"); _setMsg(messages, U_CE_NOT_FOUND_ERROR, "Currently used only while setting variable top, but can be used generally"); _setMsg(messages, U_PRIMARY_TOO_LONG_ERROR, "User tried to set variable top to a primary that is longer than two bytes"); _setMsg(messages, U_STATE_TOO_OLD_ERROR, "ICU cannot construct a service from this state, as it is no longer supported"); _setMsg(messages, U_TOO_MANY_ALIASES_ERROR, "There are too many aliases in the path to the requested resource. It is very possible that a circular alias definition has occurred"); _setMsg(messages, U_ENUM_OUT_OF_SYNC_ERROR, "UEnumeration out of sync with underlying collection"); _setMsg(messages, U_INVARIANT_CONVERSION_ERROR, "Unable to convert a UChar* string to char* with the invariant converter."); _setMsg(messages, U_INVALID_STATE_ERROR, "Requested operation can not be completed with ICU in its current state"); _setMsg(messages, U_COLLATOR_VERSION_MISMATCH, "Collator version is not compatible with the base version"); _setMsg(messages, U_USELESS_COLLATOR_ERROR, "Collator is options only and no base is specified"); _setMsg(messages, U_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_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_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_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."); #if U_ICU_VERSION_HEX >= 0x04080000 _setMsg(messages, U_FORMAT_INEXACT_ERROR, "Cannot format a number exactly and rounding mode is ROUND_UNNECESSARY"); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(61, 0, 0) _setMsg(messages, U_NUMBER_ARG_OUTOFBOUNDS_ERROR, "The argument to a NumberFormatter helper method was out of bounds; the bounds are usually 0 to 999"); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(62, 0, 0) _setMsg(messages, U_NUMBER_SKELETON_SYNTAX_ERROR, "The number skeleton passed to C++ NumberFormatter or C UNumberFormatter was invalid or contained a syntax error"); #endif } void _init_errors(PyObject *m) { PyObject *messages = PyObject_GetAttrString(PyExc_ICUError, "messages"); registerErrors(messages); Py_DECREF(messages); } ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1263422180.0 PyICU-2.4.2/errors.h0000644000076500000000000000255000000000000014343 0ustar00vajdawheel00000000000000/* ==================================================================== * 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 */ ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1569878450.0 PyICU-2.4.2/format.cpp0000644000076500000000000017070400000000000014661 0ustar00vajdawheel00000000000000/* ==================================================================== * Copyright (c) 2004-2019 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 "measureunit.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); #if U_ICU_VERSION_HEX >= VERSION_HEX(53, 0, 0) static PyObject *t_measureformat_formatMeasure(t_measureformat *self, PyObject *args); static PyObject *t_measureformat_formatMeasures(t_measureformat *self, PyObject *args); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(55, 0, 0) static PyObject *t_measureformat_formatMeasurePerUnit(t_measureformat *self, PyObject *args); #endif static PyMethodDef t_measureformat_methods[] = { DECLARE_METHOD(t_measureformat, createCurrencyFormat, METH_VARARGS | METH_CLASS), #if U_ICU_VERSION_HEX >= VERSION_HEX(53, 0, 0) DECLARE_METHOD(t_measureformat, formatMeasure, METH_VARARGS), DECLARE_METHOD(t_measureformat, formatMeasures, METH_VARARGS), #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(55, 0, 0) DECLARE_METHOD(t_measureformat, formatMeasurePerUnit, METH_VARARGS), #endif { 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); #if U_ICU_VERSION_HEX >= 0x04000000 static PyObject *t_messageformat_getFormatNames(t_messageformat *self); #endif 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 */ #if PY_MAJOR_VERSION >= 3 (binaryfunc) t_messageformat_mod, /* nb_remainder */ 0, /* nb_divmod */ #else 0, /* nb_divide */ (binaryfunc) t_messageformat_mod, /* nb_remainder */ #endif }; 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), #if U_ICU_VERSION_HEX >= 0x04000000 DECLARE_METHOD(t_messageformat, getFormatNames, METH_NOARGS), #endif DECLARE_METHOD(t_messageformat, format, METH_VARARGS), DECLARE_METHOD(t_messageformat, parse, METH_VARARGS), DECLARE_METHOD(t_messageformat, formatMessage, METH_VARARGS | METH_CLASS), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(MessageFormat, t_messageformat, Format, MessageFormat, t_messageformat_init, NULL); #if U_ICU_VERSION_HEX >= 0x04000000 /* PluralRules */ class t_pluralrules : public _wrapper { public: PluralRules *object; }; static int t_pluralrules_init(t_pluralrules *self, PyObject *args, PyObject *kwds); static PyObject *t_pluralrules_select(t_pluralrules *self, PyObject *arg); static PyObject *t_pluralrules_getKeywords(t_pluralrules *self); static PyObject *t_pluralrules_getKeywordOther(t_pluralrules *self); static PyObject *t_pluralrules_isKeyword(t_pluralrules *self, PyObject *arg); static PyObject *t_pluralrules_createRules(PyTypeObject *type, PyObject *arg); static PyObject *t_pluralrules_createDefaultRules(PyTypeObject *type); static PyObject *t_pluralrules_forLocale(PyTypeObject *type, PyObject *arg); static PyMethodDef t_pluralrules_methods[] = { DECLARE_METHOD(t_pluralrules, select, METH_O), DECLARE_METHOD(t_pluralrules, getKeywords, METH_NOARGS), DECLARE_METHOD(t_pluralrules, getKeywordOther, METH_NOARGS), DECLARE_METHOD(t_pluralrules, isKeyword, METH_O), DECLARE_METHOD(t_pluralrules, createRules, METH_O | METH_CLASS), DECLARE_METHOD(t_pluralrules, createDefaultRules, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_pluralrules, forLocale, METH_O | METH_CLASS), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(PluralRules, t_pluralrules, UObject, PluralRules, t_pluralrules_init, NULL); /* PluralFormat */ class t_pluralformat : public _wrapper { public: PluralFormat *object; PyObject *numberformat; }; static int t_pluralformat_init(t_pluralformat *self, PyObject *args, PyObject *kwds); static PyObject *t_pluralformat_setLocale(t_pluralformat *self, PyObject *arg); static PyObject *t_pluralformat_setNumberFormat(t_pluralformat *self, PyObject *arg); static PyObject *t_pluralformat_toPattern(t_pluralformat *self, PyObject *args); static PyObject *t_pluralformat_applyPattern(t_pluralformat *self, PyObject *arg); static PyObject *t_pluralformat_format(t_pluralformat *self, PyObject *args); static PyMethodDef t_pluralformat_methods[] = { DECLARE_METHOD(t_pluralformat, setLocale, METH_O), DECLARE_METHOD(t_pluralformat, setNumberFormat, METH_O), DECLARE_METHOD(t_pluralformat, toPattern, METH_VARARGS), DECLARE_METHOD(t_pluralformat, applyPattern, METH_O), DECLARE_METHOD(t_pluralformat, format, METH_VARARGS), { NULL, NULL, 0, NULL } }; static void t_pluralformat_dealloc(t_pluralformat *self) { if (self->flags & T_OWNED) delete self->object; self->object = NULL; Py_CLEAR(self->numberformat); Py_TYPE(self)->tp_free((PyObject *) self); } DECLARE_TYPE(PluralFormat, t_pluralformat, Format, PluralFormat, t_pluralformat_init, t_pluralformat_dealloc); #endif #if U_ICU_VERSION_HEX >= 0x04040000 /* SelectFormat */ class t_selectformat : public _wrapper { public: SelectFormat *object; }; static int t_selectformat_init(t_selectformat *self, PyObject *args, PyObject *kwds); static PyObject *t_selectformat_applyPattern(t_selectformat *self, PyObject *arg); static PyObject *t_selectformat_toPattern(t_selectformat *self, PyObject *args); static PyObject *t_selectformat_format(t_selectformat *self, PyObject *args); static PyObject *t_selectformat_parseObject(t_selectformat *self, PyObject *args); static PyMethodDef t_selectformat_methods[] = { DECLARE_METHOD(t_selectformat, applyPattern, METH_O), DECLARE_METHOD(t_selectformat, toPattern, METH_VARARGS), DECLARE_METHOD(t_selectformat, format, METH_VARARGS), DECLARE_METHOD(t_selectformat, parseObject, METH_VARARGS), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(SelectFormat, t_selectformat, Format, SelectFormat, t_selectformat_init, NULL); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(50, 0, 0) class t_listformatter : public _wrapper { public: ListFormatter *object; }; static PyObject *t_listformatter_format(t_listformatter *self, PyObject *arg); static PyObject *t_listformatter_createInstance(PyTypeObject *type, PyObject *args); static PyMethodDef t_listformatter_methods[] = { DECLARE_METHOD(t_listformatter, format, METH_O), DECLARE_METHOD(t_listformatter, createInstance, METH_VARARGS | METH_CLASS), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(ListFormatter, t_listformatter, UObject, ListFormatter, abstract_init, NULL); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(57, 0, 0) class t_simpleformatter : public _wrapper { public: SimpleFormatter *object; PyObject *pattern; }; static int t_simpleformatter_init(t_simpleformatter *self, PyObject *args, PyObject *kwds); static PyObject *t_simpleformatter_applyPattern( t_simpleformatter *self, PyObject *arg); static PyObject *t_simpleformatter_applyPatternMinMaxArguments( t_simpleformatter *self, PyObject *args); static PyObject *t_simpleformatter_getArgumentLimit( t_simpleformatter *self, PyObject *args); static PyObject *t_simpleformatter_format( t_simpleformatter *self, PyObject *args); static PyObject *t_simpleformatter_formatStrings( t_simpleformatter *self, PyObject *arg); static PyNumberMethods t_simpleformatter_as_number = { 0, /* nb_add */ 0, /* nb_subtract */ 0, /* nb_multiply */ #if PY_MAJOR_VERSION >= 3 (binaryfunc) t_simpleformatter_formatStrings, /* nb_remainder */ 0, /* nb_divmod */ #else 0, /* nb_divide */ (binaryfunc) t_simpleformatter_formatStrings, /* nb_remainder */ #endif }; static PyMethodDef t_simpleformatter_methods[] = { DECLARE_METHOD(t_simpleformatter, applyPattern, METH_O), DECLARE_METHOD(t_simpleformatter, applyPatternMinMaxArguments, METH_VARARGS), DECLARE_METHOD(t_simpleformatter, getArgumentLimit, METH_NOARGS), DECLARE_METHOD(t_simpleformatter, format, METH_VARARGS), DECLARE_METHOD(t_simpleformatter, formatStrings, METH_O), { NULL, NULL, 0, NULL } }; static void t_simpleformatter_dealloc(t_simpleformatter *self) { if (self->flags & T_OWNED) delete self->object; self->object = NULL; Py_CLEAR(self->pattern); Py_TYPE(self)->tp_free((PyObject *) self); } DECLARE_TYPE(SimpleFormatter, t_simpleformatter, UMemory, SimpleFormatter, t_simpleformatter_init, t_simpleformatter_dealloc); #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); } DEFINE_RICHCMP(FieldPosition, t_fieldposition); /* 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); } DEFINE_RICHCMP(ParsePosition, t_parseposition); /* Format */ PyObject *t_format_format(t_format *self, PyObject *args) { UnicodeString *u, _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); } DEFINE_RICHCMP(Format, t_format); /* 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 >= VERSION_HEX(53, 0, 0) static PyObject *t_measureformat_formatMeasure(t_measureformat *self, PyObject *args) { Measure *measure; FieldPosition dont_care(FieldPosition::DONT_CARE); FieldPosition *fp; UnicodeString u; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "P", TYPE_CLASSID(Measure), &measure)) { STATUS_CALL(self->object->formatMeasures( measure, 1, u, dont_care, status)); return PyUnicode_FromUnicodeString(&u); } break; case 2: if (!parseArgs(args, "PP", TYPE_CLASSID(Measure), TYPE_CLASSID(FieldPosition), &measure, &fp)) { STATUS_CALL(self->object->formatMeasures( measure, 1, u, *fp, status)); return PyUnicode_FromUnicodeString(&u); } break; } return PyErr_SetArgsError((PyObject *) self, "formatMeasure", args); } // Limited to one measure since 'new Measure[len]' is forbidden because // Measure() is protected. static PyObject *t_measureformat_formatMeasures(t_measureformat *self, PyObject *args) { Measure **measures = NULL; int len; FieldPosition dont_care(FieldPosition::DONT_CARE); FieldPosition *fp; UnicodeString u; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "Q", TYPE_CLASSID(Measure), &measures, &len, TYPE_CLASSID(Measure))) { if (len != 1) { free(measures); break; } STATUS_CALL( { self->object->formatMeasures( measures[0], 1, u, dont_care, status); free(measures); }); return PyUnicode_FromUnicodeString(&u); } break; case 2: if (!parseArgs(args, "QP", TYPE_CLASSID(Measure), TYPE_CLASSID(FieldPosition), &measures, &len, TYPE_CLASSID(Measure), &fp)) { if (len != 1) { free(measures); break; } STATUS_CALL( { self->object->formatMeasures( measures[0], 1, u, *fp, status); free(measures); }); return PyUnicode_FromUnicodeString(&u); } break; } return PyErr_SetArgsError((PyObject *) self, "formatMeasures", args); } #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(55, 0, 0) static PyObject *t_measureformat_formatMeasurePerUnit(t_measureformat *self, PyObject *args) { Measure *measure; MeasureUnit *unit; FieldPosition *fp; UnicodeString u; FieldPosition dont_care(FieldPosition::DONT_CARE); switch (PyTuple_Size(args)) { case 2: if (!parseArgs(args, "PP", TYPE_CLASSID(Measure), TYPE_CLASSID(MeasureUnit), &measure, &unit)) { STATUS_CALL(self->object->formatMeasurePerUnit( *measure, *unit, u, dont_care, status)); return PyUnicode_FromUnicodeString(&u); } break; case 3: if (!parseArgs(args, "PPP", TYPE_CLASSID(Measure), TYPE_CLASSID(MeasureUnit), TYPE_CLASSID(FieldPosition), &measure, &unit, &fp)) { STATUS_CALL(self->object->formatMeasurePerUnit( *measure, *unit, u, *fp, status)); return PyUnicode_FromUnicodeString(&u); } break; } return PyErr_SetArgsError((PyObject *) self, "formatMeasurePerUnit", args); } #endif #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++) { if (formats[i] == NULL) { PyList_SET_ITEM(list, i, Py_None); Py_INCREF(Py_None); } else { 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); } #if U_ICU_VERSION_HEX >= 0x04000000 static PyObject *t_messageformat_getFormatNames(t_messageformat *self) { StringEnumeration *se; STATUS_CALL(se = self->object->getFormatNames(status)); return wrap_StringEnumeration(se, T_OWNED); } #endif 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); } DEFINE_RICHCMP(PluralRules, t_pluralrules); /* PluralFormat */ static int t_pluralformat_init(t_pluralformat *self, PyObject *args, PyObject *kwds) { Locale *locale; PluralRules *rules; UnicodeString *u, _u; switch (PyTuple_Size(args)) { case 0: INT_STATUS_CALL(self->object = new PluralFormat(status)); self->flags = T_OWNED; break; case 1: if (!parseArgs(args, "P", TYPE_CLASSID(Locale), &locale)) { INT_STATUS_CALL(self->object = new PluralFormat(*locale, status)); self->flags = T_OWNED; break; } if (!parseArgs(args, "P", TYPE_CLASSID(PluralRules), &rules)) { INT_STATUS_CALL(self->object = new PluralFormat(*rules, status)); self->flags = T_OWNED; break; } if (!parseArgs(args, "S", &u, &_u)) { INT_STATUS_CALL(self->object = new PluralFormat(*u, status)); self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; case 2: if (!parseArgs(args, "PP", TYPE_CLASSID(Locale), TYPE_CLASSID(PluralRules), &locale, &rules)) { INT_STATUS_CALL(self->object = new PluralFormat(*locale, *rules, status)); self->flags = T_OWNED; break; } if (!parseArgs(args, "PS", TYPE_CLASSID(Locale), &locale, &u, &_u)) { INT_STATUS_CALL(self->object = new PluralFormat(*locale, *u, status)); self->flags = T_OWNED; break; } if (!parseArgs(args, "PS", TYPE_CLASSID(PluralRules), &rules, &u, &_u)) { INT_STATUS_CALL(self->object = new PluralFormat(*rules, *u, status)); self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; case 3: if (!parseArgs(args, "PPS", TYPE_CLASSID(Locale), TYPE_CLASSID(PluralRules), &locale, &rules, &u, &_u)) { INT_STATUS_CALL(self->object = new PluralFormat(*locale, *rules, *u, status)); self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; default: PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; } if (self->object) return 0; return -1; } static PyObject *t_pluralformat_setLocale(t_pluralformat *self, PyObject *arg) { Locale *locale; if (!parseArg(arg, "P", TYPE_CLASSID(Locale), &locale)) { STATUS_CALL(self->object->setLocale(*locale, status)); /* copied */ Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setLocale", arg); } static PyObject *t_pluralformat_setNumberFormat(t_pluralformat *self, PyObject *arg) { NumberFormat *format; if (!parseArg(arg, "p", TYPE_CLASSID(NumberFormat), &format, &self->numberformat)) /* ref'd */ { STATUS_CALL(self->object->setNumberFormat(format, status)); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setNumberFormat", arg); } static PyObject *t_pluralformat_toPattern(t_pluralformat *self, PyObject *args) { UnicodeString *u, _u; switch (PyTuple_Size(args)) { case 0: self->object->toPattern(_u); return PyUnicode_FromUnicodeString(&_u); case 1: if (!parseArgs(args, "U", &u)) { self->object->toPattern(*u); Py_RETURN_ARG(args, 0); } break; } return PyErr_SetArgsError((PyObject *) self, "toPattern", args); } static PyObject *t_pluralformat_applyPattern(t_pluralformat *self, PyObject *arg) { UnicodeString *u, _u; if (!parseArg(arg, "S", &u, &_u)) { STATUS_CALL(self->object->applyPattern(*u, status)); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "applyPattern", arg); } static PyObject *t_pluralformat_format(t_pluralformat *self, PyObject *args) { UnicodeString *u, _u; FieldPosition *fp, _fp; double d; int n; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "i", &n)) { STATUS_CALL(_u = self->object->format(n, status)); return PyUnicode_FromUnicodeString(&_u); } if (!parseArgs(args, "d", &d)) { STATUS_CALL(_u = self->object->format(d, status)); return PyUnicode_FromUnicodeString(&_u); } break; case 2: if (!parseArgs(args, "iS", &n, &u, &_u)) { STATUS_CALL(self->object->format(n, *u, _fp, status)); Py_RETURN_ARG(args, 1); } if (!parseArgs(args, "dS", &d, &u, &_u)) { STATUS_CALL(self->object->format(d, *u, _fp, status)); Py_RETURN_ARG(args, 1); } break; case 3: if (!parseArgs(args, "iSP", TYPE_CLASSID(FieldPosition), &n, &u, &_u, &fp)) { STATUS_CALL(self->object->format(n, *u, *fp, status)); Py_RETURN_ARG(args, 1); } if (!parseArgs(args, "dSP", TYPE_CLASSID(FieldPosition), &d, &u, &_u, &fp)) { STATUS_CALL(self->object->format(d, *u, *fp, status)); Py_RETURN_ARG(args, 1); } break; } return t_format_format((t_format *) self, args); } static PyObject *t_pluralformat_str(t_pluralformat *self) { UnicodeString u; self->object->toPattern(u); return PyUnicode_FromUnicodeString(&u); } #endif #if U_ICU_VERSION_HEX >= 0x04040000 /* SelectFormat */ static int t_selectformat_init(t_selectformat *self, PyObject *args, PyObject *kwds) { UnicodeString *u, _u; if (!parseArgs(args, "S", &u, &_u)) { SelectFormat *format; INT_STATUS_CALL(format = new SelectFormat(*u, status)); self->object = format; self->flags = T_OWNED; return 0; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; } static PyObject *t_selectformat_applyPattern(t_selectformat *self, PyObject *arg) { UnicodeString *u, _u; if (!parseArg(arg, "S", &u, &_u)) { STATUS_CALL(self->object->applyPattern(*u, status)); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "applyPattern", arg); } static PyObject *t_selectformat_toPattern(t_selectformat *self, PyObject *args) { UnicodeString *u, _u; switch (PyTuple_Size(args)) { case 0: self->object->toPattern(_u); return PyUnicode_FromUnicodeString(&_u); case 1: if (!parseArgs(args, "U", &u)) { self->object->toPattern(*u); Py_RETURN_ARG(args, 0); } break; } return PyErr_SetArgsError((PyObject *) self, "toPattern", args); } PyObject *t_selectformat_format(t_selectformat *self, PyObject *args) { UnicodeString *u0, _u0; UnicodeString *u1, _u1; Formattable *obj; FieldPosition *fp, _fp; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "P", TYPE_CLASSID(Formattable), &obj)) { STATUS_CALL(self->object->format(*obj, _u1, _fp, status)); return PyUnicode_FromUnicodeString(&_u1); } break; if (!parseArgs(args, "S", &u0, &_u0, &obj)) { STATUS_CALL(self->object->format(*u0, _u1, _fp, status)); return PyUnicode_FromUnicodeString(&_u1); } break; case 2: if (!parseArgs(args, "PU", TYPE_CLASSID(Formattable), &obj, &u1)) { STATUS_CALL(self->object->format(*obj, *u1, _fp, status)); Py_RETURN_ARG(args, 1); } if (!parseArgs(args, "SU", &u0, &_u0, &u1)) { STATUS_CALL(self->object->format(*u0, *u1, _fp, status)); Py_RETURN_ARG(args, 1); } if (!parseArgs(args, "PP", TYPE_CLASSID(Formattable), TYPE_CLASSID(FieldPosition), &obj, &fp)) { STATUS_CALL(self->object->format(*obj, _u1, *fp, status)); return PyUnicode_FromUnicodeString(&_u1); } if (!parseArgs(args, "SP", TYPE_CLASSID(FieldPosition), &u0, &_u0, &fp)) { STATUS_CALL(self->object->format(*u0, _u1, *fp, status)); return PyUnicode_FromUnicodeString(&_u1); } break; case 3: if (!parseArgs(args, "PUP", TYPE_CLASSID(Formattable), TYPE_CLASSID(FieldPosition), &obj, &u1, &fp)) { STATUS_CALL(self->object->format(*obj, *u1, *fp, status)); Py_RETURN_ARG(args, 1); } if (!parseArgs(args, "SUP", TYPE_CLASSID(FieldPosition), &u0, &_u0, &u1, &fp)) { STATUS_CALL(self->object->format(*u0, *u1, *fp, status)); Py_RETURN_ARG(args, 1); } break; } return PyErr_SetArgsError((PyObject *) self, "format", args); } static PyObject *t_selectformat_parseObject(t_selectformat *self, PyObject *args) { PyErr_SetString(PyExc_NotImplementedError, "SelectFormat.parseObject()"); return NULL; } static PyObject *t_selectformat_str(t_selectformat *self) { UnicodeString u; self->object->toPattern(u); return PyUnicode_FromUnicodeString(&u); } #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(50, 0, 0) /* ListFormatter */ static PyObject *t_listformatter_format(t_listformatter *self, PyObject *arg) { UnicodeString *array; int count; if (!parseArg(arg, "T", &array, &count)) { UnicodeString u; STATUS_CALL(self->object->format(array, (int32_t) count, u, status)); return PyUnicode_FromUnicodeString(&u); } return PyErr_SetArgsError((PyObject *) self, "format", arg); } static PyObject *t_listformatter_createInstance(PyTypeObject *type, PyObject *args) { ListFormatter *formatter; Locale *locale; switch (PyTuple_Size(args)) { case 0: STATUS_CALL(formatter = ListFormatter::createInstance(status)); return wrap_ListFormatter(formatter, T_OWNED); case 1: if (!parseArgs(args, "P", TYPE_CLASSID(Locale), &locale)) { STATUS_CALL(formatter = ListFormatter::createInstance( *locale, status)); return wrap_ListFormatter(formatter, T_OWNED); } break; } return PyErr_SetArgsError(type, "createInstance", args); } #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(57, 0, 0) static int t_simpleformatter_init(t_simpleformatter *self, PyObject *args, PyObject *kwds) { UnicodeString *u, _u; int n0, n1; switch (PyTuple_Size(args)) { case 0: self->object = new SimpleFormatter(); self->pattern = Py_None; Py_INCREF(self->pattern); self->flags = T_OWNED; return 0; case 1: if (!parseArgs(args, "S", &u, &_u)) { SimpleFormatter *formatter; INT_STATUS_CALL(formatter = new SimpleFormatter(*u, status)); self->object = formatter; self->pattern = PyUnicode_FromUnicodeString(u); self->flags = T_OWNED; return 0; } break; case 3: if (!parseArgs(args, "Sii", &u, &_u, &n0, &n1)) { SimpleFormatter *formatter; INT_STATUS_CALL( formatter = new SimpleFormatter(*u, n0, n1, status)); self->object = formatter; self->pattern = PyUnicode_FromUnicodeString(u); self->flags = T_OWNED; return 0; } break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; } static PyObject *t_simpleformatter_str(t_simpleformatter *self) { Py_INCREF(self->pattern); return self->pattern; } static PyObject *t_simpleformatter_applyPattern( t_simpleformatter *self, PyObject *arg) { UnicodeString *u, _u; if (!parseArg(arg, "S", &u, &_u)) { UBool result; STATUS_CALL(result = self->object->applyPattern(*u, status)); Py_DECREF(self->pattern); self->pattern = PyUnicode_FromUnicodeString(u); Py_RETURN_BOOL(result); } return PyErr_SetArgsError((PyObject *) self, "applyPattern", arg); } static PyObject *t_simpleformatter_applyPatternMinMaxArguments( t_simpleformatter *self, PyObject *args) { UnicodeString *u, _u; int n0, n1; switch (PyTuple_Size(args)) { case 3: if (!parseArgs(args, "Sii", &u, &_u, &n0, &n1)) { UBool result; STATUS_CALL(result = self->object->applyPatternMinMaxArguments( *u, n0, n1, status)); Py_DECREF(self->pattern); self->pattern = PyUnicode_FromUnicodeString(u); Py_RETURN_BOOL(result); } break; } return PyErr_SetArgsError((PyObject *) self, "applyPatternMinMaxArguments", args); } static PyObject *t_simpleformatter_getArgumentLimit( t_simpleformatter *self, PyObject *args) { return PyInt_FromLong(self->object->getArgumentLimit()); } static PyObject *t_simpleformatter_format( t_simpleformatter *self, PyObject *args) { UnicodeString *u0, *u1, *u2, _u0, _u1, _u2; UnicodeString u; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "S", &u0, &_u0)) { STATUS_CALL(u = self->object->format(*u0, u, status)); return PyUnicode_FromUnicodeString(&u); } break; case 2: if (!parseArgs(args, "SS", &u0, &_u0, &u1, &_u1)) { STATUS_CALL(u = self->object->format(*u0, *u1, u, status)); return PyUnicode_FromUnicodeString(&u); } break; case 3: if (!parseArgs(args, "SSS", &u0, &_u0, &u1, &_u1, &u2, &_u2)) { STATUS_CALL(u = self->object->format(*u0, *u1, *u2, u, status)); return PyUnicode_FromUnicodeString(&u); } break; } return PyErr_SetArgsError((PyObject *) self, "format", args); } static PyObject *t_simpleformatter_formatStrings( t_simpleformatter *self, PyObject *arg) { UnicodeString *strings, u; int count; if (!parseArg(arg, "T", &strings, &count)) { UnicodeString **args = new UnicodeString *[count]; for (int i = 0; i < count; ++i) args[i] = &strings[i]; STATUS_CALL( u = self->object->formatAndAppend(args, count, u, NULL, 0, status); delete[] args; delete[] strings); return PyUnicode_FromUnicodeString(&u); } return PyErr_SetArgsError((PyObject *) self, "formatStrings", arg); } #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 #if U_ICU_VERSION_HEX >= VERSION_HEX(57, 0, 0) SimpleFormatterType_.tp_str = (reprfunc) t_simpleformatter_str; SimpleFormatterType_.tp_as_number = &t_simpleformatter_as_number; SimpleFormatterType_.tp_flags |= Py_TPFLAGS_CHECKTYPES; #endif REGISTER_TYPE(FieldPosition, m); REGISTER_TYPE(ParsePosition, m); INSTALL_TYPE(Format, m); INSTALL_TYPE(MeasureFormat, m); REGISTER_TYPE(MessageFormat, m); #if U_ICU_VERSION_HEX >= 0x04000000 REGISTER_TYPE(PluralRules, m); REGISTER_TYPE(PluralFormat, m); #endif #if U_ICU_VERSION_HEX >= 0x04020000 REGISTER_TYPE(TimeUnitFormat, m); #endif #if U_ICU_VERSION_HEX >= 0x04040000 REGISTER_TYPE(SelectFormat, m); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(50, 0, 0) INSTALL_TYPE(ListFormatter, m); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(57, 0, 0) INSTALL_STRUCT(SimpleFormatter, 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 } ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1430285460.0 PyICU-2.4.2/format.h0000644000076500000000000000346600000000000014326 0ustar00vajdawheel00000000000000/* ==================================================================== * 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 */ ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1569892274.0 PyICU-2.4.2/gender.cpp0000644000076500000000000000630700000000000014632 0ustar00vajdawheel00000000000000/* ==================================================================== * Copyright (c) 2019 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 "gender.h" #include "locale.h" #include "macros.h" #if U_ICU_VERSION_HEX >= VERSION_HEX(50, 0, 0) DECLARE_CONSTANTS_TYPE(UGender); /* GenderInfo */ class t_genderinfo : public _wrapper { public: GenderInfo *object; }; static PyObject *t_genderinfo_getInstance(PyTypeObject *type, PyObject *arg); static PyObject *t_genderinfo_getListGender(t_genderinfo *self, PyObject *arg); static PyMethodDef t_genderinfo_methods[] = { DECLARE_METHOD(t_genderinfo, getInstance, METH_O | METH_CLASS), DECLARE_METHOD(t_genderinfo, getListGender, METH_O), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(GenderInfo, t_genderinfo, UObject, GenderInfo, abstract_init, NULL); /* GenderInfo */ static PyObject *t_genderinfo_getInstance(PyTypeObject *type, PyObject *arg) { Locale *locale; if (!parseArg(arg, "P", TYPE_CLASSID(Locale), &locale)) { const GenderInfo *result; STATUS_CALL(result = GenderInfo::getInstance(*locale, status)); return wrap_GenderInfo(const_cast(result), 0); } return PyErr_SetArgsError(type, "getInstance", arg); } static PyObject *t_genderinfo_getListGender(t_genderinfo *self, PyObject *arg) { UGender *genders; int len; if (!parseArg(arg, "H", &genders, &len)) { UGender result; STATUS_CALL( { result = self->object->getListGender(genders, len, status); delete[] genders; }); return PyInt_FromLong(result); } return PyErr_SetArgsError((PyObject *) self, "getListGender", arg); } #endif void _init_gender(PyObject *m) { #if U_ICU_VERSION_HEX >= VERSION_HEX(50, 0, 0) INSTALL_CONSTANTS_TYPE(UGender, m); REGISTER_TYPE(GenderInfo, m); INSTALL_ENUM(UGender, "MALE", UGENDER_MALE); INSTALL_ENUM(UGender, "FEMALE", UGENDER_FEMALE); INSTALL_ENUM(UGender, "OTHER", UGENDER_OTHER); #endif } ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1569865023.0 PyICU-2.4.2/gender.h0000644000076500000000000000254200000000000014274 0ustar00vajdawheel00000000000000/* ==================================================================== * Copyright (c) 2019 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 _gender_h #define _gender_h void _init_gender(PyObject *m); #endif /* _gender_h */ ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1573605241.8142097 PyICU-2.4.2/icu/0000755000076500000000000000000000000000000013434 5ustar00vajdawheel00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1571427709.0 PyICU-2.4.2/icu/__init__.py0000644000076500000000000000301100000000000015540 0ustar00vajdawheel00000000000000 # ==================================================================== # Copyright (c) 2004-2018 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 _icu import * ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1482176757.0 PyICU-2.4.2/idna.cpp0000644000076500000000000002215200000000000014275 0ustar00vajdawheel00000000000000/* ==================================================================== * Copyright (c) 2004-2015 Open Source Applications Foundation. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. * ==================================================================== */ #include #include #include "common.h" #include "structmember.h" #include "bases.h" #include "idna.h" #include "macros.h" #if U_ICU_VERSION_HEX >= VERSION_HEX(55, 1, 0) /* IDNAInfo */ class t_idnainfo : public _wrapper { public: UIDNAInfo *object; UIDNAInfo info; }; static int t_idnainfo_init(t_idnainfo *self, PyObject *args, PyObject *kwds); static PyObject *t_idnainfo_isTransitionalDifferent(t_idnainfo *self); static PyObject *t_idnainfo_errors(t_idnainfo *self); static PyMethodDef t_idnainfo_methods[] = { DECLARE_METHOD(t_idnainfo, isTransitionalDifferent, METH_NOARGS), DECLARE_METHOD(t_idnainfo, errors, METH_NOARGS), { NULL, NULL, 0, NULL } }; static void t_idnainfo_dealloc(t_idnainfo *self) { Py_TYPE(self)->tp_free((PyObject *) self); } DECLARE_STRUCT(IDNAInfo, t_idnainfo, UIDNAInfo, t_idnainfo_init, t_idnainfo_dealloc); /* IDNA */ class t_idna : public _wrapper { public: UIDNA *object; }; typedef int32_t (*idna_fn)( const UIDNA *idna, const UChar *text, int32_t len, UChar *dest, int capacity, UIDNAInfo *info, UErrorCode *status); static int t_idna_init(t_idna *self, PyObject *args, PyObject *kwds); static PyObject *t_idna_labelToASCII(t_idna *self, PyObject *args); static PyObject *t_idna_labelToUnicode(t_idna *self, PyObject *args); static PyObject *t_idna_nameToASCII(t_idna *self, PyObject *args); static PyObject *t_idna_nameToUnicode(t_idna *self, PyObject *args); static PyMethodDef t_idna_methods[] = { DECLARE_METHOD(t_idna, labelToASCII, METH_VARARGS), DECLARE_METHOD(t_idna, labelToUnicode, METH_VARARGS), DECLARE_METHOD(t_idna, nameToASCII, METH_VARARGS), DECLARE_METHOD(t_idna, nameToUnicode, METH_VARARGS), { NULL, NULL, 0, NULL } }; static void t_idna_dealloc(t_idna *self) { if (self->object != NULL) { uidna_close(self->object); self->object = NULL; } Py_TYPE(self)->tp_free((PyObject *) self); } DECLARE_STRUCT(IDNA, t_idna, UIDNA, t_idna_init, t_idna_dealloc); /* IDNAInfo */ static int t_idnainfo_init(t_idnainfo *self, PyObject *args, PyObject *kwds) { switch (PyTuple_Size(args)) { case 0: memset(&self->info, 0, sizeof(UIDNAInfo)); self->info.size = sizeof(UIDNAInfo); self->object = &self->info; self->flags = T_OWNED; return 0; default: PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; } } static PyObject *t_idnainfo_isTransitionalDifferent(t_idnainfo *self) { Py_RETURN_BOOL(self->info.isTransitionalDifferent); } static PyObject *t_idnainfo_errors(t_idnainfo *self) { return PyInt_FromLong(self->info.errors); } /* IDNA */ static int t_idna_init(t_idna *self, PyObject *args, PyObject *kwds) { uint32_t options; switch (PyTuple_Size(args)) { case 0: INT_STATUS_CALL(self->object = uidna_openUTS46(UIDNA_DEFAULT, &status)); self->flags = T_OWNED; return 0; case 1: if (!parseArgs(args, "i", &options)) { INT_STATUS_CALL(self->object = uidna_openUTS46(options, &status)); self->flags = T_OWNED; return 0; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; default: PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; } } static PyObject *apply(idna_fn fn, const char *fn_name, t_idna *self, PyObject *args) { UnicodeString *u; UnicodeString _u; t_idnainfo *infoArg; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "S", &u, &_u)) { const int32_t len = u->length(); const int32_t capacity = len * 4 + 32; UErrorCode status = U_ZERO_ERROR; UChar *dest = new UChar[capacity]; UIDNAInfo info = UIDNA_INFO_INITIALIZER; PyObject *result; int32_t size; if (!dest) { PyErr_SetNone(PyExc_MemoryError); return NULL; } size = (*fn)(self->object, u->getBuffer(), len, dest, capacity, &info, &status); if (U_FAILURE(status)) { delete[] dest; return ICUException(status).reportError(); } result = PyUnicode_FromUnicodeString(dest, size); delete[] dest; return result; } break; case 2: if (!parseArgs(args, "SO", &IDNAInfoType_, &u, &_u, &infoArg)) { const int32_t len = u->length(); const int32_t capacity = len * 4 + 32; UErrorCode status = U_ZERO_ERROR; UChar *dest = new UChar[capacity]; PyObject *result; int32_t size; if (!dest) { PyErr_SetNone(PyExc_MemoryError); return NULL; } size = (*fn)(self->object, u->getBuffer(), len, dest, capacity, infoArg->object, &status); if (U_FAILURE(status)) { delete[] dest; return ICUException(status).reportError(); } result = PyUnicode_FromUnicodeString(dest, size); delete[] dest; return result; } break; } return PyErr_SetArgsError((PyObject *) self, fn_name, args); } static PyObject *t_idna_labelToASCII(t_idna *self, PyObject *args) { return apply(uidna_labelToASCII, "labelToASCII", self, args); } static PyObject *t_idna_labelToUnicode(t_idna *self, PyObject *args) { return apply(uidna_labelToUnicode, "labelToUnicode", self, args); } static PyObject *t_idna_nameToASCII(t_idna *self, PyObject *args) { return apply(uidna_nameToASCII, "nameToASCII", self, args); } static PyObject *t_idna_nameToUnicode(t_idna *self, PyObject *args) { return apply(uidna_nameToUnicode, "nameToUnicode", self, args); } #endif void _init_idna(PyObject *m) { #if U_ICU_VERSION_HEX >= VERSION_HEX(55, 1, 0) INSTALL_STRUCT(IDNAInfo, m); INSTALL_STRUCT(IDNA, m); INSTALL_ENUM(IDNAInfo, "ERROR_EMPTY_LABEL", UIDNA_ERROR_EMPTY_LABEL); INSTALL_ENUM(IDNAInfo, "ERROR_LABEL_TOO_LONG", UIDNA_ERROR_LABEL_TOO_LONG); INSTALL_ENUM(IDNAInfo, "ERROR_DOMAIN_NAME_TOO_LONG", UIDNA_ERROR_DOMAIN_NAME_TOO_LONG); INSTALL_ENUM(IDNAInfo, "ERROR_LEADING_HYPHEN", UIDNA_ERROR_LEADING_HYPHEN); INSTALL_ENUM(IDNAInfo, "ERROR_TRAILING_HYPHEN", UIDNA_ERROR_TRAILING_HYPHEN); INSTALL_ENUM(IDNAInfo, "ERROR_HYPHEN_3_4", UIDNA_ERROR_HYPHEN_3_4); INSTALL_ENUM(IDNAInfo, "ERROR_LEADING_COMBINING_MARK", UIDNA_ERROR_LEADING_COMBINING_MARK); INSTALL_ENUM(IDNAInfo, "ERROR_DISALLOWED", UIDNA_ERROR_DISALLOWED); INSTALL_ENUM(IDNAInfo, "ERROR_PUNYCODE", UIDNA_ERROR_PUNYCODE); INSTALL_ENUM(IDNAInfo, "ERROR_LABEL_HAS_DOT", UIDNA_ERROR_LABEL_HAS_DOT); INSTALL_ENUM(IDNAInfo, "ERROR_INVALID_ACE_LABEL", UIDNA_ERROR_INVALID_ACE_LABEL); INSTALL_ENUM(IDNAInfo, "ERROR_BIDI", UIDNA_ERROR_BIDI); INSTALL_ENUM(IDNAInfo, "ERROR_CONTEXTJ", UIDNA_ERROR_CONTEXTJ); INSTALL_ENUM(IDNAInfo, "ERROR_CONTEXTO_PUNCTUATION", UIDNA_ERROR_CONTEXTO_PUNCTUATION); INSTALL_ENUM(IDNAInfo, "ERROR_CONTEXTO_DIGITS", UIDNA_ERROR_CONTEXTO_DIGITS); INSTALL_ENUM(IDNA, "DEFAULT", UIDNA_DEFAULT); INSTALL_ENUM(IDNA, "USE_STD3_RULES", UIDNA_USE_STD3_RULES); INSTALL_ENUM(IDNA, "CHECK_BIDI", UIDNA_CHECK_BIDI); INSTALL_ENUM(IDNA, "CHECK_CONTEXTJ", UIDNA_CHECK_CONTEXTJ); INSTALL_ENUM(IDNA, "CHECK_NONTRANSITIONAL_TO_ASCII", UIDNA_NONTRANSITIONAL_TO_ASCII); INSTALL_ENUM(IDNA, "CHECK_NONTRANSITIONAL_TO_UNICODE", UIDNA_NONTRANSITIONAL_TO_UNICODE); INSTALL_ENUM(IDNA, "CHECK_CONTEXT0", UIDNA_CHECK_CONTEXTO); #endif } ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1430286248.0 PyICU-2.4.2/idna.h0000644000076500000000000000264200000000000013744 0ustar00vajdawheel00000000000000/* ==================================================================== * Copyright (c) 2004-2015 Open Source Applications Foundation. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. * ==================================================================== */ #ifndef _idna_h #define _idna_h extern PyTypeObject IDNAInfoType_; extern PyTypeObject IDNAType_; void _init_idna(PyObject *m); #endif /* _idna_h */ ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1573497547.0 PyICU-2.4.2/iterators.cpp0000644000076500000000000013402200000000000015376 0ustar00vajdawheel00000000000000/* ==================================================================== * Copyright (c) 2004-2019 Open Source Applications Foundation. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. * ==================================================================== */ #include "common.h" #include "structmember.h" #include "bases.h" #include "locale.h" #include "iterators.h" #include "macros.h" /* ForwardCharacterIterator */ class t_forwardcharacteriterator : public _wrapper { public: ForwardCharacterIterator *object; }; static PyObject *t_forwardcharacteriterator_nextPostInc(t_forwardcharacteriterator *self); static PyObject *t_forwardcharacteriterator_next32PostInc(t_forwardcharacteriterator *self); static PyObject *t_forwardcharacteriterator_hasNext(t_forwardcharacteriterator *self); static PyMethodDef t_forwardcharacteriterator_methods[] = { DECLARE_METHOD(t_forwardcharacteriterator, nextPostInc, METH_NOARGS), DECLARE_METHOD(t_forwardcharacteriterator, next32PostInc, METH_NOARGS), DECLARE_METHOD(t_forwardcharacteriterator, hasNext, METH_NOARGS), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(ForwardCharacterIterator, t_forwardcharacteriterator, UObject, ForwardCharacterIterator, abstract_init, NULL); /* CharacterIterator */ class t_characteriterator : public _wrapper { public: CharacterIterator *object; }; static PyObject *t_characteriterator_first(t_characteriterator *self); static PyObject *t_characteriterator_firstPostInc(t_characteriterator *self); static PyObject *t_characteriterator_first32(t_characteriterator *self); static PyObject *t_characteriterator_first32PostInc(t_characteriterator *self); static PyObject *t_characteriterator_last(t_characteriterator *self); static PyObject *t_characteriterator_last32(t_characteriterator *self); static PyObject *t_characteriterator_current(t_characteriterator *self); static PyObject *t_characteriterator_current32(t_characteriterator *self); static PyObject *t_characteriterator_next(t_characteriterator *self); static PyObject *t_characteriterator_next32(t_characteriterator *self); static PyObject *t_characteriterator_previous(t_characteriterator *self); static PyObject *t_characteriterator_previous32(t_characteriterator *self); static PyObject *t_characteriterator_setToStart(t_characteriterator *self); static PyObject *t_characteriterator_setToEnd(t_characteriterator *self); static PyObject *t_characteriterator_setIndex(t_characteriterator *self, PyObject *arg); static PyObject *t_characteriterator_setIndex32(t_characteriterator *self, PyObject *arg); static PyObject *t_characteriterator_hasPrevious(t_characteriterator *self); static PyObject *t_characteriterator_startIndex(t_characteriterator *self); static PyObject *t_characteriterator_endIndex(t_characteriterator *self); static PyObject *t_characteriterator_getIndex(t_characteriterator *self); static PyObject *t_characteriterator_getLength(t_characteriterator *self); static PyObject *t_characteriterator_move(t_characteriterator *self, PyObject *args); static PyObject *t_characteriterator_getText(t_characteriterator *self, PyObject *args); static PyMethodDef t_characteriterator_methods[] = { DECLARE_METHOD(t_characteriterator, first, METH_NOARGS), DECLARE_METHOD(t_characteriterator, firstPostInc, METH_NOARGS), DECLARE_METHOD(t_characteriterator, first32, METH_NOARGS), DECLARE_METHOD(t_characteriterator, first32PostInc, METH_NOARGS), DECLARE_METHOD(t_characteriterator, last, METH_NOARGS), DECLARE_METHOD(t_characteriterator, last32, METH_NOARGS), DECLARE_METHOD(t_characteriterator, current, METH_NOARGS), DECLARE_METHOD(t_characteriterator, current32, METH_NOARGS), DECLARE_METHOD(t_characteriterator, next, METH_NOARGS), DECLARE_METHOD(t_characteriterator, next32, METH_NOARGS), DECLARE_METHOD(t_characteriterator, previous, METH_NOARGS), DECLARE_METHOD(t_characteriterator, previous32, METH_NOARGS), DECLARE_METHOD(t_characteriterator, setToStart, METH_NOARGS), DECLARE_METHOD(t_characteriterator, setToEnd, METH_NOARGS), DECLARE_METHOD(t_characteriterator, setIndex, METH_O), DECLARE_METHOD(t_characteriterator, setIndex32, METH_O), DECLARE_METHOD(t_characteriterator, hasPrevious, METH_NOARGS), DECLARE_METHOD(t_characteriterator, startIndex, METH_NOARGS), DECLARE_METHOD(t_characteriterator, endIndex, METH_NOARGS), DECLARE_METHOD(t_characteriterator, getIndex, METH_NOARGS), DECLARE_METHOD(t_characteriterator, getLength, METH_NOARGS), DECLARE_METHOD(t_characteriterator, move, METH_VARARGS), DECLARE_METHOD(t_characteriterator, getText, METH_VARARGS), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(CharacterIterator, t_characteriterator, ForwardCharacterIterator, CharacterIterator, abstract_init, NULL); /* UCharCharacterIterator */ class t_ucharcharacteriterator : public _wrapper { public: UCharCharacterIterator *object; PyObject *text; }; static int t_ucharcharacteriterator_init(t_ucharcharacteriterator *self, PyObject *args, PyObject *kwds); static PyObject *t_ucharcharacteriterator_setText(t_ucharcharacteriterator *self, PyObject *args); static PyMethodDef t_ucharcharacteriterator_methods[] = { DECLARE_METHOD(t_ucharcharacteriterator, setText, METH_VARARGS), { NULL, NULL, 0, NULL } }; static void t_ucharcharacteriterator_dealloc(t_ucharcharacteriterator *self) { if (self->flags & T_OWNED) delete self->object; self->object = NULL; Py_CLEAR(self->text); Py_TYPE(self)->tp_free((PyObject *) self); } DECLARE_TYPE(UCharCharacterIterator, t_ucharcharacteriterator, CharacterIterator, UCharCharacterIterator, t_ucharcharacteriterator_init, t_ucharcharacteriterator_dealloc); /* StringCharacterIterator */ class t_stringcharacteriterator : public _wrapper { public: StringCharacterIterator *object; }; static int t_stringcharacteriterator_init(t_stringcharacteriterator *self, PyObject *args, PyObject *kwds); static PyObject *t_stringcharacteriterator_setText(t_stringcharacteriterator *self, PyObject *args); static PyMethodDef t_stringcharacteriterator_methods[] = { DECLARE_METHOD(t_stringcharacteriterator, setText, METH_VARARGS), { NULL, NULL, 0, NULL } }; static void t_stringcharacteriterator_dealloc(t_stringcharacteriterator *self) { if (self->flags & T_OWNED) delete self->object; self->object = NULL; Py_TYPE(self)->tp_free((PyObject *) self); } DECLARE_TYPE(StringCharacterIterator, t_stringcharacteriterator, UCharCharacterIterator, StringCharacterIterator, t_stringcharacteriterator_init, t_stringcharacteriterator_dealloc); /* BreakIterator */ class t_breakiterator : public _wrapper { public: BreakIterator *object; PyObject *text; }; static PyObject *t_breakiterator_getText(t_breakiterator *self); static PyObject *t_breakiterator_setText(t_breakiterator *self, PyObject *arg); static PyObject *t_breakiterator_first(t_breakiterator *self); static PyObject *t_breakiterator_last(t_breakiterator *self); static PyObject *t_breakiterator_previous(t_breakiterator *self); static PyObject *t_breakiterator_nextBoundary(t_breakiterator *self, PyObject *args); static PyObject *t_breakiterator_current(t_breakiterator *self); static PyObject *t_breakiterator_following(t_breakiterator *self, PyObject *arg); static PyObject *t_breakiterator_preceding(t_breakiterator *self, PyObject *arg); static PyObject *t_breakiterator_isBoundary(t_breakiterator *self, PyObject *arg); static PyObject *t_breakiterator_getLocale(t_breakiterator *self, PyObject *args); static PyObject *t_breakiterator_getLocaleID(t_breakiterator *self, PyObject *args); static PyObject *t_breakiterator_createWordInstance(PyTypeObject *type, PyObject *arg); static PyObject *t_breakiterator_createLineInstance(PyTypeObject *type, PyObject *arg); static PyObject *t_breakiterator_createCharacterInstance(PyTypeObject *type, PyObject *arg); static PyObject *t_breakiterator_createSentenceInstance(PyTypeObject *type, PyObject *arg); static PyObject *t_breakiterator_createTitleInstance(PyTypeObject *type, PyObject *arg); static PyObject *t_breakiterator_getAvailableLocales(PyTypeObject *type); static PyObject *t_breakiterator_getDisplayName(PyTypeObject *type, PyObject *args); static PyMethodDef t_breakiterator_methods[] = { DECLARE_METHOD(t_breakiterator, getText, METH_NOARGS), DECLARE_METHOD(t_breakiterator, setText, METH_O), DECLARE_METHOD(t_breakiterator, first, METH_NOARGS), DECLARE_METHOD(t_breakiterator, last, METH_NOARGS), DECLARE_METHOD(t_breakiterator, previous, METH_NOARGS), DECLARE_METHOD(t_breakiterator, nextBoundary, METH_VARARGS), DECLARE_METHOD(t_breakiterator, current, METH_NOARGS), DECLARE_METHOD(t_breakiterator, following, METH_O), DECLARE_METHOD(t_breakiterator, preceding, METH_O), DECLARE_METHOD(t_breakiterator, isBoundary, METH_O), DECLARE_METHOD(t_breakiterator, getLocale, METH_VARARGS), DECLARE_METHOD(t_breakiterator, getLocaleID, METH_VARARGS), DECLARE_METHOD(t_breakiterator, createWordInstance, METH_O | METH_CLASS), DECLARE_METHOD(t_breakiterator, createLineInstance, METH_O | METH_CLASS), DECLARE_METHOD(t_breakiterator, createCharacterInstance, METH_O | METH_CLASS), DECLARE_METHOD(t_breakiterator, createSentenceInstance, METH_O | METH_CLASS), DECLARE_METHOD(t_breakiterator, createTitleInstance, METH_O | METH_CLASS), DECLARE_METHOD(t_breakiterator, getAvailableLocales, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_breakiterator, getDisplayName, METH_VARARGS | METH_CLASS), { NULL, NULL, 0, NULL } }; static void t_breakiterator_dealloc(t_breakiterator *self) { if (self->flags & T_OWNED) delete self->object; self->object = NULL; Py_CLEAR(self->text); Py_TYPE(self)->tp_free((PyObject *) self); } DECLARE_TYPE(BreakIterator, t_breakiterator, UObject, BreakIterator, abstract_init, t_breakiterator_dealloc); /* RuleBasedBreakIterator */ class t_rulebasedbreakiterator : public _wrapper { public: RuleBasedBreakIterator *object; PyObject *text; /* used by inherited BreakIterator.setText() */ PyObject *binaryRules; }; 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); #if U_ICU_VERSION_HEX >= 0x04080000 static PyObject *t_rulebasedbreakiterator_getBinaryRules(t_rulebasedbreakiterator *self); #endif static PyMethodDef t_rulebasedbreakiterator_methods[] = { DECLARE_METHOD(t_rulebasedbreakiterator, getRules, METH_VARARGS), DECLARE_METHOD(t_rulebasedbreakiterator, getRuleStatus, METH_NOARGS), #if U_ICU_VERSION_HEX >= 0x04080000 DECLARE_METHOD(t_rulebasedbreakiterator, getBinaryRules, METH_NOARGS), #endif { NULL, NULL, 0, NULL } }; static void t_rulebasedbreakiterator_dealloc(t_rulebasedbreakiterator *self) { Py_CLEAR(self->binaryRules); t_breakiterator_dealloc((t_breakiterator *) self); } DECLARE_TYPE(RuleBasedBreakIterator, t_rulebasedbreakiterator, BreakIterator, RuleBasedBreakIterator, t_rulebasedbreakiterator_init, t_rulebasedbreakiterator_dealloc); /* 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(); } DEFINE_RICHCMP(ForwardCharacterIterator, t_forwardcharacteriterator); /* 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); } DEFINE_RICHCMP(BreakIterator, t_breakiterator); /* RuleBasedBreakIterator */ static int t_rulebasedbreakiterator_init(t_rulebasedbreakiterator *self, PyObject *args, PyObject *kwds) { UnicodeString *u, _u; charsArg path, name; PyObject *buffer; switch (PyTuple_Size(args)) { case 0: self->object = new RuleBasedBreakIterator(); self->flags = T_OWNED; break; case 1: #if U_ICU_VERSION_HEX >= 0x04080000 if (!parseArgs(args, "C", &buffer)) { UErrorCode status = U_ZERO_ERROR; RuleBasedBreakIterator *iterator = new RuleBasedBreakIterator( (const uint8_t *) PyBytes_AS_STRING(buffer), (uint32_t) PyBytes_GET_SIZE(buffer), status); // since "C" and "S" overlap fall through to "S" case if failure if (U_SUCCESS(status)) { self->object = iterator; self->flags = T_OWNED; // keep buffer for lifetime of object self->binaryRules = buffer; Py_INCREF(buffer); break; } else { delete iterator; } } #endif 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()); } #if U_ICU_VERSION_HEX >= 0x04080000 static PyObject *t_rulebasedbreakiterator_getBinaryRules(t_rulebasedbreakiterator *self) { uint32_t length = 0; const uint8_t *data = self->object->getBinaryRules(length); return PyBytes_FromStringAndSize((char *) data, (int) length); } #endif /* 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); } ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1430285253.0 PyICU-2.4.2/iterators.h0000644000076500000000000000310700000000000015042 0ustar00vajdawheel00000000000000/* ==================================================================== * 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 */ ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1478284529.0 PyICU-2.4.2/layoutengine.cpp0000644000076500000000000007332000000000000016070 0ustar00vajdawheel00000000000000/* ==================================================================== * Copyright (c) 2011-2011 Open Source Applications Foundation. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. * ==================================================================== */ #include "common.h" #include "structmember.h" #if U_ICU_VERSION_HEX < VERSION_HEX(58, 0, 0) #include #include #include #include #include "bases.h" #include "layoutengine.h" #include "macros.h" DECLARE_CONSTANTS_TYPE(ScriptCode); DECLARE_CONSTANTS_TYPE(LanguageCode); static PyObject *getFontTable_NAME; /* LEFontInstance */ class t_lefontinstance : public _wrapper { public: LEFontInstance *object; }; U_NAMESPACE_BEGIN class U_EXPORT PythonLEFontInstance : public LEFontInstance { public: /** * ICU "poor man's RTTI", returns a UClassID for the actual class. */ virtual UClassID getDynamicClassID() const; /** * ICU "poor man's RTTI", returns a UClassID for this class. */ static UClassID getStaticClassID(); PythonLEFontInstance(t_lefontinstance *t_self) : self(t_self) { tables = PyDict_New(); } /** * Destructor. */ virtual ~PythonLEFontInstance() { Py_DECREF(tables); } le_int32 get_le_int32(const char *name) const { PyObject *s = PyString_FromString(name); PyObject *result = PyObject_CallMethodObjArgs((PyObject *) self, s, NULL); Py_DECREF(s); if (result != NULL) { int n; if (!parseArg(result, "i", &n)) { Py_DECREF(result); return (le_int32) n; } } return 0; } float get_float(const char *name) const { PyObject *s = PyString_FromString(name); PyObject *result = PyObject_CallMethodObjArgs((PyObject *) self, s, NULL); Py_DECREF(s); if (result != NULL) { double d; if (!parseArg(result, "d", &d)) { Py_DECREF(result); return (float) d; } } return 0.0f; } /** * LEFontInstance API. */ virtual const void *getFontTable(LETag tableTag, size_t &length) const { length = -1; return getFontTable(tableTag); } virtual const void *getFontTable(LETag tag) const { #if PY_MAJOR_VERSION >= 3 PyObject *key = PyUnicode_FromStringAndSize(NULL, 4); Py_UNICODE *s = PyUnicode_AS_UNICODE(key); #else PyObject *key = PyString_FromStringAndSize(NULL, 4); char *s = PyString_AS_STRING(key); #endif for (int i = 0; i < 4; ++i) { s[3 - i] = tag & 0xff; tag >>= 8; } PyObject *result = PyDict_GetItem(tables, key); if (result == NULL) { result = PyObject_CallMethodObjArgs((PyObject *) self, getFontTable_NAME, key, NULL); if (result == NULL) { if (PyErr_ExceptionMatches(PyExc_KeyError)) PyErr_Clear(); Py_DECREF(key); return NULL; } #if PY_MAJOR_VERSION >= 3 if (!PyBytes_CheckExact(result)) #else if (!PyString_CheckExact(result)) #endif { PyErr_SetObject(PyExc_TypeError, result); Py_DECREF(result); Py_DECREF(key); return NULL; } PyDict_SetItem(tables, key, result); Py_DECREF(result); Py_DECREF(key); } else Py_DECREF(key); #if PY_MAJOR_VERSION >= 3 return PyBytes_AS_STRING(result); #else return PyString_AS_STRING(result); #endif } virtual le_int32 getAscent() const { return get_le_int32("getAscent"); } virtual le_int32 getDescent() const { return get_le_int32("getDescent"); } virtual le_int32 getLeading() const { return get_le_int32("getLeading"); } virtual le_int32 getUnitsPerEM() const { return get_le_int32("getUnitsPerEm"); } virtual LEGlyphID mapCharToGlyph(LEUnicode32 u) const { PyObject *name = PyString_FromString("mapCharToGlyph"); PyObject *n = PyInt_FromLong(u); PyObject *result = PyObject_CallMethodObjArgs((PyObject *) self, name, n, NULL); Py_DECREF(n); Py_DECREF(name); if (result != NULL) { int id; if (!parseArg(result, "i", &id)) { Py_DECREF(result); return id; } } return 0; } virtual LEGlyphID mapCharToGlyph(LEUnicode32 u, const LECharMapper *mapper) const { return LEFontInstance::mapCharToGlyph(u, mapper); } virtual LEGlyphID mapCharToGlyph(LEUnicode32 u, const LECharMapper *mapper, le_bool filterZeroWidth) const { return LEFontInstance::mapCharToGlyph(u, mapper, filterZeroWidth); } virtual void getGlyphAdvance(LEGlyphID glyph, LEPoint &advance) const { PyObject *name = PyString_FromString("getGlyphAdvance"); PyObject *g = PyInt_FromLong(LE_GET_GLYPH(glyph)); PyObject *result = PyObject_CallMethodObjArgs((PyObject *) self, name, g, NULL); Py_DECREF(g); Py_DECREF(name); if (result != NULL) { PyArg_ParseTuple(result, "ff", &advance.fX, &advance.fY); Py_DECREF(result); } } virtual le_bool getGlyphPoint(LEGlyphID glyph, le_int32 pointNumber, LEPoint &point) const { PyObject *name = PyString_FromString("getGlyphPoint"); PyObject *g = PyInt_FromLong(LE_GET_GLYPH(glyph)); PyObject *pn = PyInt_FromLong(pointNumber); PyObject *result = PyObject_CallMethodObjArgs((PyObject *) self, name, g, pn, NULL); Py_DECREF(pn); Py_DECREF(g); Py_DECREF(name); if (result != NULL) { PyArg_ParseTuple(result, "ff", &point.fX, &point.fY); Py_DECREF(result); return true; } return false; } virtual float getXPixelsPerEm() const { return get_float("getXPixelsPerEm"); } virtual float getYPixelsPerEm() const { return get_float("getYPixelsPerEm"); } virtual float getScaleFactorX() const { return get_float("getScaleFactorX"); } virtual float getScaleFactorY() const { return get_float("getScaleFactorY"); } private: t_lefontinstance *self; PyObject *tables; }; U_NAMESPACE_END UOBJECT_DEFINE_RTTI_IMPLEMENTATION(PythonLEFontInstance); DEFINE_ABSTRACT(t_lefontinstance, LEFontInstance, getFontTable); DEFINE_ABSTRACT(t_lefontinstance, LEFontInstance, getAscent); DEFINE_ABSTRACT(t_lefontinstance, LEFontInstance, getDescent); DEFINE_ABSTRACT(t_lefontinstance, LEFontInstance, getLeading); DEFINE_ABSTRACT(t_lefontinstance, LEFontInstance, canDisplay); DEFINE_ABSTRACT(t_lefontinstance, LEFontInstance, getUnitsPerEm); DEFINE_ABSTRACT(t_lefontinstance, LEFontInstance, mapCharToGlyph); DEFINE_ABSTRACT(t_lefontinstance, LEFontInstance, getGlyphAdvance); DEFINE_ABSTRACT(t_lefontinstance, LEFontInstance, getGlyphPoint); DEFINE_ABSTRACT(t_lefontinstance, LEFontInstance, getXPixelsPerEm); DEFINE_ABSTRACT(t_lefontinstance, LEFontInstance, getYPixelsPerEm); DEFINE_ABSTRACT(t_lefontinstance, LEFontInstance, getScaleFactorX); DEFINE_ABSTRACT(t_lefontinstance, LEFontInstance, getScaleFactorY); static PyMethodDef t_lefontinstance_methods[] = { DECLARE_METHOD(t_lefontinstance, getFontTable, METH_O), DECLARE_METHOD(t_lefontinstance, getAscent, METH_NOARGS), DECLARE_METHOD(t_lefontinstance, getDescent, METH_NOARGS), DECLARE_METHOD(t_lefontinstance, getLeading, METH_NOARGS), DECLARE_METHOD(t_lefontinstance, canDisplay, METH_O), DECLARE_METHOD(t_lefontinstance, getUnitsPerEm, METH_NOARGS), DECLARE_METHOD(t_lefontinstance, mapCharToGlyph, METH_O), DECLARE_METHOD(t_lefontinstance, getGlyphAdvance, METH_O), DECLARE_METHOD(t_lefontinstance, getGlyphPoint, METH_VARARGS), DECLARE_METHOD(t_lefontinstance, getXPixelsPerEm, METH_NOARGS), DECLARE_METHOD(t_lefontinstance, getYPixelsPerEm, METH_NOARGS), DECLARE_METHOD(t_lefontinstance, getScaleFactorX, METH_NOARGS), DECLARE_METHOD(t_lefontinstance, getScaleFactorY, METH_NOARGS), { NULL, NULL, 0, NULL } }; static int t_lefontinstance_init(t_lefontinstance *self, PyObject *args, PyObject *kwds); DECLARE_TYPE(LEFontInstance, t_lefontinstance, UObject, LEFontInstance, t_lefontinstance_init, NULL); static int t_lefontinstance_init(t_lefontinstance *self, PyObject *args, PyObject *kwds) { if (PyTuple_Size(args) == 0) { self->object = new PythonLEFontInstance(self); self->flags = T_OWNED; return 0; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; } /* LayoutEngine */ class t_layoutengine : public _wrapper { public: LayoutEngine *object; }; static PyObject *t_layoutengine_layoutEngineFactory(PyTypeObject *type, PyObject *args); static PyObject *t_layoutengine_layoutChars(t_layoutengine *self, PyObject *args); static PyObject *t_layoutengine_getGlyphCount(t_layoutengine *self); static PyObject *t_layoutengine_getGlyphs(t_layoutengine *self); static PyObject *t_layoutengine_getCharIndices(t_layoutengine *self); static PyObject *t_layoutengine_getGlyphPositions(t_layoutengine *self); static PyObject *t_layoutengine_getGlyphPosition(t_layoutengine *self, PyObject *arg); static PyMethodDef t_layoutengine_methods[] = { DECLARE_METHOD(t_layoutengine, layoutEngineFactory, METH_VARARGS | METH_CLASS), DECLARE_METHOD(t_layoutengine, layoutChars, METH_VARARGS), DECLARE_METHOD(t_layoutengine, getGlyphCount, METH_NOARGS), DECLARE_METHOD(t_layoutengine, getGlyphs, METH_NOARGS), DECLARE_METHOD(t_layoutengine, getCharIndices, METH_NOARGS), DECLARE_METHOD(t_layoutengine, getGlyphPositions, METH_NOARGS), DECLARE_METHOD(t_layoutengine, getGlyphPosition, METH_O), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(LayoutEngine, t_layoutengine, UObject, LayoutEngine, abstract_init, NULL); static PyObject *t_layoutengine_layoutEngineFactory(PyTypeObject *type, PyObject *args) { LayoutEngine *le = NULL; LEFontInstance *fe; le_int32 script, language, typo_flag; switch (PyTuple_Size(args)) { case 3: if (!parseArgs(args, "Pii", TYPE_CLASSID(LEFontInstance), &fe, &script, &language)) { STATUS_CALL( le = LayoutEngine::layoutEngineFactory( fe, script, language, (LEErrorCode &) status)); break; } return PyErr_SetArgsError((PyObject *) type, "__init__", args); case 4: if (!parseArgs(args, "Piii", TYPE_CLASSID(LEFontInstance), &fe, &script, &language, &typo_flag)) { STATUS_CALL( le = LayoutEngine::layoutEngineFactory( fe, script, language, typo_flag, (LEErrorCode &) status)); break; } return PyErr_SetArgsError((PyObject *) type, "__init__", args); default: return PyErr_SetArgsError((PyObject *) type, "__init__", args); } return wrap_LayoutEngine(le, T_OWNED); } static PyObject *t_layoutengine_layoutChars(t_layoutengine *self, PyObject *args) { UnicodeString *u0, _u0; le_int32 n, offset, count; double x, y; int rtl; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "S", &u0, &_u0)) { STATUS_CALL( n = self->object->layoutChars( (const LEUnicode *) (u0->getBuffer()), 0, u0->length(), u0->length(), false, 0.0f, 0.0f, (LEErrorCode &) status)); return PyInt_FromLong(n); } break; case 3: if (!parseArgs(args, "Sii", &u0, &_u0, &offset, &count)) { STATUS_CALL( n = self->object->layoutChars( (const LEUnicode *) (u0->getBuffer()), offset, count, u0->length(), false, 0.0f, 0.0f, (LEErrorCode &) status)); return PyInt_FromLong(n); } break; case 4: if (!parseArgs(args, "Siii", &u0, &_u0, &offset, &count, &rtl)) { STATUS_CALL( n = self->object->layoutChars( (const LEUnicode *) (u0->getBuffer()), offset, count, u0->length(), rtl, 0.0f, 0.0f, (LEErrorCode &) status)); return PyInt_FromLong(n); } break; case 6: if (!parseArgs(args, "Siiidd", &u0, &_u0, &offset, &count, &rtl, &x, &y)) { STATUS_CALL( n = self->object->layoutChars( (const LEUnicode *) (u0->getBuffer()), offset, count, u0->length(), rtl, (float) x, (float) y, (LEErrorCode &) status)); return PyInt_FromLong(n); } break; } return PyErr_SetArgsError((PyObject *) self, "layoutChars", args); } static PyObject *t_layoutengine_getGlyphCount(t_layoutengine *self) { return PyInt_FromLong(self->object->getGlyphCount()); } static PyObject *t_layoutengine_getGlyphs(t_layoutengine *self) { le_int32 num = self->object->getGlyphCount(); LEGlyphID *glyphs = new LEGlyphID[num]; PyObject *tuple; STATUS_CALL(self->object->getGlyphs(glyphs, (LEErrorCode &) status)); tuple = PyTuple_New(num); for (int i = 0; i < num; i++) PyTuple_SET_ITEM(tuple, i, PyInt_FromLong(glyphs[i])); delete[] glyphs; return tuple; } static PyObject *t_layoutengine_getCharIndices(t_layoutengine *self) { le_int32 num = self->object->getGlyphCount(); le_int32 *charIndices = new le_int32[num]; PyObject *tuple; STATUS_CALL(self->object->getCharIndices(charIndices, (LEErrorCode &) status)); tuple = PyTuple_New(num); for (int i = 0; i < num; i++) PyTuple_SET_ITEM(tuple, i, PyInt_FromLong(charIndices[i])); delete[] charIndices; return tuple; } static PyObject *t_layoutengine_getGlyphPositions(t_layoutengine *self) { le_int32 num = self->object->getGlyphCount() + 1; float *positions = new float[num * 2]; PyObject *tuple; STATUS_CALL(self->object->getGlyphPositions(positions, (LEErrorCode &) status)); tuple = PyTuple_New(num); for (int i = 0; i < num; i++) PyTuple_SET_ITEM(tuple, i, Py_BuildValue("(ff)", positions[2 * i], positions[2 * i + 1])); delete[] positions; return tuple; } static PyObject *t_layoutengine_getGlyphPosition(t_layoutengine *self, PyObject *arg) { le_int32 n; float x, y; if (!parseArg(arg, "i", &n)) { STATUS_CALL(self->object->getGlyphPosition(n, x, y, (LEErrorCode &) status)); return Py_BuildValue("(ff)", x, y); } return PyErr_SetArgsError((PyObject *) self, "getGlyphPosition", arg); } void _init_layoutengine(PyObject *m) { INSTALL_CONSTANTS_TYPE(ScriptCode, m); INSTALL_CONSTANTS_TYPE(LanguageCode, m); REGISTER_TYPE(LEFontInstance, m); REGISTER_TYPE(LayoutEngine, m); INSTALL_ENUM(ScriptCode, "zyyy", zyyyScriptCode); #if U_ICU_VERSION_HEX >= 0x04040200 INSTALL_ENUM(ScriptCode, "zinh", zinhScriptCode); #endif INSTALL_ENUM(ScriptCode, "qaai", qaaiScriptCode); INSTALL_ENUM(ScriptCode, "arab", arabScriptCode); INSTALL_ENUM(ScriptCode, "armn", armnScriptCode); INSTALL_ENUM(ScriptCode, "beng", bengScriptCode); INSTALL_ENUM(ScriptCode, "bopo", bopoScriptCode); INSTALL_ENUM(ScriptCode, "cher", cherScriptCode); INSTALL_ENUM(ScriptCode, "copt", coptScriptCode); INSTALL_ENUM(ScriptCode, "cyrl", cyrlScriptCode); INSTALL_ENUM(ScriptCode, "dsrt", dsrtScriptCode); INSTALL_ENUM(ScriptCode, "deva", devaScriptCode); INSTALL_ENUM(ScriptCode, "ethi", ethiScriptCode); INSTALL_ENUM(ScriptCode, "geor", georScriptCode); INSTALL_ENUM(ScriptCode, "goth", gothScriptCode); INSTALL_ENUM(ScriptCode, "grek", grekScriptCode); INSTALL_ENUM(ScriptCode, "gujr", gujrScriptCode); INSTALL_ENUM(ScriptCode, "guru", guruScriptCode); INSTALL_ENUM(ScriptCode, "hani", haniScriptCode); INSTALL_ENUM(ScriptCode, "hang", hangScriptCode); INSTALL_ENUM(ScriptCode, "hebr", hebrScriptCode); INSTALL_ENUM(ScriptCode, "hira", hiraScriptCode); INSTALL_ENUM(ScriptCode, "knda", kndaScriptCode); INSTALL_ENUM(ScriptCode, "kana", kanaScriptCode); INSTALL_ENUM(ScriptCode, "khmr", khmrScriptCode); INSTALL_ENUM(ScriptCode, "laoo", laooScriptCode); INSTALL_ENUM(ScriptCode, "latn", latnScriptCode); INSTALL_ENUM(ScriptCode, "mlym", mlymScriptCode); INSTALL_ENUM(ScriptCode, "mong", mongScriptCode); INSTALL_ENUM(ScriptCode, "mymr", mymrScriptCode); INSTALL_ENUM(ScriptCode, "ogam", ogamScriptCode); INSTALL_ENUM(ScriptCode, "ital", italScriptCode); INSTALL_ENUM(ScriptCode, "orya", oryaScriptCode); INSTALL_ENUM(ScriptCode, "runr", runrScriptCode); INSTALL_ENUM(ScriptCode, "sinh", sinhScriptCode); INSTALL_ENUM(ScriptCode, "syrc", syrcScriptCode); INSTALL_ENUM(ScriptCode, "taml", tamlScriptCode); INSTALL_ENUM(ScriptCode, "telu", teluScriptCode); INSTALL_ENUM(ScriptCode, "thaa", thaaScriptCode); INSTALL_ENUM(ScriptCode, "thai", thaiScriptCode); INSTALL_ENUM(ScriptCode, "tibt", tibtScriptCode); INSTALL_ENUM(ScriptCode, "cans", cansScriptCode); INSTALL_ENUM(ScriptCode, "yiii", yiiiScriptCode); INSTALL_ENUM(ScriptCode, "tglg", tglgScriptCode); INSTALL_ENUM(ScriptCode, "hano", hanoScriptCode); INSTALL_ENUM(ScriptCode, "buhd", buhdScriptCode); INSTALL_ENUM(ScriptCode, "tagb", tagbScriptCode); INSTALL_ENUM(ScriptCode, "brai", braiScriptCode); INSTALL_ENUM(ScriptCode, "cprt", cprtScriptCode); INSTALL_ENUM(ScriptCode, "limb", limbScriptCode); INSTALL_ENUM(ScriptCode, "linb", linbScriptCode); INSTALL_ENUM(ScriptCode, "osma", osmaScriptCode); INSTALL_ENUM(ScriptCode, "shaw", shawScriptCode); INSTALL_ENUM(ScriptCode, "tale", taleScriptCode); INSTALL_ENUM(ScriptCode, "ugar", ugarScriptCode); INSTALL_ENUM(ScriptCode, "hrkt", hrktScriptCode); INSTALL_ENUM(ScriptCode, "bugi", bugiScriptCode); INSTALL_ENUM(ScriptCode, "glag", glagScriptCode); INSTALL_ENUM(ScriptCode, "khar", kharScriptCode); INSTALL_ENUM(ScriptCode, "sylo", syloScriptCode); INSTALL_ENUM(ScriptCode, "talu", taluScriptCode); INSTALL_ENUM(ScriptCode, "tfng", tfngScriptCode); INSTALL_ENUM(ScriptCode, "xpeo", xpeoScriptCode); INSTALL_ENUM(ScriptCode, "bali", baliScriptCode); INSTALL_ENUM(ScriptCode, "batk", batkScriptCode); INSTALL_ENUM(ScriptCode, "blis", blisScriptCode); INSTALL_ENUM(ScriptCode, "brah", brahScriptCode); INSTALL_ENUM(ScriptCode, "cham", chamScriptCode); INSTALL_ENUM(ScriptCode, "cirt", cirtScriptCode); INSTALL_ENUM(ScriptCode, "cyrs", cyrsScriptCode); INSTALL_ENUM(ScriptCode, "egyd", egydScriptCode); INSTALL_ENUM(ScriptCode, "egyh", egyhScriptCode); INSTALL_ENUM(ScriptCode, "egyp", egypScriptCode); INSTALL_ENUM(ScriptCode, "geok", geokScriptCode); INSTALL_ENUM(ScriptCode, "hans", hansScriptCode); INSTALL_ENUM(ScriptCode, "hant", hantScriptCode); INSTALL_ENUM(ScriptCode, "hmng", hmngScriptCode); INSTALL_ENUM(ScriptCode, "hung", hungScriptCode); INSTALL_ENUM(ScriptCode, "inds", indsScriptCode); INSTALL_ENUM(ScriptCode, "java", javaScriptCode); INSTALL_ENUM(ScriptCode, "kali", kaliScriptCode); INSTALL_ENUM(ScriptCode, "latf", latfScriptCode); INSTALL_ENUM(ScriptCode, "latg", latgScriptCode); INSTALL_ENUM(ScriptCode, "lepc", lepcScriptCode); INSTALL_ENUM(ScriptCode, "lina", linaScriptCode); INSTALL_ENUM(ScriptCode, "mand", mandScriptCode); INSTALL_ENUM(ScriptCode, "maya", mayaScriptCode); INSTALL_ENUM(ScriptCode, "mero", meroScriptCode); INSTALL_ENUM(ScriptCode, "nkoo", nkooScriptCode); INSTALL_ENUM(ScriptCode, "orkh", orkhScriptCode); INSTALL_ENUM(ScriptCode, "perm", permScriptCode); INSTALL_ENUM(ScriptCode, "phag", phagScriptCode); INSTALL_ENUM(ScriptCode, "phnx", phnxScriptCode); INSTALL_ENUM(ScriptCode, "plrd", plrdScriptCode); INSTALL_ENUM(ScriptCode, "roro", roroScriptCode); INSTALL_ENUM(ScriptCode, "sara", saraScriptCode); INSTALL_ENUM(ScriptCode, "syre", syreScriptCode); INSTALL_ENUM(ScriptCode, "syrj", syrjScriptCode); INSTALL_ENUM(ScriptCode, "syrn", syrnScriptCode); INSTALL_ENUM(ScriptCode, "teng", tengScriptCode); INSTALL_ENUM(ScriptCode, "vaii", vaiiScriptCode); INSTALL_ENUM(ScriptCode, "visp", vispScriptCode); INSTALL_ENUM(ScriptCode, "xsux", xsuxScriptCode); INSTALL_ENUM(ScriptCode, "zxxx", zxxxScriptCode); INSTALL_ENUM(ScriptCode, "zzzz", zzzzScriptCode); INSTALL_ENUM(ScriptCode, "cari", cariScriptCode); INSTALL_ENUM(ScriptCode, "jpan", jpanScriptCode); INSTALL_ENUM(ScriptCode, "lana", lanaScriptCode); INSTALL_ENUM(ScriptCode, "lyci", lyciScriptCode); INSTALL_ENUM(ScriptCode, "lydi", lydiScriptCode); INSTALL_ENUM(ScriptCode, "olck", olckScriptCode); INSTALL_ENUM(ScriptCode, "rjng", rjngScriptCode); INSTALL_ENUM(ScriptCode, "saur", saurScriptCode); INSTALL_ENUM(ScriptCode, "sgnw", sgnwScriptCode); INSTALL_ENUM(ScriptCode, "sund", sundScriptCode); INSTALL_ENUM(ScriptCode, "moon", moonScriptCode); INSTALL_ENUM(ScriptCode, "mtei", mteiScriptCode); #if U_ICU_VERSION_HEX >= 0x04000000 INSTALL_ENUM(ScriptCode, "armi", armiScriptCode); INSTALL_ENUM(ScriptCode, "avst", avstScriptCode); INSTALL_ENUM(ScriptCode, "cakm", cakmScriptCode); INSTALL_ENUM(ScriptCode, "kore", koreScriptCode); INSTALL_ENUM(ScriptCode, "kthi", kthiScriptCode); INSTALL_ENUM(ScriptCode, "mani", maniScriptCode); INSTALL_ENUM(ScriptCode, "phli", phliScriptCode); INSTALL_ENUM(ScriptCode, "phlp", phlpScriptCode); INSTALL_ENUM(ScriptCode, "phlv", phlvScriptCode); INSTALL_ENUM(ScriptCode, "prti", prtiScriptCode); INSTALL_ENUM(ScriptCode, "samr", samrScriptCode); INSTALL_ENUM(ScriptCode, "tavt", tavtScriptCode); INSTALL_ENUM(ScriptCode, "zmth", zmthScriptCode); INSTALL_ENUM(ScriptCode, "zsym", zsymScriptCode); #if U_ICU_VERSION_HEX >= 0x04040000 INSTALL_ENUM(ScriptCode, "bamu", bamuScriptCode); INSTALL_ENUM(ScriptCode, "lisu", lisuScriptCode); INSTALL_ENUM(ScriptCode, "nkgb", nkgbScriptCode); INSTALL_ENUM(ScriptCode, "sarb", sarbScriptCode); #if U_ICU_VERSION_HEX >= 0x04060000 INSTALL_ENUM(ScriptCode, "bass", bassScriptCode); INSTALL_ENUM(ScriptCode, "dupl", duplScriptCode); INSTALL_ENUM(ScriptCode, "elba", elbaScriptCode); INSTALL_ENUM(ScriptCode, "gran", granScriptCode); INSTALL_ENUM(ScriptCode, "kpel", kpelScriptCode); INSTALL_ENUM(ScriptCode, "loma", lomaScriptCode); INSTALL_ENUM(ScriptCode, "mend", mendScriptCode); INSTALL_ENUM(ScriptCode, "merc", mercScriptCode); INSTALL_ENUM(ScriptCode, "narb", narbScriptCode); INSTALL_ENUM(ScriptCode, "nbat", nbatScriptCode); INSTALL_ENUM(ScriptCode, "palm", palmScriptCode); INSTALL_ENUM(ScriptCode, "sind", sindScriptCode); INSTALL_ENUM(ScriptCode, "wara", waraScriptCode); #if U_ICU_VERSION_HEX >= VERSION_HEX(49, 0, 0) INSTALL_ENUM(ScriptCode, "afak", afakScriptCode); INSTALL_ENUM(ScriptCode, "jurc", jurcScriptCode); INSTALL_ENUM(ScriptCode, "khoj", khojScriptCode); INSTALL_ENUM(ScriptCode, "mroo", mrooScriptCode); INSTALL_ENUM(ScriptCode, "nshu", nshuScriptCode); INSTALL_ENUM(ScriptCode, "shrd", shrdScriptCode); INSTALL_ENUM(ScriptCode, "sora", soraScriptCode); INSTALL_ENUM(ScriptCode, "takr", takrScriptCode); INSTALL_ENUM(ScriptCode, "tang", tangScriptCode); INSTALL_ENUM(ScriptCode, "tirh", tirhScriptCode); INSTALL_ENUM(ScriptCode, "wole", woleScriptCode); #endif /* 49.0 */ #endif /* 4.6 */ #endif /* 4.4 */ #endif /* 4.0 */ INSTALL_ENUM(LanguageCode, "nul", nullLanguageCode); INSTALL_ENUM(LanguageCode, "ara", araLanguageCode); INSTALL_ENUM(LanguageCode, "asm", asmLanguageCode); INSTALL_ENUM(LanguageCode, "ben", benLanguageCode); INSTALL_ENUM(LanguageCode, "far", farLanguageCode); INSTALL_ENUM(LanguageCode, "guj", gujLanguageCode); INSTALL_ENUM(LanguageCode, "hin", hinLanguageCode); INSTALL_ENUM(LanguageCode, "iwr", iwrLanguageCode); INSTALL_ENUM(LanguageCode, "jii", jiiLanguageCode); INSTALL_ENUM(LanguageCode, "jan", janLanguageCode); INSTALL_ENUM(LanguageCode, "kan", kanLanguageCode); INSTALL_ENUM(LanguageCode, "kok", kokLanguageCode); INSTALL_ENUM(LanguageCode, "kor", korLanguageCode); INSTALL_ENUM(LanguageCode, "ksh", kshLanguageCode); INSTALL_ENUM(LanguageCode, "mal", malLanguageCode); INSTALL_ENUM(LanguageCode, "mar", marLanguageCode); INSTALL_ENUM(LanguageCode, "mlr", mlrLanguageCode); INSTALL_ENUM(LanguageCode, "mni", mniLanguageCode); INSTALL_ENUM(LanguageCode, "ori", oriLanguageCode); INSTALL_ENUM(LanguageCode, "san", sanLanguageCode); INSTALL_ENUM(LanguageCode, "snd", sndLanguageCode); INSTALL_ENUM(LanguageCode, "snh", snhLanguageCode); INSTALL_ENUM(LanguageCode, "syr", syrLanguageCode); INSTALL_ENUM(LanguageCode, "tam", tamLanguageCode); INSTALL_ENUM(LanguageCode, "tel", telLanguageCode); INSTALL_ENUM(LanguageCode, "tha", thaLanguageCode); INSTALL_ENUM(LanguageCode, "urd", urdLanguageCode); INSTALL_ENUM(LanguageCode, "zhp", zhpLanguageCode); INSTALL_ENUM(LanguageCode, "zhs", zhsLanguageCode); INSTALL_ENUM(LanguageCode, "zht", zhtLanguageCode); #if U_ICU_VERSION_HEX >= 0x04000000 INSTALL_ENUM(LanguageCode, "afk", afkLanguageCode); INSTALL_ENUM(LanguageCode, "bel", belLanguageCode); INSTALL_ENUM(LanguageCode, "bgr", bgrLanguageCode); INSTALL_ENUM(LanguageCode, "cat", catLanguageCode); INSTALL_ENUM(LanguageCode, "che", cheLanguageCode); INSTALL_ENUM(LanguageCode, "cop", copLanguageCode); INSTALL_ENUM(LanguageCode, "csy", csyLanguageCode); INSTALL_ENUM(LanguageCode, "dan", danLanguageCode); INSTALL_ENUM(LanguageCode, "deu", deuLanguageCode); INSTALL_ENUM(LanguageCode, "dzn", dznLanguageCode); INSTALL_ENUM(LanguageCode, "ell", ellLanguageCode); INSTALL_ENUM(LanguageCode, "eng", engLanguageCode); INSTALL_ENUM(LanguageCode, "esp", espLanguageCode); INSTALL_ENUM(LanguageCode, "eti", etiLanguageCode); INSTALL_ENUM(LanguageCode, "euq", euqLanguageCode); INSTALL_ENUM(LanguageCode, "fin", finLanguageCode); INSTALL_ENUM(LanguageCode, "fra", fraLanguageCode); INSTALL_ENUM(LanguageCode, "gae", gaeLanguageCode); INSTALL_ENUM(LanguageCode, "hau", hauLanguageCode); INSTALL_ENUM(LanguageCode, "hrv", hrvLanguageCode); INSTALL_ENUM(LanguageCode, "hun", hunLanguageCode); INSTALL_ENUM(LanguageCode, "hye", hyeLanguageCode); INSTALL_ENUM(LanguageCode, "ind", indLanguageCode); INSTALL_ENUM(LanguageCode, "ita", itaLanguageCode); INSTALL_ENUM(LanguageCode, "khm", khmLanguageCode); INSTALL_ENUM(LanguageCode, "mng", mngLanguageCode); INSTALL_ENUM(LanguageCode, "mts", mtsLanguageCode); INSTALL_ENUM(LanguageCode, "nep", nepLanguageCode); INSTALL_ENUM(LanguageCode, "nld", nldLanguageCode); INSTALL_ENUM(LanguageCode, "pas", pasLanguageCode); INSTALL_ENUM(LanguageCode, "plk", plkLanguageCode); INSTALL_ENUM(LanguageCode, "ptg", ptgLanguageCode); INSTALL_ENUM(LanguageCode, "rom", romLanguageCode); INSTALL_ENUM(LanguageCode, "rus", rusLanguageCode); INSTALL_ENUM(LanguageCode, "sky", skyLanguageCode); INSTALL_ENUM(LanguageCode, "slv", slvLanguageCode); INSTALL_ENUM(LanguageCode, "sqi", sqiLanguageCode); INSTALL_ENUM(LanguageCode, "srb", srbLanguageCode); INSTALL_ENUM(LanguageCode, "sve", sveLanguageCode); INSTALL_ENUM(LanguageCode, "tib", tibLanguageCode); INSTALL_ENUM(LanguageCode, "trk", trkLanguageCode); INSTALL_ENUM(LanguageCode, "wel", welLanguageCode); #endif /* 4.0 */ getFontTable_NAME = PyString_FromString("getFontTable"); } #endif /* < 58 */ ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1478284602.0 PyICU-2.4.2/layoutengine.h0000644000076500000000000000257700000000000015543 0ustar00vajdawheel00000000000000/* ==================================================================== * 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 */ ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1570122198.0 PyICU-2.4.2/locale.cpp0000644000076500000000000022253300000000000014626 0ustar00vajdawheel00000000000000/* ==================================================================== * Copyright (c) 2004-2019 Open Source Applications Foundation. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. * ==================================================================== */ #include #include #if defined(_MSC_VER) || defined(__WIN32) #include #else #include #include #include #endif #include "common.h" #include "structmember.h" #include "bases.h" #include "locale.h" #include "macros.h" #include "unicodeset.h" DECLARE_CONSTANTS_TYPE(ULocDataLocaleType); DECLARE_CONSTANTS_TYPE(UResType); DECLARE_CONSTANTS_TYPE(ULocaleDataDelimiterType); DECLARE_CONSTANTS_TYPE(ULocaleDataExemplarSetType); DECLARE_CONSTANTS_TYPE(UMeasurementSystem); #if U_ICU_VERSION_HEX >= VERSION_HEX(51, 0, 0) DECLARE_CONSTANTS_TYPE(URegionType); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(65, 0, 0) DECLARE_CONSTANTS_TYPE(ULocMatchFavorSubtag); DECLARE_CONSTANTS_TYPE(ULocMatchDemotion); #endif /* 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); #if U_ICU_VERSION_HEX >= VERSION_HEX(63, 0, 0) static PyObject *t_locale_createUnicodeKeywords(t_locale *self); #endif static PyObject *t_locale_getKeywordValue(t_locale *self, PyObject *arg); #if U_ICU_VERSION_HEX >= VERSION_HEX(49, 0, 0) static PyObject *t_locale_setKeywordValue(t_locale *self, PyObject *args); static PyObject *t_locale_removeKeywordValue(t_locale *self, PyObject *arg); #endif static PyObject *t_locale_isBogus(t_locale *self); static PyObject *t_locale_setToBogus(t_locale *self); #if U_ICU_VERSION_HEX >= 0x04000000 static PyObject *t_locale_addLikelySubtags(t_locale *self); static PyObject *t_locale_minimizeSubtags(t_locale *self); #endif #if U_ICU_VERSION_HEX >= 0x04040000 static PyObject *t_locale_getRoot(PyTypeObject *type); #endif static PyObject *t_locale_getEnglish(PyTypeObject *type); static PyObject *t_locale_getFrench(PyTypeObject *type); static PyObject *t_locale_getGerman(PyTypeObject *type); static PyObject *t_locale_getItalian(PyTypeObject *type); static PyObject *t_locale_getJapanese(PyTypeObject *type); static PyObject *t_locale_getKorean(PyTypeObject *type); static PyObject *t_locale_getChinese(PyTypeObject *type); static PyObject *t_locale_getSimplifiedChinese(PyTypeObject *type); static PyObject *t_locale_getTraditionalChinese(PyTypeObject *type); static PyObject *t_locale_getFrance(PyTypeObject *type); static PyObject *t_locale_getGermany(PyTypeObject *type); static PyObject *t_locale_getItaly(PyTypeObject *type); static PyObject *t_locale_getJapan(PyTypeObject *type); static PyObject *t_locale_getKorea(PyTypeObject *type); static PyObject *t_locale_getChina(PyTypeObject *type); static PyObject *t_locale_getPRC(PyTypeObject *type); static PyObject *t_locale_getTaiwan(PyTypeObject *type); static PyObject *t_locale_getUK(PyTypeObject *type); static PyObject *t_locale_getUS(PyTypeObject *type); static PyObject *t_locale_getCanada(PyTypeObject *type); static PyObject *t_locale_getCanadaFrench(PyTypeObject *type); static PyObject *t_locale_getDefault(PyTypeObject *type); static PyObject *t_locale_setDefault(PyTypeObject *type, PyObject *args); static PyObject *t_locale_createFromName(PyTypeObject *type, PyObject *args); #if U_ICU_VERSION_HEX >= VERSION_HEX(63, 0, 0) static PyObject *t_locale_forLanguageTag(PyTypeObject *type, PyObject *arg); static PyObject *t_locale_toLanguageTag(t_locale *self); #endif static PyObject *t_locale_createCanonical(PyTypeObject *type, PyObject *arg); static PyObject *t_locale_getAvailableLocales(PyTypeObject *type); static PyObject *t_locale_getISOCountries(PyTypeObject *type); static PyObject *t_locale_getISOLanguages(PyTypeObject *type); static PyMethodDef t_locale_methods[] = { DECLARE_METHOD(t_locale, getLanguage, METH_NOARGS), DECLARE_METHOD(t_locale, getScript, METH_NOARGS), DECLARE_METHOD(t_locale, getCountry, METH_NOARGS), DECLARE_METHOD(t_locale, getVariant, METH_NOARGS), DECLARE_METHOD(t_locale, getName, METH_NOARGS), DECLARE_METHOD(t_locale, getBaseName, METH_NOARGS), DECLARE_METHOD(t_locale, getISO3Language, METH_NOARGS), DECLARE_METHOD(t_locale, getISO3Country, METH_NOARGS), DECLARE_METHOD(t_locale, getLCID, METH_NOARGS), DECLARE_METHOD(t_locale, getDisplayLanguage, METH_VARARGS), DECLARE_METHOD(t_locale, getDisplayScript, METH_VARARGS), DECLARE_METHOD(t_locale, getDisplayCountry, METH_VARARGS), DECLARE_METHOD(t_locale, getDisplayVariant, METH_VARARGS), DECLARE_METHOD(t_locale, getDisplayName, METH_VARARGS), DECLARE_METHOD(t_locale, createKeywords, METH_NOARGS), #if U_ICU_VERSION_HEX >= VERSION_HEX(63, 0, 0) DECLARE_METHOD(t_locale, createUnicodeKeywords, METH_NOARGS), #endif DECLARE_METHOD(t_locale, getKeywordValue, METH_O), #if U_ICU_VERSION_HEX >= VERSION_HEX(49, 0, 0) DECLARE_METHOD(t_locale, setKeywordValue, METH_VARARGS), DECLARE_METHOD(t_locale, removeKeywordValue, METH_O), #endif DECLARE_METHOD(t_locale, isBogus, METH_NOARGS), DECLARE_METHOD(t_locale, setToBogus, METH_NOARGS), #if U_ICU_VERSION_HEX >= 0x04000000 DECLARE_METHOD(t_locale, addLikelySubtags, METH_NOARGS), DECLARE_METHOD(t_locale, minimizeSubtags, METH_NOARGS), #endif #if U_ICU_VERSION_HEX >= 0x04040000 DECLARE_METHOD(t_locale, getRoot, METH_NOARGS | METH_CLASS), #endif DECLARE_METHOD(t_locale, getEnglish, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_locale, getFrench, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_locale, getGerman, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_locale, getItalian, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_locale, getJapanese, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_locale, getKorean, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_locale, getChinese, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_locale, getSimplifiedChinese, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_locale, getTraditionalChinese, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_locale, getFrance, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_locale, getGermany, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_locale, getItaly, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_locale, getJapan, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_locale, getKorea, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_locale, getChina, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_locale, getPRC, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_locale, getTaiwan, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_locale, getUK, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_locale, getUS, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_locale, getCanada, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_locale, getCanadaFrench, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_locale, getDefault, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_locale, setDefault, METH_VARARGS | METH_CLASS), DECLARE_METHOD(t_locale, createFromName, METH_VARARGS | METH_CLASS), DECLARE_METHOD(t_locale, createCanonical, METH_O | METH_CLASS), #if U_ICU_VERSION_HEX >= VERSION_HEX(63, 0, 0) DECLARE_METHOD(t_locale, forLanguageTag, METH_O | METH_CLASS), DECLARE_METHOD(t_locale, toLanguageTag, METH_NOARGS), #endif DECLARE_METHOD(t_locale, getAvailableLocales, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_locale, getISOCountries, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_locale, getISOLanguages, METH_NOARGS | METH_CLASS), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(Locale, t_locale, UObject, Locale, t_locale_init, NULL); PyObject *wrap_Locale(const Locale &locale) { return wrap_Locale(new Locale(locale), T_OWNED); } /* ResourceBundle */ class t_resourcebundle : public _wrapper { public: ResourceBundle *object; }; static int t_resourcebundle_init(t_resourcebundle *self, PyObject *args, PyObject *kwds); static PyObject *t_resourcebundle_getSize(t_resourcebundle *self); static PyObject *t_resourcebundle_getString(t_resourcebundle *self, PyObject *args); static PyObject *t_resourcebundle_getUInt(t_resourcebundle *self); static PyObject *t_resourcebundle_getInt(t_resourcebundle *self); static PyObject *t_resourcebundle_getKey(t_resourcebundle *self); static PyObject *t_resourcebundle_getName(t_resourcebundle *self); static PyObject *t_resourcebundle_getType(t_resourcebundle *self); static PyObject *t_resourcebundle_hasNext(t_resourcebundle *self); static PyObject *t_resourcebundle_resetIterator(t_resourcebundle *self); static PyObject *t_resourcebundle_getNext(t_resourcebundle *self); static PyObject *t_resourcebundle_getNextString(t_resourcebundle *self, PyObject *args); static PyObject *t_resourcebundle_get(t_resourcebundle *self, PyObject *arg); static PyObject *t_resourcebundle_getWithFallback(t_resourcebundle *self, PyObject *arg); static PyObject *t_resourcebundle_getStringEx(t_resourcebundle *self, PyObject *args); static PyObject *t_resourcebundle_getVersionNumber(t_resourcebundle *self); static PyObject *t_resourcebundle_getBinary(t_resourcebundle *self); static PyObject *t_resourcebundle_getIntVector(t_resourcebundle *self); static PyObject *t_resourcebundle_getLocale(t_resourcebundle *self, PyObject *args); #ifndef PYPY_VERSION static PyObject *t_resourcebundle_setAppData(PyTypeObject *type, PyObject *args); #endif static PyMethodDef t_resourcebundle_methods[] = { DECLARE_METHOD(t_resourcebundle, getSize, METH_NOARGS), DECLARE_METHOD(t_resourcebundle, getString, METH_VARARGS), DECLARE_METHOD(t_resourcebundle, getUInt, METH_NOARGS), DECLARE_METHOD(t_resourcebundle, getInt, METH_NOARGS), DECLARE_METHOD(t_resourcebundle, getKey, METH_NOARGS), DECLARE_METHOD(t_resourcebundle, getName, METH_NOARGS), DECLARE_METHOD(t_resourcebundle, getType, METH_NOARGS), DECLARE_METHOD(t_resourcebundle, hasNext, METH_NOARGS), DECLARE_METHOD(t_resourcebundle, resetIterator, METH_NOARGS), DECLARE_METHOD(t_resourcebundle, getNext, METH_NOARGS), DECLARE_METHOD(t_resourcebundle, getNextString, METH_VARARGS), DECLARE_METHOD(t_resourcebundle, get, METH_O), DECLARE_METHOD(t_resourcebundle, getWithFallback, METH_O), DECLARE_METHOD(t_resourcebundle, getStringEx, METH_VARARGS), DECLARE_METHOD(t_resourcebundle, getVersionNumber, METH_NOARGS), DECLARE_METHOD(t_resourcebundle, getBinary, METH_NOARGS), DECLARE_METHOD(t_resourcebundle, getIntVector, METH_NOARGS), DECLARE_METHOD(t_resourcebundle, getLocale, METH_VARARGS), #ifndef PYPY_VERSION DECLARE_METHOD(t_resourcebundle, setAppData, METH_CLASS | METH_VARARGS), #endif { NULL, NULL, 0, NULL } }; DECLARE_TYPE(ResourceBundle, t_resourcebundle, UObject, ResourceBundle, t_resourcebundle_init, NULL); static PyObject *wrap_ResourceBundle(const ResourceBundle &resourcebundle) { return wrap_ResourceBundle(new ResourceBundle(resourcebundle), T_OWNED); } /* LocaleData */ class t_localedata : public _wrapper { public: ULocaleData *object; char *locale_id; }; static int t_localedata_init(t_localedata *self, PyObject *args, PyObject *kwds); static PyObject *t_localedata_getNoSubstitute(t_localedata *self); static PyObject *t_localedata_setNoSubstitute(t_localedata *self, PyObject *arg); static PyObject *t_localedata_getPaperSize(t_localedata *self); static PyObject *t_localedata_getLocaleDisplayPattern(t_localedata *self); static PyObject *t_localedata_getLocaleSeparator(t_localedata *self); static PyObject *t_localedata_getDelimiter(t_localedata *self, PyObject *arg); static PyObject *t_localedata_getMeasurementSystem(t_localedata *self); static PyObject *t_localedata_getExemplarSet(t_localedata *self, PyObject *args); static PyMethodDef t_localedata_methods[] = { DECLARE_METHOD(t_localedata, getNoSubstitute, METH_NOARGS), DECLARE_METHOD(t_localedata, setNoSubstitute, METH_O), DECLARE_METHOD(t_localedata, getPaperSize, METH_NOARGS), DECLARE_METHOD(t_localedata, getLocaleDisplayPattern, METH_NOARGS), DECLARE_METHOD(t_localedata, getLocaleSeparator, METH_NOARGS), DECLARE_METHOD(t_localedata, getDelimiter, METH_O), DECLARE_METHOD(t_localedata, getMeasurementSystem, METH_NOARGS), DECLARE_METHOD(t_localedata, getExemplarSet, METH_VARARGS), { NULL, NULL, 0, NULL } }; static void t_localedata_dealloc(t_localedata *self) { if (self->object) { ulocdata_close(self->object); self->object = NULL; } free(self->locale_id); self->locale_id = NULL; Py_TYPE(self)->tp_free((PyObject *) self); } DECLARE_STRUCT(LocaleData, t_localedata, ULocaleData, t_localedata_init, t_localedata_dealloc); #if U_ICU_VERSION_HEX >= VERSION_HEX(51, 0, 0) /* Region */ class t_region : public _wrapper { public: const Region *object; }; static PyObject *t_region_getInstance(PyTypeObject *type, PyObject *arg); static PyObject *t_region_getRegionCode(t_region *self); static PyObject *t_region_getNumericCode(t_region *self); static PyObject *t_region_getType(t_region *self); static PyObject *t_region_getContainingRegion(t_region *self, PyObject *args); static PyObject *t_region_contains(t_region *self, PyObject *arg); #if U_ICU_VERSION_HEX >= VERSION_HEX(55, 0, 0) static PyObject *t_region_getAvailable(PyTypeObject *type, PyObject *arg); static PyObject *t_region_getContainedRegions(t_region *self, PyObject *args); static PyObject *t_region_getPreferredValues(t_region *self); #endif static PyMethodDef t_region_methods[] = { DECLARE_METHOD(t_region, getInstance, METH_O | METH_CLASS), DECLARE_METHOD(t_region, getRegionCode, METH_NOARGS), DECLARE_METHOD(t_region, getNumericCode, METH_NOARGS), DECLARE_METHOD(t_region, getType, METH_NOARGS), DECLARE_METHOD(t_region, getContainingRegion, METH_VARARGS), DECLARE_METHOD(t_region, contains, METH_O), #if U_ICU_VERSION_HEX >= VERSION_HEX(55, 0, 0) DECLARE_METHOD(t_region, getAvailable, METH_O | METH_CLASS), DECLARE_METHOD(t_region, getPreferredValues, METH_NOARGS), DECLARE_METHOD(t_region, getContainedRegions, METH_VARARGS), #endif { NULL, NULL, 0, NULL } }; DECLARE_TYPE(Region, t_region, UObject, const Region, abstract_init, NULL); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(64, 0, 0) /* LocaleBuilder */ class t_localebuilder : public _wrapper { public: LocaleBuilder *object; }; static int t_localebuilder_init(t_localebuilder *self, PyObject *args, PyObject *kwds); static PyObject *t_localebuilder_setLocale(t_localebuilder *self, PyObject *arg); static PyObject *t_localebuilder_setLanguageTag(t_localebuilder *self, PyObject *arg); static PyObject *t_localebuilder_setLanguage(t_localebuilder *self, PyObject *arg); static PyObject *t_localebuilder_setScript(t_localebuilder *self, PyObject *arg); static PyObject *t_localebuilder_setRegion(t_localebuilder *self, PyObject *arg); static PyObject *t_localebuilder_setVariant(t_localebuilder *self, PyObject *arg); static PyObject *t_localebuilder_addUnicodeLocaleAttribute(t_localebuilder *self, PyObject *arg); static PyObject *t_localebuilder_removeUnicodeLocaleAttribute(t_localebuilder *self, PyObject *arg); static PyObject *t_localebuilder_setExtension(t_localebuilder *self, PyObject *args); static PyObject *t_localebuilder_setUnicodeLocaleKeyword(t_localebuilder *self, PyObject *args); static PyObject *t_localebuilder_clear(t_localebuilder *self); static PyObject *t_localebuilder_clearExtensions(t_localebuilder *self); static PyObject *t_localebuilder_build(t_localebuilder *self); static PyMethodDef t_localebuilder_methods[] = { DECLARE_METHOD(t_localebuilder, setLocale, METH_O), DECLARE_METHOD(t_localebuilder, setLanguageTag, METH_O), DECLARE_METHOD(t_localebuilder, setLanguage, METH_O), DECLARE_METHOD(t_localebuilder, setScript, METH_O), DECLARE_METHOD(t_localebuilder, setRegion, METH_O), DECLARE_METHOD(t_localebuilder, setVariant, METH_O), DECLARE_METHOD(t_localebuilder, addUnicodeLocaleAttribute, METH_O), DECLARE_METHOD(t_localebuilder, removeUnicodeLocaleAttribute, METH_O), DECLARE_METHOD(t_localebuilder, setExtension, METH_VARARGS), DECLARE_METHOD(t_localebuilder, setUnicodeLocaleKeyword, METH_VARARGS), DECLARE_METHOD(t_localebuilder, clear, METH_NOARGS), DECLARE_METHOD(t_localebuilder, clearExtensions, METH_NOARGS), DECLARE_METHOD(t_localebuilder, build, METH_NOARGS), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(LocaleBuilder, t_localebuilder, UObject, LocaleBuilder, t_localebuilder_init, NULL); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(65, 0, 0) using LocaleMatcherBuilder = LocaleMatcher::Builder; using LocaleMatcherResult = LocaleMatcher::Result; /* LocaleMatcherBuilder */ class t_localematcherbuilder : public _wrapper { public: LocaleMatcherBuilder *object; }; static int t_localematcherbuilder_init(t_localematcherbuilder *self, PyObject *args, PyObject *kwds); static PyObject *t_localematcherbuilder_setSupportedLocalesFromListString(t_localematcherbuilder *self, PyObject *arg); static PyObject *t_localematcherbuilder_setSupportedLocales(t_localematcherbuilder *self, PyObject *arg); static PyObject *t_localematcherbuilder_addSupportedLocale(t_localematcherbuilder *self, PyObject *arg); static PyObject *t_localematcherbuilder_setDefaultLocale(t_localematcherbuilder *self, PyObject *arg); static PyObject *t_localematcherbuilder_setFavorSubtag(t_localematcherbuilder *self, PyObject *arg); static PyObject *t_localematcherbuilder_setDemotionPerDesiredLocale(t_localematcherbuilder *self, PyObject *arg); static PyObject *t_localematcherbuilder_build(t_localematcherbuilder *self); static PyMethodDef t_localematcherbuilder_methods[] = { DECLARE_METHOD(t_localematcherbuilder, setSupportedLocalesFromListString, METH_O), DECLARE_METHOD(t_localematcherbuilder, setSupportedLocales, METH_O), DECLARE_METHOD(t_localematcherbuilder, addSupportedLocale, METH_O), DECLARE_METHOD(t_localematcherbuilder, setDefaultLocale, METH_O), DECLARE_METHOD(t_localematcherbuilder, setFavorSubtag, METH_O), DECLARE_METHOD(t_localematcherbuilder, setDemotionPerDesiredLocale, METH_O), DECLARE_METHOD(t_localematcherbuilder, build, METH_NOARGS), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(LocaleMatcherBuilder, t_localematcherbuilder, UMemory, LocaleMatcherBuilder, t_localematcherbuilder_init, NULL); /* LocaleMatcherResult */ class t_localematcherresult : public _wrapper { public: LocaleMatcherResult *object; }; static PyObject *t_localematcherresult_getDesiredLocale(t_localematcherresult *self); static PyObject *t_localematcherresult_getSupportedLocale(t_localematcherresult *self); static PyObject *t_localematcherresult_getDesiredIndex(t_localematcherresult *self); static PyObject *t_localematcherresult_getSupportedIndex(t_localematcherresult *self); static PyObject *t_localematcherresult_makeResolvedLocale(t_localematcherresult *self); static PyMethodDef t_localematcherresult_methods[] = { DECLARE_METHOD(t_localematcherresult, getDesiredLocale, METH_NOARGS), DECLARE_METHOD(t_localematcherresult, getSupportedLocale, METH_NOARGS), DECLARE_METHOD(t_localematcherresult, getDesiredIndex, METH_NOARGS), DECLARE_METHOD(t_localematcherresult, getSupportedIndex, METH_NOARGS), DECLARE_METHOD(t_localematcherresult, makeResolvedLocale, METH_NOARGS), { NULL, NULL, 0, NULL } }; DECLARE_BY_VALUE_TYPE(LocaleMatcherResult, t_localematcherresult, UMemory, LocaleMatcherResult, abstract_init); /* LocaleMatcher */ class t_localematcher : public _wrapper { public: LocaleMatcher *object; }; static PyObject *t_localematcher_getBestMatch(t_localematcher *self, PyObject *arg); static PyObject *t_localematcher_getBestMatchForListString(t_localematcher *self, PyObject *arg); static PyObject *t_localematcher_getBestMatchResult(t_localematcher *self, PyObject *arg); static PyMethodDef t_localematcher_methods[] = { DECLARE_METHOD(t_localematcher, getBestMatch, METH_O), DECLARE_METHOD(t_localematcher, getBestMatchForListString, METH_O), DECLARE_METHOD(t_localematcher, getBestMatchResult, METH_O), { NULL, NULL, 0, NULL } }; DECLARE_BY_VALUE_TYPE(LocaleMatcher, t_localematcher, UMemory, LocaleMatcher, abstract_init); #endif /* Locale */ static int t_locale_init(t_locale *self, PyObject *args, PyObject *kwds) { charsArg language, country, variant, keywords; int lcid, len; if (PyTuple_Size(args) < 4 && kwds != NULL) { PyObject *items = PyDict_Items(kwds); int len = PySequence_Fast_GET_SIZE(items); if (len > 0) { PyObject *eq = PyUnicode_FromString("="); PyObject *all = NULL; if (len > 1) { PyObject *pairs = PyTuple_New(len); for (int i = 0; i < len; ++i) { PyObject *pair = PyUnicode_Join( eq, PySequence_Fast_GET_ITEM(items, i)); if (pair == NULL) { Py_DECREF(pairs); Py_DECREF(eq); Py_DECREF(items); return -1; } PyTuple_SET_ITEM(pairs, i, pair); } PyObject *sm = PyUnicode_FromString(";"); all = PyUnicode_Join(sm, pairs); Py_DECREF(sm); Py_DECREF(pairs); } else all = PyUnicode_Join(eq, PySequence_Fast_GET_ITEM(items, 0)); Py_DECREF(eq); Py_DECREF(items); if (all == NULL) return -1; PyObject *bytes = PyUnicode_AsASCIIString(all); Py_DECREF(all); if (bytes == NULL) return -1; keywords.own(bytes); } else Py_DECREF(items); } switch (PyTuple_Size(args)) { case 0: self->object = new Locale(NULL, NULL, NULL, kwds != NULL ? keywords.c_str() : NULL); self->flags = T_OWNED; break; case 1: if (!parseArgs(args, "n", &language)) { self->object = new Locale(language, NULL, NULL, kwds != NULL ? keywords.c_str() : NULL); self->flags = T_OWNED; break; } if (!parseArgs(args, "i", &lcid)) { char code[128]; INT_STATUS_CALL(len = uloc_getLocaleForLCID( lcid, code, sizeof(code), &status)); if ((size_t) len < sizeof(code)) { self->object = new Locale( code, NULL, NULL, kwds != NULL ? keywords.c_str() : NULL); 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, NULL, kwds != NULL ? keywords.c_str() : NULL); 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, kwds != NULL ? keywords.c_str() : NULL); self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; case 4: if (!parseArgs(args, "nnnn", &language, &country, &variant, &keywords)) { self->object = new Locale(language, country, variant, keywords); 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); } #if U_ICU_VERSION_HEX >= VERSION_HEX(63, 0, 0) static PyObject *t_locale_createUnicodeKeywords(t_locale *self) { StringEnumeration *se; STATUS_CALL(se = self->object->createUnicodeKeywords(status)); return wrap_StringEnumeration(se, T_OWNED); } #endif static PyObject *t_locale_getKeywordValue(t_locale *self, PyObject *arg) { charsArg name; if (!parseArg(arg, "n", &name)) { char buf[ULOC_FULLNAME_CAPACITY]; int32_t len; STATUS_CALL(len = self->object->getKeywordValue( name, buf, sizeof(buf) - 1, status)); if (len == 0) Py_RETURN_NONE; return PyString_FromStringAndSize(buf, len); } return PyErr_SetArgsError((PyObject *) self, "getKeywordValue", arg); } #if U_ICU_VERSION_HEX >= VERSION_HEX(49, 0, 0) static PyObject *t_locale_setKeywordValue(t_locale *self, PyObject *args) { charsArg name, value; if (!parseArgs(args, "nn", &name, &value)) { STATUS_CALL(self->object->setKeywordValue(name, value, status)); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setKeywordValue", args); } static PyObject *t_locale_removeKeywordValue(t_locale *self, PyObject *arg) { charsArg name; if (!parseArg(arg, "n", &name)) { STATUS_CALL(self->object->setKeywordValue(name, "", status)); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "removeKeywordValue", arg); } #endif static PyObject *t_locale_isBogus(t_locale *self) { int retval = self->object->isBogus(); Py_RETURN_BOOL(retval); } static PyObject *t_locale_setToBogus(t_locale *self) { self->object->setToBogus(); Py_RETURN_NONE; } #if U_ICU_VERSION_HEX >= 0x04000000 && U_ICU_VERSION_HEX < VERSION_HEX(63, 0, 0) static PyObject *t_locale_addLikelySubtags(t_locale *self) { char maximized[128]; int32_t size; API_STATUS_CALL(size, uloc_addLikelySubtags, (self->object->getName(), maximized, sizeof(maximized), &status)); return PyString_FromStringAndSize(maximized, size); } static PyObject *t_locale_minimizeSubtags(t_locale *self) { char minimized[128]; int32_t size; API_STATUS_CALL(size, uloc_minimizeSubtags, (self->object->getName(), minimized, sizeof(minimized), &status)); return PyString_FromStringAndSize(minimized, size); } #elif U_ICU_VERSION_HEX >= VERSION_HEX(63, 0, 0) static PyObject *t_locale_addLikelySubtags(t_locale *self) { STATUS_CALL(self->object->addLikelySubtags(status)); Py_RETURN_SELF(); } static PyObject *t_locale_minimizeSubtags(t_locale *self) { STATUS_CALL(self->object->minimizeSubtags(status)); Py_RETURN_SELF(); } #endif #if U_ICU_VERSION_HEX >= 0x04040000 static PyObject *t_locale_getRoot(PyTypeObject *self) { return wrap_Locale(Locale::getRoot()); } #endif static PyObject *t_locale_getEnglish(PyTypeObject *self) { return wrap_Locale(Locale::getEnglish()); } static PyObject *t_locale_getFrench(PyTypeObject *self) { return wrap_Locale(Locale::getFrench()); } static PyObject *t_locale_getGerman(PyTypeObject *self) { return wrap_Locale(Locale::getGerman()); } static PyObject *t_locale_getItalian(PyTypeObject *self) { return wrap_Locale(Locale::getItalian()); } static PyObject *t_locale_getJapanese(PyTypeObject *self) { return wrap_Locale(Locale::getJapanese()); } static PyObject *t_locale_getKorean(PyTypeObject *self) { return wrap_Locale(Locale::getKorean()); } static PyObject *t_locale_getChinese(PyTypeObject *self) { return wrap_Locale(Locale::getChinese()); } static PyObject *t_locale_getSimplifiedChinese(PyTypeObject *self) { return wrap_Locale(Locale::getSimplifiedChinese()); } static PyObject *t_locale_getTraditionalChinese(PyTypeObject *self) { return wrap_Locale(Locale::getTraditionalChinese()); } static PyObject *t_locale_getFrance(PyTypeObject *self) { return wrap_Locale(Locale::getFrance()); } static PyObject *t_locale_getGermany(PyTypeObject *self) { return wrap_Locale(Locale::getGermany()); } static PyObject *t_locale_getItaly(PyTypeObject *self) { return wrap_Locale(Locale::getItaly()); } static PyObject *t_locale_getJapan(PyTypeObject *self) { return wrap_Locale(Locale::getJapan()); } static PyObject *t_locale_getKorea(PyTypeObject *self) { return wrap_Locale(Locale::getKorea()); } static PyObject *t_locale_getChina(PyTypeObject *self) { return wrap_Locale(Locale::getChina()); } static PyObject *t_locale_getPRC(PyTypeObject *self) { return wrap_Locale(Locale::getPRC()); } static PyObject *t_locale_getTaiwan(PyTypeObject *self) { return wrap_Locale(Locale::getTaiwan()); } static PyObject *t_locale_getUK(PyTypeObject *self) { return wrap_Locale(Locale::getUK()); } static PyObject *t_locale_getUS(PyTypeObject *self) { return wrap_Locale(Locale::getUS()); } static PyObject *t_locale_getCanada(PyTypeObject *self) { return wrap_Locale(Locale::getCanada()); } static PyObject *t_locale_getCanadaFrench(PyTypeObject *self) { return wrap_Locale(Locale::getCanadaFrench()); } static PyObject *t_locale_getDefault(PyTypeObject *self) { return wrap_Locale(Locale::getDefault()); } static PyObject *t_locale_setDefault(PyTypeObject *type, PyObject *args) { Locale *locale; switch (PyTuple_Size(args)) { case 0: STATUS_CALL(Locale::setDefault(NULL, status)); Py_RETURN_NONE; case 1: if (!parseArgs(args, "P", TYPE_CLASSID(Locale), &locale)) { STATUS_CALL(Locale::setDefault(*locale, status)); /* transient */ Py_RETURN_NONE; } break; } return PyErr_SetArgsError(type, "setDefault", args); } static PyObject *t_locale_createFromName(PyTypeObject *type, PyObject *args) { Locale locale; charsArg name; switch (PyTuple_Size(args)) { case 0: locale = Locale::createFromName(NULL); return wrap_Locale(locale); case 1: if (!parseArgs(args, "n", &name)) { locale = Locale::createFromName(name); return wrap_Locale(locale); } break; } return PyErr_SetArgsError(type, "createFromName", args); } static PyObject *t_locale_createCanonical(PyTypeObject *type, PyObject *arg) { Locale locale; charsArg name; if (!parseArg(arg, "n", &name)) { locale = Locale::createCanonical(name); return wrap_Locale(locale); } return PyErr_SetArgsError(type, "createCanonical", arg); } #if U_ICU_VERSION_HEX >= VERSION_HEX(63, 0, 0) static PyObject *t_locale_forLanguageTag(PyTypeObject *type, PyObject *arg) { Locale locale; charsArg name; if (!parseArg(arg, "n", &name)) { STATUS_CALL(locale = Locale::forLanguageTag(name.c_str(), status)); return wrap_Locale(locale); } return PyErr_SetArgsError(type, "forLanguageTag", arg); } static PyObject *t_locale_toLanguageTag(t_locale *self) { struct sink { UnicodeString u; void append(const char *data, int32_t n) { u.append(UnicodeString(data, n, US_INV)); } } buffer; StringByteSink sbs(&buffer); STATUS_CALL(self->object->toLanguageTag(sbs, status)); return PyUnicode_FromUnicodeString(&buffer.u); } #endif static PyObject *t_locale_getAvailableLocales(PyTypeObject *type) { int count; const Locale *locales = Locale::getAvailableLocales(count); PyObject *dict = PyDict_New(); for (int32_t i = 0; i < count; i++) { Locale *locale = (Locale *) locales + i; PyObject *obj = wrap_Locale(locale, 0); PyDict_SetItemString(dict, locale->getName(), obj); Py_DECREF(obj); } return dict; } static PyObject *t_locale_getISOCountries(PyTypeObject *type) { const char *const *countries = Locale::getISOCountries(); PyObject *list; int len = 0; while (countries[len] != NULL) len += 1; list = PyList_New(len); for (int i = 0; i < len; i++) { PyObject *str = PyString_FromStringAndSize(countries[i], 2); PyList_SET_ITEM(list, i, str); } return list; } static PyObject *t_locale_getISOLanguages(PyTypeObject *type) { const char *const *languages = Locale::getISOLanguages(); PyObject *list; int len = 0; while (languages[len] != NULL) len += 1; list = PyList_New(len); for (int i = 0; i < len; i++) { PyObject *str = PyString_FromString(languages[i]); PyList_SET_ITEM(list, i, str); } return list; } static PyObject *t_locale_str(t_locale *self) { return PyString_FromString(self->object->getName()); } static long t_locale_hash(t_locale *self) { return (long) self->object->hashCode(); } DEFINE_RICHCMP(Locale, t_locale); /* ResourceBundle */ static int t_resourcebundle_init(t_resourcebundle *self, PyObject *args, PyObject *kwds) { UnicodeString *u, _u; Locale *locale; ResourceBundle *bundle; switch (PyTuple_Size(args)) { case 0: INT_STATUS_CALL(bundle = new ResourceBundle(status)); self->object = bundle; self->flags = T_OWNED; break; case 1: if (!parseArgs(args, "S", &u, &_u)) { INT_STATUS_CALL(bundle = new ResourceBundle(*u, status)); self->object = bundle; self->flags = T_OWNED; break; } case 2: if (!parseArgs(args, "SP", TYPE_CLASSID(Locale), &u, &_u, &locale)) { INT_STATUS_CALL(bundle = new ResourceBundle(*u, *locale, status)); self->object = bundle; self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; } if (self->object) return 0; return -1; } static PyObject *t_resourcebundle_getSize(t_resourcebundle *self) { return PyInt_FromLong(self->object->getSize()); } static PyObject *t_resourcebundle_getString(t_resourcebundle *self, PyObject *args) { UnicodeString *u, _u; switch (PyTuple_Size(args)) { case 0: STATUS_CALL(_u = self->object->getString(status)); return PyUnicode_FromUnicodeString(&_u); case 1: if (!parseArgs(args, "U", &u)) { STATUS_CALL(u->setTo(self->object->getString(status))); Py_RETURN_ARG(args, 0); } break; } return PyErr_SetArgsError((PyObject *) self, "getString", args); } static PyObject *t_resourcebundle_getUInt(t_resourcebundle *self) { int n; STATUS_CALL(n = self->object->getUInt(status)); return PyInt_FromLong(n); } static PyObject *t_resourcebundle_getInt(t_resourcebundle *self) { int n; STATUS_CALL(n = self->object->getInt(status)); return PyInt_FromLong(n); } static PyObject *t_resourcebundle_getKey(t_resourcebundle *self) { return PyString_FromString(self->object->getKey()); } static PyObject *t_resourcebundle_getName(t_resourcebundle *self) { return PyString_FromString(self->object->getName()); } static PyObject *t_resourcebundle_getType(t_resourcebundle *self) { return PyInt_FromLong((long) self->object->getType()); } static PyObject *t_resourcebundle_hasNext(t_resourcebundle *self) { int b = self->object->hasNext(); Py_RETURN_BOOL(b); } static PyObject *t_resourcebundle_resetIterator(t_resourcebundle *self) { self->object->resetIterator(); Py_RETURN_NONE; } static PyObject *t_resourcebundle_getNext(t_resourcebundle *self) { UErrorCode status = U_ZERO_ERROR; ResourceBundle rb = self->object->getNext(status); if (U_FAILURE(status)) return ICUException(status).reportError(); return wrap_ResourceBundle(rb); } static PyObject *t_resourcebundle_getNextString(t_resourcebundle *self, PyObject *args) { UnicodeString *u; UnicodeString _u; switch (PyTuple_Size(args)) { case 0: STATUS_CALL(_u = self->object->getNextString(status)); return PyUnicode_FromUnicodeString(&_u); case 1: if (!parseArgs(args, "U", &u)) { STATUS_CALL(u->setTo(self->object->getNextString(status))); Py_RETURN_ARG(args, 0); } break; } return PyErr_SetArgsError((PyObject *) self, "getNextString", args); } static PyObject *t_resourcebundle_get(t_resourcebundle *self, PyObject *arg) { UErrorCode status = U_ZERO_ERROR; charsArg key; int i; if (!parseArg(arg, "i", &i)) { ResourceBundle rb = self->object->get(i, status); if (U_FAILURE(status)) return ICUException(status).reportError(); return wrap_ResourceBundle(rb); } if (!parseArg(arg, "n", &key)) { ResourceBundle rb = self->object->get(key, status); if (U_FAILURE(status)) return ICUException(status).reportError(); return wrap_ResourceBundle(rb); } return PyErr_SetArgsError((PyObject *) self, "get", arg); } static PyObject *t_resourcebundle_getWithFallback(t_resourcebundle *self, PyObject *arg) { UErrorCode status = U_ZERO_ERROR; charsArg key; if (!parseArg(arg, "n", &key)) { ResourceBundle rb = self->object->getWithFallback(key, status); if (U_FAILURE(status)) return ICUException(status).reportError(); return wrap_ResourceBundle(rb); } return PyErr_SetArgsError((PyObject *) self, "getWithFallback", arg); } static PyObject *t_resourcebundle_getStringEx(t_resourcebundle *self, PyObject *args) { UnicodeString *u; UnicodeString _u; charsArg key; int i; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "i", &i)) { STATUS_CALL(_u = self->object->getStringEx(i, status)); return PyUnicode_FromUnicodeString(&_u); } if (!parseArgs(args, "n", &key)) { STATUS_CALL(_u = self->object->getStringEx(key, status)); return PyUnicode_FromUnicodeString(&_u); } case 2: if (!parseArgs(args, "iU", &i, &u)) { STATUS_CALL(u->setTo(self->object->getStringEx(i, status))); Py_RETURN_ARG(args, 1); } if (!parseArgs(args, "nU", &key, &u)) { STATUS_CALL(u->setTo(self->object->getStringEx(key, status))); Py_RETURN_ARG(args, 1); } break; } return PyErr_SetArgsError((PyObject *) self, "getStringEx", args); } static PyObject *t_resourcebundle_getVersionNumber(t_resourcebundle *self) { return PyString_FromString(self->object->getVersionNumber()); } static PyObject *t_resourcebundle_getBinary(t_resourcebundle *self) { int32_t len; const uint8_t *data; STATUS_CALL(data = self->object->getBinary(len, status)); return PyString_FromStringAndSize((const char *) data, len); } static PyObject *t_resourcebundle_getIntVector(t_resourcebundle *self) { int32_t len; const int32_t *data; STATUS_CALL(data = self->object->getIntVector(len, status)); PyObject *list = PyList_New(len); for (int i = 0; i < len; i++) PyList_SET_ITEM(list, i, PyInt_FromLong(data[i])); return list; } static PyObject *t_resourcebundle_getLocale(t_resourcebundle *self, PyObject *args) { ULocDataLocaleType type; switch (PyTuple_Size(args)) { case 0: return wrap_Locale(self->object->getLocale()); case 1: if (!parseArgs(args, "i", &type)) { Locale locale; STATUS_CALL(locale = self->object->getLocale(type, status)); return wrap_Locale(locale); } break; } return PyErr_SetArgsError((PyObject *) self, "getLocale", args); } #ifndef PYPY_VERSION #if defined(_MSC_VER) || defined(__WIN32) static PyObject *t_resourcebundle_setAppData(PyTypeObject *type, PyObject *args) { charsArg packageName, path; if (!parseArgs(args, "nf", &packageName, &path)) { HANDLE fd = CreateFile(path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL); UErrorCode status = U_ZERO_ERROR; DWORD dwSize; HANDLE hMap; LPVOID data; if (fd == INVALID_HANDLE_VALUE) return PyErr_SetFromWindowsErrWithFilename(0, path); dwSize = GetFileSize(fd, NULL); if (dwSize == INVALID_FILE_SIZE) { PyErr_SetFromWindowsErrWithFilename(0, path); CloseHandle(fd); return NULL; } hMap = CreateFileMapping(fd, NULL, PAGE_READONLY, 0, dwSize, NULL); if (!hMap) { PyErr_SetFromWindowsErrWithFilename(0, path); CloseHandle(fd); return NULL; } CloseHandle(fd); data = MapViewOfFile(hMap, FILE_MAP_READ, 0, 0, 0); if (!data) { PyErr_SetFromWindowsErrWithFilename(0, path); CloseHandle(hMap); return NULL; } CloseHandle(hMap); udata_setAppData(packageName, data, &status); if (U_FAILURE(status)) { UnmapViewOfFile(data); return ICUException(status).reportError(); } Py_RETURN_NONE; } return PyErr_SetArgsError(type, "setAppData", args); } #else static PyObject *t_resourcebundle_setAppData(PyTypeObject *type, PyObject *args) { charsArg packageName, path; if (!parseArgs(args, "nf", &packageName, &path)) { int fd = open(path, O_RDONLY); UErrorCode status = U_ZERO_ERROR; struct stat buf; void *data; if (fd < 0) return PyErr_SetFromErrnoWithFilename(PyExc_ValueError, path); if (fstat(fd, &buf) < 0) { PyErr_SetFromErrnoWithFilename(PyExc_ValueError, path); close(fd); return NULL; } data = mmap(NULL, (size_t) 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, (size_t) buf.st_size); return ICUException(status).reportError(); } Py_RETURN_NONE; } return PyErr_SetArgsError(type, "setAppData", args); } #endif #endif // !PYPY_VERSION static PyObject *t_resourcebundle_iter(t_resourcebundle *self) { self->object->resetIterator(); Py_INCREF(self); return (PyObject *) self; } static PyObject *t_resourcebundle_next(t_resourcebundle *self) { if (self->object->hasNext()) { UErrorCode status = U_ZERO_ERROR; ResourceBundle rb = self->object->getNext(status); if (U_FAILURE(status)) return ICUException(status).reportError(); return wrap_ResourceBundle(rb); } PyErr_SetNone(PyExc_StopIteration); return NULL; } static PyObject *t_resourcebundle_str(t_resourcebundle *self) { switch (self->object->getType()) { case URES_NONE: return PyString_FromString("URES_NONE"); case URES_STRING: return PyString_FromString("URES_STRING"); case URES_BINARY: return PyString_FromString("URES_BINARY"); case URES_TABLE: return PyString_FromString("URES_TABLE"); case URES_ALIAS: return PyString_FromString("URES_ALIAS"); case URES_ARRAY: return PyString_FromString("URES_ARRAY"); case URES_INT_VECTOR: return PyString_FromString("URES_INT_VECTOR"); case RES_RESERVED: return PyString_FromString("RES_RESERVED"); default: return PyString_FromString("unknown"); } } /* LocaleData */ static int t_localedata_init(t_localedata *self, PyObject *args, PyObject *kwds) { charsArg id; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "n", &id)) { ULocaleData *locale_data; INT_STATUS_CALL(locale_data = ulocdata_open(id, &status)); self->object = locale_data; self->locale_id = strdup((const char *) id); self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; default: PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; } if (self->object) return 0; return -1; } static PyObject *t_localedata_getNoSubstitute(t_localedata *self) { if (ulocdata_getNoSubstitute(self->object)) Py_RETURN_TRUE; Py_RETURN_FALSE; } static PyObject *t_localedata_setNoSubstitute(t_localedata *self, PyObject *arg) { int setting; if (!parseArg(arg, "b", &setting)) { ulocdata_setNoSubstitute(self->object, setting); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setNoSubstitute", arg); } static PyObject *t_localedata_getPaperSize(t_localedata *self) { int32_t width, height; STATUS_CALL(ulocdata_getPaperSize(self->locale_id, &width, &height, &status)); return Py_BuildValue("ii", width, height); } static PyObject *t_localedata_getLocaleDisplayPattern(t_localedata *self) { UChar buffer[256]; int size; STATUS_CALL(size = ulocdata_getLocaleDisplayPattern(self->object, buffer, 255, &status)); return PyUnicode_FromUnicodeString(buffer, size); } static PyObject *t_localedata_getLocaleSeparator(t_localedata *self) { UChar buffer[256]; int size; STATUS_CALL(size = ulocdata_getLocaleSeparator(self->object, buffer, 255, &status)); return PyUnicode_FromUnicodeString(buffer, size); } static PyObject *t_localedata_getDelimiter(t_localedata *self, PyObject *arg) { ULocaleDataDelimiterType type; if (!parseArg(arg, "i", &type)) { UChar buffer[256]; int size; STATUS_CALL(size = ulocdata_getDelimiter(self->object, type, buffer, 255, &status)); return PyUnicode_FromUnicodeString(buffer, size); } return PyErr_SetArgsError((PyObject *) self, "getDelimiter", arg); } static PyObject *t_localedata_getMeasurementSystem(t_localedata *self) { UMeasurementSystem ms; STATUS_CALL(ms = ulocdata_getMeasurementSystem(self->locale_id, &status)); return PyInt_FromLong(ms); } static PyObject *t_localedata_getExemplarSet(t_localedata *self, PyObject *args) { int options; ULocaleDataExemplarSetType type; switch (PyTuple_Size(args)) { case 0: { USet *set; STATUS_CALL(set = ulocdata_getExemplarSet(self->object, NULL, 0, ULOCDATA_ES_STANDARD, &status)); return wrap_UnicodeSet(UnicodeSet::fromUSet(set), T_OWNED); } break; case 1: if (!parseArgs(args, "i", &type)) { USet *set; STATUS_CALL(set = ulocdata_getExemplarSet(self->object, NULL, 0, type, &status)); return wrap_UnicodeSet(UnicodeSet::fromUSet(set), T_OWNED); } break; case 2: if (!parseArgs(args, "ii", &options, &type)) { USet *set; STATUS_CALL(set = ulocdata_getExemplarSet(self->object, NULL, options, type, &status)); return wrap_UnicodeSet(UnicodeSet::fromUSet(set), T_OWNED); } } return PyErr_SetArgsError((PyObject *) self, "getExemplarSet", args); } #if U_ICU_VERSION_HEX >= VERSION_HEX(51, 0, 0) /* Region */ static PyObject *t_region_getInstance(PyTypeObject *type, PyObject *arg) { charsArg region_code; int32_t code; if (!parseArg(arg, "n", ®ion_code)) { const Region *region; STATUS_CALL(region = Region::getInstance(region_code, status)); return wrap_Region(region, 0); } if (!parseArg(arg, "i", &code)) { const Region *region; STATUS_CALL(region = Region::getInstance(code, status)); return wrap_Region(region, 0); } return PyErr_SetArgsError(type, "getInstance", arg); } static PyObject *t_region_getRegionCode(t_region *self) { return PyString_FromString(self->object->getRegionCode()); } static PyObject *t_region_getNumericCode(t_region *self) { return PyInt_FromLong(self->object->getNumericCode()); } static PyObject *t_region_getType(t_region *self) { return PyInt_FromLong(self->object->getType()); } static PyObject *t_region_getContainingRegion(t_region *self, PyObject *args) { URegionType region_type; const Region *region; switch (PyTuple_Size(args)) { case 0: region = self->object->getContainingRegion(); if (region == NULL) Py_RETURN_NONE; else return wrap_Region(region, 0); case 1: if (!parseArgs(args, "i", ®ion_type)) { region = self->object->getContainingRegion(region_type); if (region == NULL) Py_RETURN_NONE; else return wrap_Region(region, 0); } } return PyErr_SetArgsError((PyObject *) self, "getContainingRegion", args); } #if U_ICU_VERSION_HEX >= VERSION_HEX(55, 0, 0) static PyObject *t_region_getAvailable(PyTypeObject *type, PyObject *arg) { URegionType region_type; StringEnumeration *se; if (!parseArg(arg, "i", ®ion_type)) { STATUS_CALL(se = Region::getAvailable(region_type, status)); return wrap_StringEnumeration(se, T_OWNED); } return PyErr_SetArgsError(type, "getAvailable", arg); } static PyObject *t_region_getContainedRegions(t_region *self, PyObject *args) { StringEnumeration *se; URegionType region_type; switch (PyTuple_Size(args)) { case 0: STATUS_CALL(se = self->object->getContainedRegions(status)); return wrap_StringEnumeration(se, T_OWNED); case 1: if (!parseArgs(args, "i", ®ion_type)) { STATUS_CALL(se = self->object->getContainedRegions( region_type, status)); return wrap_StringEnumeration(se, T_OWNED); } break; } return PyErr_SetArgsError((PyObject *) self, "getContainedRegions", args); } static PyObject *t_region_getPreferredValues(t_region *self) { StringEnumeration *se; STATUS_CALL(se = self->object->getPreferredValues(status)); if (se == NULL) Py_RETURN_NONE; return wrap_StringEnumeration(se, T_OWNED); } #endif static PyObject *t_region_contains(t_region *self, PyObject *arg) { const Region *region; if (!parseArg(arg, "P", TYPE_CLASSID(Region), ®ion)) Py_RETURN_BOOL(self->object->contains(*region)); return PyErr_SetArgsError((PyObject *) self, "contains", arg); } static PyObject *t_region_str(t_region *self) { return PyString_FromString(self->object->getRegionCode()); } #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(64, 0, 0) /* LocaleBuilder */ static int t_localebuilder_init(t_localebuilder *self, PyObject *args, PyObject *kwds) { switch (PyTuple_Size(args)) { case 0: self->object = new LocaleBuilder(); self->flags = T_OWNED; break; default: PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; } if (self->object) return 0; return -1; } static PyObject *t_localebuilder_setLocale(t_localebuilder *self, PyObject *arg) { const Locale *locale; if (!parseArg(arg, "P", TYPE_CLASSID(Locale), &locale)) { self->object->setLocale(*locale); Py_RETURN_SELF(); } return PyErr_SetArgsError((PyObject *) self, "setLocale", arg); } #define applyLBStringPiece(setter) \ static PyObject *t_localebuilder_ ## setter(t_localebuilder *self, \ PyObject *arg) \ { \ charsArg carg; \ if (!parseArg(arg, "n", &carg)) \ { \ self->object->setter(carg.c_str()); \ Py_RETURN_SELF(); \ } \ return PyErr_SetArgsError((PyObject *) self, #setter, arg); \ } applyLBStringPiece(setLanguageTag) applyLBStringPiece(setLanguage) applyLBStringPiece(setScript) applyLBStringPiece(setRegion) applyLBStringPiece(setVariant) applyLBStringPiece(addUnicodeLocaleAttribute) applyLBStringPiece(removeUnicodeLocaleAttribute) static PyObject *t_localebuilder_setExtension(t_localebuilder *self, PyObject *args) { charsArg key, value; switch (PyTuple_Size(args)) { case 2: if (!parseArgs(args, "nn", &key, &value) && strlen(key.c_str()) == 1) { self->object->setExtension(key.c_str()[0], value.c_str()); Py_RETURN_SELF(); } break; } return PyErr_SetArgsError((PyObject *) self, "setExtension", args); } static PyObject *t_localebuilder_setUnicodeLocaleKeyword(t_localebuilder *self, PyObject *args) { charsArg key, type; switch (PyTuple_Size(args)) { case 2: if (!parseArgs(args, "nn", &key, &type)) { self->object->setUnicodeLocaleKeyword(key.c_str(), type.c_str()); Py_RETURN_SELF(); } break; } return PyErr_SetArgsError((PyObject *) self, "setUnicodeLocaleKeyword", args); } static PyObject *t_localebuilder_clear(t_localebuilder *self) { self->object->clear(); Py_RETURN_SELF(); } static PyObject *t_localebuilder_clearExtensions(t_localebuilder *self) { self->object->clearExtensions(); Py_RETURN_SELF(); } static PyObject *t_localebuilder_build(t_localebuilder *self) { Locale locale; STATUS_CALL(locale = self->object->build(status)); return wrap_Locale(locale); } #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(65, 0, 0) // takes ownership of locales pointer array class LocaleIterator : public Locale::Iterator { public: LocaleIterator(Locale **locales, int len) : locales_(locales), len_(len), current_(0) {} ~LocaleIterator() { free(locales_); // allocated with calloc in pl2cpa in common.cpp } UBool hasNext() const override { return current_ < len_; } const Locale &next() override { return *locales_[current_++]; } private: Locale **locales_; int len_; int current_; }; /* LocaleMatcherBuilder */ static int t_localematcherbuilder_init(t_localematcherbuilder *self, PyObject *args, PyObject *kwds) { switch (PyTuple_Size(args)) { case 0: self->object = new LocaleMatcherBuilder(); self->flags = T_OWNED; break; default: PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; } if (self->object) return 0; return -1; } static PyObject *t_localematcherbuilder_setSupportedLocalesFromListString( t_localematcherbuilder *self, PyObject *arg) { charsArg locales; if (!parseArg(arg, "n", &locales)) { self->object->setSupportedLocalesFromListString(locales.c_str()); Py_RETURN_SELF(); } return PyErr_SetArgsError((PyObject *) self, "setSupportedLocalesFromListString", arg); } static PyObject *t_localematcherbuilder_setSupportedLocales( t_localematcherbuilder *self, PyObject *arg) { Locale **locales; int len; if (!parseArg(arg, "Q", TYPE_CLASSID(Locale), &locales, &len, TYPE_CLASSID(Locale))) { LocaleIterator it(locales, len); self->object->setSupportedLocales(it); Py_RETURN_SELF(); } return PyErr_SetArgsError((PyObject *) self, "setSupportedLocales", arg); } static PyObject *t_localematcherbuilder_addSupportedLocale( t_localematcherbuilder *self, PyObject *arg) { Locale *locale; if (!parseArg(arg, "P", TYPE_CLASSID(Locale), &locale)) { self->object->addSupportedLocale(*locale); Py_RETURN_SELF(); } return PyErr_SetArgsError((PyObject *) self, "addSupportedLocale", arg); } static PyObject *t_localematcherbuilder_setDefaultLocale( t_localematcherbuilder *self, PyObject *arg) { Locale *locale; if (!parseArg(arg, "P", TYPE_CLASSID(Locale), &locale)) { self->object->setDefaultLocale(locale); Py_RETURN_SELF(); } return PyErr_SetArgsError((PyObject *) self, "setDefaultLocale", arg); } static PyObject *t_localematcherbuilder_setFavorSubtag( t_localematcherbuilder *self, PyObject *arg) { int option; if (!parseArg(arg, "n", &option)) { self->object->setFavorSubtag((ULocMatchFavorSubtag) option); Py_RETURN_SELF(); } return PyErr_SetArgsError((PyObject *) self, "setFavorSubtag", arg); } static PyObject *t_localematcherbuilder_setDemotionPerDesiredLocale( t_localematcherbuilder *self, PyObject *arg) { int option; if (!parseArg(arg, "n", &option)) { self->object->setDemotionPerDesiredLocale((ULocMatchDemotion) option); Py_RETURN_SELF(); } return PyErr_SetArgsError((PyObject *) self, "setDemotionPerDesiredLocale", arg); } static PyObject *t_localematcherbuilder_build(t_localematcherbuilder *self) { STATUS_RESULT_CALL(LocaleMatcher matcher = self->object->build(status), return wrap_LocaleMatcher(std::move(matcher))); } /* LocaleMatcherResult */ static PyObject *t_localematcherresult_getDesiredLocale( t_localematcherresult *self) { const Locale *locale = self->object->getDesiredLocale(); if (locale != nullptr) return wrap_Locale(*locale); Py_RETURN_NONE; } static PyObject *t_localematcherresult_getSupportedLocale( t_localematcherresult *self) { const Locale *locale = self->object->getSupportedLocale(); if (locale != nullptr) return wrap_Locale(*locale); Py_RETURN_NONE; } static PyObject *t_localematcherresult_getDesiredIndex( t_localematcherresult *self) { return PyInt_FromLong(self->object->getDesiredIndex()); } static PyObject *t_localematcherresult_getSupportedIndex( t_localematcherresult *self) { return PyInt_FromLong(self->object->getSupportedIndex()); } static PyObject *t_localematcherresult_makeResolvedLocale( t_localematcherresult *self) { STATUS_RESULT_CALL(Locale locale = self->object->makeResolvedLocale(status), return wrap_Locale(locale)); } /* LocaleMatcher */ static PyObject *t_localematcher_getBestMatch(t_localematcher *self, PyObject *arg) { const Locale *locale; Locale **locales; int len; if (!parseArg(arg, "P", TYPE_CLASSID(Locale), &locale)) { const Locale *result; STATUS_CALL(result = self->object->getBestMatch(*locale, status)); return wrap_Locale(*result); } if (!parseArg(arg, "Q", TYPE_CLASSID(Locale), &locales, &len, TYPE_CLASSID(Locale))) { LocaleIterator it(locales, len); const Locale *result; STATUS_CALL(result = self->object->getBestMatch(it, status)); return wrap_Locale(*result); } return PyErr_SetArgsError((PyObject *) self, "getBestMatch", arg); } static PyObject *t_localematcher_getBestMatchForListString( t_localematcher *self, PyObject *arg) { charsArg locales; if (!parseArg(arg, "n", &locales)) { const Locale *result; STATUS_CALL(result = self->object->getBestMatchForListString( locales.c_str(), status)); return wrap_Locale(*result); } return PyErr_SetArgsError((PyObject *) self, "getBestMatchForListString", arg); } static PyObject *t_localematcher_getBestMatchResult( t_localematcher *self, PyObject *arg) { Locale *locale; Locale **locales; int len; if (!parseArg(arg, "P", TYPE_CLASSID(Locale), &locale)) { STATUS_RESULT_CALL( LocaleMatcherResult result = self->object->getBestMatchResult( *locale, status), return wrap_LocaleMatcherResult(std::move(result))); } if (!parseArg(arg, "Q", TYPE_CLASSID(Locale), &locales, &len, TYPE_CLASSID(Locale))) { LocaleIterator it(locales, len); STATUS_RESULT_CALL( LocaleMatcherResult result = self->object->getBestMatchResult( it, status), return wrap_LocaleMatcherResult(std::move(result))); } return PyErr_SetArgsError((PyObject *) self, "getBestMatchResult", arg); } #endif void _init_locale(PyObject *m) { LocaleType_.tp_str = (reprfunc) t_locale_str; LocaleType_.tp_hash = (hashfunc) t_locale_hash; LocaleType_.tp_richcompare = (richcmpfunc) t_locale_richcmp; ResourceBundleType_.tp_iter = (getiterfunc) t_resourcebundle_iter; ResourceBundleType_.tp_iternext = (iternextfunc) t_resourcebundle_next; ResourceBundleType_.tp_str = (reprfunc) t_resourcebundle_str; #if U_ICU_VERSION_HEX >= VERSION_HEX(51, 0, 0) RegionType_.tp_str = (reprfunc) t_region_str; #endif INSTALL_CONSTANTS_TYPE(ULocDataLocaleType, m); INSTALL_CONSTANTS_TYPE(UResType, m); INSTALL_CONSTANTS_TYPE(ULocaleDataDelimiterType, m); INSTALL_CONSTANTS_TYPE(ULocaleDataExemplarSetType, m); INSTALL_CONSTANTS_TYPE(UMeasurementSystem, m); REGISTER_TYPE(Locale, m); REGISTER_TYPE(ResourceBundle, m); INSTALL_STRUCT(LocaleData, m); #if U_ICU_VERSION_HEX >= VERSION_HEX(51, 0, 0) REGISTER_TYPE(Region, m); INSTALL_CONSTANTS_TYPE(URegionType, m); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(64, 0, 0) REGISTER_TYPE(LocaleBuilder, m); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(65, 0, 0) INSTALL_STRUCT(LocaleMatcherBuilder, m); INSTALL_STRUCT(LocaleMatcherResult, m); INSTALL_STRUCT(LocaleMatcher, m); INSTALL_CONSTANTS_TYPE(ULocMatchFavorSubtag, m); INSTALL_CONSTANTS_TYPE(ULocMatchDemotion, m); PyDict_SetItemString(LocaleMatcherType_.tp_dict, "Builder", (PyObject *) &LocaleMatcherBuilderType_); PyDict_SetItemString(LocaleMatcherType_.tp_dict, "Result", (PyObject *) &LocaleMatcherResultType_); #endif INSTALL_ENUM(ULocDataLocaleType, "ACTUAL_LOCALE", ULOC_ACTUAL_LOCALE); INSTALL_ENUM(ULocDataLocaleType, "VALID_LOCALE", ULOC_VALID_LOCALE); INSTALL_ENUM(UResType, "NONE", URES_NONE); INSTALL_ENUM(UResType, "STRING", URES_STRING); INSTALL_ENUM(UResType, "BINARY", URES_BINARY); INSTALL_ENUM(UResType, "TABLE", URES_TABLE); INSTALL_ENUM(UResType, "ALIAS", URES_ALIAS); INSTALL_ENUM(UResType, "INT", URES_INT); INSTALL_ENUM(UResType, "ARRAY", URES_ARRAY); INSTALL_ENUM(UResType, "INT_VECTOR", URES_INT_VECTOR); INSTALL_ENUM(UResType, "RESERVED", RES_RESERVED); INSTALL_ENUM(ULocaleDataDelimiterType, "QUOTATION_START", ULOCDATA_QUOTATION_START); INSTALL_ENUM(ULocaleDataDelimiterType, "QUOTATION_END", ULOCDATA_QUOTATION_END); INSTALL_ENUM(ULocaleDataDelimiterType, "ALT_QUOTATION_START", ULOCDATA_ALT_QUOTATION_START); INSTALL_ENUM(ULocaleDataDelimiterType, "ALT_QUOTATION_END", ULOCDATA_ALT_QUOTATION_END); INSTALL_ENUM(ULocaleDataExemplarSetType, "ES_STANDARD", ULOCDATA_ES_STANDARD); INSTALL_ENUM(ULocaleDataExemplarSetType, "ES_AUXILIARY", ULOCDATA_ES_AUXILIARY); #if U_ICU_VERSION_HEX >= 0x04080000 INSTALL_ENUM(ULocaleDataExemplarSetType, "ES_INDEX", ULOCDATA_ES_INDEX); #endif INSTALL_ENUM(UMeasurementSystem, "SI", UMS_SI); INSTALL_ENUM(UMeasurementSystem, "US", UMS_US); // options for LocaleData.getExemplarSet() INSTALL_MODULE_INT(m, USET_IGNORE_SPACE); INSTALL_MODULE_INT(m, USET_CASE_INSENSITIVE); INSTALL_MODULE_INT(m, USET_ADD_CASE_MAPPINGS); #if U_ICU_VERSION_HEX >= VERSION_HEX(51, 0, 0) INSTALL_ENUM(URegionType, "UNKNOWN", URGN_UNKNOWN); INSTALL_ENUM(URegionType, "TERRITORY", URGN_TERRITORY); INSTALL_ENUM(URegionType, "WORLD", URGN_WORLD); INSTALL_ENUM(URegionType, "CONTINENT", URGN_CONTINENT); INSTALL_ENUM(URegionType, "SUBCONTINENT", URGN_SUBCONTINENT); INSTALL_ENUM(URegionType, "GROUPING", URGN_GROUPING); INSTALL_ENUM(URegionType, "DEPRECATED", URGN_DEPRECATED); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(65, 0, 0) INSTALL_ENUM(ULocMatchFavorSubtag, "LANGUAGE", ULOCMATCH_FAVOR_LANGUAGE); INSTALL_ENUM(ULocMatchFavorSubtag, "SCRIPT", ULOCMATCH_FAVOR_SCRIPT); INSTALL_ENUM(ULocMatchDemotion, "NONE", ULOCMATCH_DEMOTION_NONE); INSTALL_ENUM(ULocMatchDemotion, "REGION", ULOCMATCH_DEMOTION_REGION); #endif } ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1569360443.0 PyICU-2.4.2/locale.h0000644000076500000000000000275200000000000014272 0ustar00vajdawheel00000000000000/* ==================================================================== * 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 */ ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1569952598.0 PyICU-2.4.2/macros.h0000644000076500000000000006505400000000000014323 0ustar00vajdawheel00000000000000/* ==================================================================== * Copyright (c) 2004-2019 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_RESULT_CALL(action, result) \ { \ UErrorCode status = U_ZERO_ERROR; \ action; \ if (U_FAILURE(status)) \ return ICUException(status).reportError(); \ result; \ } #define API_STATUS_CALL(var, api, args) \ { \ UErrorCode status = U_ZERO_ERROR; \ var = api args; \ if (U_FAILURE(status)) \ return ICUException(status).reportError(); \ } #define STATUS_PYTHON_CALL(action) \ { \ UErrorCode status = U_ZERO_ERROR; \ action; \ if (U_FAILURE(status)) \ return ICUException(status).reportError(); \ if (PyErr_Occurred()) \ return NULL; \ } #define STATUS_PARSER_CALL(action) \ { \ UErrorCode status = U_ZERO_ERROR; \ UParseError parseError; \ action; \ if (U_FAILURE(status)) \ return ICUException(parseError, status).reportError(); \ } #define STATUS_PARSER_PYTHON_CALL(action) \ { \ UErrorCode status = U_ZERO_ERROR; \ UParseError parseError; \ action; \ if (U_FAILURE(status)) \ return ICUException(parseError, status).reportError(); \ if (PyErr_Occurred()) \ return NULL; \ } #define INT_STATUS_CALL(action) \ { \ UErrorCode status = U_ZERO_ERROR; \ action; \ if (U_FAILURE(status)) \ { \ ICUException(status).reportError(); \ return -1; \ } \ } #define INT_STATUS_PYTHON_CALL(action) \ { \ UErrorCode status = U_ZERO_ERROR; \ action; \ if (U_FAILURE(status)) \ { \ ICUException(status).reportError(); \ return -1; \ } \ if (PyErr_Occurred()) \ return -1; \ } #define INT_STATUS_PARSER_CALL(action) \ { \ UErrorCode status = U_ZERO_ERROR; \ UParseError parseError; \ action; \ if (U_FAILURE(status)) \ { \ ICUException(parseError, status).reportError(); \ return -1; \ } \ } #define INT_STATUS_PARSER_PYTHON_CALL(action) \ { \ UErrorCode status = U_ZERO_ERROR; \ UParseError parseError; \ action; \ if (U_FAILURE(status)) \ { \ ICUException(parseError, status).reportError(); \ return -1; \ } \ if (PyErr_Occurred()) \ return -1; \ } #define DECLARE_METHOD(type, name, flags) \ { #name, (PyCFunction) type##_##name, flags, "" } #define DECLARE_ABSTRACT_METHOD(type, name, flags) \ { #name, (PyCFunction) abstract_method, 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_BY_VALUE_TYPE(name, t_name, base, icuClass, init) \ void t_name##_dealloc(t_name *self) \ { \ if (self->flags & T_OWNED) \ delete self->object; \ self->object = NULL; \ Py_TYPE(self)->tp_free((PyObject *) self); \ } \ DECLARE_TYPE(name, t_name, base, icuClass, init, t_name##_dealloc) \ PyObject *wrap_##name(icuClass object) \ { \ return wrap_##name(new icuClass(std::move(object)), T_OWNED); \ } #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) 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 // used for structs and for classes without typeid() support #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); \ default: \ PyErr_SetNone(PyExc_NotImplementedError); \ return NULL; \ } \ } \ switch (op) { \ case Py_EQ: \ Py_RETURN_FALSE; \ case Py_NE: \ Py_RETURN_TRUE; \ default: \ PyErr_SetNone(PyExc_NotImplementedError); \ return NULL; \ } \ } #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 */ ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1570122663.0 PyICU-2.4.2/measureunit.cpp0000644000076500000000000013572100000000000015732 0ustar00vajdawheel00000000000000/* ==================================================================== * Copyright (c) 2004-2019 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 "measureunit.h" #include "macros.h" #if U_ICU_VERSION_HEX >= 0x04020000 DECLARE_CONSTANTS_TYPE(UTimeUnitFields); #endif /* MeasureUnit */ class t_measureunit : public _wrapper { public: MeasureUnit *object; }; #if U_ICU_VERSION_HEX >= VERSION_HEX(53, 0, 0) static PyObject *t_measureunit_getType(t_measureunit *self); static PyObject *t_measureunit_getSubtype(t_measureunit *self); static PyObject *t_measureunit_getAvailable(PyTypeObject *type, PyObject *arg); static PyObject *t_measureunit_getAvailableTypes(PyTypeObject *type); static PyObject *t_measureunit_createAcre(PyTypeObject *type); static PyObject *t_measureunit_createArcMinute(PyTypeObject *type); static PyObject *t_measureunit_createArcSecond(PyTypeObject *type); static PyObject *t_measureunit_createCelsius(PyTypeObject *type); static PyObject *t_measureunit_createCentimeter(PyTypeObject *type); static PyObject *t_measureunit_createCubicKilometer(PyTypeObject *type); static PyObject *t_measureunit_createCubicMile(PyTypeObject *type); static PyObject *t_measureunit_createDay(PyTypeObject *type); static PyObject *t_measureunit_createDegree(PyTypeObject *type); static PyObject *t_measureunit_createFahrenheit(PyTypeObject *type); static PyObject *t_measureunit_createFoot(PyTypeObject *type); static PyObject *t_measureunit_createGForce(PyTypeObject *type); static PyObject *t_measureunit_createGram(PyTypeObject *type); static PyObject *t_measureunit_createHectare(PyTypeObject *type); static PyObject *t_measureunit_createHectopascal(PyTypeObject *type); static PyObject *t_measureunit_createHorsepower(PyTypeObject *type); static PyObject *t_measureunit_createHour(PyTypeObject *type); static PyObject *t_measureunit_createInch(PyTypeObject *type); static PyObject *t_measureunit_createInchHg(PyTypeObject *type); static PyObject *t_measureunit_createKilogram(PyTypeObject *type); static PyObject *t_measureunit_createKilometer(PyTypeObject *type); static PyObject *t_measureunit_createKilometerPerHour(PyTypeObject *type); static PyObject *t_measureunit_createKilowatt(PyTypeObject *type); static PyObject *t_measureunit_createLightYear(PyTypeObject *type); static PyObject *t_measureunit_createLiter(PyTypeObject *type); static PyObject *t_measureunit_createMeter(PyTypeObject *type); static PyObject *t_measureunit_createMeterPerSecond(PyTypeObject *type); static PyObject *t_measureunit_createMile(PyTypeObject *type); static PyObject *t_measureunit_createMilePerHour(PyTypeObject *type); static PyObject *t_measureunit_createMillibar(PyTypeObject *type); static PyObject *t_measureunit_createMillimeter(PyTypeObject *type); static PyObject *t_measureunit_createMillisecond(PyTypeObject *type); static PyObject *t_measureunit_createMinute(PyTypeObject *type); static PyObject *t_measureunit_createMonth(PyTypeObject *type); static PyObject *t_measureunit_createOunce(PyTypeObject *type); static PyObject *t_measureunit_createPicometer(PyTypeObject *type); static PyObject *t_measureunit_createPound(PyTypeObject *type); static PyObject *t_measureunit_createSecond(PyTypeObject *type); static PyObject *t_measureunit_createSquareFoot(PyTypeObject *type); static PyObject *t_measureunit_createSquareKilometer(PyTypeObject *type); static PyObject *t_measureunit_createSquareMeter(PyTypeObject *type); static PyObject *t_measureunit_createSquareMile(PyTypeObject *type); static PyObject *t_measureunit_createWatt(PyTypeObject *type); static PyObject *t_measureunit_createWeek(PyTypeObject *type); static PyObject *t_measureunit_createYard(PyTypeObject *type); static PyObject *t_measureunit_createYear(PyTypeObject *type); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(54, 0, 0) static PyObject *t_measureunit_createAcreFoot(PyTypeObject *type); static PyObject *t_measureunit_createAmpere(PyTypeObject *type); static PyObject *t_measureunit_createAstronomicalUnit(PyTypeObject *type); static PyObject *t_measureunit_createBit(PyTypeObject *type); static PyObject *t_measureunit_createBushel(PyTypeObject *type); static PyObject *t_measureunit_createByte(PyTypeObject *type); static PyObject *t_measureunit_createCalorie(PyTypeObject *type); static PyObject *t_measureunit_createCarat(PyTypeObject *type); static PyObject *t_measureunit_createCentiliter(PyTypeObject *type); static PyObject *t_measureunit_createCubicCentimeter(PyTypeObject *type); static PyObject *t_measureunit_createCubicFoot(PyTypeObject *type); static PyObject *t_measureunit_createCubicInch(PyTypeObject *type); static PyObject *t_measureunit_createCubicMeter(PyTypeObject *type); static PyObject *t_measureunit_createCubicYard(PyTypeObject *type); static PyObject *t_measureunit_createCup(PyTypeObject *type); static PyObject *t_measureunit_createDeciliter(PyTypeObject *type); static PyObject *t_measureunit_createDecimeter(PyTypeObject *type); static PyObject *t_measureunit_createFathom(PyTypeObject *type); static PyObject *t_measureunit_createFluidOunce(PyTypeObject *type); static PyObject *t_measureunit_createFoodcalorie(PyTypeObject *type); static PyObject *t_measureunit_createFurlong(PyTypeObject *type); static PyObject *t_measureunit_createGallon(PyTypeObject *type); static PyObject *t_measureunit_createGigabit(PyTypeObject *type); static PyObject *t_measureunit_createGigabyte(PyTypeObject *type); static PyObject *t_measureunit_createGigahertz(PyTypeObject *type); static PyObject *t_measureunit_createGigawatt(PyTypeObject *type); static PyObject *t_measureunit_createHectoliter(PyTypeObject *type); static PyObject *t_measureunit_createHertz(PyTypeObject *type); static PyObject *t_measureunit_createJoule(PyTypeObject *type); static PyObject *t_measureunit_createKarat(PyTypeObject *type); static PyObject *t_measureunit_createKelvin(PyTypeObject *type); static PyObject *t_measureunit_createKilobit(PyTypeObject *type); static PyObject *t_measureunit_createKilobyte(PyTypeObject *type); static PyObject *t_measureunit_createKilocalorie(PyTypeObject *type); static PyObject *t_measureunit_createKilohertz(PyTypeObject *type); static PyObject *t_measureunit_createKilojoule(PyTypeObject *type); static PyObject *t_measureunit_createKilowattHour(PyTypeObject *type); static PyObject *t_measureunit_createLiterPerKilometer(PyTypeObject *type); static PyObject *t_measureunit_createLux(PyTypeObject *type); static PyObject *t_measureunit_createMegabit(PyTypeObject *type); static PyObject *t_measureunit_createMegabyte(PyTypeObject *type); static PyObject *t_measureunit_createMegahertz(PyTypeObject *type); static PyObject *t_measureunit_createMegaliter(PyTypeObject *type); static PyObject *t_measureunit_createMegawatt(PyTypeObject *type); static PyObject *t_measureunit_createMeterPerSecondSquared(PyTypeObject *type); static PyObject *t_measureunit_createMetricTon(PyTypeObject *type); static PyObject *t_measureunit_createMicrogram(PyTypeObject *type); static PyObject *t_measureunit_createMicrometer(PyTypeObject *type); static PyObject *t_measureunit_createMicrosecond(PyTypeObject *type); static PyObject *t_measureunit_createMilePerGallon(PyTypeObject *type); static PyObject *t_measureunit_createMilliampere(PyTypeObject *type); static PyObject *t_measureunit_createMilligram(PyTypeObject *type); static PyObject *t_measureunit_createMilliliter(PyTypeObject *type); static PyObject *t_measureunit_createMillimeterOfMercury(PyTypeObject *type); static PyObject *t_measureunit_createMilliwatt(PyTypeObject *type); static PyObject *t_measureunit_createNanometer(PyTypeObject *type); static PyObject *t_measureunit_createNanosecond(PyTypeObject *type); static PyObject *t_measureunit_createNauticalMile(PyTypeObject *type); static PyObject *t_measureunit_createOhm(PyTypeObject *type); static PyObject *t_measureunit_createOunceTroy(PyTypeObject *type); static PyObject *t_measureunit_createParsec(PyTypeObject *type); static PyObject *t_measureunit_createPint(PyTypeObject *type); static PyObject *t_measureunit_createPoundPerSquareInch(PyTypeObject *type); static PyObject *t_measureunit_createQuart(PyTypeObject *type); static PyObject *t_measureunit_createRadian(PyTypeObject *type); static PyObject *t_measureunit_createSquareCentimeter(PyTypeObject *type); static PyObject *t_measureunit_createSquareInch(PyTypeObject *type); static PyObject *t_measureunit_createSquareYard(PyTypeObject *type); static PyObject *t_measureunit_createStone(PyTypeObject *type); static PyObject *t_measureunit_createTablespoon(PyTypeObject *type); static PyObject *t_measureunit_createTeaspoon(PyTypeObject *type); static PyObject *t_measureunit_createTerabit(PyTypeObject *type); static PyObject *t_measureunit_createTerabyte(PyTypeObject *type); static PyObject *t_measureunit_createTon(PyTypeObject *type); static PyObject *t_measureunit_createVolt(PyTypeObject *type); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(56, 0, 0) static PyObject *t_measureunit_createCentury(PyTypeObject *type); static PyObject *t_measureunit_createCupMetric(PyTypeObject *type); static PyObject *t_measureunit_createGenericTemperature(PyTypeObject *type); static PyObject *t_measureunit_createKnot(PyTypeObject *type); static PyObject *t_measureunit_createLiterPer100Kilometers(PyTypeObject *type); static PyObject *t_measureunit_createMileScandinavian(PyTypeObject *type); static PyObject *t_measureunit_createPintMetric(PyTypeObject *type); static PyObject *t_measureunit_createRevolutionAngle(PyTypeObject *type); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(57, 0, 0) static PyObject *t_measureunit_createGallonImperial(PyTypeObject *type); static PyObject *t_measureunit_createMilePerGallonImperial(PyTypeObject *type); static PyObject *t_measureunit_createMilligramPerDeciliter(PyTypeObject *type); static PyObject *t_measureunit_createMillimolePerLiter(PyTypeObject *type); static PyObject *t_measureunit_createPartPerMillion(PyTypeObject *type); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(59, 0, 0) static PyObject *t_measureunit_createPoint(PyTypeObject *type); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(63, 0, 0) static PyObject *t_measureunit_createAtmosphere(PyTypeObject *type); static PyObject *t_measureunit_createPercent(PyTypeObject *type); static PyObject *t_measureunit_createPermille(PyTypeObject *type); static PyObject *t_measureunit_createPetabyte(PyTypeObject *type); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(64, 0, 0) static PyObject *t_measureunit_createBarrel(PyTypeObject *type); static PyObject *t_measureunit_createBritishThermalUnit(PyTypeObject *type); static PyObject *t_measureunit_createDalton(PyTypeObject *type); static PyObject *t_measureunit_createDayPerson(PyTypeObject *type); static PyObject *t_measureunit_createDunam(PyTypeObject *type); static PyObject *t_measureunit_createEarthMass(PyTypeObject *type); static PyObject *t_measureunit_createElectronvolt(PyTypeObject *type); static PyObject *t_measureunit_createFluidOunceImperial(PyTypeObject *type); static PyObject *t_measureunit_createKilopascal(PyTypeObject *type); static PyObject *t_measureunit_createMegapascal(PyTypeObject *type); static PyObject *t_measureunit_createMole(PyTypeObject *type); static PyObject *t_measureunit_createMonthPerson(PyTypeObject *type); static PyObject *t_measureunit_createNewton(PyTypeObject *type); static PyObject *t_measureunit_createNewtonMeter(PyTypeObject *type); static PyObject *t_measureunit_createPermyriad(PyTypeObject *type); static PyObject *t_measureunit_createPoundFoot(PyTypeObject *type); static PyObject *t_measureunit_createPoundForce(PyTypeObject *type); static PyObject *t_measureunit_createSolarLuminosity(PyTypeObject *type); static PyObject *t_measureunit_createSolarMass(PyTypeObject *type); static PyObject *t_measureunit_createSolarRadius(PyTypeObject *type); static PyObject *t_measureunit_createWeekPerson(PyTypeObject *type); static PyObject *t_measureunit_createYearPerson(PyTypeObject *type); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(65, 0, 0) static PyObject *t_measureunit_createBar(PyTypeObject *type); static PyObject *t_measureunit_createDecade(PyTypeObject *type); static PyObject *t_measureunit_createDotPerCentimeter(PyTypeObject *type); static PyObject *t_measureunit_createDotPerInch(PyTypeObject *type); static PyObject *t_measureunit_createEm(PyTypeObject *type); static PyObject *t_measureunit_createMegapixel(PyTypeObject *type); static PyObject *t_measureunit_createPascal(PyTypeObject *type); static PyObject *t_measureunit_createPixel(PyTypeObject *type); static PyObject *t_measureunit_createPixelPerCentimeter(PyTypeObject *type); static PyObject *t_measureunit_createPixelPerInch(PyTypeObject *type); static PyObject *t_measureunit_createThermUs(PyTypeObject *type); #endif static PyMethodDef t_measureunit_methods[] = { #if U_ICU_VERSION_HEX >= VERSION_HEX(53, 0, 0) DECLARE_METHOD(t_measureunit, getType, METH_NOARGS), DECLARE_METHOD(t_measureunit, getSubtype, METH_NOARGS), DECLARE_METHOD(t_measureunit, getAvailable, METH_O | METH_CLASS), DECLARE_METHOD(t_measureunit, getAvailableTypes, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createAcre, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createArcMinute, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createArcSecond, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createCelsius, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createCentimeter, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createCubicKilometer, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createCubicMile, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createDay, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createDegree, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createFahrenheit, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createFoot, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createGForce, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createGram, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createHectare, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createHectopascal, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createHorsepower, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createHour, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createInch, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createInchHg, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createKilogram, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createKilometer, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createKilometerPerHour, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createKilowatt, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createLightYear, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createLiter, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createMeter, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createMeterPerSecond, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createMile, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createMilePerHour, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createMillibar, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createMillimeter, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createMillisecond, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createMinute, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createMonth, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createOunce, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createPicometer, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createPound, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createSecond, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createSquareFoot, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createSquareKilometer, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createSquareMeter, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createSquareMile, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createWatt, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createWeek, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createYard, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createYear, METH_NOARGS | METH_CLASS), #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(54, 0, 0) DECLARE_METHOD(t_measureunit, createAcreFoot, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createAmpere, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createAstronomicalUnit, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createBit, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createBushel, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createByte, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createCalorie, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createCarat, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createCentiliter, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createCubicCentimeter, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createCubicFoot, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createCubicInch, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createCubicMeter, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createCubicYard, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createCup, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createDeciliter, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createDecimeter, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createFathom, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createFluidOunce, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createFoodcalorie, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createFurlong, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createGallon, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createGigabit, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createGigabyte, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createGigahertz, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createGigawatt, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createHectoliter, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createHertz, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createJoule, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createKarat, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createKelvin, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createKilobit, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createKilobyte, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createKilocalorie, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createKilohertz, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createKilojoule, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createKilowattHour, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createLiterPerKilometer, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createLux, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createMegabit, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createMegabyte, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createMegahertz, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createMegaliter, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createMegawatt, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createMeterPerSecondSquared, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createMetricTon, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createMicrogram, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createMicrometer, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createMicrosecond, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createMilePerGallon, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createMilliampere, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createMilligram, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createMilliliter, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createMillimeterOfMercury, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createMilliwatt, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createNanometer, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createNanosecond, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createNauticalMile, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createOhm, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createOunceTroy, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createParsec, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createPint, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createPoundPerSquareInch, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createQuart, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createRadian, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createSquareCentimeter, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createSquareInch, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createSquareYard, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createStone, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createTablespoon, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createTeaspoon, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createTerabit, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createTerabyte, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createTon, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createVolt, METH_NOARGS | METH_CLASS), #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(56, 0, 0) DECLARE_METHOD(t_measureunit, createCentury, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createCupMetric, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createGenericTemperature, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createKnot, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createLiterPer100Kilometers, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createMileScandinavian, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createPintMetric, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createRevolutionAngle, METH_NOARGS | METH_CLASS), #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(57, 0, 0) DECLARE_METHOD(t_measureunit, createGallonImperial, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createMilePerGallonImperial, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createMilligramPerDeciliter, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createMillimolePerLiter, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createPartPerMillion, METH_NOARGS | METH_CLASS), #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(59, 0, 0) DECLARE_METHOD(t_measureunit, createPoint, METH_NOARGS | METH_CLASS), #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(63, 0, 0) DECLARE_METHOD(t_measureunit, createAtmosphere, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createPercent, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createPermille, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createPetabyte, METH_NOARGS | METH_CLASS), #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(64, 0, 0) DECLARE_METHOD(t_measureunit, createBarrel, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createBritishThermalUnit, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createDalton, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createDayPerson, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createDunam, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createEarthMass, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createElectronvolt, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createFluidOunceImperial, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createKilopascal, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createMegapascal, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createMole, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createMonthPerson, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createNewton, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createNewtonMeter, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createPermyriad, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createPoundFoot, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createPoundForce, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createSolarLuminosity, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createSolarMass, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createSolarRadius, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createWeekPerson, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createYearPerson, METH_NOARGS | METH_CLASS), #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(65, 0, 0) DECLARE_METHOD(t_measureunit, createBar, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createDecade, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createDotPerCentimeter, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createDotPerInch, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createEm, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createMegapixel, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createPascal, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createPixel, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createPixelPerCentimeter, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createPixelPerInch, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_measureunit, createThermUs, METH_NOARGS | METH_CLASS), #endif { NULL, NULL, 0, NULL } }; DECLARE_TYPE(MeasureUnit, t_measureunit, UObject, MeasureUnit, abstract_init, NULL); /* Measure */ class t_measure : public _wrapper { public: Measure *object; }; #if U_ICU_VERSION_HEX >= VERSION_HEX(53, 1, 0) static int t_measure_init(t_measure *self, PyObject *args, PyObject *kwds); #endif 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 } }; #if U_ICU_VERSION_HEX >= VERSION_HEX(53, 1, 0) DECLARE_TYPE(Measure, t_measure, UObject, Measure, t_measure_init, NULL); #else DECLARE_TYPE(Measure, t_measure, UObject, Measure, abstract_init, NULL); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(60, 0, 0) /* NoUnit */ class t_nounit : public _wrapper { public: NoUnit *object; }; static PyObject *t_nounit_base(PyTypeObject *type); static PyObject *t_nounit_percent(PyTypeObject *type); static PyObject *t_nounit_permille(PyTypeObject *type); static PyMethodDef t_nounit_methods[] = { DECLARE_METHOD(t_nounit, base, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_nounit, percent, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_nounit, permille, METH_NOARGS | METH_CLASS), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(NoUnit, t_nounit, MeasureUnit, NoUnit, abstract_init, NULL); #endif /* 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); /* TimeUnit */ #if U_ICU_VERSION_HEX >= 0x04020000 class t_timeunit : public _wrapper { public: TimeUnit *object; }; static PyObject *t_timeunit_getTimeUnitField(t_timeunit *self); static PyObject *t_timeunit_createInstance(PyTypeObject *type, PyObject *arg); static PyMethodDef t_timeunit_methods[] = { DECLARE_METHOD(t_timeunit, getTimeUnitField, METH_NOARGS), DECLARE_METHOD(t_timeunit, createInstance, METH_O | METH_CLASS), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(TimeUnit, t_timeunit, MeasureUnit, TimeUnit, abstract_init, NULL); /* TimeUnitAmount */ class t_timeunitamount : public _wrapper { public: TimeUnitAmount *object; }; static int t_timeunitamount_init(t_timeunitamount *self, PyObject *args, PyObject *kwds); static PyObject *t_timeunitamount_getUnit(t_timeunitamount *self); static PyObject *t_timeunitamount_getTimeUnitField(t_timeunitamount *self); static PyMethodDef t_timeunitamount_methods[] = { DECLARE_METHOD(t_timeunitamount, getUnit, METH_NOARGS), DECLARE_METHOD(t_timeunitamount, getTimeUnitField, METH_NOARGS), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(TimeUnitAmount, t_timeunitamount, Measure, TimeUnitAmount, t_timeunitamount_init, NULL); #endif /* MeasureUnit */ DEFINE_RICHCMP(MeasureUnit, t_measureunit); #if U_ICU_VERSION_HEX >= VERSION_HEX(53, 0, 0) static PyObject *t_measureunit_str(t_measureunit *self) { return PyString_FromString(self->object->getSubtype()); } static PyObject *t_measureunit_getType(t_measureunit *self) { return PyString_FromString(self->object->getType()); } static PyObject *t_measureunit_getSubtype(t_measureunit *self) { return PyString_FromString(self->object->getSubtype()); } static PyObject *t_measureunit_getAvailable(PyTypeObject *type, PyObject *arg) { charsArg type_name; if (!parseArg(arg, "n", &type_name)) { UErrorCode status = U_ZERO_ERROR; int32_t size = MeasureUnit::getAvailable(type_name, NULL, 0, status); if (U_FAILURE(status)) { if (status != U_BUFFER_OVERFLOW_ERROR) return ICUException(status).reportError(); MeasureUnit *mus = new MeasureUnit[size]; status = U_ZERO_ERROR; size = MeasureUnit::getAvailable(type_name, mus, size, status); if (U_FAILURE(status)) { delete[] mus; return ICUException(status).reportError(); } PyObject *result = PyTuple_New(size); for (int i = 0; i < size; ++i) PyTuple_SET_ITEM(result, i, wrap_MeasureUnit( (MeasureUnit *) mus[i].clone(), T_OWNED)); delete[] mus; return result; } } return PyErr_SetArgsError(type, "getAvailable", arg); } static PyObject *t_measureunit_getAvailableTypes(PyTypeObject *type) { StringEnumeration *e; STATUS_CALL(e = MeasureUnit::getAvailableTypes(status)); return wrap_StringEnumeration(e, T_OWNED); } #define createMU(unit) \ static PyObject *t_measureunit_create ## unit(PyTypeObject *type) \ { \ MeasureUnit *mu; \ STATUS_CALL(mu = MeasureUnit::create ## unit(status)); \ return wrap_MeasureUnit(mu, T_OWNED); \ } createMU(Acre) createMU(ArcMinute) createMU(ArcSecond) createMU(Celsius) createMU(Centimeter) createMU(CubicKilometer) createMU(CubicMile) createMU(Day) createMU(Degree) createMU(Fahrenheit) createMU(Foot) createMU(GForce) createMU(Gram) createMU(Hectare) createMU(Hectopascal) createMU(Horsepower) createMU(Hour) createMU(Inch) createMU(InchHg) createMU(Kilogram) createMU(Kilometer) createMU(KilometerPerHour) createMU(Kilowatt) createMU(LightYear) createMU(Liter) createMU(Meter) createMU(MeterPerSecond) createMU(Mile) createMU(MilePerHour) createMU(Millibar) createMU(Millimeter) createMU(Millisecond) createMU(Minute) createMU(Month) createMU(Ounce) createMU(Picometer) createMU(Pound) createMU(Second) createMU(SquareFoot) createMU(SquareKilometer) createMU(SquareMeter) createMU(SquareMile) createMU(Watt) createMU(Week) createMU(Yard) createMU(Year) #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(54, 0, 0) createMU(AcreFoot) createMU(Ampere) createMU(AstronomicalUnit) createMU(Bit) createMU(Bushel) createMU(Byte) createMU(Calorie) createMU(Carat) createMU(Centiliter) createMU(CubicCentimeter) createMU(CubicFoot) createMU(CubicInch) createMU(CubicMeter) createMU(CubicYard) createMU(Cup) createMU(Deciliter) createMU(Decimeter) createMU(Fathom) createMU(FluidOunce) createMU(Foodcalorie) createMU(Furlong) createMU(Gallon) createMU(Gigabit) createMU(Gigabyte) createMU(Gigahertz) createMU(Gigawatt) createMU(Hectoliter) createMU(Hertz) createMU(Joule) createMU(Karat) createMU(Kelvin) createMU(Kilobit) createMU(Kilobyte) createMU(Kilocalorie) createMU(Kilohertz) createMU(Kilojoule) createMU(KilowattHour) createMU(LiterPerKilometer) createMU(Lux) createMU(Megabit) createMU(Megabyte) createMU(Megahertz) createMU(Megaliter) createMU(Megawatt) createMU(MeterPerSecondSquared) createMU(MetricTon) createMU(Microgram) createMU(Micrometer) createMU(Microsecond) createMU(MilePerGallon) createMU(Milliampere) createMU(Milligram) createMU(Milliliter) createMU(MillimeterOfMercury) createMU(Milliwatt) createMU(Nanometer) createMU(Nanosecond) createMU(NauticalMile) createMU(Ohm) createMU(OunceTroy) createMU(Parsec) createMU(Pint) createMU(PoundPerSquareInch) createMU(Quart) createMU(Radian) createMU(SquareCentimeter) createMU(SquareInch) createMU(SquareYard) createMU(Stone) createMU(Tablespoon) createMU(Teaspoon) createMU(Terabit) createMU(Terabyte) createMU(Ton) createMU(Volt) #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(56, 0, 0) createMU(Century) createMU(CupMetric) createMU(GenericTemperature) createMU(Knot) createMU(LiterPer100Kilometers) createMU(MileScandinavian) createMU(PintMetric) createMU(RevolutionAngle) #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(57, 0, 0) createMU(GallonImperial) createMU(MilePerGallonImperial) createMU(MilligramPerDeciliter) createMU(MillimolePerLiter) createMU(PartPerMillion) #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(59, 0, 0) createMU(Point) #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(63, 0, 0) createMU(Atmosphere) createMU(Percent) createMU(Permille) createMU(Petabyte) #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(64, 0, 0) createMU(Barrel) createMU(BritishThermalUnit) createMU(Dalton) createMU(DayPerson) createMU(Dunam) createMU(EarthMass) createMU(Electronvolt) createMU(FluidOunceImperial) createMU(Kilopascal) createMU(Megapascal) createMU(Mole) createMU(MonthPerson) createMU(Newton) createMU(NewtonMeter) createMU(Permyriad) createMU(PoundFoot) createMU(PoundForce) createMU(SolarLuminosity) createMU(SolarMass) createMU(SolarRadius) createMU(WeekPerson) createMU(YearPerson) #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(65, 0, 0) createMU(Bar) createMU(Decade) createMU(DotPerCentimeter) createMU(DotPerInch) createMU(Em) createMU(Megapixel) createMU(Pascal) createMU(Pixel) createMU(PixelPerCentimeter) createMU(PixelPerInch) createMU(ThermUs) #endif /* Measure */ #if U_ICU_VERSION_HEX >= VERSION_HEX(53, 1, 0) static int t_measure_init(t_measure *self, PyObject *args, PyObject *kwds) { Formattable *number; MeasureUnit *unit; double d; switch (PyTuple_Size(args)) { case 2: if (!parseArgs(args, "dP", TYPE_ID(MeasureUnit), &d, &unit)) { INT_STATUS_CALL(self->object = new Measure( Formattable(d), (MeasureUnit *) unit->clone(), status)); self->flags = T_OWNED; break; } if (!parseArgs(args, "PP", TYPE_CLASSID(Formattable), TYPE_ID(MeasureUnit), &number, &unit)) { INT_STATUS_CALL(self->object = new Measure( *number, (MeasureUnit *) unit->clone(), 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; } #endif 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_str(t_measure *self) { #if U_ICU_VERSION_HEX >= VERSION_HEX(60, 0, 0) UnicodeString u; // this conditional is wider than necessary because of // www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4296.pdf#section.16.3 // and to placate the msvc++ compiler #if U_ICU_VERSION_HEX >= VERSION_HEX(64, 0, 0) STATUS_CALL(u = icu::number::NumberFormatter::withLocale( Locale::getDefault()) .unit(self->object->getUnit()) .unitWidth(UNumberUnitWidth::UNUM_UNIT_WIDTH_FULL_NAME) .formatDouble(self->object->getNumber().getDouble(), status) .toString(status)); #else STATUS_CALL(u = icu::number::NumberFormatter::withLocale( Locale::getDefault()) .unit(self->object->getUnit()) .unitWidth(UNumberUnitWidth::UNUM_UNIT_WIDTH_FULL_NAME) .formatDouble(self->object->getNumber().getDouble(), status) .toString()); #endif return PyUnicode_FromUnicodeString(&u); #else PyObject *value = wrap_Formattable(const_cast(&self->object->getNumber()), 0); PyObject *unit = wrap_MeasureUnit(const_cast(&self->object->getUnit()), 0); PyObject *v_str = PyObject_Str(value); PyObject *u_str = PyObject_Str(unit); PyObject *args = PyTuple_Pack(2, v_str, u_str); PyObject *format = PyString_FromString("%s %s"); PyObject *str = PyString_Format(format, args); Py_DECREF(format); Py_DECREF(args); Py_DECREF(u_str); Py_DECREF(v_str); Py_DECREF(unit); Py_DECREF(value); return str; #endif } DEFINE_RICHCMP(Measure, t_measure); /* NoUnit */ #if U_ICU_VERSION_HEX >= VERSION_HEX(60, 0, 0) static PyObject *t_nounit_base(PyTypeObject *type) { return wrap_NoUnit((NoUnit *) NoUnit::base().clone(), T_OWNED); } static PyObject *t_nounit_percent(PyTypeObject *type) { return wrap_NoUnit((NoUnit *) NoUnit::percent().clone(), T_OWNED); } static PyObject *t_nounit_permille(PyTypeObject *type) { return wrap_NoUnit((NoUnit *) NoUnit::permille().clone(), T_OWNED); } #endif /* 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; } /* TimeUnit */ #if U_ICU_VERSION_HEX >= 0x04020000 static PyObject *t_timeunit_getTimeUnitField(t_timeunit *self) { return PyInt_FromLong(self->object->getTimeUnitField()); } static PyObject *t_timeunit_createInstance(PyTypeObject *type, PyObject *arg) { TimeUnit::UTimeUnitFields field; if (!parseArg(arg, "i", &field)) { TimeUnit *tu; STATUS_CALL(tu = TimeUnit::createInstance(field, status)); return wrap_TimeUnit(tu, T_OWNED); } return PyErr_SetArgsError(type, "getAvailable", arg); } /* TimeUnitAmount */ static int t_timeunitamount_init(t_timeunitamount *self, PyObject *args, PyObject *kwds) { Formattable *obj; TimeUnit::UTimeUnitFields field; double d; switch (PyTuple_Size(args)) { case 2: if (!parseArgs(args, "Pi", TYPE_CLASSID(Formattable), &obj, &field)) { INT_STATUS_CALL(self->object = new TimeUnitAmount( *obj, field, status)); self->flags = T_OWNED; break; } if (!parseArgs(args, "di", &d, &field)) { INT_STATUS_CALL(self->object = new TimeUnitAmount( d, field, 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_timeunitamount_getUnit(t_timeunitamount *self) { return wrap_TimeUnit( (TimeUnit *) self->object->getTimeUnit().clone(), T_OWNED); } static PyObject *t_timeunitamount_getTimeUnitField(t_timeunitamount *self) { return PyInt_FromLong(self->object->getTimeUnitField()); } #endif void _init_measureunit(PyObject *m) { #if U_ICU_VERSION_HEX >= VERSION_HEX(53, 0, 0) MeasureUnitType_.tp_str = (reprfunc) t_measureunit_str; #endif 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; MeasureType_.tp_str = (reprfunc) t_measure_str; #if U_ICU_VERSION_HEX >= 0x04020000 INSTALL_CONSTANTS_TYPE(UTimeUnitFields, m); #endif INSTALL_TYPE(MeasureUnit, m); INSTALL_TYPE(Measure, m); #if U_ICU_VERSION_HEX >= VERSION_HEX(60, 0, 0) REGISTER_TYPE(NoUnit, m); #endif REGISTER_TYPE(CurrencyUnit, m); REGISTER_TYPE(CurrencyAmount, m); #if U_ICU_VERSION_HEX >= 0x04020000 REGISTER_TYPE(TimeUnit, m); REGISTER_TYPE(TimeUnitAmount, m); #endif #if U_ICU_VERSION_HEX >= 0x04020000 INSTALL_ENUM(UTimeUnitFields, "YEAR", TimeUnit::UTIMEUNIT_YEAR); INSTALL_ENUM(UTimeUnitFields, "MONTH", TimeUnit::UTIMEUNIT_MONTH); INSTALL_ENUM(UTimeUnitFields, "DAY", TimeUnit::UTIMEUNIT_DAY); INSTALL_ENUM(UTimeUnitFields, "WEEK", TimeUnit::UTIMEUNIT_WEEK); INSTALL_ENUM(UTimeUnitFields, "HOUR", TimeUnit::UTIMEUNIT_HOUR); INSTALL_ENUM(UTimeUnitFields, "MINUTE", TimeUnit::UTIMEUNIT_MINUTE); INSTALL_ENUM(UTimeUnitFields, "SECOND", TimeUnit::UTIMEUNIT_SECOND); #endif } ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1516561556.0 PyICU-2.4.2/measureunit.h0000644000076500000000000000275100000000000015373 0ustar00vajdawheel00000000000000/* ==================================================================== * Copyright (c) 2004-2017 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 _measureunit_h #define _measureunit_h extern PyTypeObject MeasureUnitType_; extern PyTypeObject CurrencyUnitType_; extern PyTypeObject MeasureType_; void _init_measureunit(PyObject *m); #endif /* _measureunit_h */ ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1569878505.0 PyICU-2.4.2/normalizer.cpp0000644000076500000000000006000600000000000015544 0ustar00vajdawheel00000000000000/* ==================================================================== * Copyright (c) 2010-2019 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); #if U_ICU_VERSION_HEX >= VERSION_HEX(49, 0, 0) static PyObject *t_normalizer2_getNFCInstance(PyTypeObject *type); static PyObject *t_normalizer2_getNFDInstance(PyTypeObject *type); static PyObject *t_normalizer2_getNFKCInstance(PyTypeObject *type); static PyObject *t_normalizer2_getNFKDInstance(PyTypeObject *type); static PyObject *t_normalizer2_getNFKCCasefoldInstance(PyTypeObject *type); #endif 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), #if U_ICU_VERSION_HEX >= VERSION_HEX(49, 0, 0) DECLARE_METHOD(t_normalizer2, getNFCInstance, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_normalizer2, getNFDInstance, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_normalizer2, getNFKCInstance, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_normalizer2, getNFKDInstance, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_normalizer2, getNFKCCasefoldInstance, METH_NOARGS | METH_CLASS), #endif { 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); } DEFINE_RICHCMP(Normalizer, t_normalizer); static long t_normalizer_hash(t_normalizer *self) { return (long) self->object->hashCode(); } static PyObject *t_normalizer_iter(t_normalizer *self) { Py_RETURN_SELF(); } static PyObject *t_normalizer_iter_next(t_normalizer *self) { if (self->object->getIndex() < self->object->endIndex()) { UChar32 c = self->object->next(); return PyInt_FromLong(c); } PyErr_SetNone(PyExc_StopIteration); return NULL; } #if U_ICU_VERSION_HEX >= 0x04040000 /* Normalizer2 */ static PyObject *t_normalizer2_normalize(t_normalizer2 *self, PyObject *args) { UnicodeString *u, _u, *result; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "S", &u, &_u)) { UnicodeString dest; STATUS_CALL(self->object->normalize(*u, dest, status)); return PyUnicode_FromUnicodeString(&dest); } break; case 2: if (!parseArgs(args, "SU", &u, &_u, &result)) { STATUS_CALL(self->object->normalize(*u, *result, status)); Py_RETURN_ARG(args, 1); } break; } return PyErr_SetArgsError((PyObject *) self, "normalize", args); } static PyObject *t_normalizer2_normalizeSecondAndAppend(t_normalizer2 *self, PyObject *args) { UnicodeString *u, _u, *result; if (!parseArgs(args, "US", &result, &u, &_u)) { STATUS_CALL(self->object->normalizeSecondAndAppend(*result, *u, status)); Py_RETURN_ARG(args, 0); } return PyErr_SetArgsError((PyObject *) self, "normalizeSecondAndAppend", args); } static PyObject *t_normalizer2_append(t_normalizer2 *self, PyObject *args) { UnicodeString *u, _u, *result; if (!parseArgs(args, "US", &result, &u, &_u)) { STATUS_CALL(self->object->append(*result, *u, status)); Py_RETURN_ARG(args, 0); } return PyErr_SetArgsError((PyObject *) self, "append", args); } static PyObject *t_normalizer2_isNormalized(t_normalizer2 *self, PyObject *arg) { UnicodeString *u, _u; if (!parseArg(arg, "S", &u, &_u)) { UBool b; STATUS_CALL(b = self->object->isNormalized(*u, status)); Py_RETURN_BOOL(b); } return PyErr_SetArgsError((PyObject *) self, "isNormalized", arg); } static PyObject *t_normalizer2_quickCheck(t_normalizer2 *self, PyObject *arg) { UnicodeString *u, _u; if (!parseArg(arg, "S", &u, &_u)) { UNormalizationCheckResult uncr; STATUS_CALL(uncr = self->object->quickCheck(*u, status)); return PyInt_FromLong(uncr); } return PyErr_SetArgsError((PyObject *) self, "quickCheck", arg); } static PyObject *t_normalizer2_spanQuickCheckYes(t_normalizer2 *self, PyObject *arg) { UnicodeString *u, _u; if (!parseArg(arg, "S", &u, &_u)) { int32_t end; STATUS_CALL(end = self->object->spanQuickCheckYes(*u, status)); return PyInt_FromLong(end); } return PyErr_SetArgsError((PyObject *) self, "spanQuickCheckYes", arg); } static PyObject *t_normalizer2_hasBoundaryBefore(t_normalizer2 *self, PyObject *arg) { UnicodeString *u, _u; if (!parseArg(arg, "S", &u, &_u)) { UChar32 c; int32_t len; UBool b; STATUS_CALL(len = toUChar32(*u, &c, status)); if (len == 1) { b = self->object->hasBoundaryBefore(c); Py_RETURN_BOOL(b); } } return PyErr_SetArgsError((PyObject *) self, "hasBoundaryBefore", arg); } static PyObject *t_normalizer2_hasBoundaryAfter(t_normalizer2 *self, PyObject *arg) { UnicodeString *u, _u; if (!parseArg(arg, "S", &u, &_u)) { UChar32 c; int32_t len; UBool b; STATUS_CALL(len = toUChar32(*u, &c, status)); if (len == 1) { b = self->object->hasBoundaryAfter(c); Py_RETURN_BOOL(b); } } return PyErr_SetArgsError((PyObject *) self, "hasBoundaryAfter", arg); } static PyObject *t_normalizer2_isInert(t_normalizer2 *self, PyObject *arg) { UnicodeString *u, _u; if (!parseArg(arg, "S", &u, &_u)) { UChar32 c; int32_t len; UBool b; STATUS_CALL(len = toUChar32(*u, &c, status)); if (len == 1) { b = self->object->isInert(c); Py_RETURN_BOOL(b); } } return PyErr_SetArgsError((PyObject *) self, "isInert", arg); } static PyObject *t_normalizer2_getInstance(PyTypeObject *type, PyObject *args) { const char *packageName, *name; UNormalization2Mode mode; const Normalizer2 *normalizer; if (PyArg_ParseTuple(args, "zsi", &packageName, &name, &mode)) { STATUS_CALL(normalizer = Normalizer2::getInstance(packageName, name, mode, status)); return wrap_Normalizer2((Normalizer2 *) normalizer, 0); } return PyErr_SetArgsError(type, "getInstance", args); } #if U_ICU_VERSION_HEX >= VERSION_HEX(49, 0, 0) static PyObject *t_normalizer2_getNFCInstance(PyTypeObject *type) { const Normalizer2 *normalizer; STATUS_CALL(normalizer = Normalizer2::getNFCInstance(status)); return wrap_Normalizer2((Normalizer2 *) normalizer, 0); } static PyObject *t_normalizer2_getNFDInstance(PyTypeObject *type) { const Normalizer2 *normalizer; STATUS_CALL(normalizer = Normalizer2::getNFDInstance(status)); return wrap_Normalizer2((Normalizer2 *) normalizer, 0); } static PyObject *t_normalizer2_getNFKCInstance(PyTypeObject *type) { const Normalizer2 *normalizer; STATUS_CALL(normalizer = Normalizer2::getNFKCInstance(status)); return wrap_Normalizer2((Normalizer2 *) normalizer, 0); } static PyObject *t_normalizer2_getNFKDInstance(PyTypeObject *type) { const Normalizer2 *normalizer; STATUS_CALL(normalizer = Normalizer2::getNFKDInstance(status)); return wrap_Normalizer2((Normalizer2 *) normalizer, 0); } static PyObject *t_normalizer2_getNFKCCasefoldInstance(PyTypeObject *type) { const Normalizer2 *normalizer; STATUS_CALL(normalizer = Normalizer2::getNFKCCasefoldInstance(status)); return wrap_Normalizer2((Normalizer2 *) normalizer, 0); } #endif /* 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 } ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1267744309.0 PyICU-2.4.2/normalizer.h0000644000076500000000000000256700000000000015221 0ustar00vajdawheel00000000000000/* ==================================================================== * 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 */ ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1569878513.0 PyICU-2.4.2/numberformat.cpp0000644000076500000000000042270700000000000016075 0ustar00vajdawheel00000000000000/* ==================================================================== * Copyright (c) 2004-2019 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 "measureunit.h" #include "macros.h" #if U_HAVE_RBNF DECLARE_CONSTANTS_TYPE(URBNFRuleSetTag); #endif DECLARE_CONSTANTS_TYPE(UNumberFormatRoundingMode); DECLARE_CONSTANTS_TYPE(UNumberFormatStyle); #if U_ICU_VERSION_HEX >= 0x04080000 DECLARE_CONSTANTS_TYPE(UCurrencySpacing); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(51, 0, 0) DECLARE_CONSTANTS_TYPE(UNumberCompactStyle); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(54, 0, 0) DECLARE_CONSTANTS_TYPE(UCurrencyUsage); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(61, 0, 0) #if U_ICU_VERSION_HEX < VERSION_HEX(63, 0, 0) using UNumberGroupingStrategy = UGroupingStrategy; #endif DECLARE_CONSTANTS_TYPE(UNumberGroupingStrategy); #endif /* DecimalFormatSymbols */ class t_decimalformatsymbols : public _wrapper { public: DecimalFormatSymbols *object; }; static int t_decimalformatsymbols_init(t_decimalformatsymbols *self, PyObject *args, PyObject *kwds); static PyObject *t_decimalformatsymbols_getSymbol(t_decimalformatsymbols *self, PyObject *args); static PyObject *t_decimalformatsymbols_setSymbol(t_decimalformatsymbols *self, PyObject *args); static PyObject *t_decimalformatsymbols_getLocale(t_decimalformatsymbols *self, PyObject *args); #if U_ICU_VERSION_HEX >= 0x04020000 static PyObject *t_decimalformatsymbols_getPatternForCurrencySpacing(t_decimalformatsymbols *self, PyObject *args); static PyObject *t_decimalformatsymbols_setPatternForCurrencySpacing(t_decimalformatsymbols *self, PyObject *args); #endif static PyMethodDef t_decimalformatsymbols_methods[] = { DECLARE_METHOD(t_decimalformatsymbols, getSymbol, METH_VARARGS), DECLARE_METHOD(t_decimalformatsymbols, setSymbol, METH_VARARGS), DECLARE_METHOD(t_decimalformatsymbols, getLocale, METH_VARARGS), #if U_ICU_VERSION_HEX >= 0x04020000 DECLARE_METHOD(t_decimalformatsymbols, getPatternForCurrencySpacing, METH_VARARGS), DECLARE_METHOD(t_decimalformatsymbols, setPatternForCurrencySpacing, METH_VARARGS), #endif { NULL, NULL, 0, NULL } }; DECLARE_TYPE(DecimalFormatSymbols, t_decimalformatsymbols, UObject, DecimalFormatSymbols, t_decimalformatsymbols_init, NULL); /* NumberFormat */ class t_numberformat : public _wrapper { public: NumberFormat *object; }; static PyObject *t_numberformat_format(t_numberformat *self, PyObject *args); static PyObject *t_numberformat_parse(t_numberformat *self, PyObject *args); static PyObject *t_numberformat_parseCurrency(t_numberformat *self, PyObject *args); static PyObject *t_numberformat_isParseIntegerOnly(t_numberformat *self); static PyObject *t_numberformat_setParseIntegerOnly(t_numberformat *self, PyObject *arg); static PyObject *t_numberformat_isGroupingUsed(t_numberformat *self); static PyObject *t_numberformat_setGroupingUsed(t_numberformat *self, PyObject *arg); static PyObject *t_numberformat_getMaximumIntegerDigits(t_numberformat *self); static PyObject *t_numberformat_setMaximumIntegerDigits(t_numberformat *self, PyObject *arg); static PyObject *t_numberformat_getMinimumIntegerDigits(t_numberformat *self); static PyObject *t_numberformat_setMinimumIntegerDigits(t_numberformat *self, PyObject *arg); static PyObject *t_numberformat_getMaximumFractionDigits(t_numberformat *self); static PyObject *t_numberformat_setMaximumFractionDigits(t_numberformat *self, PyObject *arg); static PyObject *t_numberformat_getMinimumFractionDigits(t_numberformat *self); static PyObject *t_numberformat_setMinimumFractionDigits(t_numberformat *self, PyObject *arg); #if U_ICU_VERSION_HEX >= 0x04080000 static PyObject *t_numberformat_isLenient(t_numberformat *self); static PyObject *t_numberformat_setLenient(t_numberformat *self, PyObject *arg); #endif static PyObject *t_numberformat_getCurrency(t_numberformat *self); static PyObject *t_numberformat_setCurrency(t_numberformat *self, PyObject *arg); static PyObject *t_numberformat_createInstance(PyTypeObject *type, PyObject *args); static PyObject *t_numberformat_createCurrencyInstance(PyTypeObject *type, PyObject *args); static PyObject *t_numberformat_createPercentInstance(PyTypeObject *type, PyObject *args); static PyObject *t_numberformat_createScientificInstance(PyTypeObject *type, PyObject *args); static PyObject *t_numberformat_getAvailableLocales(PyTypeObject *type); static PyMethodDef t_numberformat_methods[] = { DECLARE_METHOD(t_numberformat, format, METH_VARARGS), DECLARE_METHOD(t_numberformat, parse, METH_VARARGS), DECLARE_METHOD(t_numberformat, parseCurrency, METH_VARARGS), DECLARE_METHOD(t_numberformat, isParseIntegerOnly, METH_NOARGS), DECLARE_METHOD(t_numberformat, setParseIntegerOnly, METH_O), DECLARE_METHOD(t_numberformat, isGroupingUsed, METH_NOARGS), DECLARE_METHOD(t_numberformat, setGroupingUsed, METH_O), DECLARE_METHOD(t_numberformat, getMaximumIntegerDigits, METH_NOARGS), DECLARE_METHOD(t_numberformat, setMaximumIntegerDigits, METH_O), DECLARE_METHOD(t_numberformat, getMinimumIntegerDigits, METH_NOARGS), DECLARE_METHOD(t_numberformat, setMinimumIntegerDigits, METH_O), DECLARE_METHOD(t_numberformat, getMaximumFractionDigits, METH_NOARGS), DECLARE_METHOD(t_numberformat, setMaximumFractionDigits, METH_O), DECLARE_METHOD(t_numberformat, getMinimumFractionDigits, METH_NOARGS), DECLARE_METHOD(t_numberformat, setMinimumFractionDigits, METH_O), #if U_ICU_VERSION_HEX >= 0x04080000 DECLARE_METHOD(t_numberformat, isLenient, METH_NOARGS), DECLARE_METHOD(t_numberformat, setLenient, METH_O), #endif DECLARE_METHOD(t_numberformat, getCurrency, METH_NOARGS), DECLARE_METHOD(t_numberformat, setCurrency, METH_O), DECLARE_METHOD(t_numberformat, createInstance, METH_VARARGS | METH_CLASS), DECLARE_METHOD(t_numberformat, createCurrencyInstance, METH_VARARGS | METH_CLASS), DECLARE_METHOD(t_numberformat, createPercentInstance, METH_VARARGS | METH_CLASS), DECLARE_METHOD(t_numberformat, createScientificInstance, METH_VARARGS | METH_CLASS), DECLARE_METHOD(t_numberformat, getAvailableLocales, METH_NOARGS | METH_CLASS), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(NumberFormat, t_numberformat, Format, NumberFormat, abstract_init, NULL); #if U_ICU_VERSION_HEX >= 0x04020000 /* CurrencyPluralInfo */ class t_currencypluralinfo : public _wrapper { public: CurrencyPluralInfo *object; }; static int t_currencypluralinfo_init(t_currencypluralinfo *self, PyObject *args, PyObject *kwds); static PyObject *t_currencypluralinfo_getPluralRules(t_currencypluralinfo *self); static PyObject *t_currencypluralinfo_setPluralRules(t_currencypluralinfo *self, PyObject *arg); static PyObject *t_currencypluralinfo_getCurrencyPluralPattern(t_currencypluralinfo *self, PyObject *args); static PyObject *t_currencypluralinfo_setCurrencyPluralPattern(t_currencypluralinfo *self, PyObject *args); static PyObject *t_currencypluralinfo_getLocale(t_currencypluralinfo *self); static PyObject *t_currencypluralinfo_setLocale(t_currencypluralinfo *self, PyObject *arg); static PyMethodDef t_currencypluralinfo_methods[] = { DECLARE_METHOD(t_currencypluralinfo, getPluralRules, METH_NOARGS), DECLARE_METHOD(t_currencypluralinfo, setPluralRules, METH_O), DECLARE_METHOD(t_currencypluralinfo, getCurrencyPluralPattern, METH_VARARGS), DECLARE_METHOD(t_currencypluralinfo, setCurrencyPluralPattern, METH_VARARGS), DECLARE_METHOD(t_currencypluralinfo, getLocale, METH_NOARGS), DECLARE_METHOD(t_currencypluralinfo, setLocale, METH_O), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(CurrencyPluralInfo, t_currencypluralinfo, UObject, CurrencyPluralInfo, t_currencypluralinfo_init, NULL); /* NumberingSystem */ class t_numberingsystem : public _wrapper { public: NumberingSystem *object; }; static int t_numberingsystem_init(t_numberingsystem *self, PyObject *args, PyObject *kwds); static PyObject *t_numberingsystem_getRadix(t_numberingsystem *self); static PyObject *t_numberingsystem_getName(t_numberingsystem *self); static PyObject *t_numberingsystem_getDescription(t_numberingsystem *self); static PyObject *t_numberingsystem_isAlgorithmic(t_numberingsystem *self); static PyObject *t_numberingsystem_createInstance(PyTypeObject *type, PyObject *args); static PyObject *t_numberingsystem_createInstanceByName(PyTypeObject *type, PyObject *arg); static PyObject *t_numberingsystem_getAvailableNames(PyTypeObject *type); static PyMethodDef t_numberingsystem_methods[] = { DECLARE_METHOD(t_numberingsystem, getRadix, METH_NOARGS), DECLARE_METHOD(t_numberingsystem, getName, METH_NOARGS), DECLARE_METHOD(t_numberingsystem, getDescription, METH_NOARGS), DECLARE_METHOD(t_numberingsystem, isAlgorithmic, METH_NOARGS), DECLARE_METHOD(t_numberingsystem, createInstance, METH_VARARGS | METH_CLASS), DECLARE_METHOD(t_numberingsystem, createInstanceByName, METH_O | METH_CLASS), DECLARE_METHOD(t_numberingsystem, getAvailableNames, METH_NOARGS | METH_CLASS), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(NumberingSystem, t_numberingsystem, UObject, NumberingSystem, t_numberingsystem_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); #if U_ICU_VERSION_HEX >= VERSION_HEX(62, 0, 0) static PyObject *t_decimalformat_getMultiplierScale(t_decimalformat *self); static PyObject *t_decimalformat_setMultiplierScale(t_decimalformat *self, PyObject *arg); #endif 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), #if U_ICU_VERSION_HEX >= VERSION_HEX(62, 0, 0) DECLARE_METHOD(t_decimalformat, getMultiplierScale, METH_NOARGS), DECLARE_METHOD(t_decimalformat, setMultiplierScale, METH_O), #endif DECLARE_METHOD(t_decimalformat, getRoundingIncrement, METH_NOARGS), DECLARE_METHOD(t_decimalformat, setRoundingIncrement, METH_O), DECLARE_METHOD(t_decimalformat, getRoundingMode, METH_NOARGS), DECLARE_METHOD(t_decimalformat, setRoundingMode, METH_O), DECLARE_METHOD(t_decimalformat, getFormatWidth, METH_NOARGS), DECLARE_METHOD(t_decimalformat, setFormatWidth, METH_O), DECLARE_METHOD(t_decimalformat, getPadCharacterString, METH_VARARGS), DECLARE_METHOD(t_decimalformat, setPadCharacter, METH_O), DECLARE_METHOD(t_decimalformat, getPadPosition, METH_NOARGS), DECLARE_METHOD(t_decimalformat, setPadPosition, METH_O), DECLARE_METHOD(t_decimalformat, isScientificNotation, METH_NOARGS), DECLARE_METHOD(t_decimalformat, setScientificNotation, METH_O), DECLARE_METHOD(t_decimalformat, getMinimumExponentDigits, METH_NOARGS), DECLARE_METHOD(t_decimalformat, setMinimumExponentDigits, METH_O), DECLARE_METHOD(t_decimalformat, isExponentSignAlwaysShown, METH_NOARGS), DECLARE_METHOD(t_decimalformat, setExponentSignAlwaysShown, METH_O), DECLARE_METHOD(t_decimalformat, isDecimalSeparatorAlwaysShown, METH_NOARGS), DECLARE_METHOD(t_decimalformat, setDecimalSeparatorAlwaysShown, METH_O), DECLARE_METHOD(t_decimalformat, getGroupingSize, METH_NOARGS), DECLARE_METHOD(t_decimalformat, setGroupingSize, METH_O), DECLARE_METHOD(t_decimalformat, getSecondaryGroupingSize, METH_NOARGS), DECLARE_METHOD(t_decimalformat, setSecondaryGroupingSize, METH_O), DECLARE_METHOD(t_decimalformat, toPattern, METH_VARARGS), DECLARE_METHOD(t_decimalformat, toLocalizedPattern, METH_VARARGS), DECLARE_METHOD(t_decimalformat, applyPattern, METH_O), DECLARE_METHOD(t_decimalformat, applyLocalizedPattern, METH_O), DECLARE_METHOD(t_decimalformat, getMaximumSignificantDigits, METH_NOARGS), DECLARE_METHOD(t_decimalformat, setMaximumSignificantDigits, METH_O), DECLARE_METHOD(t_decimalformat, getMinimumSignificantDigits, METH_NOARGS), DECLARE_METHOD(t_decimalformat, setMinimumSignificantDigits, METH_O), DECLARE_METHOD(t_decimalformat, areSignificantDigitsUsed, METH_NOARGS), DECLARE_METHOD(t_decimalformat, setSignificantDigitsUsed, METH_O), DECLARE_METHOD(t_decimalformat, getDecimalFormatSymbols, METH_NOARGS), DECLARE_METHOD(t_decimalformat, setDecimalFormatSymbols, METH_O), #if U_ICU_VERSION_HEX >= 0x04020000 DECLARE_METHOD(t_decimalformat, getCurrencyPluralInfo, METH_NOARGS), DECLARE_METHOD(t_decimalformat, setCurrencyPluralInfo, METH_O), #endif { NULL, NULL, 0, NULL } }; DECLARE_TYPE(DecimalFormat, t_decimalformat, NumberFormat, DecimalFormat, t_decimalformat_init, NULL); #if U_ICU_VERSION_HEX >= VERSION_HEX(51, 0, 0) /* CompactDecimalFormat */ class t_compactdecimalformat : public _wrapper { public: CompactDecimalFormat *object; }; static PyObject *t_compactdecimalformat_createInstance(PyTypeObject *type, PyObject *args); static PyMethodDef t_compactdecimalformat_methods[] = { DECLARE_METHOD(t_compactdecimalformat, createInstance, METH_VARARGS | METH_CLASS), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(CompactDecimalFormat, t_compactdecimalformat, DecimalFormat, CompactDecimalFormat, abstract_init, NULL); #endif /* RuleBasedNumberFormat */ class t_rulebasednumberformat : public _wrapper { public: RuleBasedNumberFormat *object; }; static int t_rulebasednumberformat_init(t_rulebasednumberformat *self, PyObject *args, PyObject *kwds); static PyObject *t_rulebasednumberformat_getRules(t_rulebasednumberformat *self, PyObject *args); static PyObject *t_rulebasednumberformat_getNumberOfRuleSetNames(t_rulebasednumberformat *self); static PyObject *t_rulebasednumberformat_getRuleSetName(t_rulebasednumberformat *self, PyObject *args); static PyObject *t_rulebasednumberformat_getNumberOfRuleSetDisplayNameLocales(t_rulebasednumberformat *self); static PyObject *t_rulebasednumberformat_getRuleSetDisplayName(t_rulebasednumberformat *self, PyObject *args); static PyObject *t_rulebasednumberformat_format(t_rulebasednumberformat *self, PyObject *args); static PyObject *t_rulebasednumberformat_isLenient(t_rulebasednumberformat *self); static PyObject *t_rulebasednumberformat_setLenient(t_rulebasednumberformat *self, PyObject *arg); static PyObject *t_rulebasednumberformat_getDefaultRuleSetName(t_rulebasednumberformat *self, PyObject *args); static PyObject *t_rulebasednumberformat_setDefaultRuleSet(t_rulebasednumberformat *self, PyObject *arg); static PyMethodDef t_rulebasednumberformat_methods[] = { DECLARE_METHOD(t_rulebasednumberformat, getRules, METH_VARARGS), DECLARE_METHOD(t_rulebasednumberformat, getNumberOfRuleSetNames, METH_NOARGS), DECLARE_METHOD(t_rulebasednumberformat, getRuleSetName, METH_VARARGS), DECLARE_METHOD(t_rulebasednumberformat, getNumberOfRuleSetDisplayNameLocales, METH_NOARGS), DECLARE_METHOD(t_rulebasednumberformat, getRuleSetDisplayName, METH_VARARGS), DECLARE_METHOD(t_rulebasednumberformat, format, METH_VARARGS), DECLARE_METHOD(t_rulebasednumberformat, isLenient, METH_NOARGS), DECLARE_METHOD(t_rulebasednumberformat, setLenient, METH_O), DECLARE_METHOD(t_rulebasednumberformat, getDefaultRuleSetName, METH_VARARGS), DECLARE_METHOD(t_rulebasednumberformat, setDefaultRuleSet, METH_O), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(RuleBasedNumberFormat, t_rulebasednumberformat, NumberFormat, RuleBasedNumberFormat, t_rulebasednumberformat_init, NULL); PyObject *wrap_NumberFormat(NumberFormat *format) { RETURN_WRAPPED_IF_ISINSTANCE(format, DecimalFormat); RETURN_WRAPPED_IF_ISINSTANCE(format, RuleBasedNumberFormat); return wrap_NumberFormat(format, T_OWNED); } /* ChoiceFormat */ class t_choiceformat : public _wrapper { public: ChoiceFormat *object; }; static int t_choiceformat_init(t_choiceformat *self, PyObject *args, PyObject *kwds); static PyObject *t_choiceformat_toPattern(t_choiceformat *self, PyObject *args); static PyObject *t_choiceformat_applyPattern(t_choiceformat *self, PyObject *arg); static PyObject *t_choiceformat_setChoices(t_choiceformat *self, PyObject *args); static PyObject *t_choiceformat_getLimits(t_choiceformat *self); static PyObject *t_choiceformat_getClosures(t_choiceformat *self); static PyObject *t_choiceformat_getFormats(t_choiceformat *self); static PyObject *t_choiceformat_format(t_choiceformat *self, PyObject *args); static PyMethodDef t_choiceformat_methods[] = { DECLARE_METHOD(t_choiceformat, toPattern, METH_VARARGS), DECLARE_METHOD(t_choiceformat, applyPattern, METH_O), DECLARE_METHOD(t_choiceformat, setChoices, METH_VARARGS), DECLARE_METHOD(t_choiceformat, getLimits, METH_NOARGS), DECLARE_METHOD(t_choiceformat, getClosures, METH_NOARGS), DECLARE_METHOD(t_choiceformat, getFormats, METH_NOARGS), DECLARE_METHOD(t_choiceformat, format, METH_VARARGS), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(ChoiceFormat, t_choiceformat, NumberFormat, ChoiceFormat, t_choiceformat_init, NULL); #if U_ICU_VERSION_HEX >= VERSION_HEX(60, 0, 0) using icu::number::NumberFormatter; using icu::number::UnlocalizedNumberFormatter; using icu::number::LocalizedNumberFormatter; using icu::number::Notation; using icu::number::ScientificNotation; using icu::number::IntegerWidth; #if U_ICU_VERSION_HEX < VERSION_HEX(64, 0, 0) using icu::number::Rounder; using icu::number::FractionRounder; using icu::number::IncrementRounder; using icu::number::CurrencyRounder; #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(62, 0, 0) using icu::number::Precision; using icu::number::FractionPrecision; using icu::number::SignificantDigitsPrecision; using icu::number::IncrementPrecision; using icu::number::CurrencyPrecision; using icu::number::Scale; #endif DECLARE_CONSTANTS_TYPE(UNumberSignDisplay); DECLARE_CONSTANTS_TYPE(UNumberDecimalSeparatorDisplay); DECLARE_CONSTANTS_TYPE(UNumberUnitWidth); /* NumberFormatter */ class t_numberformatter : public _wrapper { public: NumberFormatter *object; }; static PyObject *t_numberformatter_with_(PyTypeObject *type); static PyObject *t_numberformatter_withLocale(PyTypeObject *type, PyObject *arg); #if U_ICU_VERSION_HEX >= VERSION_HEX(62, 0, 0) static PyObject *t_numberformatter_forSkeleton(PyTypeObject *type, PyObject *arg); #endif static PyMethodDef t_numberformatter_methods[] = { DECLARE_METHOD(t_numberformatter, with_, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_numberformatter, withLocale, METH_O | METH_CLASS), #if U_ICU_VERSION_HEX >= VERSION_HEX(62, 0, 0) DECLARE_METHOD(t_numberformatter, forSkeleton, METH_O | METH_CLASS), #endif { NULL, NULL, 0, NULL } }; DECLARE_TYPE(NumberFormatter, t_numberformatter, UMemory, NumberFormatter, abstract_init, NULL); /* UnlocalizedNumberFormatter */ class t_unlocalizednumberformatter : public _wrapper { public: UnlocalizedNumberFormatter *object; }; static PyObject *t_unlocalizednumberformatter_unit( t_unlocalizednumberformatter *self, PyObject *arg); #if U_ICU_VERSION_HEX >= VERSION_HEX(61, 0, 0) static PyObject *t_unlocalizednumberformatter_perUnit( t_unlocalizednumberformatter *self, PyObject *arg); #endif #if U_ICU_VERSION_HEX < VERSION_HEX(64, 0, 0) static PyObject *t_unlocalizednumberformatter_rounding( t_unlocalizednumberformatter *self, PyObject *arg); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(61, 0, 0) static PyObject *t_unlocalizednumberformatter_grouping( t_unlocalizednumberformatter *self, PyObject *arg); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(62, 0, 0) static PyObject *t_unlocalizednumberformatter_roundingMode( t_unlocalizednumberformatter *self, PyObject *arg); static PyObject *t_unlocalizednumberformatter_precision( t_unlocalizednumberformatter *self, PyObject *arg); static PyObject *t_unlocalizednumberformatter_scale( t_unlocalizednumberformatter *self, PyObject *arg); static PyObject *t_unlocalizednumberformatter_toSkeleton( t_unlocalizednumberformatter *self); #endif static PyObject *t_unlocalizednumberformatter_symbols( t_unlocalizednumberformatter *self, PyObject *arg); static PyObject *t_unlocalizednumberformatter_notation( t_unlocalizednumberformatter *self, PyObject *arg); static PyObject *t_unlocalizednumberformatter_sign( t_unlocalizednumberformatter *self, PyObject *arg); static PyObject *t_unlocalizednumberformatter_decimal( t_unlocalizednumberformatter *self, PyObject *arg); static PyObject *t_unlocalizednumberformatter_unitWidth( t_unlocalizednumberformatter *self, PyObject *arg); static PyObject *t_unlocalizednumberformatter_integerWidth( t_unlocalizednumberformatter *self, PyObject *arg); static PyObject *t_unlocalizednumberformatter_locale( t_unlocalizednumberformatter *self, PyObject *arg); static PyMethodDef t_unlocalizednumberformatter_methods[] = { DECLARE_METHOD(t_unlocalizednumberformatter, unit, METH_O), #if U_ICU_VERSION_HEX >= VERSION_HEX(61, 0, 0) DECLARE_METHOD(t_unlocalizednumberformatter, perUnit, METH_O), #endif #if U_ICU_VERSION_HEX < VERSION_HEX(64, 0, 0) DECLARE_METHOD(t_unlocalizednumberformatter, rounding, METH_O), #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(61, 0, 0) DECLARE_METHOD(t_unlocalizednumberformatter, grouping, METH_O), #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(62, 0, 0) DECLARE_METHOD(t_unlocalizednumberformatter, roundingMode, METH_O), DECLARE_METHOD(t_unlocalizednumberformatter, precision, METH_O), DECLARE_METHOD(t_unlocalizednumberformatter, scale, METH_O), DECLARE_METHOD(t_unlocalizednumberformatter, toSkeleton, METH_NOARGS), #endif DECLARE_METHOD(t_unlocalizednumberformatter, symbols, METH_O), DECLARE_METHOD(t_unlocalizednumberformatter, notation, METH_O), DECLARE_METHOD(t_unlocalizednumberformatter, sign, METH_O), DECLARE_METHOD(t_unlocalizednumberformatter, decimal, METH_O), DECLARE_METHOD(t_unlocalizednumberformatter, unitWidth, METH_O), DECLARE_METHOD(t_unlocalizednumberformatter, integerWidth, METH_O), DECLARE_METHOD(t_unlocalizednumberformatter, locale, METH_O), { NULL, NULL, 0, NULL } }; static int t_unlocalizednumberformatter_init(t_unlocalizednumberformatter *self, PyObject *args, PyObject *kwds); DECLARE_BY_VALUE_TYPE(UnlocalizedNumberFormatter, t_unlocalizednumberformatter, UMemory, UnlocalizedNumberFormatter, t_unlocalizednumberformatter_init); /* LocalizedNumberFormatter */ class t_localizednumberformatter : public _wrapper { public: LocalizedNumberFormatter *object; }; static PyObject *t_localizednumberformatter_unit( t_localizednumberformatter *self, PyObject *arg); #if U_ICU_VERSION_HEX >= VERSION_HEX(61, 0, 0) static PyObject *t_localizednumberformatter_perUnit( t_localizednumberformatter *self, PyObject *arg); #endif #if U_ICU_VERSION_HEX < VERSION_HEX(64, 0, 0) static PyObject *t_localizednumberformatter_rounding( t_localizednumberformatter *self, PyObject *arg); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(61, 0, 0) static PyObject *t_localizednumberformatter_grouping( t_localizednumberformatter *self, PyObject *arg); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(62, 0, 0) static PyObject *t_localizednumberformatter_roundingMode( t_localizednumberformatter *self, PyObject *arg); static PyObject *t_localizednumberformatter_precision( t_localizednumberformatter *self, PyObject *arg); static PyObject *t_localizednumberformatter_scale( t_localizednumberformatter *self, PyObject *arg); static PyObject *t_localizednumberformatter_toSkeleton( t_localizednumberformatter *self); #endif static PyObject *t_localizednumberformatter_symbols( t_localizednumberformatter *self, PyObject *arg); static PyObject *t_localizednumberformatter_notation( t_localizednumberformatter *self, PyObject *arg); static PyObject *t_localizednumberformatter_sign( t_localizednumberformatter *self, PyObject *arg); static PyObject *t_localizednumberformatter_decimal( t_localizednumberformatter *self, PyObject *arg); static PyObject *t_localizednumberformatter_unitWidth( t_localizednumberformatter *self, PyObject *arg); static PyObject *t_localizednumberformatter_integerWidth( t_localizednumberformatter *self, PyObject *arg); static PyObject *t_localizednumberformatter_formatInt( t_localizednumberformatter *self, PyObject *arg); static PyObject *t_localizednumberformatter_formatDouble( t_localizednumberformatter *self, PyObject *arg); static PyObject *t_localizednumberformatter_formatDecimal( t_localizednumberformatter *self, PyObject *arg); static PyMethodDef t_localizednumberformatter_methods[] = { DECLARE_METHOD(t_localizednumberformatter, unit, METH_O), #if U_ICU_VERSION_HEX >= VERSION_HEX(61, 0, 0) DECLARE_METHOD(t_localizednumberformatter, perUnit, METH_O), #endif #if U_ICU_VERSION_HEX < VERSION_HEX(64, 0, 0) DECLARE_METHOD(t_localizednumberformatter, rounding, METH_O), #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(61, 0, 0) DECLARE_METHOD(t_localizednumberformatter, grouping, METH_O), #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(62, 0, 0) DECLARE_METHOD(t_localizednumberformatter, roundingMode, METH_O), DECLARE_METHOD(t_localizednumberformatter, precision, METH_O), DECLARE_METHOD(t_localizednumberformatter, scale, METH_O), DECLARE_METHOD(t_localizednumberformatter, toSkeleton, METH_NOARGS), #endif DECLARE_METHOD(t_localizednumberformatter, symbols, METH_O), DECLARE_METHOD(t_localizednumberformatter, notation, METH_O), DECLARE_METHOD(t_localizednumberformatter, sign, METH_O), DECLARE_METHOD(t_localizednumberformatter, decimal, METH_O), DECLARE_METHOD(t_localizednumberformatter, unitWidth, METH_O), DECLARE_METHOD(t_localizednumberformatter, integerWidth, METH_O), DECLARE_METHOD(t_localizednumberformatter, formatInt, METH_O), DECLARE_METHOD(t_localizednumberformatter, formatDouble, METH_O), DECLARE_METHOD(t_localizednumberformatter, formatDecimal, METH_O), { NULL, NULL, 0, NULL } }; static int t_localizednumberformatter_init(t_localizednumberformatter *self, PyObject *args, PyObject *kwds); DECLARE_BY_VALUE_TYPE(LocalizedNumberFormatter, t_localizednumberformatter, UMemory, LocalizedNumberFormatter, t_localizednumberformatter_init); /* Notation */ class t_notation : public _wrapper { public: Notation *object; }; static PyObject *t_notation_scientific(PyTypeObject *type, PyObject *args); static PyObject *t_notation_engineering(PyTypeObject *type, PyObject *arg); static PyObject *t_notation_compactShort(PyTypeObject *type, PyObject *arg); static PyObject *t_notation_compactLong(PyTypeObject *type, PyObject *arg); static PyObject *t_notation_simple(PyTypeObject *type, PyObject *arg); static PyMethodDef t_notation_methods[] = { DECLARE_METHOD(t_notation, scientific, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_notation, engineering, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_notation, compactShort, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_notation, compactLong, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_notation, simple, METH_NOARGS | METH_CLASS), { NULL, NULL, 0, NULL } }; DECLARE_BY_VALUE_TYPE(Notation, t_notation, UMemory, Notation, abstract_init); /* ScientificNotation */ class t_scientificnotation : public _wrapper { public: ScientificNotation *object; }; static PyObject *t_scientificnotation_withMinExponentDigits( t_scientificnotation *self, PyObject *args); static PyObject *t_scientificnotation_withExponentSignDisplay( t_scientificnotation *self, PyObject *args); static PyMethodDef t_scientificnotation_methods[] = { DECLARE_METHOD(t_scientificnotation, withMinExponentDigits, METH_O), DECLARE_METHOD(t_scientificnotation, withExponentSignDisplay, METH_O), { NULL, NULL, 0, NULL } }; DECLARE_BY_VALUE_TYPE(ScientificNotation, t_scientificnotation, Notation, ScientificNotation, abstract_init); /* IntegerWidth */ class t_integerwidth : public _wrapper { public: IntegerWidth *object; }; static PyObject *t_integerwidth_zeroFillTo(PyTypeObject *type, PyObject *arg); static PyObject *t_integerwidth_truncateAt(t_integerwidth *self, PyObject *arg); static PyMethodDef t_integerwidth_methods[] = { DECLARE_METHOD(t_integerwidth, zeroFillTo, METH_O | METH_CLASS), DECLARE_METHOD(t_integerwidth, truncateAt, METH_O), { NULL, NULL, 0, NULL } }; DECLARE_BY_VALUE_TYPE(IntegerWidth, t_integerwidth, UMemory, IntegerWidth, abstract_init); #if U_ICU_VERSION_HEX < VERSION_HEX(64, 0, 0) /* Rounder */ class t_rounder : public _wrapper { public: Rounder *object; }; static PyObject *t_rounder_unlimited(PyTypeObject *type, PyObject *args); static PyObject *t_rounder_integer(PyTypeObject *type, PyObject *args); static PyObject *t_rounder_fixedFraction(PyTypeObject *type, PyObject *arg); static PyObject *t_rounder_minFraction(PyTypeObject *type, PyObject *arg); static PyObject *t_rounder_maxFraction(PyTypeObject *type, PyObject *arg); static PyObject *t_rounder_minMaxFraction(PyTypeObject *type, PyObject *args); static PyObject *t_rounder_fixedDigits(PyTypeObject *type, PyObject *arg); static PyObject *t_rounder_minDigits(PyTypeObject *type, PyObject *arg); static PyObject *t_rounder_maxDigits(PyTypeObject *type, PyObject *arg); static PyObject *t_rounder_minMaxDigits(PyTypeObject *type, PyObject *args); static PyObject *t_rounder_increment(PyTypeObject *type, PyObject *arg); static PyObject *t_rounder_currency(PyTypeObject *type, PyObject *arg); static PyObject *t_rounder_withMode(t_rounder *self, PyObject *arg); static PyMethodDef t_rounder_methods[] = { DECLARE_METHOD(t_rounder, unlimited, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_rounder, integer, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_rounder, fixedFraction, METH_O | METH_CLASS), DECLARE_METHOD(t_rounder, minFraction, METH_O | METH_CLASS), DECLARE_METHOD(t_rounder, maxFraction, METH_O | METH_CLASS), DECLARE_METHOD(t_rounder, minMaxFraction, METH_VARARGS | METH_CLASS), DECLARE_METHOD(t_rounder, fixedDigits, METH_O | METH_CLASS), DECLARE_METHOD(t_rounder, minDigits, METH_O | METH_CLASS), DECLARE_METHOD(t_rounder, maxDigits, METH_O | METH_CLASS), DECLARE_METHOD(t_rounder, minMaxDigits, METH_VARARGS | METH_CLASS), DECLARE_METHOD(t_rounder, increment, METH_O | METH_CLASS), DECLARE_METHOD(t_rounder, currency, METH_O | METH_CLASS), DECLARE_METHOD(t_rounder, withMode, METH_O), { NULL, NULL, 0, NULL } }; DECLARE_BY_VALUE_TYPE(Rounder, t_rounder, UMemory, Rounder, abstract_init); /* FractionRounder */ class t_fractionrounder : public _wrapper { public: FractionRounder *object; }; static PyObject *t_fractionrounder_withMinDigits(t_fractionrounder *self, PyObject *arg); static PyObject *t_fractionrounder_withMaxDigits(t_fractionrounder *self, PyObject *arg); static PyMethodDef t_fractionrounder_methods[] = { DECLARE_METHOD(t_fractionrounder, withMinDigits, METH_O), DECLARE_METHOD(t_fractionrounder, withMaxDigits, METH_O), { NULL, NULL, 0, NULL } }; DECLARE_BY_VALUE_TYPE(FractionRounder, t_fractionrounder, Rounder, FractionRounder, abstract_init); /* IncrementRounder */ class t_incrementrounder : public _wrapper { public: IncrementRounder *object; }; static PyObject *t_incrementrounder_withMinFraction(t_incrementrounder *self, PyObject *arg); static PyMethodDef t_incrementrounder_methods[] = { DECLARE_METHOD(t_incrementrounder, withMinFraction, METH_O), { NULL, NULL, 0, NULL } }; DECLARE_BY_VALUE_TYPE(IncrementRounder, t_incrementrounder, Rounder, IncrementRounder, abstract_init); /* CurrencyRounder */ class t_currencyrounder : public _wrapper { public: CurrencyRounder *object; }; static PyObject *t_currencyrounder_withCurrency(t_currencyrounder *self, PyObject *arg); static PyMethodDef t_currencyrounder_methods[] = { DECLARE_METHOD(t_currencyrounder, withCurrency, METH_O), { NULL, NULL, 0, NULL } }; DECLARE_BY_VALUE_TYPE(CurrencyRounder, t_currencyrounder, Rounder, CurrencyRounder, abstract_init); #endif // ICU < 64 #if U_ICU_VERSION_HEX >= VERSION_HEX(62, 0, 0) /* Precision */ class t_precision : public _wrapper { public: Precision *object; }; static PyObject *t_precision_unlimited(PyTypeObject *type, PyObject *args); static PyObject *t_precision_integer(PyTypeObject *type, PyObject *args); static PyObject *t_precision_fixedFraction(PyTypeObject *type, PyObject *arg); static PyObject *t_precision_minFraction(PyTypeObject *type, PyObject *arg); static PyObject *t_precision_maxFraction(PyTypeObject *type, PyObject *arg); static PyObject *t_precision_minMaxFraction(PyTypeObject *type, PyObject *args); static PyObject *t_precision_fixedSignificantDigits(PyTypeObject *type, PyObject *arg); static PyObject *t_precision_minSignificantDigits(PyTypeObject *type, PyObject *arg); static PyObject *t_precision_maxSignificantDigits(PyTypeObject *type, PyObject *arg); static PyObject *t_precision_minMaxSignificantDigits(PyTypeObject *type, PyObject *args); static PyObject *t_precision_increment(PyTypeObject *type, PyObject *arg); static PyObject *t_precision_currency(PyTypeObject *type, PyObject *arg); static PyMethodDef t_precision_methods[] = { DECLARE_METHOD(t_precision, unlimited, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_precision, integer, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_precision, fixedFraction, METH_O | METH_CLASS), DECLARE_METHOD(t_precision, minFraction, METH_O | METH_CLASS), DECLARE_METHOD(t_precision, maxFraction, METH_O | METH_CLASS), DECLARE_METHOD(t_precision, minMaxFraction, METH_VARARGS | METH_CLASS), DECLARE_METHOD(t_precision, fixedSignificantDigits, METH_O | METH_CLASS), DECLARE_METHOD(t_precision, minSignificantDigits, METH_O | METH_CLASS), DECLARE_METHOD(t_precision, maxSignificantDigits, METH_O | METH_CLASS), DECLARE_METHOD(t_precision, minMaxSignificantDigits, METH_VARARGS | METH_CLASS), DECLARE_METHOD(t_precision, increment, METH_O | METH_CLASS), DECLARE_METHOD(t_precision, currency, METH_O | METH_CLASS), { NULL, NULL, 0, NULL } }; DECLARE_BY_VALUE_TYPE(Precision, t_precision, UMemory, Precision, abstract_init); /* FractionPrecision */ class t_fractionprecision : public _wrapper { public: FractionPrecision *object; }; static PyObject *t_fractionprecision_minSignificantDigits( t_fractionprecision *self, PyObject *arg); static PyObject *t_fractionprecision_maxSignificantDigits( t_fractionprecision *self, PyObject *arg); static PyMethodDef t_fractionprecision_methods[] = { DECLARE_METHOD(t_fractionprecision, minSignificantDigits, METH_O), DECLARE_METHOD(t_fractionprecision, maxSignificantDigits, METH_O), { NULL, NULL, 0, NULL } }; DECLARE_BY_VALUE_TYPE(FractionPrecision, t_fractionprecision, Precision, FractionPrecision, abstract_init); /* IncrementPrecision */ class t_incrementprecision : public _wrapper { public: IncrementPrecision *object; }; static PyObject *t_incrementprecision_withMinFraction(t_incrementprecision *self, PyObject *arg); static PyMethodDef t_incrementprecision_methods[] = { DECLARE_METHOD(t_incrementprecision, withMinFraction, METH_O), { NULL, NULL, 0, NULL } }; DECLARE_BY_VALUE_TYPE(IncrementPrecision, t_incrementprecision, Precision, IncrementPrecision, abstract_init); /* CurrencyPrecision */ class t_currencyprecision : public _wrapper { public: CurrencyPrecision *object; }; static PyObject *t_currencyprecision_withCurrency(t_currencyprecision *self, PyObject *arg); static PyMethodDef t_currencyprecision_methods[] = { DECLARE_METHOD(t_currencyprecision, withCurrency, METH_O), { NULL, NULL, 0, NULL } }; DECLARE_BY_VALUE_TYPE(CurrencyPrecision, t_currencyprecision, Precision, CurrencyPrecision, abstract_init); /* Scale */ class t_scale : public _wrapper { public: Scale *object; }; static PyObject *t_scale_none(PyTypeObject *type, PyObject *args); static PyObject *t_scale_powerOfTen(PyTypeObject *type, PyObject *arg); static PyObject *t_scale_byDecimal(PyTypeObject *type, PyObject *arg); static PyObject *t_scale_byDouble(PyTypeObject *type, PyObject *arg); static PyObject *t_scale_byDoubleAndPowerOfTen( PyTypeObject *type, PyObject *args); static PyMethodDef t_scale_methods[] = { DECLARE_METHOD(t_scale, none, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_scale, powerOfTen, METH_O | METH_CLASS), DECLARE_METHOD(t_scale, byDecimal, METH_O | METH_CLASS), DECLARE_METHOD(t_scale, byDouble, METH_O | METH_CLASS), DECLARE_METHOD(t_scale, byDoubleAndPowerOfTen, METH_VARARGS | METH_CLASS), { NULL, NULL, 0, NULL } }; DECLARE_BY_VALUE_TYPE(Scale, t_scale, UMemory, Scale, abstract_init); #endif // ICU >= 62 #endif // ICU >= 60 /* DecimalFormatSymbols */ static int t_decimalformatsymbols_init(t_decimalformatsymbols *self, PyObject *args, PyObject *kwds) { Locale *locale; DecimalFormatSymbols *dfs; #if U_ICU_VERSION_HEX >= VERSION_HEX(60, 0, 0) NumberingSystem *system; #endif 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; #if U_ICU_VERSION_HEX >= VERSION_HEX(60, 0, 0) case 2: if (!parseArgs(args, "PP", TYPE_CLASSID(Locale), TYPE_CLASSID(NumberingSystem), &locale, &system)) { INT_STATUS_CALL(dfs = new DecimalFormatSymbols( *locale, *system, status)); self->object = dfs; self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; #endif default: PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; } if (self->object) return 0; return -1; } static PyObject *t_decimalformatsymbols_getSymbol(t_decimalformatsymbols *self, PyObject *args) { DecimalFormatSymbols::ENumberFormatSymbol symbol; UnicodeString *u; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "i", &symbol)) { UnicodeString u = self->object->getSymbol(symbol); return PyUnicode_FromUnicodeString(&u); } case 2: if (!parseArgs(args, "iU", &symbol, &u)) { u->setTo(self->object->getSymbol(symbol)); Py_RETURN_ARG(args, 1); } break; } return PyErr_SetArgsError((PyObject *) self, "getSymbol", args); } static PyObject *t_decimalformatsymbols_setSymbol(t_decimalformatsymbols *self, PyObject *args) { DecimalFormatSymbols::ENumberFormatSymbol symbol; UnicodeString *u, _u; if (!parseArgs(args, "iS", &symbol, &u, &_u)) { self->object->setSymbol(symbol, *u); /* copied */ Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setSymbol", args); } static PyObject *t_decimalformatsymbols_getLocale(t_decimalformatsymbols *self, PyObject *args) { ULocDataLocaleType type; Locale locale; switch (PyTuple_Size(args)) { case 0: STATUS_CALL(locale = self->object->getLocale(ULOC_VALID_LOCALE, status)); return wrap_Locale(locale); case 1: if (!parseArgs(args, "i", &type)) { STATUS_CALL(locale = self->object->getLocale(type, status)); return wrap_Locale(locale); } break; } return PyErr_SetArgsError((PyObject *) self, "getLocale", args); } #if U_ICU_VERSION_HEX >= 0x04020000 static PyObject *t_decimalformatsymbols_getPatternForCurrencySpacing(t_decimalformatsymbols *self, PyObject *args) { #if U_ICU_VERSION_HEX >= 0x04080000 UCurrencySpacing type; #else DecimalFormatSymbols::ECurrencySpacing type; #endif UBool beforeCurrency; if (!parseArgs(args, "ib", &type, &beforeCurrency)) { UnicodeString u; STATUS_CALL(u = self->object->getPatternForCurrencySpacing(type, beforeCurrency, status)); return PyUnicode_FromUnicodeString(&u); } return PyErr_SetArgsError((PyObject *) self, "getPatternForCurrencySpacing", args); } static PyObject *t_decimalformatsymbols_setPatternForCurrencySpacing(t_decimalformatsymbols *self, PyObject *args) { UnicodeString *u, _u; #if U_ICU_VERSION_HEX >= 0x04080000 UCurrencySpacing type; #else DecimalFormatSymbols::ECurrencySpacing type; #endif UBool beforeCurrency; if (!parseArgs(args, "ibS", &type, &beforeCurrency, &u, &_u)) { /* copied */ self->object->setPatternForCurrencySpacing(type, beforeCurrency, *u); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setPatternForCurrencySpacing", args); } #endif DEFINE_RICHCMP(DecimalFormatSymbols, t_decimalformatsymbols); /* NumberFormat */ static PyObject *t_numberformat_format(t_numberformat *self, PyObject *args) { UnicodeString *u; UnicodeString _u; double d; int i; PY_LONG_LONG l; FieldPosition *fp; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "d", &d)) { self->object->format(d, _u); return PyUnicode_FromUnicodeString(&_u); } if (!parseArgs(args, "i", &i)) { self->object->format(i, _u); return PyUnicode_FromUnicodeString(&_u); } if (!parseArgs(args, "L", &l)) { self->object->format((int64_t) l, _u); return PyUnicode_FromUnicodeString(&_u); } break; case 2: if (!parseArgs(args, "dP", TYPE_CLASSID(FieldPosition), &d, &fp)) { self->object->format(d, _u, *fp); return PyUnicode_FromUnicodeString(&_u); } if (!parseArgs(args, "iP", TYPE_CLASSID(FieldPosition), &i, &fp)) { self->object->format(i, _u, *fp); return PyUnicode_FromUnicodeString(&_u); } if (!parseArgs(args, "LP", TYPE_CLASSID(FieldPosition), &l, &fp)) { self->object->format((int64_t) l, _u, *fp); return PyUnicode_FromUnicodeString(&_u); } break; case 3: if (!parseArgs(args, "dUP", TYPE_CLASSID(FieldPosition), &d, &u, &fp)) { self->object->format(d, *u, *fp); Py_RETURN_ARG(args, 1); } if (!parseArgs(args, "iUP", TYPE_CLASSID(FieldPosition), &i, &u, &fp)) { self->object->format(i, *u, *fp); Py_RETURN_ARG(args, 1); } if (!parseArgs(args, "LUP", TYPE_CLASSID(FieldPosition), &l, &u, &fp)) { self->object->format((int64_t) l, *u, *fp); Py_RETURN_ARG(args, 1); } break; } return t_format_format((t_format *) self, args); } static PyObject *t_numberformat_parse(t_numberformat *self, PyObject *args) { UnicodeString *u; UnicodeString _u; Formattable *f; ParsePosition *pp; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "S", &u, &_u)) { Formattable result; STATUS_CALL(self->object->parse(*u, result, status)); return wrap_Formattable(result); } break; case 2: if (!parseArgs(args, "SP", TYPE_CLASSID(Formattable), &u, &_u, &f)) { STATUS_CALL(self->object->parse(*u, *f, status)); Py_RETURN_ARG(args, 1); } if (!parseArgs(args, "SP", TYPE_CLASSID(ParsePosition), &u, &_u, &pp)) { Formattable result; pp->setErrorIndex(-1); self->object->parse(*u, result, *pp); if (pp->getErrorIndex() != -1) Py_RETURN_NONE; return wrap_Formattable(result); } break; case 3: if (!parseArgs(args, "SPP", TYPE_CLASSID(Formattable), TYPE_CLASSID(ParsePosition), &u, &_u, &f, &pp)) { pp->setErrorIndex(-1); self->object->parse(*u, *f, *pp); if (pp->getErrorIndex() != -1) Py_RETURN_NONE; Py_RETURN_ARG(args, 1); } break; } return PyErr_SetArgsError((PyObject *) self, "parse", args); } #if U_ICU_VERSION_HEX < VERSION_HEX(49, 0, 0) static PyObject *t_numberformat_parseCurrency(t_numberformat *self, PyObject *args) { UnicodeString *u; UnicodeString _u; Formattable *f; ParsePosition *pp; ParsePosition _pp; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "S", &u, &_u)) { Formattable result; _pp.setErrorIndex(-1); self->object->parseCurrency(*u, result, _pp); if (_pp.getErrorIndex() != -1) Py_RETURN_NONE; return wrap_Formattable(result); } break; case 2: if (!parseArgs(args, "SP", TYPE_CLASSID(Formattable), &u, &_u, &f)) { _pp.setErrorIndex(-1); self->object->parseCurrency(*u, *f, _pp); if (_pp.getErrorIndex() != -1) Py_RETURN_NONE; Py_RETURN_ARG(args, 1); } if (!parseArgs(args, "SP", TYPE_CLASSID(ParsePosition), &u, &_u, &pp)) { Formattable result; pp->setErrorIndex(-1); self->object->parseCurrency(*u, result, *pp); if (pp->getErrorIndex() != -1) Py_RETURN_NONE; return wrap_Formattable(result); } break; case 3: if (!parseArgs(args, "SPP", TYPE_CLASSID(Formattable), TYPE_CLASSID(ParsePosition), &u, &_u, &f, &pp)) { pp->setErrorIndex(-1); self->object->parseCurrency(*u, *f, *pp); if (pp->getErrorIndex() != -1) Py_RETURN_NONE; Py_RETURN_ARG(args, 1); } break; } return PyErr_SetArgsError((PyObject *) self, "parseCurrency", args); } #else static PyObject *t_numberformat_parseCurrency(t_numberformat *self, PyObject *args) { UnicodeString _u, *u; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "S", &u, &_u)) { CurrencyAmount *a; ParsePosition _pp; _pp.setErrorIndex(-1); a = self->object->parseCurrency(*u, _pp); if (_pp.getErrorIndex() != -1) Py_RETURN_NONE; return wrap_CurrencyAmount(a, T_OWNED); } break; } return PyErr_SetArgsError((PyObject *) self, "parseCurrency", args); } #endif static PyObject *t_numberformat_isParseIntegerOnly(t_numberformat *self) { int b = self->object->isParseIntegerOnly(); Py_RETURN_BOOL(b); } static PyObject *t_numberformat_setParseIntegerOnly(t_numberformat *self, PyObject *arg) { int b; if (!parseArg(arg, "b", &b)) { self->object->setParseIntegerOnly(b); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setParseIntegerOnly", arg); } static PyObject *t_numberformat_isGroupingUsed(t_numberformat *self) { int b = self->object->isGroupingUsed(); Py_RETURN_BOOL(b); } static PyObject *t_numberformat_setGroupingUsed(t_numberformat *self, PyObject *arg) { int b; if (!parseArg(arg, "b", &b)) { self->object->setGroupingUsed(b); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setGroupingUsed", arg); } static PyObject *t_numberformat_getMaximumIntegerDigits(t_numberformat *self) { int n = self->object->getMaximumIntegerDigits(); return PyInt_FromLong(n); } static PyObject *t_numberformat_setMaximumIntegerDigits(t_numberformat *self, PyObject *arg) { int n; if (!parseArg(arg, "i", &n)) { self->object->setMaximumIntegerDigits(n); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setMaximumIntegerDigits", arg); } static PyObject *t_numberformat_getMinimumIntegerDigits(t_numberformat *self) { int n = self->object->getMinimumIntegerDigits(); return PyInt_FromLong(n); } static PyObject *t_numberformat_setMinimumIntegerDigits(t_numberformat *self, PyObject *arg) { int n; if (!parseArg(arg, "i", &n)) { self->object->setMinimumIntegerDigits(n); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setMinimumIntegerDigits", arg); } static PyObject *t_numberformat_getMaximumFractionDigits(t_numberformat *self) { int n = self->object->getMaximumFractionDigits(); return PyInt_FromLong(n); } static PyObject *t_numberformat_setMaximumFractionDigits(t_numberformat *self, PyObject *arg) { int n; if (!parseArg(arg, "i", &n)) { self->object->setMaximumFractionDigits(n); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setMaximumFractionDigits", arg); } static PyObject *t_numberformat_getMinimumFractionDigits(t_numberformat *self) { int n = self->object->getMinimumFractionDigits(); return PyInt_FromLong(n); } static PyObject *t_numberformat_setMinimumFractionDigits(t_numberformat *self, PyObject *arg) { int n; if (!parseArg(arg, "i", &n)) { self->object->setMinimumFractionDigits(n); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setMinimumFractionDigits", arg); } #if U_ICU_VERSION_HEX >= 0x04080000 static PyObject *t_numberformat_isLenient(t_numberformat *self) { UBool n = self->object->isLenient(); Py_RETURN_BOOL(n); } static PyObject *t_numberformat_setLenient(t_numberformat *self, PyObject *arg) { int b; if (!parseArg(arg, "b", &b)) { self->object->setLenient(b); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setLenient", arg); } #endif static PyObject *t_numberformat_getCurrency(t_numberformat *self) { UnicodeString u(self->object->getCurrency()); return PyUnicode_FromUnicodeString(&u); } static PyObject *t_numberformat_setCurrency(t_numberformat *self, PyObject *arg) { UnicodeString *u, _u; if (!parseArg(arg, "S", &u, &_u)) { /* copied */ STATUS_CALL(self->object->setCurrency(u->getBuffer(), status)); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setCurrency", arg); } static PyObject *t_numberformat_createInstance(PyTypeObject *type, PyObject *args) { NumberFormat *format; Locale *locale; switch (PyTuple_Size(args)) { case 0: STATUS_CALL(format = NumberFormat::createInstance(status)); return wrap_NumberFormat(format); case 1: if (!parseArgs(args, "P", TYPE_CLASSID(Locale), &locale)) { STATUS_CALL(format = NumberFormat::createInstance(*locale, status)); return wrap_NumberFormat(format); } break; } return PyErr_SetArgsError(type, "createInstance", args); } static PyObject *t_numberformat_createCurrencyInstance(PyTypeObject *type, PyObject *args) { NumberFormat *format; Locale *locale; switch (PyTuple_Size(args)) { case 0: STATUS_CALL(format = NumberFormat::createCurrencyInstance(status)); return wrap_NumberFormat(format); case 1: if (!parseArgs(args, "P", TYPE_CLASSID(Locale), &locale)) { STATUS_CALL(format = NumberFormat::createCurrencyInstance(*locale, status)); return wrap_NumberFormat(format); } break; } return PyErr_SetArgsError(type, "createCurrencyInstance", args); } static PyObject *t_numberformat_createPercentInstance(PyTypeObject *type, PyObject *args) { NumberFormat *format; Locale *locale; switch (PyTuple_Size(args)) { case 0: STATUS_CALL(format = NumberFormat::createPercentInstance(status)); return wrap_NumberFormat(format); case 1: if (!parseArgs(args, "P", TYPE_CLASSID(Locale), &locale)) { STATUS_CALL(format = NumberFormat::createPercentInstance(*locale, status)); return wrap_NumberFormat(format); } break; } return PyErr_SetArgsError(type, "createPercentInstance", args); } static PyObject *t_numberformat_createScientificInstance(PyTypeObject *type, PyObject *args) { NumberFormat *format; Locale *locale; switch (PyTuple_Size(args)) { case 0: STATUS_CALL(format = NumberFormat::createScientificInstance(status)); return wrap_NumberFormat(format); case 1: if (!parseArgs(args, "P", TYPE_CLASSID(Locale), &locale)) { STATUS_CALL(format = NumberFormat::createScientificInstance(*locale, status)); return wrap_NumberFormat(format); } break; } return PyErr_SetArgsError(type, "createScientificInstance", args); } static PyObject *t_numberformat_getAvailableLocales(PyTypeObject *type) { int count; const Locale *locales = NumberFormat::getAvailableLocales(count); PyObject *dict = PyDict_New(); for (int32_t i = 0; i < count; i++) { Locale *locale = (Locale *) locales + i; PyObject *obj = wrap_Locale(locale, 0); PyDict_SetItemString(dict, locale->getName(), obj); Py_DECREF(obj); } return dict; } #if U_ICU_VERSION_HEX >= 0x04020000 /* CurrencyPluralInfo */ static int t_currencypluralinfo_init(t_currencypluralinfo *self, PyObject *args, PyObject *kwds) { Locale *locale; switch (PyTuple_Size(args)) { case 0: INT_STATUS_CALL(self->object = new CurrencyPluralInfo(status)); self->flags = T_OWNED; break; case 1: if (!parseArgs(args, "P", TYPE_CLASSID(Locale), &locale)) { INT_STATUS_CALL(self->object = new CurrencyPluralInfo(*locale, status)); self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; break; default: PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; } if (self->object) return 0; return -1; } static PyObject *t_currencypluralinfo_getPluralRules(t_currencypluralinfo *self) { return wrap_PluralRules(self->object->getPluralRules()->clone(), T_OWNED); } static PyObject *t_currencypluralinfo_setPluralRules(t_currencypluralinfo *self, PyObject *arg) { UnicodeString *u, _u; if (!parseArg(arg, "S", &u, &_u)) { STATUS_CALL(self->object->setPluralRules(*u, status)); /* transient */ Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setPluralRules", arg); } static PyObject *t_currencypluralinfo_getCurrencyPluralPattern(t_currencypluralinfo *self, PyObject *args) { UnicodeString *u0, _u0; UnicodeString *u1, _u1; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "S", &u0, &_u0)) { self->object->getCurrencyPluralPattern(*u0, _u1); return PyUnicode_FromUnicodeString(&_u1); } break; case 2: if (!parseArgs(args, "SU", &u0, &_u0, &u1)) { self->object->getCurrencyPluralPattern(*u0, *u1); Py_RETURN_ARG(args, 1); } break; } return PyErr_SetArgsError((PyObject *) self, "getCurrencyPluralPattern", args); } static PyObject *t_currencypluralinfo_setCurrencyPluralPattern(t_currencypluralinfo *self, PyObject *args) { UnicodeString *u0, _u0; UnicodeString *u1, _u1; if (!parseArgs(args, "SS", &u0, &u1)) { /* u0 transient, u1 copied */ STATUS_CALL(self->object->setCurrencyPluralPattern(*u0, *u1, status)); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setCurrencyPluralPattern", args); } static PyObject *t_currencypluralinfo_getLocale(t_currencypluralinfo *self) { return wrap_Locale(self->object->getLocale()); } static PyObject *t_currencypluralinfo_setLocale(t_currencypluralinfo *self, PyObject *arg) { Locale *locale; if (!parseArg(arg, "P", TYPE_CLASSID(Locale), &locale)) { STATUS_CALL(self->object->setLocale(*locale, status)); /* copied */ Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setLocale", arg); } DEFINE_RICHCMP(CurrencyPluralInfo, t_currencypluralinfo); /* NumberingSystem */ static int t_numberingsystem_init(t_numberingsystem *self, PyObject *args, PyObject *kwds) { switch (PyTuple_Size(args)) { case 0: self->object = new NumberingSystem(); self->flags = T_OWNED; break; default: PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; } if (self->object) return 0; return -1; } static PyObject *t_numberingsystem_getRadix(t_numberingsystem *self) { return PyInt_FromLong(self->object->getRadix()); } static PyObject *t_numberingsystem_getName(t_numberingsystem *self) { return PyString_FromString(self->object->getName()); } static PyObject *t_numberingsystem_getDescription(t_numberingsystem *self) { UnicodeString u = self->object->getDescription(); return PyUnicode_FromUnicodeString(&u); } static PyObject *t_numberingsystem_isAlgorithmic(t_numberingsystem *self) { Py_RETURN_BOOL(self->object->isAlgorithmic()); } static PyObject *t_numberingsystem_str(t_numberingsystem *self) { return PyString_FromString(self->object->getName()); } static PyObject *t_numberingsystem_createInstance(PyTypeObject *type, PyObject *args) { NumberingSystem *system; Locale *locale; UnicodeString *u, _u; int radix, algorithmic; switch (PyTuple_Size(args)) { case 0: STATUS_CALL(system = NumberingSystem::createInstance(status)); return wrap_NumberingSystem(system, T_OWNED); case 1: if (!parseArgs(args, "P", TYPE_CLASSID(Locale), &locale)) { STATUS_CALL(system = NumberingSystem::createInstance(*locale, status)); return wrap_NumberingSystem(system, T_OWNED); } break; case 3: if (!parseArgs(args, "ibS", &radix, &algorithmic, &u, &_u)) { STATUS_CALL(system = NumberingSystem::createInstance( radix, algorithmic, *u, status)); return wrap_NumberingSystem(system, T_OWNED); } break; } return PyErr_SetArgsError(type, "createInstance", args); } static PyObject *t_numberingsystem_createInstanceByName(PyTypeObject *type, PyObject *arg) { charsArg name; if (!parseArg(arg, "n", &name)) { NumberingSystem *system; STATUS_CALL(system = NumberingSystem::createInstanceByName(name, status)); return wrap_NumberingSystem(system, T_OWNED); } return PyErr_SetArgsError(type, "createInstanceByName", arg); } static PyObject *t_numberingsystem_getAvailableNames(PyTypeObject *type) { StringEnumeration *names; STATUS_CALL(names = NumberingSystem::getAvailableNames(status)); return wrap_StringEnumeration(names, T_OWNED); } #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); } #if U_ICU_VERSION_HEX >= VERSION_HEX(62, 0, 0) static PyObject *t_decimalformat_getMultiplierScale(t_decimalformat *self) { return PyInt_FromLong(self->object->getMultiplierScale()); } static PyObject *t_decimalformat_setMultiplierScale(t_decimalformat *self, PyObject *arg) { int n; if (!parseArg(arg, "i", &n)) { self->object->setMultiplierScale(n); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setMultiplierScale", arg); } #endif static PyObject *t_decimalformat_getRoundingIncrement(t_decimalformat *self) { return PyFloat_FromDouble(self->object->getRoundingIncrement()); } static PyObject *t_decimalformat_setRoundingIncrement(t_decimalformat *self, PyObject *arg) { double d; if (!parseArg(arg, "d", &d)) { self->object->setRoundingIncrement(d); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setRoundingIncrement", arg); } static PyObject *t_decimalformat_getRoundingMode(t_decimalformat *self) { DecimalFormat::ERoundingMode mode = self->object->getRoundingMode(); return PyInt_FromLong(mode); } static PyObject *t_decimalformat_setRoundingMode(t_decimalformat *self, PyObject *arg) { DecimalFormat::ERoundingMode mode; if (!parseArg(arg, "i", &mode)) { self->object->setRoundingMode(mode); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setRoundingMode", arg); } static PyObject *t_decimalformat_getFormatWidth(t_decimalformat *self) { return PyInt_FromLong(self->object->getFormatWidth()); } static PyObject *t_decimalformat_setFormatWidth(t_decimalformat *self, PyObject *arg) { int width; if (!parseArg(arg, "i", &width)) { self->object->setFormatWidth(width); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setFormatWidth", arg); } static PyObject *t_decimalformat_getPadCharacterString(t_decimalformat *self, PyObject *args) { UnicodeString *u; switch (PyTuple_Size(args)) { case 0: { UnicodeString u = self->object->getPadCharacterString(); return PyUnicode_FromUnicodeString(&u); } case 1: if (!parseArgs(args, "U", &u)) { u->setTo(self->object->getPadCharacterString()); Py_RETURN_ARG(args, 0); } break; } return PyErr_SetArgsError((PyObject *) self, "getPadCharacterString", args); } static PyObject *t_decimalformat_setPadCharacter(t_decimalformat *self, PyObject *arg) { UnicodeString *u, _u; if (!parseArg(arg, "S", &u, &_u)) { self->object->setPadCharacter(*u); /* copied */ Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setPadCharacter", arg); } static PyObject *t_decimalformat_getPadPosition(t_decimalformat *self) { return PyInt_FromLong(self->object->getPadPosition()); } static PyObject *t_decimalformat_setPadPosition(t_decimalformat *self, PyObject *arg) { DecimalFormat::EPadPosition pos; if (!parseArg(arg, "i", &pos)) { self->object->setPadPosition(pos); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setPadPosition", arg); } static PyObject *t_decimalformat_isScientificNotation(t_decimalformat *self) { int b = self->object->isScientificNotation(); Py_RETURN_BOOL(b); } static PyObject *t_decimalformat_setScientificNotation(t_decimalformat *self, PyObject *arg) { int b; if (!parseArg(arg, "b", &b)) { self->object->setScientificNotation(b); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setScientificNotation", arg); } static PyObject *t_decimalformat_getMinimumExponentDigits(t_decimalformat *self) { return PyInt_FromLong(self->object->getMinimumExponentDigits()); } static PyObject *t_decimalformat_setMinimumExponentDigits(t_decimalformat *self, PyObject *arg) { int digits; if (!parseArg(arg, "i", &digits)) { self->object->setMinimumExponentDigits(digits); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setMinimumExponentDigits", arg); } static PyObject *t_decimalformat_isExponentSignAlwaysShown(t_decimalformat *self) { int b = self->object->isExponentSignAlwaysShown(); Py_RETURN_BOOL(b); } static PyObject *t_decimalformat_setExponentSignAlwaysShown(t_decimalformat *self, PyObject *arg) { int b; if (!parseArg(arg, "b", &b)) { self->object->setExponentSignAlwaysShown(b); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setExponentSignAlwaysShown", arg); } static PyObject *t_decimalformat_isDecimalSeparatorAlwaysShown(t_decimalformat *self) { int b = self->object->isDecimalSeparatorAlwaysShown(); Py_RETURN_BOOL(b); } static PyObject *t_decimalformat_setDecimalSeparatorAlwaysShown(t_decimalformat *self, PyObject *arg) { int b; if (!parseArg(arg, "b", &b)) { self->object->setDecimalSeparatorAlwaysShown(b); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setDecimalSeparatorAlwaysShown", arg); } static PyObject *t_decimalformat_getGroupingSize(t_decimalformat *self) { return PyInt_FromLong(self->object->getGroupingSize()); } static PyObject *t_decimalformat_setGroupingSize(t_decimalformat *self, PyObject *arg) { int size; if (!parseArg(arg, "i", &size)) { self->object->setGroupingSize(size); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setGroupingSize", arg); } static PyObject *t_decimalformat_getSecondaryGroupingSize(t_decimalformat *self) { return PyInt_FromLong(self->object->getSecondaryGroupingSize()); } static PyObject *t_decimalformat_setSecondaryGroupingSize(t_decimalformat *self, PyObject *arg) { int size; if (!parseArg(arg, "i", &size)) { self->object->setSecondaryGroupingSize(size); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setSecondaryGroupingSize", arg); } static PyObject *t_decimalformat_toPattern(t_decimalformat *self, PyObject *args) { UnicodeString *u; UnicodeString _u; switch (PyTuple_Size(args)) { case 0: self->object->toPattern(_u); return PyUnicode_FromUnicodeString(&_u); case 1: if (!parseArgs(args, "U", &u)) { self->object->toPattern(*u); Py_RETURN_ARG(args, 0); } break; } return PyErr_SetArgsError((PyObject *) self, "toPattern", args); } static PyObject *t_decimalformat_toLocalizedPattern(t_decimalformat *self, PyObject *args) { UnicodeString *u; UnicodeString _u; switch (PyTuple_Size(args)) { case 0: self->object->toLocalizedPattern(_u); return PyUnicode_FromUnicodeString(&_u); case 1: if (!parseArgs(args, "U", &u)) { self->object->toLocalizedPattern(*u); Py_RETURN_ARG(args, 0); } break; } return PyErr_SetArgsError((PyObject *) self, "toLocalizedPattern", args); } static PyObject *t_decimalformat_applyPattern(t_decimalformat *self, PyObject *arg) { UnicodeString *u; UnicodeString _u; if (!parseArg(arg, "S", &u, &_u)) { STATUS_CALL(self->object->applyPattern(*u, status)); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "applyPattern", arg); } static PyObject *t_decimalformat_applyLocalizedPattern(t_decimalformat *self, PyObject *arg) { UnicodeString *u; UnicodeString _u; if (!parseArg(arg, "S", &u, &_u)) { STATUS_CALL(self->object->applyLocalizedPattern(*u, status)); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "applyLocalizedPattern", arg); } static PyObject *t_decimalformat_getMaximumSignificantDigits(t_decimalformat *self) { return PyInt_FromLong(self->object->getMaximumSignificantDigits()); } static PyObject *t_decimalformat_setMaximumSignificantDigits(t_decimalformat *self, PyObject *arg) { int digits; if (!parseArg(arg, "i", &digits)) { self->object->setMaximumSignificantDigits(digits); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setMaximumSignificantDigits", arg); } static PyObject *t_decimalformat_getMinimumSignificantDigits(t_decimalformat *self) { return PyInt_FromLong(self->object->getMinimumSignificantDigits()); } static PyObject *t_decimalformat_setMinimumSignificantDigits(t_decimalformat *self, PyObject *arg) { int digits; if (!parseArg(arg, "i", &digits)) { self->object->setMinimumSignificantDigits(digits); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setMinimumSignificantDigits", arg); } static PyObject *t_decimalformat_areSignificantDigitsUsed(t_decimalformat *self) { int b = self->object->areSignificantDigitsUsed(); Py_RETURN_BOOL(b); } static PyObject *t_decimalformat_setSignificantDigitsUsed(t_decimalformat *self, PyObject *arg) { int b; if (!parseArg(arg, "b", &b)) { self->object->setSignificantDigitsUsed(b); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setSignificantDigitsUsed", arg); } static PyObject *t_decimalformat_getDecimalFormatSymbols(t_decimalformat *self) { const DecimalFormatSymbols *dfs = self->object->getDecimalFormatSymbols(); return wrap_DecimalFormatSymbols(new DecimalFormatSymbols(*dfs), T_OWNED); } static PyObject *t_decimalformat_setDecimalFormatSymbols(t_decimalformat *self, PyObject *arg) { DecimalFormatSymbols *dfs; if (!parseArg(arg, "P", TYPE_CLASSID(DecimalFormatSymbols), &dfs)) { self->object->adoptDecimalFormatSymbols(new DecimalFormatSymbols(*dfs)); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setDecimalFormatSymbols", arg); } #if U_ICU_VERSION_HEX >= 0x04020000 static PyObject *t_decimalformat_getCurrencyPluralInfo(t_decimalformat *self) { const CurrencyPluralInfo *cpi = self->object->getCurrencyPluralInfo(); return wrap_CurrencyPluralInfo(cpi->clone(), T_OWNED); } static PyObject *t_decimalformat_setCurrencyPluralInfo(t_decimalformat *self, PyObject *arg) { CurrencyPluralInfo *cpi; if (!parseArg(arg, "P", TYPE_CLASSID(CurrencyPluralInfo), &cpi)) { self->object->adoptCurrencyPluralInfo(cpi->clone()); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setCurrencyPluralInfo", arg); } #endif static PyObject *t_decimalformat_str(t_decimalformat *self) { UnicodeString u; self->object->toPattern(u); return PyUnicode_FromUnicodeString(&u); } #if U_ICU_VERSION_HEX >= VERSION_HEX(51, 0, 0) /* CompactDecimalFormat */ static PyObject *t_compactdecimalformat_createInstance(PyTypeObject *type, PyObject *args) { CompactDecimalFormat *format; Locale *locale; UNumberCompactStyle style; switch (PyTuple_Size(args)) { case 2: if (!parseArgs(args, "Pi", TYPE_CLASSID(Locale), &locale, &style)) { STATUS_CALL(format = CompactDecimalFormat::createInstance( *locale, style, status)); return wrap_CompactDecimalFormat(format, T_OWNED); } break; } return PyErr_SetArgsError(type, "createInstance", args); } #endif /* RuleBasedNumberFormat */ static int t_rulebasednumberformat_init(t_rulebasednumberformat *self, PyObject *args, PyObject *kwds) { UnicodeString *u, *v; UnicodeString _u, _v; Locale *locale; RuleBasedNumberFormat *rbf; #if U_HAVE_RBNF URBNFRuleSetTag tag; #endif switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "S", &u, &_u)) { INT_STATUS_PARSER_CALL(rbf = new RuleBasedNumberFormat(*u, parseError, status)); self->object = rbf; self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; case 2: if (!parseArgs(args, "SS", &u, &_u, &v, &_v)) { INT_STATUS_PARSER_CALL(rbf = new RuleBasedNumberFormat(*u, *v, parseError, status)); self->object = rbf; self->flags = T_OWNED; break; } if (!parseArgs(args, "SP", TYPE_CLASSID(Locale), &u, &_u, &locale)) { INT_STATUS_PARSER_CALL(rbf = new RuleBasedNumberFormat(*u, *locale, parseError, status)); self->object = rbf; self->flags = T_OWNED; break; } #if U_HAVE_RBNF if (!parseArgs(args, "iP", TYPE_CLASSID(Locale), &tag, &locale)) { INT_STATUS_CALL(rbf = new RuleBasedNumberFormat(tag, *locale, status)); self->object = rbf; self->flags = T_OWNED; break; } #endif PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; case 3: if (!parseArgs(args, "SSP", TYPE_CLASSID(Locale), &u, &_u, &v, &_v, &locale)) { INT_STATUS_PARSER_CALL(rbf = new RuleBasedNumberFormat(*u, *v, *locale, parseError, status)); self->object = rbf; self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; default: PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; } if (self->object) return 0; return -1; } static PyObject *t_rulebasednumberformat_getRules(t_rulebasednumberformat *self, PyObject *args) { UnicodeString *u; switch (PyTuple_Size(args)) { case 0: { UnicodeString u = self->object->getRules(); return PyUnicode_FromUnicodeString(&u); } case 1: if (!parseArgs(args, "U", &u)) { u->setTo(self->object->getRules()); Py_RETURN_ARG(args, 0); } break; } return PyErr_SetArgsError((PyObject *) self, "getRules", args); } static PyObject *t_rulebasednumberformat_getNumberOfRuleSetNames(t_rulebasednumberformat *self) { return PyInt_FromLong(self->object->getNumberOfRuleSetNames()); } static PyObject *t_rulebasednumberformat_getRuleSetName(t_rulebasednumberformat *self, PyObject *args) { int index; UnicodeString *u; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "i", &index)) { UnicodeString u = self->object->getRuleSetName(index); return PyUnicode_FromUnicodeString(&u); } case 2: if (!parseArgs(args, "iU", &index, &u)) { u->setTo(self->object->getRuleSetName(index)); Py_RETURN_ARG(args, 1); } break; } return PyErr_SetArgsError((PyObject *) self, "getRuleSetName", args); } static PyObject *t_rulebasednumberformat_getNumberOfRuleSetDisplayNameLocales(t_rulebasednumberformat *self) { return PyInt_FromLong(self->object->getNumberOfRuleSetDisplayNameLocales()); } static PyObject *t_rulebasednumberformat_getRuleSetDisplayName(t_rulebasednumberformat *self, PyObject *args) { int index; Locale *locale; UnicodeString *u; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "i", &index)) { UnicodeString u = self->object->getRuleSetDisplayName(index); return PyUnicode_FromUnicodeString(&u); } case 2: if (!parseArgs(args, "iP", TYPE_CLASSID(Locale), &index, &locale)) { UnicodeString u = self->object->getRuleSetDisplayName(index, *locale); return PyUnicode_FromUnicodeString(&u); } if (!parseArgs(args, "iU", &index, &u)) { u->setTo(self->object->getRuleSetDisplayName(index)); Py_RETURN_ARG(args, 1); } break; case 3: if (!parseArgs(args, "iPU", TYPE_CLASSID(Locale), &index, &locale, &u)) { u->setTo(self->object->getRuleSetDisplayName(index, *locale)); Py_RETURN_ARG(args, 2); } break; } return PyErr_SetArgsError((PyObject *) self, "getRuleSetDisplayName", args); } static PyObject *t_rulebasednumberformat_format(t_rulebasednumberformat *self, PyObject *args) { UnicodeString *u, *v; UnicodeString _u, _v; double d; int i; PY_LONG_LONG l; FieldPosition *fp; switch (PyTuple_Size(args)) { case 3: if (!parseArgs(args, "dSP", TYPE_CLASSID(FieldPosition), &d, &u, &_u, &fp)) { STATUS_CALL(self->object->format(d, *u, _v, *fp, status)); return PyUnicode_FromUnicodeString(&_v); } if (!parseArgs(args, "iSP", TYPE_CLASSID(FieldPosition), &i, &u, &_u, &fp)) { STATUS_CALL(self->object->format(i, *u, _v, *fp, status)); return PyUnicode_FromUnicodeString(&_v); } if (!parseArgs(args, "LSP", TYPE_CLASSID(FieldPosition), &l, &u, &_u, &fp)) { STATUS_CALL(self->object->format((int64_t) l, *u, _v, *fp, status)); return PyUnicode_FromUnicodeString(&_v); } case 4: if (!parseArgs(args, "dSUP", TYPE_CLASSID(FieldPosition), &d, &u, &_u, &v, &fp)) { STATUS_CALL(self->object->format(d, *u, *v, *fp, status)); Py_RETURN_ARG(args, 2); } if (!parseArgs(args, "iSUP", TYPE_CLASSID(FieldPosition), &i, &u, &_u, &v, &fp)) { STATUS_CALL(self->object->format(i, *u, *v, *fp, status)); Py_RETURN_ARG(args, 2); } if (!parseArgs(args, "LSUP", TYPE_CLASSID(FieldPosition), &l, &u, &_u, &v, &fp)) { STATUS_CALL(self->object->format((int64_t) l, *u, *v, *fp, status)); Py_RETURN_ARG(args, 2); } break; } return t_numberformat_format((t_numberformat *) self, args); } static PyObject *t_rulebasednumberformat_isLenient(t_rulebasednumberformat *self) { int b = self->object->isLenient(); Py_RETURN_BOOL(b); } static PyObject *t_rulebasednumberformat_setLenient(t_rulebasednumberformat *self, PyObject *arg) { int b; if (!parseArg(arg, "b", &b)) { self->object->setLenient(b); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setLenient", arg); } static PyObject *t_rulebasednumberformat_getDefaultRuleSetName(t_rulebasednumberformat *self, PyObject *args) { UnicodeString *u; switch (PyTuple_Size(args)) { case 0: { UnicodeString _u = self->object->getDefaultRuleSetName(); return PyUnicode_FromUnicodeString(&_u); } case 1: if (!parseArgs(args, "U", &u)) { u->setTo(self->object->getDefaultRuleSetName()); Py_RETURN_ARG(args, 0); } break; } return PyErr_SetArgsError((PyObject *) self, "getDefaultRuleSetName", args); } static PyObject *t_rulebasednumberformat_setDefaultRuleSet(t_rulebasednumberformat *self, PyObject *arg) { UnicodeString *u, _u; if (!parseArg(arg, "S", &u, &_u)) { /* transient */ STATUS_CALL(self->object->setDefaultRuleSet(*u, status)); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setDefaultRuleSet", arg); } static PyObject *t_rulebasednumberformat_str(t_rulebasednumberformat *self) { UnicodeString u = self->object->getRules(); return PyUnicode_FromUnicodeString(&u); } /* ChoiceFormat */ static int t_choiceformat_init(t_choiceformat *self, PyObject *args, PyObject *kwds) { UnicodeString *u; UnicodeString _u; ChoiceFormat *cf; double *limits; int limitCount; UBool *closures; int closureCount; UnicodeString *formats; int formatCount; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "S", &u, &_u)) { INT_STATUS_CALL(cf = new ChoiceFormat(*u, status)); self->object = cf; self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; case 2: if (!parseArgs(args, "FT", &limits, &limitCount, &formats, &formatCount)) { cf = new ChoiceFormat(limits, formats, limitCount); delete[] limits; delete[] formats; self->object = cf; self->flags = T_OWNED; break; } case 3: if (!parseArgs(args, "FGT", &limits, &limitCount, &closures, &closureCount, &formats, &formatCount)) { cf = new ChoiceFormat(limits, closures, formats, limitCount); delete[] limits; delete[] closures; delete[] formats; self->object = cf; self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; default: PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; } if (self->object) return 0; return -1; } static PyObject *t_choiceformat_toPattern(t_choiceformat *self, PyObject *args) { UnicodeString *u; UnicodeString _u; switch (PyTuple_Size(args)) { case 0: self->object->toPattern(_u); return PyUnicode_FromUnicodeString(&_u); case 1: if (!parseArgs(args, "U", &u)) { self->object->toPattern(*u); Py_RETURN_ARG(args, 0); } break; } return PyErr_SetArgsError((PyObject *) self, "toPattern", args); } static PyObject *t_choiceformat_applyPattern(t_choiceformat *self, PyObject *arg) { UnicodeString *u, _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); } #if U_ICU_VERSION_HEX >= VERSION_HEX(60, 0, 0) /* NumberFormatter */ static PyObject *t_numberformatter_with_(PyTypeObject *type) { return wrap_UnlocalizedNumberFormatter(NumberFormatter::with()); } static PyObject *t_numberformatter_withLocale(PyTypeObject *type, PyObject *arg) { Locale *locale; if (!parseArg(arg, "P", TYPE_CLASSID(Locale), &locale)) return wrap_LocalizedNumberFormatter(NumberFormatter::withLocale(*locale)); return PyErr_SetArgsError(type, "withLocale", arg); } #if U_ICU_VERSION_HEX >= VERSION_HEX(62, 0, 0) static PyObject *t_numberformatter_forSkeleton(PyTypeObject *type, PyObject *arg) { UnicodeString *u, _u; if (!parseArg(arg, "S", &u, &_u)) { UnlocalizedNumberFormatter result; STATUS_CALL(result = NumberFormatter::forSkeleton(*u, status)); return wrap_UnlocalizedNumberFormatter(result); } return PyErr_SetArgsError(type, "forSkeleton", arg); } #endif /* UnlocalizedNumberFormatter */ static int t_unlocalizednumberformatter_init(t_unlocalizednumberformatter *self, PyObject *args, PyObject *kwds) { switch (PyTuple_Size(args)) { case 0: self->object = new UnlocalizedNumberFormatter(NumberFormatter::with()); self->flags = T_OWNED; break; } if (self->object) return 0; return -1; } static PyObject *t_unlocalizednumberformatter_unit( t_unlocalizednumberformatter *self, PyObject *arg) { MeasureUnit *unit; if (!parseArg(arg, "P", TYPE_CLASSID(MeasureUnit), &unit)) { return wrap_UnlocalizedNumberFormatter( self->object->adoptUnit( dynamic_cast(unit->clone()))); } return PyErr_SetArgsError((PyObject *) self, "unit", arg); } #if U_ICU_VERSION_HEX >= VERSION_HEX(61, 0, 0) static PyObject *t_unlocalizednumberformatter_perUnit( t_unlocalizednumberformatter *self, PyObject *arg) { MeasureUnit *unit; if (!parseArg(arg, "P", TYPE_CLASSID(MeasureUnit), &unit)) { return wrap_UnlocalizedNumberFormatter( self->object->adoptPerUnit( dynamic_cast(unit->clone()))); } return PyErr_SetArgsError((PyObject *) self, "perUnit", arg); } #endif #if U_ICU_VERSION_HEX < VERSION_HEX(64, 0, 0) static PyObject *t_unlocalizednumberformatter_rounding( t_unlocalizednumberformatter *self, PyObject *arg) { PyObject *rounder; if (!parseArg(arg, "O", &RounderType_, &rounder)) return wrap_UnlocalizedNumberFormatter( self->object->rounding(*((t_rounder *) rounder)->object)); return PyErr_SetArgsError((PyObject *) self, "rounding", arg); } #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(61, 0, 0) static PyObject *t_unlocalizednumberformatter_grouping( t_unlocalizednumberformatter *self, PyObject *arg) { int strategy; if (!parseArg(arg, "i", &strategy)) return wrap_UnlocalizedNumberFormatter( self->object->grouping((UNumberGroupingStrategy) strategy)); return PyErr_SetArgsError((PyObject *) self, "grouping", arg); } #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(62, 0, 0) static PyObject *t_unlocalizednumberformatter_roundingMode( t_unlocalizednumberformatter *self, PyObject *arg) { int mode; if (!parseArg(arg, "i", &mode)) return wrap_UnlocalizedNumberFormatter( self->object->roundingMode((UNumberFormatRoundingMode) mode)); return PyErr_SetArgsError((PyObject *) self, "roundingMode", arg); } static PyObject *t_unlocalizednumberformatter_precision( t_unlocalizednumberformatter *self, PyObject *arg) { PyObject *precision; if (!parseArg(arg, "O", &PrecisionType_, &precision)) return wrap_UnlocalizedNumberFormatter( self->object->precision(*((t_precision *) precision)->object)); return PyErr_SetArgsError((PyObject *) self, "precision", arg); } static PyObject *t_unlocalizednumberformatter_scale( t_unlocalizednumberformatter *self, PyObject *arg) { PyObject *scale; if (!parseArg(arg, "O", &ScaleType_, &scale)) return wrap_UnlocalizedNumberFormatter( self->object->scale(*((t_scale *) scale)->object)); return PyErr_SetArgsError((PyObject *) self, "scale", arg); } static PyObject *t_unlocalizednumberformatter_toSkeleton( t_unlocalizednumberformatter *self) { UnicodeString u; STATUS_CALL(u = self->object->toSkeleton(status)); return PyUnicode_FromUnicodeString(&u); } #endif static PyObject *t_unlocalizednumberformatter_symbols( t_unlocalizednumberformatter *self, PyObject *arg) { DecimalFormatSymbols *symbols; if (!parseArg(arg, "P", TYPE_CLASSID(DecimalFormatSymbols), &symbols)) return wrap_UnlocalizedNumberFormatter(self->object->symbols(*symbols)); return PyErr_SetArgsError((PyObject *) self, "symbols", arg); } static PyObject *t_unlocalizednumberformatter_notation( t_unlocalizednumberformatter *self, PyObject *arg) { PyObject *notation; if (!parseArg(arg, "O", &NotationType_, ¬ation)) return wrap_UnlocalizedNumberFormatter( self->object->notation(*((t_notation *) notation)->object)); return PyErr_SetArgsError((PyObject *) self, "notation", arg); } static PyObject *t_unlocalizednumberformatter_sign( t_unlocalizednumberformatter *self, PyObject *arg) { int n; if (!parseArg(arg, "i", &n)) { return wrap_UnlocalizedNumberFormatter( self->object->sign((UNumberSignDisplay) n)); } return PyErr_SetArgsError((PyObject *) self, "sign", arg); } static PyObject *t_unlocalizednumberformatter_decimal( t_unlocalizednumberformatter *self, PyObject *arg) { int n; if (!parseArg(arg, "i", &n)) { return wrap_UnlocalizedNumberFormatter( self->object->decimal((UNumberDecimalSeparatorDisplay) n)); } return PyErr_SetArgsError((PyObject *) self, "sign", arg); } static PyObject *t_unlocalizednumberformatter_unitWidth( t_unlocalizednumberformatter *self, PyObject *arg) { int n; if (!parseArg(arg, "i", &n)) { return wrap_UnlocalizedNumberFormatter( self->object->unitWidth((UNumberUnitWidth) n)); } return PyErr_SetArgsError((PyObject *) self, "unitWidth", arg); } static PyObject *t_unlocalizednumberformatter_integerWidth( t_unlocalizednumberformatter *self, PyObject *arg) { PyObject *iw; if (!parseArg(arg, "O", &IntegerWidthType_, &iw)) return wrap_UnlocalizedNumberFormatter(self->object->integerWidth( *((t_integerwidth *) iw)->object)); return PyErr_SetArgsError((PyObject *) self, "integerWidth", arg); } static PyObject *t_unlocalizednumberformatter_locale( t_unlocalizednumberformatter *self, PyObject *arg) { Locale *locale; if (!parseArg(arg, "P", TYPE_CLASSID(Locale), &locale)) return wrap_LocalizedNumberFormatter(self->object->locale(*locale)); return PyErr_SetArgsError((PyObject *) self, "locale", arg); } /* LocalizedNumberFormatter */ static int t_localizednumberformatter_init(t_localizednumberformatter *self, PyObject *args, PyObject *kwds) { switch (PyTuple_Size(args)) { case 1: { Locale *locale; if (!parseArgs(args, "P", TYPE_CLASSID(Locale), &locale)) { self->object = new LocalizedNumberFormatter( NumberFormatter::withLocale(*locale)); self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); break; } } if (self->object) return 0; return -1; } static PyObject *t_localizednumberformatter_unit( t_localizednumberformatter *self, PyObject *arg) { MeasureUnit *unit; if (!parseArg(arg, "P", TYPE_CLASSID(MeasureUnit), &unit)) { return wrap_LocalizedNumberFormatter( self->object->adoptUnit( dynamic_cast(unit->clone()))); } return PyErr_SetArgsError((PyObject *) self, "unit", arg); } #if U_ICU_VERSION_HEX >= VERSION_HEX(61, 0, 0) static PyObject *t_localizednumberformatter_perUnit( t_localizednumberformatter *self, PyObject *arg) { MeasureUnit *unit; if (!parseArg(arg, "P", TYPE_CLASSID(MeasureUnit), &unit)) { return wrap_LocalizedNumberFormatter( self->object->adoptPerUnit( dynamic_cast(unit->clone()))); } return PyErr_SetArgsError((PyObject *) self, "perUnit", arg); } #endif #if U_ICU_VERSION_HEX < VERSION_HEX(64, 0, 0) static PyObject *t_localizednumberformatter_rounding( t_localizednumberformatter *self, PyObject *arg) { PyObject *rounder; if (!parseArg(arg, "O", &RounderType_, &rounder)) return wrap_LocalizedNumberFormatter( self->object->rounding(*((t_rounder *) rounder)->object)); return PyErr_SetArgsError((PyObject *) self, "rounding", arg); } #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(61, 0, 0) static PyObject *t_localizednumberformatter_grouping( t_localizednumberformatter *self, PyObject *arg) { int strategy; if (!parseArg(arg, "i", &strategy)) return wrap_LocalizedNumberFormatter( self->object->grouping((UNumberGroupingStrategy) strategy)); return PyErr_SetArgsError((PyObject *) self, "grouping", arg); } #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(62, 0, 0) static PyObject *t_localizednumberformatter_roundingMode( t_localizednumberformatter *self, PyObject *arg) { int mode; if (!parseArg(arg, "i", &mode)) return wrap_LocalizedNumberFormatter( self->object->roundingMode((UNumberFormatRoundingMode) mode)); return PyErr_SetArgsError((PyObject *) self, "roundingMode", arg); } static PyObject *t_localizednumberformatter_precision( t_localizednumberformatter *self, PyObject *arg) { PyObject *precision; if (!parseArg(arg, "O", &PrecisionType_, &precision)) return wrap_LocalizedNumberFormatter( self->object->precision(*((t_precision *) precision)->object)); return PyErr_SetArgsError((PyObject *) self, "precision", arg); } static PyObject *t_localizednumberformatter_scale( t_localizednumberformatter *self, PyObject *arg) { PyObject *scale; if (!parseArg(arg, "O", &ScaleType_, &scale)) return wrap_LocalizedNumberFormatter( self->object->scale(*((t_scale *) scale)->object)); return PyErr_SetArgsError((PyObject *) self, "scale", arg); } static PyObject *t_localizednumberformatter_toSkeleton( t_localizednumberformatter *self) { UnicodeString u; STATUS_CALL(u = self->object->toSkeleton(status)); return PyUnicode_FromUnicodeString(&u); } #endif static PyObject *t_localizednumberformatter_symbols( t_localizednumberformatter *self, PyObject *arg) { DecimalFormatSymbols *symbols; if (!parseArg(arg, "P", TYPE_CLASSID(DecimalFormatSymbols), &symbols)) return wrap_LocalizedNumberFormatter(self->object->symbols(*symbols)); return PyErr_SetArgsError((PyObject *) self, "symbols", arg); } static PyObject *t_localizednumberformatter_notation( t_localizednumberformatter *self, PyObject *arg) { PyObject *notation; if (!parseArg(arg, "O", &NotationType_, ¬ation)) return wrap_LocalizedNumberFormatter(self->object->notation( *((t_notation *) notation)->object)); return PyErr_SetArgsError((PyObject *) self, "notation", arg); } static PyObject *t_localizednumberformatter_sign( t_localizednumberformatter *self, PyObject *arg) { int n; if (!parseArg(arg, "i", &n)) { return wrap_LocalizedNumberFormatter( self->object->sign((UNumberSignDisplay) n)); } return PyErr_SetArgsError((PyObject *) self, "sign", arg); } static PyObject *t_localizednumberformatter_decimal( t_localizednumberformatter *self, PyObject *arg) { int n; if (!parseArg(arg, "i", &n)) { return wrap_LocalizedNumberFormatter( self->object->decimal((UNumberDecimalSeparatorDisplay) n)); } return PyErr_SetArgsError((PyObject *) self, "sign", arg); } static PyObject *t_localizednumberformatter_unitWidth( t_localizednumberformatter *self, PyObject *arg) { int n; if (!parseArg(arg, "i", &n)) { return wrap_LocalizedNumberFormatter( self->object->unitWidth((UNumberUnitWidth) n)); } return PyErr_SetArgsError((PyObject *) self, "unitWidth", arg); } static PyObject *t_localizednumberformatter_integerWidth( t_localizednumberformatter *self, PyObject *arg) { PyObject *iw; if (!parseArg(arg, "O", &IntegerWidthType_, &iw)) return wrap_LocalizedNumberFormatter(self->object->integerWidth( *((t_integerwidth *) iw)->object)); return PyErr_SetArgsError((PyObject *) self, "integerWidth", arg); } static PyObject *t_localizednumberformatter_formatInt( t_localizednumberformatter *self, PyObject *arg) { int n; double d; PY_LONG_LONG l; UnicodeString u; if (!parseArg(arg, "i", &n)) { #if U_ICU_VERSION_HEX >= VERSION_HEX(64, 0, 0) STATUS_CALL(u = self->object->formatInt(n, status).toString(status)); #else STATUS_CALL(u = self->object->formatInt(n, status).toString()); #endif return PyUnicode_FromUnicodeString(&u); } if (!parseArg(arg, "d", &d)) { #if U_ICU_VERSION_HEX >= VERSION_HEX(64, 0, 0) STATUS_CALL(u = self->object->formatInt( (int64_t) d, status).toString(status)); #else STATUS_CALL(u = self->object->formatInt( (int64_t) d, status).toString()); #endif return PyUnicode_FromUnicodeString(&u); } if (!parseArg(arg, "L", &l)) { #if U_ICU_VERSION_HEX >= VERSION_HEX(64, 0, 0) STATUS_CALL(u = self->object->formatInt( (int64_t) l, status).toString(status)); #else STATUS_CALL(u = self->object->formatInt( (int64_t) l, status).toString()); #endif return PyUnicode_FromUnicodeString(&u); } return PyErr_SetArgsError((PyObject *) self, "formatInt", arg); } static PyObject *t_localizednumberformatter_formatDouble( t_localizednumberformatter *self, PyObject *arg) { int n; double d; PY_LONG_LONG l; UnicodeString u; if (!parseArg(arg, "i", &n)) { #if U_ICU_VERSION_HEX >= VERSION_HEX(64, 0, 0) STATUS_CALL(u = self->object->formatDouble( (double) n, status).toString(status)); #else STATUS_CALL(u = self->object->formatDouble( (double) n, status).toString()); #endif return PyUnicode_FromUnicodeString(&u); } if (!parseArg(arg, "d", &d)) { #if U_ICU_VERSION_HEX >= VERSION_HEX(64, 0, 0) STATUS_CALL(u = self->object->formatDouble(d, status).toString(status)); #else STATUS_CALL(u = self->object->formatDouble(d, status).toString()); #endif return PyUnicode_FromUnicodeString(&u); } if (!parseArg(arg, "L", &l)) { #if U_ICU_VERSION_HEX >= VERSION_HEX(64, 0, 0) STATUS_CALL(u = self->object->formatDouble( (double) l, status).toString(status)); #else STATUS_CALL(u = self->object->formatDouble( (double) l, status).toString()); #endif return PyUnicode_FromUnicodeString(&u); } return PyErr_SetArgsError((PyObject *) self, "formatDouble", arg); } static PyObject *t_localizednumberformatter_formatDecimal( t_localizednumberformatter *self, PyObject *arg) { char *s; UnicodeString u; if (!parseArg(arg, "c", &s)) { #if U_ICU_VERSION_HEX >= VERSION_HEX(64, 0, 0) STATUS_CALL(u = self->object->formatDecimal( s, status).toString(status)); #else STATUS_CALL(u = self->object->formatDecimal( s, status).toString()); #endif return PyUnicode_FromUnicodeString(&u); } return PyErr_SetArgsError((PyObject *) self, "formatDecimal", arg); } /* Notation */ static PyObject *t_notation_scientific(PyTypeObject *type, PyObject *args) { return wrap_ScientificNotation(Notation::scientific()); } static PyObject *t_notation_engineering(PyTypeObject *type, PyObject *args) { return wrap_ScientificNotation(Notation::engineering()); } static PyObject *t_notation_compactShort(PyTypeObject *type, PyObject *args) { return wrap_Notation(Notation::compactShort()); } static PyObject *t_notation_compactLong(PyTypeObject *type, PyObject *args) { return wrap_Notation(Notation::compactLong()); } static PyObject *t_notation_simple(PyTypeObject *type, PyObject *args) { return wrap_Notation(Notation::simple()); } /* ScientificNotation */ static PyObject *t_scientificnotation_withMinExponentDigits( t_scientificnotation *self, PyObject *arg) { int n; if (!parseArg(arg, "i", &n)) return wrap_ScientificNotation(self->object->withMinExponentDigits(n)); return PyErr_SetArgsError((PyObject *) self, "withMinExponentDigits", arg); } static PyObject *t_scientificnotation_withExponentSignDisplay( t_scientificnotation *self, PyObject *arg) { int n; if (!parseArg(arg, "i", &n)) return wrap_ScientificNotation(self->object->withExponentSignDisplay( (UNumberSignDisplay) n)); return PyErr_SetArgsError((PyObject *) self, "withMinExponentDigits", arg); } /* IntegerWidth */ static PyObject *t_integerwidth_zeroFillTo(PyTypeObject *type, PyObject *arg) { int n; if (!parseArg(arg, "i", &n)) return wrap_IntegerWidth(IntegerWidth::zeroFillTo(n)); return PyErr_SetArgsError(type, "zeroFillTo", arg); } static PyObject *t_integerwidth_truncateAt(t_integerwidth *self, PyObject *arg) { int n; if (!parseArg(arg, "i", &n)) return wrap_IntegerWidth(self->object->truncateAt(n)); return PyErr_SetArgsError((PyObject *) self, "truncateAt", arg); } /* Rounder */ #if U_ICU_VERSION_HEX < VERSION_HEX(64, 0, 0) static PyObject *t_rounder_unlimited(PyTypeObject *type, PyObject *args) { return wrap_Rounder(Rounder::unlimited()); } static PyObject *t_rounder_integer(PyTypeObject *type, PyObject *args) { return wrap_FractionRounder(Rounder::integer()); } static PyObject *t_rounder_fixedFraction(PyTypeObject *type, PyObject *arg) { int n; if (!parseArg(arg, "i", &n)) return wrap_FractionRounder(Rounder::fixedFraction(n)); return PyErr_SetArgsError(type, "fixedFraction", arg); } static PyObject *t_rounder_minFraction(PyTypeObject *type, PyObject *arg) { int n; if (!parseArg(arg, "i", &n)) return wrap_FractionRounder(Rounder::minFraction(n)); return PyErr_SetArgsError(type, "minFraction", arg); } static PyObject *t_rounder_maxFraction(PyTypeObject *type, PyObject *arg) { int n; if (!parseArg(arg, "i", &n)) return wrap_FractionRounder(Rounder::maxFraction(n)); return PyErr_SetArgsError(type, "maxFraction", arg); } static PyObject *t_rounder_minMaxFraction(PyTypeObject *type, PyObject *args) { int n0, n1; if (!parseArgs(args, "ii", &n0, &n1)) return wrap_FractionRounder(Rounder::minMaxFraction(n0, n1)); return PyErr_SetArgsError(type, "minMaxFraction", args); } static PyObject *t_rounder_fixedDigits(PyTypeObject *type, PyObject *arg) { int n; if (!parseArg(arg, "i", &n)) return wrap_Rounder(Rounder::fixedDigits(n)); return PyErr_SetArgsError(type, "fixedDigits", arg); } static PyObject *t_rounder_minDigits(PyTypeObject *type, PyObject *arg) { int n; if (!parseArg(arg, "i", &n)) return wrap_Rounder(Rounder::minDigits(n)); return PyErr_SetArgsError(type, "minDigits", arg); } static PyObject *t_rounder_maxDigits(PyTypeObject *type, PyObject *arg) { int n; if (!parseArg(arg, "i", &n)) return wrap_Rounder(Rounder::maxDigits(n)); return PyErr_SetArgsError(type, "maxDigits", arg); } static PyObject *t_rounder_minMaxDigits(PyTypeObject *type, PyObject *args) { int n0, n1; if (!parseArgs(args, "ii", &n0, &n1)) return wrap_Rounder(Rounder::minMaxDigits(n0, n1)); return PyErr_SetArgsError(type, "minMaxDigits", args); } static PyObject *t_rounder_increment(PyTypeObject *type, PyObject *arg) { double d; if (!parseArg(arg, "d", &d)) return wrap_IncrementRounder(Rounder::increment(d)); return PyErr_SetArgsError(type, "increment", arg); } static PyObject *t_rounder_currency(PyTypeObject *type, PyObject *arg) { int n; if (!parseArg(arg, "i", &n)) return wrap_CurrencyRounder(Rounder::currency((UCurrencyUsage) n)); return PyErr_SetArgsError(type, "currency", arg); } static PyObject *t_rounder_withMode(t_rounder *self, PyObject *arg) { int n; if (!parseArg(arg, "i", &n)) return wrap_Rounder(self->object->withMode( (UNumberFormatRoundingMode) n)); return PyErr_SetArgsError((PyObject *) self, "withMode", arg); } /* FractionRounder */ static PyObject *t_fractionrounder_withMinDigits( t_fractionrounder *self, PyObject *arg) { int n; if (!parseArg(arg, "i", &n)) return wrap_Rounder(self->object->withMinDigits(n)); return PyErr_SetArgsError((PyObject *) self, "withMinDigits", arg); } static PyObject *t_fractionrounder_withMaxDigits( t_fractionrounder *self, PyObject *arg) { int n; if (!parseArg(arg, "i", &n)) return wrap_Rounder(self->object->withMaxDigits(n)); return PyErr_SetArgsError((PyObject *) self, "withMaxDigits", arg); } /* IncrementRounder */ static PyObject *t_incrementrounder_withMinFraction( t_incrementrounder *self, PyObject *arg) { int n; if (!parseArg(arg, "i", &n)) return wrap_Rounder(self->object->withMinFraction(n)); return PyErr_SetArgsError((PyObject *) self, "withMinFraction", arg); } /* CurrencyRounder */ static PyObject *t_currencyrounder_withCurrency( t_currencyrounder *self, PyObject *arg) { CurrencyUnit *unit; if (!parseArg(arg, "P", TYPE_CLASSID(CurrencyUnit), &unit)) return wrap_Rounder(self->object->withCurrency(*unit)); return PyErr_SetArgsError((PyObject *) self, "withCurrency", arg); } #endif // ICU < 64 #if U_ICU_VERSION_HEX >= VERSION_HEX(62, 0, 0) /* Precision */ static PyObject *t_precision_unlimited(PyTypeObject *type, PyObject *args) { return wrap_Precision(Precision::unlimited()); } static PyObject *t_precision_integer(PyTypeObject *type, PyObject *args) { return wrap_FractionPrecision(Precision::integer()); } static PyObject *t_precision_fixedFraction(PyTypeObject *type, PyObject *arg) { int n; if (!parseArg(arg, "i", &n)) return wrap_FractionPrecision(Precision::fixedFraction(n)); return PyErr_SetArgsError(type, "fixedFraction", arg); } static PyObject *t_precision_minFraction(PyTypeObject *type, PyObject *arg) { int n; if (!parseArg(arg, "i", &n)) return wrap_FractionPrecision(Precision::minFraction(n)); return PyErr_SetArgsError(type, "minFraction", arg); } static PyObject *t_precision_maxFraction(PyTypeObject *type, PyObject *arg) { int n; if (!parseArg(arg, "i", &n)) return wrap_FractionPrecision(Precision::maxFraction(n)); return PyErr_SetArgsError(type, "maxFraction", arg); } static PyObject *t_precision_minMaxFraction(PyTypeObject *type, PyObject *args) { int n0, n1; if (!parseArgs(args, "ii", &n0, &n1)) return wrap_FractionPrecision(Precision::minMaxFraction(n0, n1)); return PyErr_SetArgsError(type, "minMaxFraction", args); } static PyObject *t_precision_fixedSignificantDigits(PyTypeObject *type, PyObject *arg) { int n; if (!parseArg(arg, "i", &n)) return wrap_Precision(Precision::fixedSignificantDigits(n)); return PyErr_SetArgsError(type, "fixedSignificantDigits", arg); } static PyObject *t_precision_minSignificantDigits(PyTypeObject *type, PyObject *arg) { int n; if (!parseArg(arg, "i", &n)) return wrap_Precision(Precision::minSignificantDigits(n)); return PyErr_SetArgsError(type, "minSignificantDigits", arg); } static PyObject *t_precision_maxSignificantDigits(PyTypeObject *type, PyObject *arg) { int n; if (!parseArg(arg, "i", &n)) return wrap_Precision(Precision::maxSignificantDigits(n)); return PyErr_SetArgsError(type, "maxSignificantDigits", arg); } static PyObject *t_precision_minMaxSignificantDigits(PyTypeObject *type, PyObject *args) { int n0, n1; if (!parseArgs(args, "ii", &n0, &n1)) return wrap_Precision(Precision::minMaxSignificantDigits(n0, n1)); return PyErr_SetArgsError(type, "minMaxSignificantDigits", args); } static PyObject *t_precision_increment(PyTypeObject *type, PyObject *arg) { double d; if (!parseArg(arg, "d", &d)) return wrap_IncrementPrecision(Precision::increment(d)); return PyErr_SetArgsError(type, "increment", arg); } static PyObject *t_precision_currency(PyTypeObject *type, PyObject *arg) { int n; if (!parseArg(arg, "i", &n)) return wrap_CurrencyPrecision(Precision::currency((UCurrencyUsage) n)); return PyErr_SetArgsError(type, "currency", arg); } /* FractionPrecision */ static PyObject *t_fractionprecision_minSignificantDigits( t_fractionprecision *self, PyObject *arg) { int n; if (!parseArg(arg, "i", &n)) return wrap_Precision(self->object->minSignificantDigits(n)); return PyErr_SetArgsError( (PyObject *) self, "minSignificantDigits", arg); } static PyObject *t_fractionprecision_maxSignificantDigits( t_fractionprecision *self, PyObject *arg) { int n; if (!parseArg(arg, "i", &n)) return wrap_Precision(self->object->maxSignificantDigits(n)); return PyErr_SetArgsError( (PyObject *) self, "maxSignificantDigits", arg); } /* IncrementPrecision */ static PyObject *t_incrementprecision_withMinFraction( t_incrementprecision *self, PyObject *arg) { int n; if (!parseArg(arg, "i", &n)) return wrap_Precision(self->object->withMinFraction(n)); return PyErr_SetArgsError((PyObject *) self, "withMinFraction", arg); } /* CurrencyPrecision */ static PyObject *t_currencyprecision_withCurrency( t_currencyprecision *self, PyObject *arg) { CurrencyUnit *unit; if (!parseArg(arg, "P", TYPE_CLASSID(CurrencyUnit), &unit)) return wrap_Precision(self->object->withCurrency(*unit)); return PyErr_SetArgsError((PyObject *) self, "withCurrency", arg); } /* Scale */ static PyObject *t_scale_none(PyTypeObject *type, PyObject *args) { return wrap_Scale(Scale::none()); } static PyObject *t_scale_powerOfTen(PyTypeObject *type, PyObject *arg) { int power; if (!parseArg(arg, "i", &power)) return wrap_Scale(Scale::powerOfTen(power)); return PyErr_SetArgsError(type, "powerOfTen", arg); } static PyObject *t_scale_byDecimal(PyTypeObject *type, PyObject *arg) { charsArg multiplicand; if (!parseArg(arg, "n", &multiplicand)) return wrap_Scale(Scale::byDecimal(multiplicand.c_str())); return PyErr_SetArgsError(type, "byDecimal", arg); } static PyObject *t_scale_byDouble(PyTypeObject *type, PyObject *arg) { double multiplicand; if (!parseArg(arg, "d", &multiplicand)) return wrap_Scale(Scale::byDouble(multiplicand)); return PyErr_SetArgsError(type, "byDouble", arg); } static PyObject *t_scale_byDoubleAndPowerOfTen(PyTypeObject *type, PyObject *args) { double multiplicand; int power; if (!parseArgs(args, "id", &power, &multiplicand)) return wrap_Scale(Scale::byDoubleAndPowerOfTen(multiplicand, power)); return PyErr_SetArgsError(type, "byDoubleAndPowerOfTen", args); } #endif // ICU >= 62 #endif // ICU >= 60 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; NumberingSystemType_.tp_str = (reprfunc) t_numberingsystem_str; #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); REGISTER_TYPE(NumberingSystem, m); #endif REGISTER_TYPE(DecimalFormat, m); #if U_ICU_VERSION_HEX >= VERSION_HEX(51, 0, 0) REGISTER_TYPE(CompactDecimalFormat, m); #endif REGISTER_TYPE(RuleBasedNumberFormat, m); REGISTER_TYPE(ChoiceFormat, m); #if U_ICU_VERSION_HEX >= VERSION_HEX(60, 0, 0) INSTALL_STRUCT(NumberFormatter, m); INSTALL_STRUCT(UnlocalizedNumberFormatter, m); INSTALL_STRUCT(LocalizedNumberFormatter, m); INSTALL_STRUCT(Notation, m); INSTALL_STRUCT(ScientificNotation, m); INSTALL_STRUCT(IntegerWidth, m); #if U_ICU_VERSION_HEX < VERSION_HEX(64, 0, 0) INSTALL_STRUCT(Rounder, m); INSTALL_STRUCT(FractionRounder, m); INSTALL_STRUCT(IncrementRounder, m); INSTALL_STRUCT(CurrencyRounder, m); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(62, 0, 0) INSTALL_STRUCT(Precision, m); INSTALL_STRUCT(FractionPrecision, m); INSTALL_STRUCT(IncrementPrecision, m); INSTALL_STRUCT(CurrencyPrecision, m); INSTALL_STRUCT(Scale, m); #endif #endif 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 INSTALL_CONSTANTS_TYPE(UNumberFormatRoundingMode, m); INSTALL_ENUM(UNumberFormatRoundingMode, "HALFEVEN", UNUM_ROUND_HALFEVEN); #if U_ICU_VERSION_HEX >= 0x04080000 INSTALL_ENUM(UNumberFormatRoundingMode, "UNNECESSARY", UNUM_ROUND_UNNECESSARY); #endif INSTALL_CONSTANTS_TYPE(UNumberFormatStyle, m); INSTALL_ENUM(UNumberFormatStyle, "PATTERN_DECIMAL", UNUM_PATTERN_DECIMAL); INSTALL_ENUM(UNumberFormatStyle, "DECIMAL", UNUM_DECIMAL); INSTALL_ENUM(UNumberFormatStyle, "CURRENCY", UNUM_CURRENCY); INSTALL_ENUM(UNumberFormatStyle, "PERCENT", UNUM_PERCENT); INSTALL_ENUM(UNumberFormatStyle, "SCIENTIFIC", UNUM_SCIENTIFIC); INSTALL_ENUM(UNumberFormatStyle, "SPELLOUT", UNUM_SPELLOUT); INSTALL_ENUM(UNumberFormatStyle, "ORDINAL", UNUM_ORDINAL); INSTALL_ENUM(UNumberFormatStyle, "DURATION", UNUM_DURATION); INSTALL_ENUM(UNumberFormatStyle, "PATTERN_RULEBASED", UNUM_PATTERN_RULEBASED); INSTALL_ENUM(UNumberFormatStyle, "DEFAULT", UNUM_DEFAULT); INSTALL_ENUM(UNumberFormatStyle, "IGNORE", UNUM_IGNORE); #if U_ICU_VERSION_HEX >= 0x04020000 INSTALL_ENUM(UNumberFormatStyle, "NUMBERING_SYSTEM", UNUM_NUMBERING_SYSTEM); #endif #if U_ICU_VERSION_HEX >= 0x04080000 INSTALL_ENUM(UNumberFormatStyle, "CURRENCY_ISO", UNUM_CURRENCY_ISO); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(53, 0, 0) INSTALL_ENUM(UNumberFormatStyle, "CURRENCY_ACCOUNTING", UNUM_CURRENCY_ACCOUNTING); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(54, 0, 0) INSTALL_ENUM(UNumberFormatStyle, "CASH_CURRENCY", UNUM_CASH_CURRENCY); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(56, 0, 0) INSTALL_ENUM(UNumberFormatStyle, "DECIMAL_COMPACT_SHORT", UNUM_DECIMAL_COMPACT_SHORT); INSTALL_ENUM(UNumberFormatStyle, "DECIMAL_COMPACT_LONG", UNUM_DECIMAL_COMPACT_LONG); INSTALL_ENUM(UNumberFormatStyle, "CURRENCY_STANDARD", UNUM_CURRENCY_STANDARD); #endif #if U_ICU_VERSION_HEX >= 0x04080000 INSTALL_CONSTANTS_TYPE(UCurrencySpacing, m); INSTALL_ENUM(UCurrencySpacing, "MATCH", UNUM_CURRENCY_MATCH); INSTALL_ENUM(UCurrencySpacing, "SURROUNDING_MATCH", UNUM_CURRENCY_SURROUNDING_MATCH); INSTALL_ENUM(UCurrencySpacing, "INSERT", UNUM_CURRENCY_INSERT); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(54, 0, 0) INSTALL_CONSTANTS_TYPE(UCurrencyUsage, m); INSTALL_ENUM(UCurrencyUsage, "STANDARD", UCURR_USAGE_STANDARD); INSTALL_ENUM(UCurrencyUsage, "CASH", UCURR_USAGE_CASH); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(51, 0, 0) INSTALL_CONSTANTS_TYPE(UNumberCompactStyle, m); INSTALL_ENUM(UNumberCompactStyle, "SHORT", UNUM_SHORT); INSTALL_ENUM(UNumberCompactStyle, "LONG", UNUM_LONG); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(60, 0, 0) INSTALL_CONSTANTS_TYPE(UNumberSignDisplay, m); INSTALL_ENUM(UNumberSignDisplay, "AUTO", UNUM_SIGN_AUTO); INSTALL_ENUM(UNumberSignDisplay, "ALWAYS", UNUM_SIGN_ALWAYS); INSTALL_ENUM(UNumberSignDisplay, "NEVER", UNUM_SIGN_NEVER); INSTALL_ENUM(UNumberSignDisplay, "ACCOUNTING", UNUM_SIGN_ACCOUNTING); INSTALL_ENUM(UNumberSignDisplay, "ACCOUNTING_ALWAYS", UNUM_SIGN_ACCOUNTING_ALWAYS); INSTALL_CONSTANTS_TYPE(UNumberDecimalSeparatorDisplay, m); INSTALL_ENUM(UNumberDecimalSeparatorDisplay, "AUTO", UNUM_DECIMAL_SEPARATOR_AUTO); INSTALL_ENUM(UNumberDecimalSeparatorDisplay, "ALWAYS", UNUM_DECIMAL_SEPARATOR_ALWAYS); INSTALL_CONSTANTS_TYPE(UNumberUnitWidth, m); INSTALL_ENUM(UNumberUnitWidth, "NARROW", UNUM_UNIT_WIDTH_NARROW); INSTALL_ENUM(UNumberUnitWidth, "SHORT", UNUM_UNIT_WIDTH_SHORT); INSTALL_ENUM(UNumberUnitWidth, "FULL_NAME", UNUM_UNIT_WIDTH_FULL_NAME); INSTALL_ENUM(UNumberUnitWidth, "ISO_CODE", UNUM_UNIT_WIDTH_ISO_CODE); INSTALL_ENUM(UNumberUnitWidth, "HIDDEN", UNUM_UNIT_WIDTH_HIDDEN); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(61, 0, 0) INSTALL_CONSTANTS_TYPE(UNumberGroupingStrategy, m); INSTALL_ENUM(UNumberGroupingStrategy, "OFF", UNUM_GROUPING_OFF); INSTALL_ENUM(UNumberGroupingStrategy, "MIN2", UNUM_GROUPING_MIN2); INSTALL_ENUM(UNumberGroupingStrategy, "AUTO", UNUM_GROUPING_AUTO); INSTALL_ENUM(UNumberGroupingStrategy, "ON_ALIGNED", UNUM_GROUPING_ON_ALIGNED); INSTALL_ENUM(UNumberGroupingStrategy, "THOUSANDS", UNUM_GROUPING_THOUSANDS); #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); } ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1430285446.0 PyICU-2.4.2/numberformat.h0000644000076500000000000000320500000000000015526 0ustar00vajdawheel00000000000000/* ==================================================================== * 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 */ ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1569878521.0 PyICU-2.4.2/regex.cpp0000644000076500000000000007105000000000000014475 0ustar00vajdawheel00000000000000/* ==================================================================== * Copyright (c) 2010-2019 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); } DEFINE_RICHCMP(RegexPattern, t_regexpattern); /* 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 } ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1267744307.0 PyICU-2.4.2/regex.h0000644000076500000000000000254300000000000014143 0ustar00vajdawheel00000000000000/* ==================================================================== * 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 */ ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1573605241.8157198 PyICU-2.4.2/samples/0000755000076500000000000000000000000000000014320 5ustar00vajdawheel00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1270058156.0 PyICU-2.4.2/samples/break.py0000644000076500000000000000753300000000000015766 0ustar00vajdawheel00000000000000# ==================================================================== # 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() ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1271548622.0 PyICU-2.4.2/samples/strsrch.py0000644000076500000000000001500100000000000016357 0ustar00vajdawheel00000000000000# ==================================================================== # 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 ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1553763390.0 PyICU-2.4.2/script.cpp0000644000076500000000000005543600000000000014701 0ustar00vajdawheel00000000000000/* ==================================================================== * Copyright (c) 2004-2013 Open Source Applications Foundation. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. * ==================================================================== */ #include #include #include "common.h" #include "structmember.h" #include "bases.h" #include "script.h" #include "macros.h" DECLARE_CONSTANTS_TYPE(UScriptCode); #if U_ICU_VERSION_HEX >= VERSION_HEX(51, 0, 0) DECLARE_CONSTANTS_TYPE(UScriptUsage); #endif /* Script */ class t_script : public _wrapper { public: UNone *object; UScriptCode code; }; static int t_script_init(t_script *self, PyObject *args, PyObject *kwds); static PyObject *t_script_getName(t_script *self); static PyObject *t_script_getShortName(t_script *self); static PyObject *t_script_getScriptCode(t_script *self); static PyObject *t_script_getCode(PyTypeObject *type, PyObject *arg); static PyObject *t_script_getScript(PyTypeObject *type, PyObject *arg); #if U_ICU_VERSION_HEX >= VERSION_HEX(49, 0, 0) static PyObject *t_script_hasScript(PyTypeObject *type, PyObject *args); static PyObject *t_script_getScriptExtensions(PyTypeObject *type, PyObject *arg); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(51, 0, 0) static PyObject *t_script_isRightToLeft(t_script *self); static PyObject *t_script_isCased(t_script *self); static PyObject *t_script_breaksBetweenLetters(t_script *self); static PyObject *t_script_getSampleString(t_script *self); static PyObject *t_script_getUsage(t_script *self); #endif static PyMethodDef t_script_methods[] = { DECLARE_METHOD(t_script, getName, METH_NOARGS), DECLARE_METHOD(t_script, getShortName, METH_NOARGS), DECLARE_METHOD(t_script, getScriptCode, METH_NOARGS), DECLARE_METHOD(t_script, getCode, METH_O | METH_CLASS), DECLARE_METHOD(t_script, getScript, METH_O | METH_CLASS), #if U_ICU_VERSION_HEX >= VERSION_HEX(49, 0, 0) DECLARE_METHOD(t_script, hasScript, METH_VARARGS | METH_CLASS), DECLARE_METHOD(t_script, getScriptExtensions, METH_O | METH_CLASS), #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(51, 0, 0) DECLARE_METHOD(t_script, isRightToLeft, METH_NOARGS), DECLARE_METHOD(t_script, isCased, METH_NOARGS), DECLARE_METHOD(t_script, breaksBetweenLetters, METH_NOARGS), DECLARE_METHOD(t_script, getSampleString, METH_NOARGS), DECLARE_METHOD(t_script, getUsage, METH_NOARGS), #endif { NULL, NULL, 0, NULL } }; static void t_script_dealloc(t_script *self) { Py_TYPE(self)->tp_free((PyObject *) self); } DECLARE_STRUCT(Script, t_script, UNone, t_script_init, t_script_dealloc); /* Script */ static int t_script_init(t_script *self, PyObject *args, PyObject *kwds) { UScriptCode code; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "i", &code)) { if (uscript_getName(code) == NULL) { PyErr_Format(PyExc_ValueError, "Invalid script code: %d", code); return -1; } self->object = NULL; /* there is no ICU struct for this */ self->code = code; self->flags = T_OWNED; return 0; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; default: PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; } } static PyObject *t_script_getName(t_script *self) { return PyString_FromString(uscript_getName(self->code)); } static PyObject *t_script_getShortName(t_script *self) { return PyString_FromString(uscript_getShortName(self->code)); } static PyObject *t_script_getScriptCode(t_script *self) { return PyInt_FromLong(self->code); } static PyObject *t_script_getCode(PyTypeObject *type, PyObject *arg) { charsArg name; if (!parseArg(arg, "n", &name)) { UScriptCode codes[256]; int count; STATUS_CALL(count = uscript_getCode( name, codes, sizeof(codes) / sizeof(UScriptCode), &status)); PyObject *tuple = PyTuple_New(count); for (int i = 0; i < count; ++i) PyTuple_SET_ITEM(tuple, i, PyInt_FromLong(codes[i])); return tuple; } return PyErr_SetArgsError((PyObject *) type, "getCode", arg); } static PyObject *t_script_getScript(PyTypeObject *type, PyObject *arg) { UnicodeString *u, _u; int cp; if (!parseArg(arg, "S", &u, &_u)) { UScriptCode code; if (u->countChar32() != 1) { PyObject *tuple = Py_BuildValue( "(sO)", "string must contain only one codepoint", arg); PyErr_SetObject(PyExc_ValueError, tuple); Py_DECREF(tuple); return NULL; } STATUS_CALL(code = uscript_getScript(u->char32At(0), &status)); return PyObject_CallFunction((PyObject *) type, (char *) "i", code); } if (!parseArg(arg, "i", &cp)) { UScriptCode code; STATUS_CALL(code = uscript_getScript((UChar32) cp, &status)); return PyObject_CallFunction((PyObject *) type, (char *) "i", code); } return PyErr_SetArgsError((PyObject *) type, "getScript", arg); } #if U_ICU_VERSION_HEX >= VERSION_HEX(49, 0, 0) static PyObject *t_script_hasScript(PyTypeObject *type, PyObject *args) { UnicodeString *u, _u; UScriptCode code; int cp; switch (PyTuple_Size(args)) { case 2: if (!parseArgs(args, "Si", &u, &_u, &code)) { if (u->countChar32() != 1) { PyObject *tuple = Py_BuildValue( "(sO)", "string must contain only one codepoint", PyTuple_GET_ITEM(args, 0)); PyErr_SetObject(PyExc_ValueError, tuple); Py_DECREF(tuple); return NULL; } if (uscript_hasScript(u->char32At(0), code)) Py_RETURN_TRUE; Py_RETURN_FALSE; } if (!parseArgs(args, "ii", &cp, &code)) { if (uscript_hasScript((UChar32) cp, code)) Py_RETURN_TRUE; Py_RETURN_FALSE; } break; } return PyErr_SetArgsError((PyObject *) type, "hasScript", args); } static PyObject *t_script_getScriptExtensions(PyTypeObject *type, PyObject *arg) { UnicodeString *u, _u; int cp; if (!parseArg(arg, "S", &u, &_u)) { if (u->countChar32() != 1) { PyObject *tuple = Py_BuildValue( "(sO)", "string must contain only one codepoint", arg); PyErr_SetObject(PyExc_ValueError, tuple); Py_DECREF(tuple); return NULL; } UScriptCode codes[256]; int count; STATUS_CALL(count = uscript_getScriptExtensions( u->char32At(0), codes, sizeof(codes) / sizeof(UScriptCode), &status)); PyObject *tuple = PyTuple_New(count); for (int i = 0; i < count; ++i) PyTuple_SET_ITEM(tuple, i, PyInt_FromLong(codes[i])); return tuple; } if (!parseArg(arg, "i", &cp)) { UScriptCode codes[256]; int count; STATUS_CALL(count = uscript_getScriptExtensions( (UChar32) cp, codes, sizeof(codes) / sizeof(UScriptCode), &status)); PyObject *tuple = PyTuple_New(count); for (int i = 0; i < count; ++i) PyTuple_SET_ITEM(tuple, i, PyInt_FromLong(codes[i])); return tuple; } return PyErr_SetArgsError((PyObject *) type, "getScriptExtensions", arg); } #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(51, 0, 0) static PyObject *t_script_isRightToLeft(t_script *self) { if (uscript_isRightToLeft(self->code)) Py_RETURN_TRUE; Py_RETURN_FALSE; } static PyObject *t_script_isCased(t_script *self) { if (uscript_isCased(self->code)) Py_RETURN_TRUE; Py_RETURN_FALSE; } static PyObject *t_script_breaksBetweenLetters(t_script *self) { if (uscript_breaksBetweenLetters(self->code)) Py_RETURN_TRUE; Py_RETURN_FALSE; } static PyObject *t_script_getSampleString(t_script *self) { UChar dest[32]; int32_t count; STATUS_CALL(count = uscript_getSampleString(self->code, dest, sizeof(dest), &status)); return PyUnicode_FromUnicodeString(dest, count); } static PyObject *t_script_getUsage(t_script *self) { return PyInt_FromLong(uscript_getUsage(self->code)); } #endif static PyObject *t_script__getCode(t_script *self, void *data) { return PyInt_FromLong(self->code); } static PyGetSetDef t_script_properties[] = { { (char *) "code", (getter) t_script__getCode, NULL, (char *) "", NULL }, { NULL, NULL, NULL, NULL, NULL } }; void _init_script(PyObject *m) { ScriptType_.tp_getset = t_script_properties; INSTALL_CONSTANTS_TYPE(UScriptCode, m); #if U_ICU_VERSION_HEX >= VERSION_HEX(51, 0, 0) INSTALL_CONSTANTS_TYPE(UScriptUsage, m); #endif INSTALL_STRUCT(Script, m); INSTALL_ENUM(UScriptCode, "COMMON", USCRIPT_COMMON); INSTALL_ENUM(UScriptCode, "INHERITED", USCRIPT_INHERITED); INSTALL_ENUM(UScriptCode, "ARABIC", USCRIPT_ARABIC); INSTALL_ENUM(UScriptCode, "ARMENIAN", USCRIPT_ARMENIAN); INSTALL_ENUM(UScriptCode, "BENGALI", USCRIPT_BENGALI); INSTALL_ENUM(UScriptCode, "BOPOMOFO", USCRIPT_BOPOMOFO); INSTALL_ENUM(UScriptCode, "CHEROKEE", USCRIPT_CHEROKEE); INSTALL_ENUM(UScriptCode, "COPTIC", USCRIPT_COPTIC); INSTALL_ENUM(UScriptCode, "CYRILLIC", USCRIPT_CYRILLIC); INSTALL_ENUM(UScriptCode, "DESERET", USCRIPT_DESERET); INSTALL_ENUM(UScriptCode, "DEVANAGARI", USCRIPT_DEVANAGARI); INSTALL_ENUM(UScriptCode, "ETHIOPIC", USCRIPT_ETHIOPIC); INSTALL_ENUM(UScriptCode, "GEORGIAN", USCRIPT_GEORGIAN); INSTALL_ENUM(UScriptCode, "GOTHIC", USCRIPT_GOTHIC); INSTALL_ENUM(UScriptCode, "GREEK", USCRIPT_GREEK); INSTALL_ENUM(UScriptCode, "GUJARATI", USCRIPT_GUJARATI); INSTALL_ENUM(UScriptCode, "GURMUKHI", USCRIPT_GURMUKHI); INSTALL_ENUM(UScriptCode, "HAN", USCRIPT_HAN); INSTALL_ENUM(UScriptCode, "HANGUL", USCRIPT_HANGUL); INSTALL_ENUM(UScriptCode, "HEBREW", USCRIPT_HEBREW); INSTALL_ENUM(UScriptCode, "HIRAGANA", USCRIPT_HIRAGANA); INSTALL_ENUM(UScriptCode, "KANNADA", USCRIPT_KANNADA); INSTALL_ENUM(UScriptCode, "KATAKANA", USCRIPT_KATAKANA); INSTALL_ENUM(UScriptCode, "KHMER", USCRIPT_KHMER); INSTALL_ENUM(UScriptCode, "LAO", USCRIPT_LAO); INSTALL_ENUM(UScriptCode, "LATIN", USCRIPT_LATIN); INSTALL_ENUM(UScriptCode, "MALAYALAM", USCRIPT_MALAYALAM); INSTALL_ENUM(UScriptCode, "MONGOLIAN", USCRIPT_MONGOLIAN); INSTALL_ENUM(UScriptCode, "MYANMAR", USCRIPT_MYANMAR); INSTALL_ENUM(UScriptCode, "OGHAM", USCRIPT_OGHAM); INSTALL_ENUM(UScriptCode, "OLD_ITALIC", USCRIPT_OLD_ITALIC); INSTALL_ENUM(UScriptCode, "ORIYA", USCRIPT_ORIYA); INSTALL_ENUM(UScriptCode, "RUNIC", USCRIPT_RUNIC); INSTALL_ENUM(UScriptCode, "SINHALA", USCRIPT_SINHALA); INSTALL_ENUM(UScriptCode, "SYRIAC", USCRIPT_SYRIAC); INSTALL_ENUM(UScriptCode, "TAMIL", USCRIPT_TAMIL); INSTALL_ENUM(UScriptCode, "TELUGU", USCRIPT_TELUGU); INSTALL_ENUM(UScriptCode, "THAANA", USCRIPT_THAANA); INSTALL_ENUM(UScriptCode, "THAI", USCRIPT_THAI); INSTALL_ENUM(UScriptCode, "TIBETAN", USCRIPT_TIBETAN); INSTALL_ENUM(UScriptCode, "CANADIAN_ABORIGINAL", USCRIPT_CANADIAN_ABORIGINAL); INSTALL_ENUM(UScriptCode, "UCAS", USCRIPT_UCAS); INSTALL_ENUM(UScriptCode, "YI", USCRIPT_YI); INSTALL_ENUM(UScriptCode, "TAGALOG", USCRIPT_TAGALOG); INSTALL_ENUM(UScriptCode, "HANUNOO", USCRIPT_HANUNOO); INSTALL_ENUM(UScriptCode, "BUHID", USCRIPT_BUHID); INSTALL_ENUM(UScriptCode, "TAGBANWA", USCRIPT_TAGBANWA); INSTALL_ENUM(UScriptCode, "BRAILLE", USCRIPT_BRAILLE); INSTALL_ENUM(UScriptCode, "CYPRIOT", USCRIPT_CYPRIOT); INSTALL_ENUM(UScriptCode, "LIMBU", USCRIPT_LIMBU); INSTALL_ENUM(UScriptCode, "LINEAR_B", USCRIPT_LINEAR_B); INSTALL_ENUM(UScriptCode, "OSMANYA", USCRIPT_OSMANYA); INSTALL_ENUM(UScriptCode, "SHAVIAN", USCRIPT_SHAVIAN); INSTALL_ENUM(UScriptCode, "TAI_LE", USCRIPT_TAI_LE); INSTALL_ENUM(UScriptCode, "UGARITIC", USCRIPT_UGARITIC); INSTALL_ENUM(UScriptCode, "KATAKANA_OR_HIRAGANA", USCRIPT_KATAKANA_OR_HIRAGANA); INSTALL_ENUM(UScriptCode, "BUGINESE", USCRIPT_BUGINESE); INSTALL_ENUM(UScriptCode, "GLAGOLITIC", USCRIPT_GLAGOLITIC); INSTALL_ENUM(UScriptCode, "KHAROSHTHI", USCRIPT_KHAROSHTHI); INSTALL_ENUM(UScriptCode, "SYLOTI_NAGRI", USCRIPT_SYLOTI_NAGRI); INSTALL_ENUM(UScriptCode, "NEW_TAI_LUE", USCRIPT_NEW_TAI_LUE); INSTALL_ENUM(UScriptCode, "TIFINAGH", USCRIPT_TIFINAGH); INSTALL_ENUM(UScriptCode, "OLD_PERSIAN", USCRIPT_OLD_PERSIAN); INSTALL_ENUM(UScriptCode, "BALINESE", USCRIPT_BALINESE); INSTALL_ENUM(UScriptCode, "BATAK", USCRIPT_BATAK); INSTALL_ENUM(UScriptCode, "BLISSYMBOLS", USCRIPT_BLISSYMBOLS); INSTALL_ENUM(UScriptCode, "BRAHMI", USCRIPT_BRAHMI); INSTALL_ENUM(UScriptCode, "CHAM", USCRIPT_CHAM); INSTALL_ENUM(UScriptCode, "CIRTH", USCRIPT_CIRTH); INSTALL_ENUM(UScriptCode, "OLD_CHURCH_SLAVONIC_CYRILLIC", USCRIPT_OLD_CHURCH_SLAVONIC_CYRILLIC); INSTALL_ENUM(UScriptCode, "DEMOTIC_EGYPTIAN", USCRIPT_DEMOTIC_EGYPTIAN); INSTALL_ENUM(UScriptCode, "HIERATIC_EGYPTIAN", USCRIPT_HIERATIC_EGYPTIAN); INSTALL_ENUM(UScriptCode, "EGYPTIAN_HIEROGLYPHS", USCRIPT_EGYPTIAN_HIEROGLYPHS); INSTALL_ENUM(UScriptCode, "KHUTSURI", USCRIPT_KHUTSURI); INSTALL_ENUM(UScriptCode, "SIMPLIFIED_HAN", USCRIPT_SIMPLIFIED_HAN); INSTALL_ENUM(UScriptCode, "TRADITIONAL_HAN", USCRIPT_TRADITIONAL_HAN); INSTALL_ENUM(UScriptCode, "PAHAWH_HMONG", USCRIPT_PAHAWH_HMONG); INSTALL_ENUM(UScriptCode, "OLD_HUNGARIAN", USCRIPT_OLD_HUNGARIAN); INSTALL_ENUM(UScriptCode, "HARAPPAN_INDUS", USCRIPT_HARAPPAN_INDUS); INSTALL_ENUM(UScriptCode, "JAVANESE", USCRIPT_JAVANESE); INSTALL_ENUM(UScriptCode, "KAYAH_LI", USCRIPT_KAYAH_LI); INSTALL_ENUM(UScriptCode, "LATIN_FRAKTUR", USCRIPT_LATIN_FRAKTUR); INSTALL_ENUM(UScriptCode, "LATIN_GAELIC", USCRIPT_LATIN_GAELIC); INSTALL_ENUM(UScriptCode, "LEPCHA", USCRIPT_LEPCHA); INSTALL_ENUM(UScriptCode, "LINEAR_A", USCRIPT_LINEAR_A); INSTALL_ENUM(UScriptCode, "MANDAEAN", USCRIPT_MANDAEAN); INSTALL_ENUM(UScriptCode, "MEROITIC", USCRIPT_MEROITIC); INSTALL_ENUM(UScriptCode, "ORKHON", USCRIPT_ORKHON); INSTALL_ENUM(UScriptCode, "OLD_PERMIC", USCRIPT_OLD_PERMIC); INSTALL_ENUM(UScriptCode, "PHAGS_PA", USCRIPT_PHAGS_PA); INSTALL_ENUM(UScriptCode, "PHOENICIAN", USCRIPT_PHOENICIAN); INSTALL_ENUM(UScriptCode, "PHONETIC_POLLARD", USCRIPT_PHONETIC_POLLARD); INSTALL_ENUM(UScriptCode, "RONGORONGO", USCRIPT_RONGORONGO); INSTALL_ENUM(UScriptCode, "SARATI", USCRIPT_SARATI); INSTALL_ENUM(UScriptCode, "ESTRANGELO_SYRIAC", USCRIPT_ESTRANGELO_SYRIAC); INSTALL_ENUM(UScriptCode, "WESTERN_SYRIAC", USCRIPT_WESTERN_SYRIAC); INSTALL_ENUM(UScriptCode, "EASTERN_SYRIAC", USCRIPT_EASTERN_SYRIAC); INSTALL_ENUM(UScriptCode, "TENGWAR", USCRIPT_TENGWAR); INSTALL_ENUM(UScriptCode, "VAI", USCRIPT_VAI); INSTALL_ENUM(UScriptCode, "VISIBLE_SPEECH", USCRIPT_VISIBLE_SPEECH); INSTALL_ENUM(UScriptCode, "CUNEIFORM", USCRIPT_CUNEIFORM); INSTALL_ENUM(UScriptCode, "UNWRITTEN_LANGUAGES", USCRIPT_UNWRITTEN_LANGUAGES); INSTALL_ENUM(UScriptCode, "UNKNOWN", USCRIPT_UNKNOWN); INSTALL_ENUM(UScriptCode, "CARIAN", USCRIPT_CARIAN); INSTALL_ENUM(UScriptCode, "JAPANESE", USCRIPT_JAPANESE); INSTALL_ENUM(UScriptCode, "LANNA", USCRIPT_LANNA); INSTALL_ENUM(UScriptCode, "LYCIAN", USCRIPT_LYCIAN); INSTALL_ENUM(UScriptCode, "LYDIAN", USCRIPT_LYDIAN); INSTALL_ENUM(UScriptCode, "OL_CHIKI", USCRIPT_OL_CHIKI); INSTALL_ENUM(UScriptCode, "REJANG", USCRIPT_REJANG); INSTALL_ENUM(UScriptCode, "SAURASHTRA", USCRIPT_SAURASHTRA); INSTALL_ENUM(UScriptCode, "SIGN_WRITING", USCRIPT_SIGN_WRITING); INSTALL_ENUM(UScriptCode, "SUNDANESE", USCRIPT_SUNDANESE); INSTALL_ENUM(UScriptCode, "MOON", USCRIPT_MOON); INSTALL_ENUM(UScriptCode, "MEITEI_MAYEK", USCRIPT_MEITEI_MAYEK); #if U_ICU_VERSION_HEX >= 0x04000000 INSTALL_ENUM(UScriptCode, "IMPERIAL_ARAMAIC", USCRIPT_IMPERIAL_ARAMAIC); INSTALL_ENUM(UScriptCode, "AVESTAN", USCRIPT_AVESTAN); INSTALL_ENUM(UScriptCode, "CHAKMA", USCRIPT_CHAKMA); INSTALL_ENUM(UScriptCode, "KOREAN", USCRIPT_KOREAN); INSTALL_ENUM(UScriptCode, "KAITHI", USCRIPT_KAITHI); INSTALL_ENUM(UScriptCode, "MANICHAEAN", USCRIPT_MANICHAEAN); INSTALL_ENUM(UScriptCode, "INSCRIPTIONAL_PAHLAVI", USCRIPT_INSCRIPTIONAL_PAHLAVI); INSTALL_ENUM(UScriptCode, "PSALTER_PAHLAVI", USCRIPT_PSALTER_PAHLAVI); INSTALL_ENUM(UScriptCode, "BOOK_PAHLAVI", USCRIPT_BOOK_PAHLAVI); INSTALL_ENUM(UScriptCode, "INSCRIPTIONAL_PARTHIAN", USCRIPT_INSCRIPTIONAL_PARTHIAN); INSTALL_ENUM(UScriptCode, "SAMARITAN", USCRIPT_SAMARITAN); INSTALL_ENUM(UScriptCode, "TAI_VIET", USCRIPT_TAI_VIET); INSTALL_ENUM(UScriptCode, "MATHEMATICAL_NOTATION", USCRIPT_MATHEMATICAL_NOTATION); INSTALL_ENUM(UScriptCode, "SYMBOLS", USCRIPT_SYMBOLS); #endif #if U_ICU_VERSION_HEX >= 0x04040000 INSTALL_ENUM(UScriptCode, "BAMUM", USCRIPT_BAMUM); INSTALL_ENUM(UScriptCode, "LISU", USCRIPT_LISU); INSTALL_ENUM(UScriptCode, "NAKHI_GEBA", USCRIPT_NAKHI_GEBA); INSTALL_ENUM(UScriptCode, "OLD_SOUTH_ARABIAN", USCRIPT_OLD_SOUTH_ARABIAN); #endif #if U_ICU_VERSION_HEX >= 0x04060000 INSTALL_ENUM(UScriptCode, "BASSA_VAH", USCRIPT_BASSA_VAH); INSTALL_ENUM(UScriptCode, "DUPLOYAN_SHORTAND", USCRIPT_DUPLOYAN_SHORTAND); INSTALL_ENUM(UScriptCode, "ELBASAN", USCRIPT_ELBASAN); INSTALL_ENUM(UScriptCode, "GRANTHA", USCRIPT_GRANTHA); INSTALL_ENUM(UScriptCode, "KPELLE", USCRIPT_KPELLE); INSTALL_ENUM(UScriptCode, "LOMA", USCRIPT_LOMA); INSTALL_ENUM(UScriptCode, "MANDAIC", USCRIPT_MANDAIC); INSTALL_ENUM(UScriptCode, "MENDE", USCRIPT_MENDE); INSTALL_ENUM(UScriptCode, "MEROITIC_CURSIVE", USCRIPT_MEROITIC_CURSIVE); INSTALL_ENUM(UScriptCode, "MEROITIC_HIEROGLYPHS", USCRIPT_MEROITIC_HIEROGLYPHS); INSTALL_ENUM(UScriptCode, "OLD_NORTH_ARABIAN", USCRIPT_OLD_NORTH_ARABIAN); INSTALL_ENUM(UScriptCode, "NABATAEAN", USCRIPT_NABATAEAN); INSTALL_ENUM(UScriptCode, "PALMYRENE", USCRIPT_PALMYRENE); INSTALL_ENUM(UScriptCode, "SINDHI", USCRIPT_SINDHI); INSTALL_ENUM(UScriptCode, "WARANG_CITI", USCRIPT_WARANG_CITI); #endif #if U_ICU_VERSION_HEX >= 0x04080000 INSTALL_ENUM(UScriptCode, "AFAKA", USCRIPT_AFAKA); INSTALL_ENUM(UScriptCode, "JURCHEN", USCRIPT_JURCHEN); INSTALL_ENUM(UScriptCode, "MRO", USCRIPT_MRO); INSTALL_ENUM(UScriptCode, "NUSHU", USCRIPT_NUSHU); INSTALL_ENUM(UScriptCode, "SHARADA", USCRIPT_SHARADA); INSTALL_ENUM(UScriptCode, "SORA_SOMPENG", USCRIPT_SORA_SOMPENG); INSTALL_ENUM(UScriptCode, "TAKRI", USCRIPT_TAKRI); INSTALL_ENUM(UScriptCode, "TANGUT", USCRIPT_TANGUT); INSTALL_ENUM(UScriptCode, "WOLEAI", USCRIPT_WOLEAI); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(49, 0, 0) INSTALL_ENUM(UScriptCode, "ANATOLIAN_HIEROGLYPHS", USCRIPT_ANATOLIAN_HIEROGLYPHS); INSTALL_ENUM(UScriptCode, "KHOJKI", USCRIPT_KHOJKI); INSTALL_ENUM(UScriptCode, "TIRHUTA", USCRIPT_TIRHUTA); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(52, 0, 0) INSTALL_ENUM(UScriptCode, "MIAO", USCRIPT_MIAO); INSTALL_ENUM(UScriptCode, "CAUCASIAN_ALBANIAN", USCRIPT_CAUCASIAN_ALBANIAN); INSTALL_ENUM(UScriptCode, "MAHAJANI", USCRIPT_MAHAJANI); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(54, 0, 0) INSTALL_ENUM(UScriptCode, "DUPLOYAN", USCRIPT_DUPLOYAN); INSTALL_ENUM(UScriptCode, "KHUDAWADI", USCRIPT_KHUDAWADI); INSTALL_ENUM(UScriptCode, "AHOM", USCRIPT_AHOM); INSTALL_ENUM(UScriptCode, "HATRAN", USCRIPT_HATRAN); INSTALL_ENUM(UScriptCode, "MODI", USCRIPT_MODI); INSTALL_ENUM(UScriptCode, "MULTANI", USCRIPT_MULTANI); INSTALL_ENUM(UScriptCode, "PAU_CIN_HAU", USCRIPT_PAU_CIN_HAU); INSTALL_ENUM(UScriptCode, "SIDDHAM", USCRIPT_SIDDHAM); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(58, 0, 0) INSTALL_ENUM(UScriptCode, "ADLAM", USCRIPT_ADLAM); INSTALL_ENUM(UScriptCode, "BHAIKSUKI", USCRIPT_BHAIKSUKI); INSTALL_ENUM(UScriptCode, "MARCHEN", USCRIPT_MARCHEN); INSTALL_ENUM(UScriptCode, "NEWA", USCRIPT_NEWA); INSTALL_ENUM(UScriptCode, "OSAGE", USCRIPT_OSAGE); INSTALL_ENUM(UScriptCode, "HAN_WITH_BOPOMOFO", USCRIPT_HAN_WITH_BOPOMOFO); INSTALL_ENUM(UScriptCode, "JAMO", USCRIPT_JAMO); INSTALL_ENUM(UScriptCode, "SYMBOLS_EMOJI", USCRIPT_SYMBOLS_EMOJI); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(60, 0, 0) INSTALL_ENUM(UScriptCode, "MASARAM_GONDI", USCRIPT_MASARAM_GONDI); INSTALL_ENUM(UScriptCode, "SOYOMBO", USCRIPT_SOYOMBO); INSTALL_ENUM(UScriptCode, "ZANABAZAR_SQUARE", USCRIPT_ZANABAZAR_SQUARE); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(62, 0, 0) INSTALL_ENUM(UScriptCode, "DOGRA", USCRIPT_DOGRA); INSTALL_ENUM(UScriptCode, "GUNJALA_GONDI", USCRIPT_GUNJALA_GONDI); INSTALL_ENUM(UScriptCode, "MAKASAR", USCRIPT_MAKASAR); INSTALL_ENUM(UScriptCode, "MEDEFAIDRIN", USCRIPT_MEDEFAIDRIN); INSTALL_ENUM(UScriptCode, "HANIFI_ROHINGYA", USCRIPT_HANIFI_ROHINGYA); INSTALL_ENUM(UScriptCode, "SOGDIAN", USCRIPT_SOGDIAN); INSTALL_ENUM(UScriptCode, "OLD_SOGDIAN", USCRIPT_OLD_SOGDIAN); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(64, 0, 0) INSTALL_ENUM(UScriptCode, "ELYMAIC", USCRIPT_ELYMAIC); INSTALL_ENUM(UScriptCode, "NANDINAGARI", USCRIPT_NANDINAGARI); INSTALL_ENUM(UScriptCode, "NYIAKENG_PUACHUE_HMONG", USCRIPT_NYIAKENG_PUACHUE_HMONG); INSTALL_ENUM(UScriptCode, "WANCHO", USCRIPT_WANCHO); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(51, 0, 0) INSTALL_ENUM(UScriptUsage, "NOT_ENCODED", USCRIPT_USAGE_NOT_ENCODED); INSTALL_ENUM(UScriptUsage, "UNKNOWN", USCRIPT_USAGE_UNKNOWN); INSTALL_ENUM(UScriptUsage, "EXCLUDED", USCRIPT_USAGE_EXCLUDED); INSTALL_ENUM(UScriptUsage, "LIMITED_USE", USCRIPT_USAGE_LIMITED_USE); INSTALL_ENUM(UScriptUsage, "ASPIRATIONAL", USCRIPT_USAGE_ASPIRATIONAL); INSTALL_ENUM(UScriptUsage, "RECOMMENDED", USCRIPT_USAGE_RECOMMENDED); #endif } ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1362600805.0 PyICU-2.4.2/script.h0000644000076500000000000000254700000000000014341 0ustar00vajdawheel00000000000000/* ==================================================================== * Copyright (c) 2004-2013 Open Source Applications Foundation. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. * ==================================================================== */ #ifndef _script_h #define _script_h void _init_script(PyObject *m); #endif /* _script_h */ ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1430285670.0 PyICU-2.4.2/search.cpp0000644000076500000000000004744400000000000014642 0ustar00vajdawheel00000000000000/* ==================================================================== * 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); } ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1269729210.0 PyICU-2.4.2/search.h0000644000076500000000000000255000000000000014274 0ustar00vajdawheel00000000000000/* ==================================================================== * 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 */ ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1573605241.8464522 PyICU-2.4.2/setup.cfg0000644000076500000000000000007300000000000014475 0ustar00vajdawheel00000000000000[egg_info] tag_build = tag_date = 0 tag_svn_revision = 0 ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1573515820.0 PyICU-2.4.2/setup.py0000644000076500000000000002043400000000000014371 0ustar00vajdawheel00000000000000 import os, sys try: from setuptools import setup, Extension except ImportError: from distutils.core import setup, Extension from distutils.spawn import find_executable VERSION = '2.4.2' try: from subprocess import check_output as subprocess_check_output def check_output(popenargs): print("(running '%s')" %(' '.join(popenargs))) return subprocess_check_output(popenargs) except ImportError: from subprocess import Popen, PIPE def check_output(*popenargs): print("(running '%s')" %(' '.join(*popenargs))) process = Popen(stdout=PIPE, *popenargs) output, ignore = process.communicate() retcode = process.poll() if retcode: raise RuntimeError((retcode, popenargs[0], output)) return output def configure_with_icu_config(flags, config_args, label): try: output = check_output(('icu-config',) + config_args).strip() if sys.version_info >= (3,): output = str(output, 'ascii') flags.extend(output.split()) if output: print('Adding %s="%s" from %s' % (label, output, find_executable('icu-config'))) except: print('Could not configure %s with icu-config' %(label)) raise def configure_with_pkg_config(flags, config_args, label): try: output = check_output(('pkg-config',) + config_args + ('icu-i18n',)).strip() if sys.version_info >= (3,): output = str(output, 'ascii') flags.extend(output.split()) if output: print('Adding %s="%s" from %s' % (label, output, find_executable('pkg-config'))) except: print('Could not configure %s with pkg-config' %(label)) raise try: ICU_VERSION = os.environ['ICU_VERSION'] except: try: ICU_VERSION = check_output(('icu-config', '--version')).strip() except: try: ICU_VERSION = check_output(('pkg-config', '--modversion', 'icu-i18n')).strip() except: raise RuntimeError(''' Please install pkg-config on your system or set the ICU_VERSION environment variable to the version of ICU you have installed. ''') if sys.version_info >= (3,): ICU_VERSION = str(ICU_VERSION, 'ascii') print(''' Building PyICU %s for ICU %s ''' %(VERSION, ICU_VERSION)) CONFIGURE_WITH_ICU_CONFIG = { 'darwin': True, 'linux': True, 'freebsd': False, # not tested 'win32': False, # no icu-config 'sunos5': False, # not tested 'cygwin': False, # not tested } CONFIGURE_WITH_PKG_CONFIG = { 'darwin': False, # no pkg-config ? 'linux': True, 'freebsd': False, # not tested 'win32': False, # no pkg-config ? 'sunos5': False, # not tested 'cygwin': False, # not tested } INCLUDES = { 'darwin': [], 'linux': [], 'freebsd': ['/usr/local/include'], 'win32': ['c:/icu/include'], 'sunos5': [], 'cygwin': [], } VER_FLAGS = { 'darwin': ['-DPYICU_VER="%s"' %(VERSION)], 'linux': ['-DPYICU_VER="%s"' %(VERSION)], 'freebsd': ['-DPYICU_VER="%s"' %(VERSION)], 'win32': ['/DPYICU_VER=\\"%s\\"' %(VERSION)], 'sunos5': ['-DPYICU_VER="%s"' %(VERSION)], 'cygwin': ['-DPYICU_VER="%s"' %(VERSION)], } CFLAGS = { 'darwin': [], 'linux': [], 'freebsd': ['-std=c++11'], 'win32': ['/Zc:wchar_t', '/EHsc'], 'sunos5': ['-std=c++11'], 'cygwin': ['-D_GNU_SOURCE=1', '-std=c++11'], } # added to CFLAGS when setup is invoked with --debug DEBUG_CFLAGS = { 'darwin': ['-O0', '-g', '-DDEBUG'], 'linux': ['-O0', '-g', '-DDEBUG'], 'freebsd': ['-O0', '-g', '-DDEBUG'], 'win32': ['/Od', '/DDEBUG'], 'sunos5': ['-DDEBUG'], 'cygwin': ['-Og', '-g', '-DDEBUG'], } LFLAGS = { 'darwin': [], 'linux': [], 'freebsd': ['-L/usr/local/lib'], 'win32': ['/LIBPATH:c:/icu/lib'], 'sunos5': [], 'cygwin': [], } LIBRARIES = { 'darwin': [], 'linux': [], 'freebsd': ['icui18n', 'icuuc', 'icudata'], 'win32': ['icuin', 'icuuc', 'icudt'], 'sunos5': ['icui18n', 'icuuc', 'icudata'], 'cygwin': ['icui18n', 'icuuc', 'icudata'], } platform = sys.platform if platform.startswith(('linux', 'gnu')): platform = 'linux' elif platform.startswith('freebsd'): platform = 'freebsd' if 'PYICU_INCLUDES' in os.environ: _includes = os.environ['PYICU_INCLUDES'].split(os.pathsep) else: _includes = INCLUDES[platform] if 'PYICU_CFLAGS' in os.environ: _cflags = os.environ['PYICU_CFLAGS'].split(os.pathsep) else: _cflags = CFLAGS[platform] try: if CONFIGURE_WITH_ICU_CONFIG[platform]: try: configure_with_icu_config( _cflags, ('--cxxflags', '--cppflags'), 'CFLAGS') except: if CONFIGURE_WITH_PKG_CONFIG[platform]: configure_with_pkg_config(_cflags, ('--cflags',), 'CFLAGS') else: raise elif CONFIGURE_WITH_PKG_CONFIG[platform]: configure_with_pkg_config(_cflags, ('--cflags',), 'CFLAGS') except: if not _cflags: raise RuntimeError(''' Please install pkg-config on your system or set the PYICU_CFLAGS environment variable to the flags required by the C++ compiler to find the header files for ICU, and possibly -std=c++11 if using ICU version >= 60 ''') 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] _cflags += VER_FLAGS[platform] if 'PYICU_LFLAGS' in os.environ: _lflags = os.environ['PYICU_LFLAGS'].split(os.pathsep) else: _lflags = LFLAGS[platform] try: if CONFIGURE_WITH_ICU_CONFIG[platform]: try: configure_with_icu_config(_lflags, ('--ldflags',), 'LFLAGS') except: if CONFIGURE_WITH_PKG_CONFIG[platform]: configure_with_pkg_config(_lflags, ('--libs',), 'LFLAGS') else: raise elif CONFIGURE_WITH_PKG_CONFIG[platform]: configure_with_pkg_config(_lflags, ('--libs',), 'LFLAGS') except: if not _lflags: raise RuntimeError(''' Please install pkg-config on your system or set the PYICU_LFLAGS environment variable to the flags required by the linker to find the libraries for ICU ''') if 'PYICU_LIBRARIES' in os.environ: _libraries = os.environ['PYICU_LIBRARIES'].split(os.pathsep) elif ICU_VERSION < '58': _libraries = LIBRARIES[platform][:] + ['icule'] else: _libraries = LIBRARIES[platform] if sys.version_info < (2, 4): def sorted(iterable, *args, **kwargs): iterable = list(iterable) iterable.sort(*args, **kwargs) return iterable setup(name="PyICU", description='Python extension wrapping the ICU C++ API', long_description=open('README.md').read(), long_description_content_type="text/markdown", version=VERSION, test_suite="test", url='https://github.com/ovalhub/pyicu', author='Andi Vajda', author_email='github@ovaltofu.org', license='MIT', classifiers=[ 'Development Status :: 5 - Production/Stable', 'Environment :: Console', 'Intended Audience :: Developers', 'License :: OSI Approved', 'Operating System :: OS Independent', 'Programming Language :: C++', 'Programming Language :: Python', 'Programming Language :: Python :: 2', 'Programming Language :: Python :: 3', 'Programming Language :: Python :: Implementation :: CPython', 'Programming Language :: Python :: Implementation :: PyPy', 'Topic :: Software Development :: Localization', 'Topic :: Software Development :: Internationalization'], ext_modules=[Extension('_icu', [filename for filename in sorted(os.listdir(os.curdir)) if filename.endswith('.cpp')], include_dirs=_includes, extra_compile_args=_cflags, extra_link_args=_lflags, libraries=_libraries)], packages=['icu'], py_modules=['PyICU'], tests_require=['pytest', 'six']) ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1530571673.0 PyICU-2.4.2/shape.cpp0000644000076500000000000001655000000000000014467 0ustar00vajdawheel00000000000000/* ==================================================================== * Copyright (c) 2004-2015 Open Source Applications Foundation. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. * ==================================================================== */ #include #include #include "common.h" #include "structmember.h" #include "bases.h" #include "shape.h" #include "macros.h" /* Shape */ class t_shape : public _wrapper { public: UNone *object; }; static int t_shape_init(t_shape *self, PyObject *args, PyObject *kwds); static PyObject *t_shape_shapeArabic(PyTypeObject *type, PyObject *args); static PyMethodDef t_shape_methods[] = { DECLARE_METHOD(t_shape, shapeArabic, METH_VARARGS | METH_CLASS), { NULL, NULL, 0, NULL } }; static void t_shape_dealloc(t_shape *self) { Py_TYPE(self)->tp_free((PyObject *) self); } DECLARE_STRUCT(Shape, t_shape, UNone, t_shape_init, t_shape_dealloc); /* Shape */ static int t_shape_init(t_shape *self, PyObject *args, PyObject *kwds) { switch (PyTuple_Size(args)) { case 0: self->object = NULL; /* there is no ICU struct for this */ self->flags = T_OWNED; return 0; default: PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; } } static PyObject *t_shape_shapeArabic(PyTypeObject *type, PyObject *args) { UnicodeString *u, _u; uint32_t options = 0; switch (PyTuple_Size(args)) { case 2: if (!parseArgs(args, "Si", &u, &_u, &options)) { const int32_t len = u->length(); const int32_t capacity = len * 4 + 32; UErrorCode status = U_ZERO_ERROR; UChar *dest = new UChar[capacity]; PyObject *result; int32_t size; if (!dest) { PyErr_SetNone(PyExc_MemoryError); return NULL; } size = u_shapeArabic(u->getBuffer(), len, dest, capacity, options, &status); if (U_FAILURE(status)) { delete[] dest; return ICUException(status).reportError(); } result = PyUnicode_FromUnicodeString(dest, size); delete[] dest; return result; } break; } return PyErr_SetArgsError((PyObject *) type, "shapeArabic", args); } void _init_shape(PyObject *m) { INSTALL_STRUCT(Shape, m); INSTALL_ENUM(Shape, "LENGTH_GROW_SHRINK", U_SHAPE_LENGTH_GROW_SHRINK); INSTALL_ENUM(Shape, "LAMALEF_RESIZE", U_SHAPE_LAMALEF_RESIZE); INSTALL_ENUM(Shape, "LENGTH_FIXED_SPACES_NEAR", U_SHAPE_LENGTH_FIXED_SPACES_NEAR); INSTALL_ENUM(Shape, "LAMALEF_NEAR", U_SHAPE_LAMALEF_NEAR); INSTALL_ENUM(Shape, "LENGTH_FIXED_SPACES_AT_END", U_SHAPE_LENGTH_FIXED_SPACES_AT_END); INSTALL_ENUM(Shape, "LAMALEF_END", U_SHAPE_LAMALEF_END); INSTALL_ENUM(Shape, "LENGTH_FIXED_SPACES_AT_BEGINNING", U_SHAPE_LENGTH_FIXED_SPACES_AT_BEGINNING); INSTALL_ENUM(Shape, "TEXT_DIRECTION_LOGICAL", U_SHAPE_TEXT_DIRECTION_LOGICAL); INSTALL_ENUM(Shape, "TEXT_DIRECTION_MASK", U_SHAPE_TEXT_DIRECTION_MASK); INSTALL_ENUM(Shape, "TEXT_DIRECTION_VISUAL_LTR", U_SHAPE_TEXT_DIRECTION_VISUAL_LTR); #if U_ICU_VERSION_HEX >= 0x04020000 INSTALL_ENUM(Shape, "LAMALEF_BEGIN", U_SHAPE_LAMALEF_BEGIN); INSTALL_ENUM(Shape, "LAMALEF_AUTO", U_SHAPE_LAMALEF_AUTO); INSTALL_ENUM(Shape, "LENGTH_MASK", U_SHAPE_LENGTH_MASK); INSTALL_ENUM(Shape, "LAMALEF_MASK", U_SHAPE_LAMALEF_MASK); INSTALL_ENUM(Shape, "LAMALEF_NEAR", U_SHAPE_LAMALEF_NEAR); INSTALL_ENUM(Shape, "LAMALEF_RESIZE", U_SHAPE_LAMALEF_RESIZE); INSTALL_ENUM(Shape, "TEXT_DIRECTION_VISUAL_RTL", U_SHAPE_TEXT_DIRECTION_VISUAL_RTL); #endif INSTALL_ENUM(Shape, "LETTERS_NOOP", U_SHAPE_LETTERS_NOOP); INSTALL_ENUM(Shape, "LETTERS_SHAPE", U_SHAPE_LETTERS_SHAPE); INSTALL_ENUM(Shape, "LETTERS_UNSHAPE", U_SHAPE_LETTERS_UNSHAPE); INSTALL_ENUM(Shape, "LETTERS_SHAPE_TASHKEEL_ISOLATED", U_SHAPE_LETTERS_SHAPE_TASHKEEL_ISOLATED); INSTALL_ENUM(Shape, "LETTERS_MASK", U_SHAPE_LETTERS_MASK); INSTALL_ENUM(Shape, "DIGITS_NOOP", U_SHAPE_DIGITS_NOOP); INSTALL_ENUM(Shape, "DIGITS_EN2AN", U_SHAPE_DIGITS_EN2AN); INSTALL_ENUM(Shape, "DIGITS_AN2EN", U_SHAPE_DIGITS_AN2EN); INSTALL_ENUM(Shape, "DIGITS_ALEN2AN_INIT_LR", U_SHAPE_DIGITS_ALEN2AN_INIT_LR); INSTALL_ENUM(Shape, "DIGITS_ALEN2AN_INIT_AL", U_SHAPE_DIGITS_ALEN2AN_INIT_AL); INSTALL_ENUM(Shape, "DIGITS_RESERVED", U_SHAPE_DIGITS_RESERVED); INSTALL_ENUM(Shape, "DIGITS_MASK", U_SHAPE_DIGITS_MASK); INSTALL_ENUM(Shape, "DIGIT_TYPE_AN", U_SHAPE_DIGIT_TYPE_AN); INSTALL_ENUM(Shape, "DIGIT_TYPE_AN_EXTENDED", U_SHAPE_DIGIT_TYPE_AN_EXTENDED); INSTALL_ENUM(Shape, "DIGIT_TYPE_RESERVED", U_SHAPE_DIGIT_TYPE_RESERVED); INSTALL_ENUM(Shape, "DIGIT_TYPE_MASK", U_SHAPE_DIGIT_TYPE_MASK); INSTALL_ENUM(Shape, "AGGREGATE_TASHKEEL", U_SHAPE_AGGREGATE_TASHKEEL); INSTALL_ENUM(Shape, "AGGREGATE_TASHKEEL_NOOP", U_SHAPE_AGGREGATE_TASHKEEL_NOOP); INSTALL_ENUM(Shape, "AGGREGATE_TASHKEEL_MASK", U_SHAPE_AGGREGATE_TASHKEEL_MASK); INSTALL_ENUM(Shape, "PRESERVE_PRESENTATION", U_SHAPE_PRESERVE_PRESENTATION); INSTALL_ENUM(Shape, "PRESERVE_PRESENTATION_NOOP", U_SHAPE_PRESERVE_PRESENTATION_NOOP); INSTALL_ENUM(Shape, "PRESERVE_PRESENTATION_MASK", U_SHAPE_PRESERVE_PRESENTATION_MASK); INSTALL_ENUM(Shape, "SEEN_TWOCELL_NEAR", U_SHAPE_SEEN_TWOCELL_NEAR); #if U_ICU_VERSION_HEX >= 0x04020000 INSTALL_ENUM(Shape, "SEEN_MASK", U_SHAPE_SEEN_MASK); INSTALL_ENUM(Shape, "YEHHAMZA_TWOCELL_NEAR", U_SHAPE_YEHHAMZA_TWOCELL_NEAR); INSTALL_ENUM(Shape, "YEHHAMZA_MASK", U_SHAPE_YEHHAMZA_MASK); INSTALL_ENUM(Shape, "TASHKEEL_BEGIN", U_SHAPE_TASHKEEL_BEGIN); INSTALL_ENUM(Shape, "TASHKEEL_END", U_SHAPE_TASHKEEL_END); INSTALL_ENUM(Shape, "TASHKEEL_RESIZE", U_SHAPE_TASHKEEL_RESIZE); INSTALL_ENUM(Shape, "TASHKEEL_REPLACE_BY_TATWEEL", U_SHAPE_TASHKEEL_REPLACE_BY_TATWEEL); INSTALL_ENUM(Shape, "TASHKEEL_MASK", U_SHAPE_TASHKEEL_MASK); INSTALL_ENUM(Shape, "SPACES_RELATIVE_TO_TEXT_BEGIN_END", U_SHAPE_SPACES_RELATIVE_TO_TEXT_BEGIN_END); INSTALL_ENUM(Shape, "SPACES_RELATIVE_TO_TEXT_MASK", U_SHAPE_SPACES_RELATIVE_TO_TEXT_MASK); #endif #if U_ICU_VERSION_HEX >= 0x04080000 INSTALL_ENUM(Shape, "TAIL_NEW_UNICODE", U_SHAPE_TAIL_NEW_UNICODE); INSTALL_ENUM(Shape, "TAIL_TYPE_MASK", U_SHAPE_TAIL_TYPE_MASK); #endif } ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1430255121.0 PyICU-2.4.2/shape.h0000644000076500000000000000254300000000000014131 0ustar00vajdawheel00000000000000/* ==================================================================== * Copyright (c) 2004-2015 Open Source Applications Foundation. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. * ==================================================================== */ #ifndef _shape_h #define _shape_h void _init_shape(PyObject *m); #endif /* _shape_h */ ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1539913979.0 PyICU-2.4.2/spoof.cpp0000644000076500000000000003027000000000000014510 0ustar00vajdawheel00000000000000/* ==================================================================== * Copyright (c) 2014-2014 Open Source Applications Foundation. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. * ==================================================================== */ #include "common.h" #include "structmember.h" #include "bases.h" #include "unicodeset.h" #include "spoof.h" #include "macros.h" #if U_ICU_VERSION_HEX >= 0x04020000 DECLARE_CONSTANTS_TYPE(USpoofChecks); #if U_ICU_VERSION_HEX >= VERSION_HEX(51, 0, 0) DECLARE_CONSTANTS_TYPE(URestrictionLevel); #endif /* SpoofChecker */ class t_spoofchecker : public _wrapper { public: USpoofChecker *object; }; static int t_spoofchecker_init(t_spoofchecker *self, PyObject *args, PyObject *kwds); static PyObject *t_spoofchecker_setChecks(t_spoofchecker *self, PyObject *arg); static PyObject *t_spoofchecker_getChecks(t_spoofchecker *self); static PyObject *t_spoofchecker_setAllowedLocales(t_spoofchecker *self, PyObject *arg); static PyObject *t_spoofchecker_getAllowedLocales(t_spoofchecker *self); static PyObject *t_spoofchecker_setAllowedUnicodeSet(t_spoofchecker *self, PyObject *arg); static PyObject *t_spoofchecker_getAllowedUnicodeSet(t_spoofchecker *self); static PyObject *t_spoofchecker_check(t_spoofchecker *self, PyObject *arg); static PyObject *t_spoofchecker_areConfusable(t_spoofchecker *self, PyObject *args); static PyObject *t_spoofchecker_getSkeleton(t_spoofchecker *self, PyObject *args); #if U_ICU_VERSION_HEX >= VERSION_HEX(51, 0, 0) static PyObject *t_spoofchecker_setRestrictionLevel(t_spoofchecker *self, PyObject *arg); static PyObject *t_spoofchecker_getRestrictionLevel(t_spoofchecker *self); static PyObject *t_spoofchecker_getInclusionUnicodeSet(PyTypeObject *type); static PyObject *t_spoofchecker_getRecommendedUnicodeSet(PyTypeObject *type); #endif static PyMethodDef t_spoofchecker_methods[] = { DECLARE_METHOD(t_spoofchecker, setChecks, METH_O), DECLARE_METHOD(t_spoofchecker, getChecks, METH_NOARGS), DECLARE_METHOD(t_spoofchecker, setAllowedLocales, METH_O), DECLARE_METHOD(t_spoofchecker, getAllowedLocales, METH_NOARGS), DECLARE_METHOD(t_spoofchecker, setAllowedUnicodeSet, METH_O), DECLARE_METHOD(t_spoofchecker, getAllowedUnicodeSet, METH_NOARGS), DECLARE_METHOD(t_spoofchecker, check, METH_O), DECLARE_METHOD(t_spoofchecker, areConfusable, METH_VARARGS), DECLARE_METHOD(t_spoofchecker, getSkeleton, METH_VARARGS), #if U_ICU_VERSION_HEX >= VERSION_HEX(51, 0, 0) DECLARE_METHOD(t_spoofchecker, setRestrictionLevel, METH_O), DECLARE_METHOD(t_spoofchecker, getRestrictionLevel, METH_NOARGS), DECLARE_METHOD(t_spoofchecker, getInclusionUnicodeSet, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_spoofchecker, getRecommendedUnicodeSet, METH_NOARGS | METH_CLASS), #endif { NULL, NULL, 0, NULL } }; static void t_spoofchecker_dealloc(t_spoofchecker *self) { if (self->object != NULL) { uspoof_close(self->object); self->object = NULL; } Py_TYPE(self)->tp_free((PyObject *) self); } DECLARE_STRUCT(SpoofChecker, t_spoofchecker, USpoofChecker, t_spoofchecker_init, t_spoofchecker_dealloc); /* SpoofChecker */ static int t_spoofchecker_init(t_spoofchecker *self, PyObject *args, PyObject *kwds) { USpoofChecker *usc = NULL; t_spoofchecker *sc = NULL; switch (PyTuple_Size(args)) { case 0: INT_STATUS_CALL(usc = uspoof_open(&status)); self->object = usc; self->flags = T_OWNED; break; case 1: if (!parseArgs(args, "O", &SpoofCheckerType_, &sc)) { INT_STATUS_CALL(usc = uspoof_clone(sc->object, &status)); self->object = usc; self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; default: PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; } if (self->object != NULL) return 0; return -1; } static PyObject *t_spoofchecker_setChecks(t_spoofchecker *self, PyObject *arg) { int32_t checks = (int32_t) PyInt_AsLong(arg); if (PyErr_Occurred()) return NULL; STATUS_CALL(uspoof_setChecks(self->object, (uint32_t) checks, &status)); Py_RETURN_NONE; } static PyObject *t_spoofchecker_getChecks(t_spoofchecker *self) { uint32_t checks; STATUS_CALL(checks = uspoof_getChecks(self->object, &status)); return PyInt_FromLong((int32_t) checks); } static PyObject *t_spoofchecker_setAllowedLocales(t_spoofchecker *self, PyObject *arg) { char *localesList; if (!parseArg(arg, "c", &localesList)) { STATUS_CALL(uspoof_setAllowedLocales(self->object, localesList, &status)); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setAllowedLocales", arg); } static PyObject *t_spoofchecker_getAllowedLocales(t_spoofchecker *self) { const char *localesList; STATUS_CALL(localesList = uspoof_getAllowedLocales(self->object, &status)); return PyString_FromString(localesList); } static PyObject *t_spoofchecker_setAllowedUnicodeSet(t_spoofchecker *self, PyObject *arg) { const UnicodeSet *set; if (!parseArg(arg, "P", TYPE_CLASSID(UnicodeSet), &set)) { STATUS_CALL(uspoof_setAllowedUnicodeSet(self->object, set, &status)); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "setAllowedUnicodeSet", arg); } static PyObject *t_spoofchecker_getAllowedUnicodeSet(t_spoofchecker *self) { const UnicodeSet *set; STATUS_CALL(set = uspoof_getAllowedUnicodeSet(self->object, &status)); return wrap_UnicodeSet(new UnicodeSet(*set), T_OWNED); } static PyObject *t_spoofchecker_check(t_spoofchecker *self, PyObject *arg) { UnicodeString *u, _u; int32_t checks; if (!parseArg(arg, "S", &u, &_u)) { STATUS_CALL(checks = uspoof_check(self->object, u->getBuffer(), u->length(), NULL, &status)); return PyInt_FromLong(checks); } return PyErr_SetArgsError((PyObject *) self, "check", arg); } static PyObject *t_spoofchecker_areConfusable(t_spoofchecker *self, PyObject *args) { UnicodeString *u0, _u0; UnicodeString *u1, _u1; int32_t checks; switch (PyTuple_Size(args)) { case 2: if (!parseArgs(args, "SS", &u0, &_u0, &u1, &_u1)) { STATUS_CALL(checks = uspoof_areConfusable( self->object, u0->getBuffer(), u0->length(), u1->getBuffer(), u1->length(), &status)); return PyInt_FromLong(checks); } } return PyErr_SetArgsError((PyObject *) self, "areConfusable", args); } static PyObject *t_spoofchecker_getSkeleton(t_spoofchecker *self, PyObject *args) { UnicodeString *u, _u; int32_t type; switch (PyTuple_Size(args)) { case 2: if (!parseArgs(args, "iS", &type, &u, &_u)) { const int32_t len = u->length(); Buffer dest(len + 32); UErrorCode status = U_ZERO_ERROR; int32_t size = uspoof_getSkeleton(self->object, type, u->getBuffer(), len, dest.buffer, dest.size, &status); if (U_SUCCESS(status)) return PyUnicode_FromUnicodeString(dest.buffer, size); if (status == U_BUFFER_OVERFLOW_ERROR) { Buffer dest(size); STATUS_CALL(size = uspoof_getSkeleton( self->object, type, u->getBuffer(), len, dest.buffer, dest.size, &status)); return PyUnicode_FromUnicodeString(dest.buffer, size); } return ICUException(status).reportError(); } } return PyErr_SetArgsError((PyObject *) self, "getSkeleton", args); } #if U_ICU_VERSION_HEX >= VERSION_HEX(51, 0, 0) static PyObject *t_spoofchecker_setRestrictionLevel(t_spoofchecker *self, PyObject *arg) { int32_t level = (int32_t) PyInt_AsLong(arg); if (PyErr_Occurred()) return NULL; uspoof_setRestrictionLevel(self->object, (URestrictionLevel) level); Py_RETURN_NONE; } static PyObject *t_spoofchecker_getRestrictionLevel(t_spoofchecker *self) { URestrictionLevel level = uspoof_getRestrictionLevel(self->object); return PyInt_FromLong((int32_t) level); } static PyObject *t_spoofchecker_getInclusionUnicodeSet(PyTypeObject *type) { const UnicodeSet *set; STATUS_CALL(set = uspoof_getInclusionUnicodeSet(&status)); if (!set->isFrozen()) const_cast(set)->freeze(); // documented to be frozen return wrap_UnicodeSet(const_cast(set), 0); // owned by icu } static PyObject *t_spoofchecker_getRecommendedUnicodeSet(PyTypeObject *type) { const UnicodeSet *set; STATUS_CALL(set = uspoof_getRecommendedUnicodeSet(&status)); if (!set->isFrozen()) const_cast(set)->freeze(); // documented to be frozen return wrap_UnicodeSet(const_cast(set), 0); // owned by icu } #endif /* 51 */ #endif /* 4.2 */ void _init_spoof(PyObject *m) { #if U_ICU_VERSION_HEX >= 0x04020000 INSTALL_CONSTANTS_TYPE(USpoofChecks, m); #if U_ICU_VERSION_HEX >= VERSION_HEX(51, 0, 0) INSTALL_CONSTANTS_TYPE(URestrictionLevel, m); #endif INSTALL_STRUCT(SpoofChecker, m); INSTALL_ENUM(USpoofChecks, "SINGLE_SCRIPT_CONFUSABLE", USPOOF_SINGLE_SCRIPT_CONFUSABLE); INSTALL_ENUM(USpoofChecks, "MIXED_SCRIPT_CONFUSABLE", USPOOF_MIXED_SCRIPT_CONFUSABLE); INSTALL_ENUM(USpoofChecks, "WHOLE_SCRIPT_CONFUSABLE", USPOOF_WHOLE_SCRIPT_CONFUSABLE); INSTALL_ENUM(USpoofChecks, "ANY_CASE", USPOOF_ANY_CASE); INSTALL_ENUM(USpoofChecks, "INVISIBLE", USPOOF_INVISIBLE); INSTALL_ENUM(USpoofChecks, "CHAR_LIMIT", USPOOF_CHAR_LIMIT); #if U_ICU_VERSION_HEX >= 0x04060000 INSTALL_ENUM(USpoofChecks, "ALL_CHECKS", USPOOF_ALL_CHECKS); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(51, 0, 0) INSTALL_ENUM(USpoofChecks, "RESTRICTION_LEVEL", USPOOF_RESTRICTION_LEVEL); INSTALL_ENUM(USpoofChecks, "MIXED_NUMBERS", USPOOF_MIXED_NUMBERS); INSTALL_ENUM(USpoofChecks, "AUX_INFO", USPOOF_AUX_INFO); #else INSTALL_ENUM(USpoofChecks, "SINGLE_SCRIPT", USPOOF_SINGLE_SCRIPT); #endif #if U_ICU_VERSION_HEX >= VERSION_HEX(51, 0, 0) INSTALL_ENUM(URestrictionLevel, "ASCII", USPOOF_ASCII); INSTALL_ENUM(URestrictionLevel, "HIGHLY_RESTRICTIVE", USPOOF_HIGHLY_RESTRICTIVE); INSTALL_ENUM(URestrictionLevel, "MODERATELY_RESTRICTIVE", USPOOF_MODERATELY_RESTRICTIVE); INSTALL_ENUM(URestrictionLevel, "MINIMALLY_RESTRICTIVE", USPOOF_MINIMALLY_RESTRICTIVE); INSTALL_ENUM(URestrictionLevel, "UNRESTRICTIVE", USPOOF_UNRESTRICTIVE); #endif /* 51 */ #if U_ICU_VERSION_HEX >= VERSION_HEX(53, 0, 0) INSTALL_ENUM(URestrictionLevel, "SINGLE_SCRIPT_RESTRICTIVE", USPOOF_SINGLE_SCRIPT_RESTRICTIVE); INSTALL_ENUM(URestrictionLevel, "RESTRICTION_LEVEL_MASK", USPOOF_RESTRICTION_LEVEL_MASK); #endif #endif /* 4.2 */ } ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1431205733.0 PyICU-2.4.2/spoof.h0000644000076500000000000000262000000000000014153 0ustar00vajdawheel00000000000000/* ==================================================================== * Copyright (c) 2014-2014 Open Source Applications Foundation. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. * ==================================================================== */ #ifndef _spoof_h #define _spoof_h PyObject *wrap_Spoof(NumberFormat *, int); void _init_spoof(PyObject *m); #endif /* _spoof_h */ ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1573605241.8440402 PyICU-2.4.2/test/0000755000076500000000000000000000000000000013633 5ustar00vajdawheel00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1491580779.0 PyICU-2.4.2/test/__init__.py0000644000076500000000000000146200000000000015747 0ustar00vajdawheel00000000000000# 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 ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1316052020.0 PyICU-2.4.2/test/lohit_hi.ttf0000644000076500000000000023711400000000000016161 0ustar00vajdawheel00000000000000FFTMNOj§>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ƨ£././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1143939619.0 PyICU-2.4.2/test/noms.txt0000644000076500000000000000006100000000000015345 0ustar00vajdawheel00000000000000école enfant faon fille demain Dominique Élevé././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1569878289.0 PyICU-2.4.2/test/test_BreakIterator.py0000644000076500000000000000526300000000000020010 0ustar00vajdawheel00000000000000# ==================================================================== # Copyright (c) 2005-2019 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) def testCreateInstanceFromBinaryRules(self): if ICU_VERSION >= '4.8': bi = BreakIterator.createWordInstance(Locale.getEnglish()) self.assertIsInstance(bi, RuleBasedBreakIterator) data = bi.getBinaryRules() rbi = RuleBasedBreakIterator(data) self.assertEqual(data, rbi.getBinaryRules()) if __name__ == "__main__": main() ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1569864520.0 PyICU-2.4.2/test/test_BytesTrie.py0000644000076500000000000000520600000000000017161 0ustar00vajdawheel00000000000000# -*- coding: utf-8 -*- # ==================================================================== # Copyright (c) 2019 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, six from unittest import TestCase, main from icu import * class TestBytesTrie(TestCase): def testBuildAndIterate(self): mappings = { 'ab': 3, 'abc': 6, 'abcd': 2, 'abcef': 11, 'abcp': 88, 'abcqr': 20 } builder = BytesTrie.Builder() for key, value in mappings.items(): builder.add(key, value) trie = builder.build(UStringTrieBuildOption.FAST) for key, value in trie: self.assertEqual(mappings[key], value) def testAccess(self): mappings = { 'ab': 3, 'abc': 6, 'abcd': 2, 'abcef': 11, 'abcp': 88, 'abcqr': 20 } builder = BytesTrie.Builder() for key, value in mappings.items(): builder.add(key, value) trie = builder.build(UStringTrieBuildOption.FAST) self.assertEqual((3, 6), (trie.next('abc'), trie.getValue())) state = trie.saveState() self.assertEqual(b'depq', trie.getNextBytes()) self.assertEqual((2, 2), (trie.next('d'), trie.getValue())) self.assertEqual((0, None), (trie.next('e'), trie.getValue())) trie.resetToState(state) self.assertEqual((2, 11), (trie.next('ef'), trie.getValue())) trie.resetToState(state) self.assertEqual((2, 88), (trie.next('p'), trie.getValue())) if __name__ == "__main__": if ICU_VERSION >= '4.8': main() ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1493166223.0 PyICU-2.4.2/test/test_Charset.py0000644000076500000000000000477300000000000016650 0ustar00vajdawheel00000000000000# ==================================================================== # 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, six 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 = six.text_type(CharsetDetector(bytes).detect()) self.assertTrue(ustring.encode('iso-8859-1') == bytes) if __name__ == "__main__": main() ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1536874327.0 PyICU-2.4.2/test/test_Collator.py0000644000076500000000000001371700000000000017034 0ustar00vajdawheel00000000000000# ==================================================================== # Copyright (c) 2005-2018 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, six 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 = [six.text_type(n.strip(), 'utf-8') for n in input.readlines()] input.close() ecole = names[0] names.sort() self.assertTrue(names[-1] is ecole) if (sys.version_info >= (3,)): names.sort(key=collator.getSortKey) else: names.sort(collator.compare) self.assertTrue(names[2] is ecole) def testCreateInstancePolymorph(self): collator = Collator.createInstance(Locale("epo")) # Esperanto self.assertIsInstance(collator, RuleBasedCollator) rules = collator.getRules() def testGetSortKey(self): # Do not test sort key byte sequences directly: # They are unstable, that is, likely to change # with every UCA/CLDR/ICU release. # Instead, test that compare() is consistent with # comparing the equivalent sort keys. collator = Collator.createInstance(Locale.getJapanese()) collator.setAttribute(UCollAttribute.NORMALIZATION_MODE, UCollAttributeValue.ON) collator.setAttribute(UCollAttribute.ALTERNATE_HANDLING, UCollAttributeValue.SHIFTED) collator.setAttribute(UCollAttribute.STRENGTH, UCollAttributeValue.TERTIARY) # In Japanese, the following characters should be different # only on quaternary level. hira_ge = u'\u3052' # Hiragana letter Ge kana_ge = u'\u30B2' # Katakana letter Ge self.assertEqual(0, collator.compare(hira_ge, kana_ge)) hira_ge_key = collator.getSortKey(hira_ge) kana_ge_key = collator.getSortKey(kana_ge) self.assertEqual(hira_ge_key, kana_ge_key) collator.setAttribute(UCollAttribute.STRENGTH, UCollAttributeValue.QUATERNARY) self.assertEqual(-1, collator.compare(hira_ge, kana_ge)) hira_ge_key = collator.getSortKey(hira_ge) kana_ge_key = collator.getSortKey(kana_ge) self.assertTrue(hira_ge_key < kana_ge_key) def setupCollator(self, collator): collator.setAttribute(UCollAttribute.NORMALIZATION_MODE, UCollAttributeValue.ON) collator.setAttribute(UCollAttribute.CASE_FIRST, UCollAttributeValue.UPPER_FIRST) collator.setAttribute(UCollAttribute.ALTERNATE_HANDLING, UCollAttributeValue.SHIFTED) collator.setAttribute(UCollAttribute.STRENGTH, UCollAttributeValue.QUATERNARY) collator.setAttribute(UCollAttribute.HIRAGANA_QUATERNARY_MODE, UCollAttributeValue.ON) def LoadCollatorFromRules(self): rules = u"&z<\u00e6 &h= '4.6': collator = self.LoadCollatorFromRules() s = u'hchz\u00e6' key0 = collator.getSortKey(s) bin = collator.cloneBinary() collator = self.LoadCollatorFromBinaryBuffer(bin) key1 = collator.getSortKey(s) self.assertTrue(key0 == key1) def testAlphabeticIndex(self): if ICU_VERSION >= '4.8': index = AlphabeticIndex(Locale.getItaly()) index.addRecord("foo", "bar") index.addRecord("topo", "lino") def allData(index): for ((label, type)) in index: while index.nextRecord(): yield (label, type, index.recordData) self.assertTrue(list(allData(index)) == [ ('F', 0, 'bar'), ('T', 0, 'lino')]) if ICU_VERSION >= '5.1': self.assertTrue(len(index.buildImmutableIndex()) == 28) if __name__ == "__main__": main() ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1491580779.0 PyICU-2.4.2/test/test_DateTimeParserGenerator.py0000644000076500000000000001113700000000000021767 0ustar00vajdawheel00000000000000# -*- coding: utf-8 -*- # ==================================================================== # Copyright (c) 2016-2016 Open Source Applications Foundation. # # Permission is hereby granted, free of charge, to any person obtaining a # copy of this software and associated documentation files (the "Software"), # to deal in the Software without restriction, including without limitation # the rights to use, copy, modify, merge, publish, distribute, sublicense, # and/or sell copies of the Software, and to permit persons to whom the # Software is furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included # in all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS # OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING # FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER # DEALINGS IN THE SOFTWARE. # ==================================================================== # from unittest import TestCase, main from icu import * # These tests were lifted from the examples in ``dtptngsample.cpp`` in icu4c class TestDateTimePatternGenerator(TestCase): def setUp(self): cal = Calendar.createInstance() cal.setTimeZone(TimeZone.getGMT()) cal.set(2016, 4, 10, 0, 30, 0) # month value is 0-based self.date = cal.getTime() self.tz = TimeZone.createTimeZone('America/Los_Angeles') def testAddPattern(self): """Test overwriting a pattern with the same skeleton.""" locale = Locale.getFrance() dtpg = DateTimePatternGenerator.createInstance(locale) sdf = SimpleDateFormat(dtpg.getBestPattern('MMMMddHmm'), locale) sdf.setTimeZone(self.tz) self.assertEqual(sdf.format(self.date), u'09 mai à 17:30') self.assertEqual(sdf.toPattern(), u"dd MMMM 'à' HH:mm") dtpg.addPattern("dd'. von' MMMM", True) sdf.applyPattern(dtpg.getBestPattern('MMMMddHmm')) sdf.setTimeZone(self.tz) self.assertEqual(sdf.format(self.date), u'09. von mai à 17:30') self.assertEqual(sdf.toPattern(), u"dd'. von' MMMM 'à' HH:mm") def testGetBestPattern(self): """Test a few different languages and common patterns.""" skeletons = ('yQQQQ', # year + full name of quarter, i.e., 4th quarter 1999 'yMMMM', # year + full name of month, i.e., October 1999 'MMMMd', # full name of month + day of the month, i.e., October 25 'hhmm', # 12-hour-cycle format, i.e., 1:32 PM 'jjmm') # preferred hour format for the given locale, i.e., 24-hour-cycle format for fr_FR locales = ((Locale('en_US'), (u'2nd quarter 2016', u'May 2016', u'May 9', u'5:30 PM', u'5:30 PM')), (Locale('fr_FR'), (u'2e trimestre 2016', u'mai 2016', u'9 mai', u'5:30 PM', u'17:30')), (Locale('zh_CN'), (u'2016年第2季度', u'2016å¹´5月', u'5月9æ—¥', u'下åˆ5:30', u'下åˆ5:30')),) for locale, locale_data in locales: dtpg = DateTimePatternGenerator.createInstance(locale) for index, skeleton in enumerate(skeletons): pattern = dtpg.getBestPattern(skeleton) sdf = SimpleDateFormat(pattern, locale) sdf.setTimeZone(self.tz) self.assertEqual(sdf.format(self.date), locale_data[index]) def testReplaceFieldType(self): """Test replacing an element of a pattern.""" locale = Locale.getFrance() dtpg = DateTimePatternGenerator.createInstance(locale) sdf = SimpleDateFormat('EEEE d MMMM y HH:mm:ss zzzz', locale) sdf.setTimeZone(self.tz) pattern = sdf.toPattern() self.assertEqual(pattern, u'EEEE d MMMM y HH:mm:ss zzzz') self.assertEqual(sdf.format(self.date), u'lundi 9 mai 2016 17:30:00 heure d’été du Pacifique') newPattern = dtpg.replaceFieldTypes(pattern, 'vvvv') sdf.applyPattern(newPattern) sdf.setTimeZone(self.tz) self.assertEqual(sdf.toPattern(), u'EEEE d MMMM y HH:mm:ss vvvv') self.assertEqual(sdf.format(self.date), u'lundi 9 mai 2016 17:30:00 heure du Pacifique nord-américain') if __name__ == '__main__': main() ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1493166223.0 PyICU-2.4.2/test/test_LayoutEngine.py0000644000076500000000000001043600000000000017653 0ustar00vajdawheel00000000000000# -*- 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, six from unittest import TestCase, main from icu import * try: if ICU_VERSION >= '58': raise NotImplementedError from fontTools.ttLib import TTFont except ImportError as e: sys.stderr.write("\nfontTools package not found, skipping LayoutEngine tests\n") except NotImplementedError: sys.stderr.write("\nLayoutEngine not available in ICU %s" %(ICU_VERSION)) else: class TTXLEFont(LEFontInstance): def __init__(self, fname, size=12): super(TTXLEFont, self).__init__() self.ttx = TTFont(fname) self.size = size self.upem = self.ttx['head'].unitsPerEm self.cmap = self.ttx['cmap'].getcmap(3, 1).cmap def getFontTable(self, table): return self.ttx.getTableData(table) def getAscent(self): self.ttx['hhea'].ascent * self.size * 1. / self.upem def getDescent(self): self.ttx['hhea'].descent * self.size * 1. / self.upem def getLeading(self): self.ttx['hhea'].lineGap * self.size * 1. / self.upem def getUnitsPerEm(self): return self.upem def mapCharToGlyph(self, code): return self.ttx.getGlyphID(self.cmap[code]) def getGlyphAdvance(self, glyph): if glyph >= self.ttx['maxp'].numGlyphs: return (0., 0.) name = self.ttx.getGlyphName(glyph) x = self.ttx['hmtx'][name][0] * self.size * 1. / self.upem if 'vmtx' in self.ttx: y = self.ttx['vmtx'][name][0] * self.size * 1. / self.upem else: y = 0. return (x, y) def getGlyphPoint(self, glyph, point): return (0., 0.) def getXPixelsPerEm(self): return self.size def getYPixelsPerEm(self): return self.size def getScaleFactorX(self): return 1. def getScaleFactorY(self): return 1. try: if ICU_VERSION >= '58': raise NotImplementedError import fontTools except ImportError: pass except NotImplementedError: pass else: class TestLayoutEngine(TestCase): def filePath(self, name): module = sys.modules[TestLayoutEngine.__module__].__file__ return os.path.join(os.path.dirname(module), name) def setUp(self): self.font = TTXLEFont(self.filePath("lohit_hi.ttf")) self.layout = LayoutEngine.layoutEngineFactory(self.font, ScriptCode.deva, LanguageCode.nul) def testHello(self): self.layout.layoutChars(u"नमसà¥à¤¤à¥‡ दà¥à¤¨à¤¿à¤¯à¤¾") self.assertEqual(self.layout.getGlyphCount(), 13) if __name__ == "__main__": try: if ICU_VERSION >= '58': raise NotImplementedError import fontTools except ImportError: pass except NotImplementedError: pass else: main() ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1515080378.0 PyICU-2.4.2/test/test_ListFormatter.py0000644000076500000000000000343500000000000020050 0ustar00vajdawheel00000000000000# ==================================================================== # Copyright (c) 2014 Open Source Applications Foundation. # # Permission is hereby granted, free of charge, to any person obtaining a # copy of this software and associated documentation files (the "Software"), # to deal in the Software without restriction, including without limitation # the rights to use, copy, modify, merge, publish, distribute, sublicense, # and/or sell copies of the Software, and to permit persons to whom the # Software is furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included # in all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS # OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING # FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER # DEALINGS IN THE SOFTWARE. # ==================================================================== # import sys, os from unittest import TestCase, main from icu import * class TestListFormatter(TestCase): def testDefault(self): Locale.setDefault(Locale.getUS()) formatter = ListFormatter.createInstance() text = formatter.format(('a', 'b', 'c')) self.assertTrue(text == u'a, b, and c') def testLocale(self): formatter = ListFormatter.createInstance(Locale.getFrance()) text = formatter.format(('a', 'b', 'c')) self.assertTrue(text == u'a, b et c') if __name__ == "__main__": main() ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1569527900.0 PyICU-2.4.2/test/test_Locale.py0000644000076500000000000000341200000000000016443 0ustar00vajdawheel00000000000000# -*- coding: utf-8 -*- # ==================================================================== # Copyright (c) 2019 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, six from unittest import TestCase, main from icu import * class TestLocale(TestCase): def testConstructWithKeywords(self): l0 = Locale('fr', 'be', collation='phonebook', currency='euro') l1 = Locale('fr', 'be', '', 'collation=phonebook;currency=euro') self.assertEqual('fr_BE@collation=phonebook;currency=euro', str(l0)) self.assertEqual('fr_BE@collation=phonebook;currency=euro', str(l1)) self.assertEqual(l0, l1) if __name__ == "__main__": main() ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1515079578.0 PyICU-2.4.2/test/test_LocaleData.py0000644000076500000000000002344000000000000017240 0ustar00vajdawheel00000000000000# ==================================================================== # Copyright (c) 2007-2013 Open Source Applications Foundation. # # Permission is hereby granted, free of charge, to any person obtaining a # copy of this software and associated documentation files (the "Software"), # to deal in the Software without restriction, including without limitation # the rights to use, copy, modify, merge, publish, distribute, sublicense, # and/or sell copies of the Software, and to permit persons to whom the # Software is furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included # in all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS # OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING # FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER # DEALINGS IN THE SOFTWARE. # ==================================================================== # # This is a python translation of ICU's LocaleDataTest.java import sys, os, six from unittest import TestCase, main from icu import * NOT_FOUND_ERR = 'The requested resource cannot be found, error code: 2' def print_output(string): pass class ExemplarGroup: def __init__(_self, s, scriptCodes): _self.set = s _self.scs = scriptCodes def __hash__(_self): hash = 0 for i in range(len(_self.scs) if len(_self.scs) < 4 else 4): hash = (hash << 8) + _self.scs[i] return hash def __eq__(_self, other): return (_self.set == other.set) and (_self.scs == other.scs) class TestLocaleData(TestCase): def setUp(self): self.availableLocales = Locale.getAvailableLocales() def testPapersize(self): for locale in self.availableLocales.keys(): papersize = LocaleData(locale).getPaperSize() #language = Locale(locale).getLanguage() country = Locale(locale).getCountry() if (['BZ','CA','CL','CO','CR','GT','MX','NI','PA','PH','PR','SV','US','VE'].count(country) > 0): self.assertTrue(papersize == (279, 216)) elif country: self.assertTrue(papersize == (297, 210)) def testMeasurementSystem(self): for locale in self.availableLocales.keys(): measurementSystem = LocaleData(locale).getMeasurementSystem() #language = Locale(locale).getLanguage() country = Locale(locale).getCountry() # 0 means SI, 1 means US, 2 mean UK if (country in ['LR', 'MM', 'US']): self.assertTrue(measurementSystem == 1) elif country in ['GB']: self.assertTrue(measurementSystem in [0, 2]) elif country: self.assertTrue(measurementSystem == 0) def testExemplarSet(self): testedExemplars = set() equalCount = 0 for locale in self.availableLocales: scriptCodes = Script.getCode(locale) exemplarSets = [] for k in range(2): # it seems USET_CASE_INSENSITIVE = 2 option = 0 if k == 0 else 2 # standard = 0, auxiliary = 1, index = 2, count = 3 exemplarSet = LocaleData(locale).getExemplarSet(option, 0) exemplarSets.append(exemplarSet) exGrp = ExemplarGroup(exemplarSet, scriptCodes) if (not exGrp in testedExemplars): testedExemplars.add(exGrp) sets = [] for j in range(len(scriptCodes)): sets.append(UnicodeSet('[:' + Script(scriptCodes[j]).getShortName() + ':]')) existsInScript = False iter = UnicodeSetIterator(exemplarSet) while (not existsInScript and iter.nextRange()): if (not iter.isString()): for j in range(len(sets)): if sets[j].contains(iter.getCodepoint(), iter.getCodepointEnd()): existsInScript = True break else: for j in range(len(sets)): if sets[j].contains(iter.getString()): existsInScript = True break if existsInScript == False: print_output("ExemplarSet containment failed for locale : "+ locale) print_output(locale + " exemplar " + repr(six.text_type(exemplarSets[0]))) print_output(locale + " exemplar(case-folded) " + repr(six.text_type(exemplarSets[1]))) self.assertTrue(locale + " case-folded is a superset", exemplarSets[1].containsAll(exemplarSets[0])) if (exemplarSets[1] == exemplarSets[0]): ++equalCount self.assertTrue("case-folded is sometimes a strict superset, and sometimes equal",\ equalCount > 0 and equalCount < len(self.availableLocales)) def testExemplarSet2(self): testedExemplars = set() equalCount = 0 for locale in self.availableLocales: ld = LocaleData(locale) scriptCodes = Script.getCode(locale) exemplarSets = [] for k in range(2): # for casing option in (normal, uncased) # it seems USET_CASE_INSENSITIVE = 2 option = 0 if k == 0 else 2 for h in range(2): esType = 0 if h == 0 else 1 # standard = 0, auxiliary = 1, index = 2, count = 3 exemplarSet = LocaleData(locale).getExemplarSet(option, esType) exemplarSets.append(exemplarSet) exGrp = ExemplarGroup(exemplarSet, scriptCodes) if (not exGrp in testedExemplars): testedExemplars.add(exGrp) sets = [] for j in range(len(scriptCodes)): sets.append(UnicodeSet('[:' + Script(scriptCodes[j]).getShortName() + ':]')) existsInScript = False iter = UnicodeSetIterator(exemplarSet) while (not existsInScript and iter.nextRange()): if (not iter.isString()): for j in range(len(sets)): if sets[j].contains(iter.getCodepoint(), iter.getCodepointEnd()): existsInScript = True break else: for j in range(len(sets)): if sets[j].contains(iter.getString()): existsInScript = True break if existsInScript == False and h == 0: print_output("ExemplarSet containment failed for locale,option,type : " \ + locale + "," + str(option) + "," + str(esType)) print_output(locale + " exemplar(ES_STANDARD)" + repr(six.text_type(exemplarSets[0]))) print_output(locale + " exemplar(ES_AUXILIARY)" + repr(six.text_type(exemplarSets[1]))) print_output(locale + " exemplar(case-folded,ES_STANDARD)" + repr(six.text_type(exemplarSets[2]))) print_output(locale + " exemplar(case-folded,ES_AUXILIARY)" + repr(six.text_type(exemplarSets[3]))) self.assertTrue(locale + " case-folded is a superset", exemplarSets[2].containsAll(exemplarSets[0])) self.assertTrue(locale + " case-folder is a superset", exemplarSets[3].containsAll(exemplarSets[1])) if (exemplarSets[2] == exemplarSets[0]): ++equalCount if (exemplarSets[3] == exemplarSets[1]): ++equalCount self.assertTrue("case-folded is sometimes a strict superset, and sometimes equal",\ equalCount > 0 and equalCount < len(self.availableLocales) * 2) def testCoverage(self): ld = LocaleData(Locale().getName()) t = ld.getNoSubstitute() ld.setNoSubstitute(t) self.assertEqual(t, ld.getNoSubstitute()) for i in range(4): print_output(repr(ld.getDelimiter(i))) def testLocaleDisplayPattern(self): ld = LocaleData(Locale().getName()) print_output("Default locale LocaleDisplayPattern:" + ld.getLocaleDisplayPattern()); print_output("Default locale LocaleSeparator:" + ld.getLocaleSeparator()); for locale in self.availableLocales: ld = LocaleData(locale) try: print_output(locale + " LocaleDisplayPattern:" + repr(ld.getLocaleDisplayPattern())) getLocaleDisplayPattern = True except ICUError as e: # resource not found getLocaleDisplayPattern = str(e) == NOT_FOUND_ERR except: getLocaleDisplayPattern = False self.assertTrue(getLocaleDisplayPattern) try: print_output(locale + " LocaleSeparator:" + repr(ld.getLocaleSeparator())) getLocaleSeparator = True except ICUError as e: # resource not found getLocaleSeparator = str(e) == NOT_FOUND_ERR except: getLocaleSeparator = False self.assertTrue(getLocaleSeparator) if __name__ == "__main__": main() ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1569538335.0 PyICU-2.4.2/test/test_LocaleMatcher.py0000644000076500000000000000501300000000000017746 0ustar00vajdawheel00000000000000# -*- coding: utf-8 -*- # ==================================================================== # Copyright (c) 2019 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, six from unittest import TestCase, main from icu import * class TestLocaleMatcher(TestCase): def testSetSupportedLocales(self): locales = (Locale.getFrance(), Locale.getGermany()) matcher = LocaleMatcher.Builder().setSupportedLocales(locales).build() self.assertEqual(Locale.getFrance(), matcher.getBestMatch(Locale.getItaly())) self.assertEqual(Locale.getGermany(), matcher.getBestMatch(Locale('de-AT'))) def testGetBestMatch(self): locales = (Locale.getFrance(), Locale.getGermany()) matcher = LocaleMatcher.Builder().setSupportedLocales(locales).build() self.assertEqual(Locale.getGermany(), matcher.getBestMatch((Locale('de-AT'), Locale('fr')))) def testGetBestMatchResult(self): locales = (Locale.getFrance(), Locale.getGermany()) matcher = LocaleMatcher.Builder().setSupportedLocales(locales).build() result = matcher.getBestMatchResult((Locale('de-AT'), Locale('fr'))) self.assertEqual(Locale('de-AT'), result.getDesiredLocale()) self.assertEqual(Locale.getGermany(), result.getSupportedLocale()) if __name__ == "__main__": if ICU_VERSION >= '65.0': main() ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1491580779.0 PyICU-2.4.2/test/test_MessageFormat.py0000644000076500000000000000750500000000000020010 0ustar00vajdawheel00000000000000# -*- coding: utf-8 -*- # ==================================================================== # Copyright (c) 2005-2010 Open Source Applications Foundation. # # Permission is hereby granted, free of charge, to any person obtaining a # copy of this software and associated documentation files (the "Software"), # to deal in the Software without restriction, including without limitation # the rights to use, copy, modify, merge, publish, distribute, sublicense, # and/or sell copies of the Software, and to permit persons to whom the # Software is furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included # in all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS # OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING # FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER # DEALINGS IN THE SOFTWARE. # ==================================================================== # import sys, os from unittest import TestCase, main from icu import * class TestMessageFormat(TestCase): def testFormatMessage(self): x = 'x' f = Formattable(UnicodeString(x)) text = MessageFormat.formatMessage("This is a string: {0}.", [f]) self.assertTrue(text == "This is a string: x.") def testFormat(self): x = 'x' f = Formattable(UnicodeString(x)) msgFormat = MessageFormat("This is a string: {0}") text = msgFormat.format([f], FieldPosition()) self.assertTrue(text == "This is a string: x") if (sys.version_info < (3,) and 'PyPy' not in sys.version): # Reduced features of % operator might be intentional f = UnicodeString(x) text = msgFormat % f self.assertTrue(text == "This is a string: x") def testFormatAppend(self): x = 'x' f = Formattable(UnicodeString(x)) msgFormat = MessageFormat("This is a string: {0}") text = msgFormat.format([f], UnicodeString("x"), FieldPosition()) self.assertTrue(text == "xThis is a string: x") def testFormats(self): orig = TimeZone.createDefault().getID() tzid = 'America/Indiana/Vevay' msgFormat = MessageFormat("{0,time,short} {0,time,z}") formats = msgFormat.getFormats() formats[0].setTimeZone(TimeZone.createTimeZone(tzid)) self.assertTrue(msgFormat.getFormats()[0].getTimeZone().getID() == orig) msgFormat.setFormats(formats) self.assertTrue(msgFormat.getFormats()[0].getTimeZone().getID() == tzid) def testSelectFormat(self): try: from icu import SelectFormat except ImportError: return format = u"{0} est {1, select, female {allée} other {allé}} à Paris." msgFormat = MessageFormat(format, Locale("fr")) args = [Formattable("Kirti"), Formattable("female")] self.assertTrue(msgFormat.format(args) == u"Kirti est allée à Paris.") def testNamedArgs(self): if ICU_VERSION >= '4.0': msg = \ '{num_emails_to_send, plural, ' \ '=0 {unused plural form} ' \ '=1 {One email will be sent.} ' \ 'other {# emails will be sent.}}' messageFormat = MessageFormat(msg, Locale("en")) name0 = "num_emails_to_send" arg0 = Formattable(5) result = messageFormat.format([name0], [arg0]) self.assertTrue(result == u'5 emails will be sent.') if __name__ == "__main__": main() ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1515082480.0 PyICU-2.4.2/test/test_Normalizer.py0000644000076500000000000000503000000000000017364 0ustar00vajdawheel00000000000000# -*- 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 assertNorm(self, normalizer2, expected, source): self.assertEqual(expected, normalizer2.normalize(source)) a = UnicodeString() normalizer2.normalize(source, a) self.assertEqual(UnicodeString(expected), a) def testNormalize(self): try: from icu import Normalizer2 except ImportError: return self.assertNorm(Normalizer2.getInstance(None, "nfkc_cf", UNormalizationMode2.COMPOSE), u'hi there', "Hi There") self.assertNorm(Normalizer2.getNFCInstance(), u"äßáＷ", u"äßa\u0301ï¼·") self.assertNorm(Normalizer2.getNFDInstance(), u"a\u0308ßa\u0301ï¼·", u"äßa\u0301ï¼·") self.assertNorm(Normalizer2.getNFKCInstance(), u"äßáW", u"äßa\u0301ï¼·") self.assertNorm(Normalizer2.getNFKDInstance(), u"a\u0308ßa\u0301W", u"äßa\u0301ï¼·") self.assertNorm(Normalizer2.getNFKCCasefoldInstance(), u"ässáw", u"äßa\u0301ï¼·") if __name__ == "__main__": main() ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1552730585.0 PyICU-2.4.2/test/test_NumberFormatter.py0000644000076500000000000000707600000000000020372 0ustar00vajdawheel00000000000000# -*- coding: utf-8 -*- # ==================================================================== # Copyright (c) 2018 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 TestNumberFormatter(TestCase): def testBasic(self): if ICU_VERSION >= '60.0': text = NumberFormatter.withLocale(Locale.getUS()).formatInt(1234) self.assertEqual(text, u'1,234') text = LocalizedNumberFormatter(Locale.getUS()).formatInt(1234) self.assertEqual(text, u'1,234') def testFancy(self): if ICU_VERSION >= '60.0' and ICU_VERSION < '64.0': text = NumberFormatter.with_() \ .notation(Notation.compactShort()) \ .unit(CurrencyUnit('EUR')) \ .rounding(Rounder.maxDigits(2)) \ .locale(Locale.getFrance()) \ .formatInt(1234) self.assertEqual(text, u'1,2\xa0k\xa0€') if ICU_VERSION >= '62.0': text = NumberFormatter.with_() \ .notation(Notation.compactShort()) \ .unit(CurrencyUnit('EUR')) \ .precision(Precision.maxSignificantDigits(2)) \ .locale(Locale.getFrance()) \ .formatInt(1234) self.assertEqual(text, u'1,2\xa0k\xa0€') def testUnit(self): if ICU_VERSION >= '60.0': formatter = UnlocalizedNumberFormatter() \ .sign(UNumberSignDisplay.ALWAYS) \ .unit(MeasureUnit.createMeter()) \ .unitWidth(UNumberUnitWidth.FULL_NAME) text = formatter.locale(Locale.getUS()).formatInt(1234) self.assertEqual(text, u'+1,234 meters') text = formatter.locale(Locale.getFrance()).formatInt(1234) if ICU_VERSION >= '63.0': self.assertEqual(text, u'+1\u202f234\xa0mètres') else: self.assertEqual(text, u'+1\xa0234 mètres') if ICU_VERSION >= '61.0': formatter = UnlocalizedNumberFormatter() \ .sign(UNumberSignDisplay.ALWAYS) \ .unit(MeasureUnit.createMeter()) \ .perUnit(MeasureUnit.createSecond()) \ .unitWidth(UNumberUnitWidth.FULL_NAME) text = formatter.locale(Locale.getUS()).formatInt(1234) self.assertEqual(text, u'+1,234 meters per second') if __name__ == "__main__": if ICU_VERSION >= '60.0': main() ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1569965477.0 PyICU-2.4.2/test/test_PythonReplaceable.py0000644000076500000000000000625700000000000020657 0ustar00vajdawheel00000000000000# -*- coding: utf-8 -*- # ==================================================================== # Copyright (c) 2019 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, six from unittest import TestCase, main from icu import * class _Replaceable(object): def __init__(self, buffer): self.buffer = buffer def getLength(self): return len(self.buffer) def getCharAt(self, offset): return self.buffer[offset] def getChar32At(self, offset): return self.buffer[offset] def extractBetween(self, start, limit): return self.buffer[start:limit] def handleReplaceBetween(self, start, limit, text): self.buffer = ''.join((self.buffer[:start], text, self.buffer[limit:])) def copy(self, start, limit, dest): self.buffer = ''.join((self.buffer[:dest], self.buffer[start:limit], self.buffer[dest:])) def hasMetaData(self): return False class TestPythonReplaceable(TestCase): def testAccess(self): _rep = _Replaceable('abcd') # the python implementation rep = PythonReplaceable(_rep) # the wrapper to pass to ICU self.assertEqual(4, rep.length()) self.assertEqual(ord('b'), rep.charAt(1)) self.assertEqual(ord('c'), rep.char32At(2)) self.assertEqual('bc', rep.extractBetween(1, 3)) rep.handleReplaceBetween(1, 3, 'pqrs') self.assertEqual('apqrsd', _rep.buffer) def testTransliterate(self): trans = Transliterator.createInstance('Accents-Any') inverse = trans.createInverse() string = u'\xe9v\xe9nement' if ICU_VERSION < '4.0': result = u"e<'>ve<'>nement" else: result = u"e\u2190'\u2192ve\u2190'\u2192nement" _rep = _Replaceable(string) # the python implementation rep = PythonReplaceable(_rep) # the wrapper to pass to ICU trans.transliterate(rep) self.assertEqual(result, _rep.buffer) inverse.transliterate(rep) self.assertEqual(string, _rep.buffer) if __name__ == "__main__": main() ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1569878281.0 PyICU-2.4.2/test/test_Script.py0000644000076500000000000000732200000000000016514 0ustar00vajdawheel00000000000000# ==================================================================== # Copyright (c) 2016-2019 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, six from unittest import TestCase, main from icu import * # python2 can be built with 16- or 32-bit unicode chars (UCS2 or UCS4) # python3 uses 32-bit unicode chars (logically) def is_unicode_32bit(): return len(u'\U0001f600') == 1 class TestScript(TestCase): def testSurrogatePairs(self): pairs = u'a\u0950\u4e2d\U00029efa' unicode_32bit = is_unicode_32bit() names = [Script.getScript(cp).getShortName() for cp in pairs] if unicode_32bit: self.assertEqual(['Latn', 'Deva', 'Hani', 'Hani'], names) else: self.assertTrue( (['Latn', 'Deva', 'Hani', 'Zzzz', 'Zzzz'] == names) or (['Latn', 'Deva', 'Hani', 'Zyyy', 'Zyyy'] == names)) pairs = UnicodeString(pairs) # iterating UChar, not codepoints names = [Script.getScript(c).getShortName() for c in pairs] self.assertTrue( (['Latn', 'Deva', 'Hani', 'Zzzz', 'Zzzz'] == names) or (['Latn', 'Deva', 'Hani', 'Zyyy', 'Zyyy'] == names)) # iterating codepoints not UChar names = [Script.getScript(cp).getShortName() for cp in six.text_type(pairs)] if unicode_32bit: self.assertEqual(['Latn', 'Deva', 'Hani', 'Hani'], names) else: self.assertTrue( (['Latn', 'Deva', 'Hani', 'Zzzz', 'Zzzz'] == names) or (['Latn', 'Deva', 'Hani', 'Zyyy', 'Zyyy'] == names)) # iterating codepoints, not UChar names = [Script.getScript(pairs.char32At(i)).getShortName() for i in range(pairs.countChar32())] self.assertEqual(['Latn', 'Deva', 'Hani', 'Hani'], names) iterator = StringCharacterIterator(pairs) names = [] while iterator.hasNext(): desc = Script.getScript(iterator.next32PostInc()).getShortName() names.append(desc) self.assertEqual(['Latn', 'Deva', 'Hani', 'Hani'], names) def testSmileyFace(self): char = u'\U0001f600' u = UnicodeString(char) self.assertEqual(u.countChar32(), 1) if sys.version_info >= (3,): self.assertEqual(len(char), 1) self.assertEqual(str(u), char) elif is_unicode_32bit(): self.assertEqual(len(char), 1) self.assertEqual(six.text_type(u), char) else: self.assertEqual(len(char), 2) self.assertEqual(six.text_type(u), char) if __name__ == "__main__": main() ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1515082395.0 PyICU-2.4.2/test/test_SimpleFormatter.py0000644000076500000000000000314600000000000020365 0ustar00vajdawheel00000000000000# ==================================================================== # Copyright (c) 2018 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 TestSimpleFormatter(TestCase): def testDefault(self): formatter = SimpleFormatter("{1} '{born}' in {0}") text = formatter %("england", "paul") self.assertTrue(text == u'paul {born} in england') if __name__ == "__main__": if ICU_VERSION >= '57.0': main() ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1515082488.0 PyICU-2.4.2/test/test_Spoof.py0000644000076500000000000001647600000000000016350 0ustar00vajdawheel00000000000000# ==================================================================== # Copyright (c) 2014-2014 Open Source Applications Foundation. # # Permission is hereby granted, free of charge, to any person obtaining a # copy of this software and associated documentation files (the "Software"), # to deal in the Software without restriction, including without limitation # the rights to use, copy, modify, merge, publish, distribute, sublicense, # and/or sell copies of the Software, and to permit persons to whom the # Software is furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included # in all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS # OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING # FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER # DEALINGS IN THE SOFTWARE. # ==================================================================== # import sys, os from unittest import TestCase, main from icu import * class TestSpoofChecker(TestCase): def setUp(self): self.checker = SpoofChecker() def testCheck(self): checks = self.checker.check("xyz") self.assertEqual(checks, 0) def testAreConfusable(self): checks = self.checker.areConfusable("cxs", u"\u0441\u0445\u0455") self.assertEqual(checks, (USpoofChecks.MIXED_SCRIPT_CONFUSABLE | USpoofChecks.WHOLE_SCRIPT_CONFUSABLE)) checks = self.checker.areConfusable( "A long string that will overflow stack buffers. A long string that will overflow stack buffers. A long string that will overflow stack buffers. A long string that will overflow stack buffers. ", "A long string that wi11 overflow stack buffers. A long string that will overflow stack buffers. A long string that wi11 overflow stack buffers. A long string that will overflow stack buffers. ") self.assertEqual(checks, USpoofChecks.SINGLE_SCRIPT_CONFUSABLE) def testGetSkeleton(self): ML = 0 SL = USpoofChecks.SINGLE_SCRIPT_CONFUSABLE MA = USpoofChecks.ANY_CASE SA = USpoofChecks.SINGLE_SCRIPT_CONFUSABLE | USpoofChecks.ANY_CASE def checkSkeleton(checks, string, result): skeleton = self.checker.getSkeleton(checks, string) self.assertEqual(skeleton, result) self.maxDiff = None checkSkeleton(MA, "I1l0O", "lllOO") # A long "identifier" that will overflow implementation stack buffers, # forcing heap allocations. if ICU_VERSION < '60.1': skeleton = u" A long 'identifier' that vvill overflovv irnplernentation stack buffers, forcing heap allocations. A long 'identifier' that vvill overflovv irnplernentation stack buffers, forcing heap allocations. A long 'identifier' that vvill overflovv irnplernentation stack buffers, forcing heap allocations. A long 'identifier' that vvill overflovv irnplernentation stack buffers, forcing heap allocations." else: skeleton = u" A long 'identifier' that will overflow irnplernentation stack buffers, forcing heap allocations. A long 'identifier' that will overflow irnplernentation stack buffers, forcing heap allocations. A long 'identifier' that will overflow irnplernentation stack buffers, forcing heap allocations. A long 'identifier' that will overflow irnplernentation stack buffers, forcing heap allocations." checkSkeleton(SL, u" A 1ong \u02b9identifier' that will overflow implementation stack buffers, forcing heap allocations. A 1ong 'identifier' that will overflow implementation stack buffers, forcing heap allocations. A 1ong 'identifier' that will overflow implementation stack buffers, forcing heap allocations. A 1ong 'identifier' that will overflow implementation stack buffers, forcing heap allocations.", skeleton) checkSkeleton(SL, "nochange", "nochange") checkSkeleton(MA, "love", "love") checkSkeleton(MA, "1ove", "love") # Digit 1 to letter l checkSkeleton(ML, "OOPS", "OOPS") if ICU_VERSION < '55.1': # Digit 0 unchanged in lower case mode. checkSkeleton(ML, "00PS", "00PS") else: checkSkeleton(ML, "00PS", "OOPS") checkSkeleton(MA, "OOPS", "OOPS") checkSkeleton(MA, "00PS", "OOPS") # Digit 0 to letter O in any case mode only checkSkeleton(SL, u"\u059c", u"\u0301") checkSkeleton(SL, u"\u2A74", u"\u003A\u003A\u003D") checkSkeleton(SL, u"\u247E", u"\u0028\u006C\u006C\u0029") # "(ll)" if ICU_VERSION < '55.1': checkSkeleton(SL, u"\uFDFB", u"\u062C\u0644\u0020\u062C\u0644\u0627\u0644\u0647") else: checkSkeleton(SL, u"\uFDFB", u"\u062C\u0644\u0020\u062c\u0644l\u0644o") # This mapping exists in the ML and MA tables, does not exist in SL, SA # 0C83 ; 0C03 ; if ICU_VERSION < '55.1': checkSkeleton(SL, u"\u0C83", u"\u0C83") checkSkeleton(SA, u"\u0C83", u"\u0C83") else: checkSkeleton(SL, u"\u0C83", u"\u0983") checkSkeleton(SA, u"\u0C83", u"\u0983") checkSkeleton(ML, u"\u0C83", u"\u0983") checkSkeleton(MA, u"\u0C83", u"\u0983") # 0391 ; 0041 ; # This mapping exists only in the MA table. checkSkeleton(MA, u"\u0391", "A") if ICU_VERSION < '55.1': checkSkeleton(SA, u"\u0391", u"\u0391") checkSkeleton(ML, u"\u0391", u"\u0391") checkSkeleton(SL, u"\u0391", u"\u0391") else: checkSkeleton(SA, u"\u0391", u'A') checkSkeleton(ML, u"\u0391", u'A') checkSkeleton(SL, u"\u0391", u'A') # 13CF ; 0062 ; # This mapping exists in the ML and MA tables checkSkeleton(ML, u"\u13CF", "b") checkSkeleton(MA, u"\u13CF", "b") if ICU_VERSION < '55.1': checkSkeleton(SL, u"\u13CF", u"\u13CF") checkSkeleton(SA, u"\u13CF", u"\u13CF") else: checkSkeleton(SL, u"\u13CF", u'b') checkSkeleton(SA, u"\u13CF", u'b') # 0022 ; 0027 0027 ; # all tables. checkSkeleton(SL, u"\u0022", u"\u0027\u0027") checkSkeleton(SA, u"\u0022", u"\u0027\u0027") checkSkeleton(ML, u"\u0022", u"\u0027\u0027") checkSkeleton(MA, u"\u0022", u"\u0027\u0027") # 017F ; 0066 ; # This mapping exists in the SA and MA tables checkSkeleton(MA, u"\u017F", "f") checkSkeleton(SA, u"\u017F", "f") def testInvisible(self): checks = self.checker.check(u"abcd\u0301ef") self.assertEqual(checks, 0) checks = self.checker.check(u"abcd\u0301\u0302\u0301ef") self.assertEqual(checks, USpoofChecks.INVISIBLE) # Two acute accents, one from the composed a with acute accent, \u00e1, # and one separate. checks = self.checker.check(u"abcd\u00e1\u0301xyz") self.assertEqual(checks, USpoofChecks.INVISIBLE) if __name__ == "__main__": main() ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1493166223.0 PyICU-2.4.2/test/test_Transliterator.py0000644000076500000000000000716500000000000020272 0ustar00vajdawheel00000000000000# -*- coding: utf-8 -*- # ==================================================================== # Copyright (c) 2009-2015 Open Source Applications Foundation. # # Permission is hereby granted, free of charge, to any person obtaining a # copy of this software and associated documentation files (the "Software"), # to deal in the Software without restriction, including without limitation # the rights to use, copy, modify, merge, publish, distribute, sublicense, # and/or sell copies of the Software, and to permit persons to whom the # Software is furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included # in all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS # OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING # FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER # DEALINGS IN THE SOFTWARE. # ==================================================================== # import sys, os, six from unittest import TestCase, main from icu import * class TestTransliterator(TestCase): def testTransliterate(self): trans = Transliterator.createInstance('Accents-Any') inverse = trans.createInverse() string = u'\xe9v\xe9nement' if ICU_VERSION < '4.0': result = u"e<'>ve<'>nement" else: result = u"e\u2190'\u2192ve\u2190'\u2192nement" self.assertTrue(trans.transliterate(string) == result) self.assertTrue(inverse.transliterate(result) == string) def testUnicodeString(self): trans = Transliterator.createInstance('NumericPinyin-Latin') string = UnicodeString("Shang4hai3 zi4lai2shui3 lai2 zi4 hai3 shang4") result = u'Sh\xe0ngh\u01cei z\xecl\xe1ishu\u01d0 l\xe1i z\xec h\u01cei sh\xe0ng' self.assertTrue(trans.transliterate(six.text_type(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 range(pos.start, pos.limit): if text[i] in u"aeiouüöä": text[i] = _self.char pos.start = pos.limit trans = vowelSubst() # see http://en.wikipedia.org/wiki/Drei_Chinesen_mit_dem_Kontrabass string = u"Drei Chinesen mit dem Kontrabass" result = u'Drii Chinisin mit dim Kintribiss' self.assertTrue(trans.transliterate(string) == result) # test registration Transliterator.registerInstance(trans) regTrans = Transliterator.createInstance("vowel") self.assertTrue(regTrans.transliterate(string) == result) def testPythonTransliteratorException(self): class faultySubst(Transliterator): def __init__(_self): super(faultySubst, _self).__init__("faulty") def handleTransliterate(_self, text, pos, incremental): raise ValueError("faulty") trans = faultySubst() self.assertRaises(ValueError, trans.transliterate, "whatever") if __name__ == "__main__": main() ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1491580779.0 PyICU-2.4.2/test/test_UCS4.py0000644000076500000000000000364500000000000015772 0ustar00vajdawheel00000000000000# ==================================================================== # 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() ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1569864506.0 PyICU-2.4.2/test/test_UCharsTrie.py0000644000076500000000000000521200000000000017255 0ustar00vajdawheel00000000000000# -*- coding: utf-8 -*- # ==================================================================== # Copyright (c) 2019 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, six from unittest import TestCase, main from icu import * class TestUCharsTrie(TestCase): def testBuildAndIterate(self): mappings = { 'ab': 3, 'abc': 6, 'abcd': 2, 'abcef': 11, 'abcp': 88, 'abcqr': 20 } builder = UCharsTrie.Builder() for key, value in mappings.items(): builder.add(key, value) trie = builder.build(UStringTrieBuildOption.FAST) for key, value in trie: self.assertEqual(mappings[key], value) def testAccess(self): mappings = { 'ab': 3, 'abc': 6, 'abcd': 2, 'abcef': 11, 'abcp': 88, 'abcqr': 20 } builder = UCharsTrie.Builder() for key, value in mappings.items(): builder.add(key, value) trie = builder.build(UStringTrieBuildOption.FAST) self.assertEqual((3, 6), (trie.next('abc'), trie.getValue())) state = trie.saveState() self.assertEqual(u'depq', trie.getNextUChars()) self.assertEqual((2, 2), (trie.next('d'), trie.getValue())) self.assertEqual((0, None), (trie.next('e'), trie.getValue())) trie.resetToState(state) self.assertEqual((2, 11), (trie.next('ef'), trie.getValue())) trie.resetToState(state) self.assertEqual((2, 88), (trie.next('p'), trie.getValue())) if __name__ == "__main__": if ICU_VERSION >= '4.8': main() ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1297797374.0 PyICU-2.4.2/test/test_UDate.py0000644000076500000000000000362200000000000016251 0ustar00vajdawheel00000000000000# ==================================================================== # 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() ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1569961646.0 PyICU-2.4.2/transliterator.cpp0000644000076500000000000005721100000000000016443 0ustar00vajdawheel00000000000000/* ==================================================================== * Copyright (c) 2009-2019 Open Source Applications Foundation. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. * ==================================================================== */ #include "common.h" #include "structmember.h" #include "bases.h" #include "transliterator.h" #include "unicodeset.h" #include "macros.h" DECLARE_CONSTANTS_TYPE(UTransDirection); /* UTransPosition */ class t_utransposition : public _wrapper { public: UTransPosition *object; }; static int t_utransposition_init(t_utransposition *self, PyObject *args, PyObject *kwds); static PyMethodDef t_utransposition_methods[] = { { NULL, NULL, 0, NULL } }; static void t_utransposition_dealloc(t_utransposition *self) { if (self->object) { if (self->flags & T_OWNED) delete self->object; self->object = NULL; } Py_TYPE(self)->tp_free((PyObject *) self); } DECLARE_STRUCT(UTransPosition, t_utransposition, UTransPosition, t_utransposition_init, t_utransposition_dealloc); /* Transliterator */ static int t_transliterator_init(t_transliterator *self, PyObject *args, PyObject *kwds); static PyObject *t_transliterator_getMaximumContextLength(t_transliterator *self); static PyObject *t_transliterator_countElements(t_transliterator *self); static PyObject *t_transliterator_getElement(t_transliterator *self, PyObject *arg); static PyObject *t_transliterator_getSourceSet(t_transliterator *self); static PyObject *t_transliterator_getTargetSet(t_transliterator *self); static PyObject *t_transliterator_createInverse(t_transliterator *self); static PyObject *t_transliterator_toRules(t_transliterator *self, PyObject *args); static PyObject *t_transliterator_transliterate(t_transliterator *self, PyObject *args); static PyObject *t_transliterator_finishTransliteration(t_transliterator *self, PyObject *args); static PyObject *t_transliterator_filteredTransliterate(t_transliterator *self, PyObject *args); static PyObject *t_transliterator_getFilter(t_transliterator *self); static PyObject *t_transliterator_orphanFilter(t_transliterator *self); static PyObject *t_transliterator_adoptFilter(t_transliterator *self, PyObject *arg); static PyObject *t_transliterator_getAvailableIDs(PyTypeObject *type); static PyObject *t_transliterator_createInstance(PyTypeObject *type, PyObject *args); static PyObject *t_transliterator_createFromRules(PyTypeObject *type, PyObject *args); static PyObject *t_transliterator_registerInstance(PyTypeObject *type, PyObject *args); static PyMethodDef t_transliterator_methods[] = { DECLARE_METHOD(t_transliterator, transliterate, METH_VARARGS), DECLARE_METHOD(t_transliterator, finishTransliteration, METH_VARARGS), DECLARE_METHOD(t_transliterator, filteredTransliterate, METH_VARARGS), DECLARE_METHOD(t_transliterator, getMaximumContextLength, METH_NOARGS), DECLARE_METHOD(t_transliterator, countElements, METH_NOARGS), DECLARE_METHOD(t_transliterator, getElement, METH_O), DECLARE_METHOD(t_transliterator, getSourceSet, METH_NOARGS), DECLARE_METHOD(t_transliterator, getTargetSet, METH_NOARGS), DECLARE_METHOD(t_transliterator, createInverse, METH_NOARGS), DECLARE_METHOD(t_transliterator, toRules, METH_VARARGS), DECLARE_METHOD(t_transliterator, getFilter, METH_NOARGS), DECLARE_METHOD(t_transliterator, orphanFilter, METH_NOARGS), DECLARE_METHOD(t_transliterator, adoptFilter, METH_O), DECLARE_METHOD(t_transliterator, getAvailableIDs, METH_NOARGS | METH_CLASS), DECLARE_METHOD(t_transliterator, createInstance, METH_VARARGS | METH_CLASS), DECLARE_METHOD(t_transliterator, createFromRules, METH_VARARGS | METH_CLASS), DECLARE_METHOD(t_transliterator, registerInstance, METH_VARARGS | METH_CLASS), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(Transliterator, t_transliterator, UObject, Transliterator, t_transliterator_init, NULL); /* PythonTransliterator */ UOBJECT_DEFINE_RTTI_IMPLEMENTATION(PythonTransliterator); PythonTransliterator::PythonTransliterator(t_transliterator *self, UnicodeString &id) : Transliterator(id, NULL) { this->self = self; Py_XINCREF(this->self); } PythonTransliterator::PythonTransliterator(t_transliterator *self, UnicodeString &id, UnicodeFilter *adoptedFilter) : Transliterator(id, adoptedFilter) { this->self = self; Py_XINCREF(this->self); } /** * Copy constructor. */ PythonTransliterator::PythonTransliterator(const PythonTransliterator& p) : Transliterator(p) { this->self = p.self; Py_XINCREF(this->self); } PythonTransliterator::~PythonTransliterator() { Py_XDECREF(this->self); this->self = NULL; } Transliterator* PythonTransliterator::clone(void) const { return new PythonTransliterator(*this); } void PythonTransliterator::handleTransliterate(Replaceable& text, UTransPosition& pos, UBool incremental) const { if (ISINSTANCE(&text, UnicodeString)) { PyObject *name = PyString_FromString("handleTransliterate"); PyObject *p_text = wrap_UnicodeString((UnicodeString *) &text, 0); PyObject *p_pos = wrap_UTransPosition(&pos, 0); PyObject *result = PyObject_CallMethodObjArgs((PyObject *) self, name, p_text, p_pos, incremental ? Py_True : Py_False, NULL); Py_DECREF(name); Py_DECREF(p_text); Py_DECREF(p_pos); Py_XDECREF(result); } } /* UTransPosition */ static int t_utransposition_init(t_utransposition *self, PyObject *args, PyObject *kwds) { static const char *kwnames[] = { "contextStart", "contextLimit", "start", "limit", NULL }; int contextStart = 0, contextLimit = 0, start = 0, limit = 0; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|iiii", (char **) kwnames, &contextStart, &contextLimit, &start, &limit)) return -1; self->object = new UTransPosition(); if (!self->object) { PyErr_NoMemory(); return -1; } self->object->contextStart = contextStart; self->object->contextLimit = contextLimit; self->object->start = start; self->object->limit = limit; self->flags = T_OWNED; return 0; } static int t_utransposition_setter(int32_t *slot, PyObject *value) { int32_t n; if (value == NULL) { PyErr_SetString(PyExc_TypeError, "Cannot delete attribute"); return -1; } n = (int32_t) PyInt_AsLong(value); if (PyErr_Occurred()) return -1; *slot = n; return 0; } static PyObject *t_utransposition_getContextLimit(t_utransposition *self, void *closure) { return PyInt_FromLong(self->object->contextLimit); } static int t_utransposition_setContextLimit(t_utransposition *self, PyObject *value, void *closure) { return t_utransposition_setter(&self->object->contextLimit, value); } static PyObject *t_utransposition_getContextStart(t_utransposition *self, void *closure) { return PyInt_FromLong(self->object->contextStart); } static int t_utransposition_setContextStart(t_utransposition *self, PyObject *value, void *closure) { return t_utransposition_setter(&self->object->contextStart, value); } static PyObject *t_utransposition_getLimit(t_utransposition *self, void *closure) { return PyInt_FromLong(self->object->limit); } static int t_utransposition_setLimit(t_utransposition *self, PyObject *value, void *closure) { return t_utransposition_setter(&self->object->limit, value); } static PyObject *t_utransposition_getStart(t_utransposition *self, void *closure) { return PyInt_FromLong(self->object->start); } static int t_utransposition_setStart(t_utransposition *self, PyObject *value, void *closure) { return t_utransposition_setter(&self->object->start, value); } static PyGetSetDef t_utransposition_properties[] = { {(char *) "contextLimit", (getter) t_utransposition_getContextLimit, (setter) t_utransposition_setContextLimit, (char *) "Ending index, exclusive, of the context to be considered for a transliteration operation.", NULL}, {(char *) "contextStart", (getter) t_utransposition_getContextStart, (setter) t_utransposition_setContextStart, (char *) "Beginning index, inclusive, of the context to be considered for a transliteration operation.", NULL}, {(char *) "limit", (getter) t_utransposition_getLimit, (setter) t_utransposition_setLimit, (char *) "Ending index, exclusive, of the text to be transliterated.", NULL}, {(char *) "start", (getter) t_utransposition_getStart, (setter) t_utransposition_setStart, (char *) "Beginning index, inclusive, of the text to be transliterated.", NULL}, {NULL} /* Sentinel */ }; /* Transliterator */ static int t_transliterator_init(t_transliterator *self, PyObject *args, PyObject *kwds) { UnicodeString *u, _u; UnicodeFilter *adoptedFilter; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "S", &u, &_u)) { self->object = new PythonTransliterator(self, *u); self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; case 2: if (!parseArgs(args, "SP", &u, &_u, TYPE_CLASSID(UnicodeFilter), &adoptedFilter)) { self->object = new PythonTransliterator(self, *u, (UnicodeFilter *) adoptedFilter->clone()); self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; default: PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; } if (self->object) return 0; return -1; } PyObject *wrap_Transliterator(Transliterator *transliterator) { return wrap_Transliterator(transliterator, T_OWNED); } PyObject *wrap_Transliterator(const Transliterator &transliterator) { return wrap_Transliterator(transliterator.clone(), T_OWNED); } static PyObject *t_transliterator_toRules(t_transliterator *self, PyObject *args) { UnicodeString u; int b = 0; switch (PyTuple_Size(args)) { case 0: PYTHON_CALL(self->object->toRules(u, 0)); return PyUnicode_FromUnicodeString(&u); case 1: if (!parseArgs(args, "b", &b)) { PYTHON_CALL(self->object->toRules(u, b)); return PyUnicode_FromUnicodeString(&u); } break; } return PyErr_SetArgsError((PyObject *) self, "toRules", args); } static PyObject *t_transliterator_transliterate(t_transliterator *self, PyObject *args) { UnicodeString *u0, _u0; UnicodeString *u1, _u1; t_utransposition *utransposition; int32_t start, limit, len; PythonReplaceable *rep; 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); } if (!parseArgs(args, "P", TYPE_CLASSID(PythonReplaceable), &rep)) { PYTHON_CALL(self->object->transliterate(*rep)); Py_RETURN_ARG(args, 0); } 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); } if (!parseArgs(args, "PO", TYPE_CLASSID(PythonReplaceable), &UTransPositionType_, &rep, &utransposition)) { STATUS_PYTHON_CALL(self->object->transliterate(*rep, *utransposition->object, status)); Py_RETURN_ARG(args, 0); } 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, "Pii", TYPE_CLASSID(PythonReplaceable), &rep, &start, &limit)) { PYTHON_CALL(limit = self->object->transliterate(*rep, start, limit)); return PyInt_FromLong(limit); } 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); } if (!parseArgs(args, "POS", TYPE_CLASSID(PythonReplaceable), &UTransPositionType_, &rep, &utransposition, &u1, &_u1)) { STATUS_CALL(len = toUChar32(*u1, &c, status)); if (len == 1) { STATUS_PYTHON_CALL(self->object->transliterate(*rep, *utransposition->object, c, status)); } else { STATUS_PYTHON_CALL(self->object->transliterate(*rep, *utransposition->object, _u1, status)); } Py_RETURN_ARG(args, 0); } break; } return PyErr_SetArgsError((PyObject *) self, "transliterate", args); } static PyObject *t_transliterator_finishTransliteration(t_transliterator *self, PyObject *args) { UnicodeString *u, _u; t_utransposition *utransposition; PythonReplaceable *rep; 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); } if (!parseArgs(args, "PO", TYPE_CLASSID(PythonReplaceable), &UTransPositionType_, &rep, &utransposition)) { self->object->finishTransliteration(*rep, *utransposition->object); Py_RETURN_ARG(args, 0); } 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; PythonReplaceable *rep; 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); } if (!parseArgs(args, "POB", TYPE_CLASSID(PythonReplaceable), &UTransPositionType_, &rep, &utransposition, &incremental)) { self->object->filteredTransliterate(*rep, *utransposition->object, incremental); Py_RETURN_ARG(args, 0); } 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 = (int32_t) PyInt_AsLong(arg); const Transliterator *transliterator; if (PyErr_Occurred()) return NULL; STATUS_CALL(transliterator = &self->object->getElement(i, status)); return wrap_Transliterator(*transliterator); } static PyObject *t_transliterator_getSourceSet(t_transliterator *self) { UnicodeSet set; self->object->getSourceSet(set); return wrap_UnicodeSet(new UnicodeSet(set), T_OWNED); } static PyObject *t_transliterator_getTargetSet(t_transliterator *self) { UnicodeSet set; self->object->getTargetSet(set); return wrap_UnicodeSet(new UnicodeSet(set), T_OWNED); } static PyObject *t_transliterator_createInverse(t_transliterator *self) { Transliterator *transliterator; STATUS_CALL(transliterator = self->object->createInverse(status)); return wrap_Transliterator(transliterator); } static PyObject *t_transliterator_getFilter(t_transliterator *self) { const UnicodeFilter *filter = self->object->getFilter(); if (filter == NULL) Py_RETURN_NONE; return wrap_UnicodeFilter((UnicodeFilter *) filter->clone(), T_OWNED); } static PyObject *t_transliterator_orphanFilter(t_transliterator *self) { UnicodeFilter *filter = self->object->orphanFilter(); if (filter == NULL) Py_RETURN_NONE; return wrap_UnicodeFilter(filter, T_OWNED); } static PyObject *t_transliterator_adoptFilter(t_transliterator *self, PyObject *arg) { UnicodeFilter *filter; if (arg == Py_None) self->object->adoptFilter(NULL); else if (!parseArg(arg, "P", TYPE_CLASSID(UnicodeFilter), &filter)) self->object->adoptFilter((UnicodeFilter *) filter->clone()); else return PyErr_SetArgsError((PyObject *) self, "adoptFilter", arg); Py_RETURN_NONE; } static PyObject *t_transliterator_getAvailableIDs(PyTypeObject *type) { StringEnumeration *se; STATUS_CALL(se = Transliterator::getAvailableIDs(status)); return wrap_StringEnumeration(se, T_OWNED); } static PyObject *t_transliterator_createInstance(PyTypeObject *type, PyObject *args) { Transliterator *transliterator; UnicodeString *u, _u; UTransDirection direction = UTRANS_FORWARD; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "S", &u, &_u)) { STATUS_CALL(transliterator = Transliterator::createInstance( *u, direction, status)); return wrap_Transliterator(transliterator); } break; case 2: if (!parseArgs(args, "Si", &u, &_u, &direction)) { STATUS_CALL(transliterator = Transliterator::createInstance( *u, direction, status)); return wrap_Transliterator(transliterator); } break; } return PyErr_SetArgsError(type, "createInstance", args); } static PyObject *t_transliterator_createFromRules(PyTypeObject *type, PyObject *args) { Transliterator *transliterator; UnicodeString *u0, _u0; UnicodeString *u1, _u1; UTransDirection direction = UTRANS_FORWARD; switch (PyTuple_Size(args)) { case 2: if (!parseArgs(args, "SS", &u0, &_u0, &u1, &_u1)) { STATUS_PARSER_CALL(transliterator = Transliterator::createFromRules( *u0, *u1, direction, parseError, status)); return wrap_Transliterator(transliterator); } break; case 3: if (!parseArgs(args, "SSi", &u0, &_u0, &u1, &_u1, &direction)) { STATUS_PARSER_CALL(transliterator = Transliterator::createFromRules( *u0, *u1, direction, parseError, status)); return wrap_Transliterator(transliterator); } break; } return PyErr_SetArgsError(type, "createFromRules", args); } static PyObject *t_transliterator_registerInstance(PyTypeObject *type, PyObject *args) { Transliterator *transliterator; if (!parseArgs(args, "P", TYPE_CLASSID(Transliterator), &transliterator)) { Transliterator::registerInstance(transliterator->clone()); 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); } ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1285690129.0 PyICU-2.4.2/transliterator.h0000644000076500000000000000537000000000000016107 0ustar00vajdawheel00000000000000/* ==================================================================== * 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 */ ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1569804118.0 PyICU-2.4.2/tries.cpp0000644000076500000000000006210300000000000014510 0ustar00vajdawheel00000000000000/* ==================================================================== * Copyright (c) 2019 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 "tries.h" #include "macros.h" #if U_ICU_VERSION_HEX >= 0x04080000 using BytesTrieIterator = BytesTrie::Iterator; using BytesTrieState = BytesTrie::State; using UCharsTrieIterator = UCharsTrie::Iterator; using UCharsTrieState = UCharsTrie::State; DECLARE_CONSTANTS_TYPE(UStringTrieBuildOption); DECLARE_CONSTANTS_TYPE(UStringTrieResult); /* StringTrieBuilder */ class t_stringtriebuilder : public _wrapper { public: StringTrieBuilder *object; }; static PyMethodDef t_stringtriebuilder_methods[] = { { NULL, NULL, 0, NULL } }; DECLARE_TYPE(StringTrieBuilder, t_stringtriebuilder, UObject, StringTrieBuilder, abstract_init, NULL); /* BytesTrieBuilder */ class t_bytestriebuilder : public _wrapper { public: BytesTrieBuilder *object; }; static int t_bytestriebuilder_init( t_bytestriebuilder *self, PyObject *args, PyObject *kwds); static PyObject *t_bytestriebuilder_add( t_bytestriebuilder *self, PyObject *args); static PyObject *t_bytestriebuilder_clear(t_bytestriebuilder *self); static PyObject *t_bytestriebuilder_build( t_bytestriebuilder *self, PyObject *arg); static PyMethodDef t_bytestriebuilder_methods[] = { DECLARE_METHOD(t_bytestriebuilder, add, METH_VARARGS), DECLARE_METHOD(t_bytestriebuilder, clear, METH_NOARGS), DECLARE_METHOD(t_bytestriebuilder, build, METH_O), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(BytesTrieBuilder, t_bytestriebuilder, StringTrieBuilder, BytesTrieBuilder, t_bytestriebuilder_init, NULL); /* BytesTrieIterator */ class t_bytestrieiterator : public _wrapper { public: BytesTrieIterator *object; }; int t_bytestrieiterator_init( t_bytestrieiterator *self, PyObject *args, PyObject *kwds); static PyObject *t_bytestrieiterator_reset(t_bytestrieiterator *self); static PyObject *t_bytestrieiterator_hasNext(t_bytestrieiterator *self); static PyObject *t_bytestrieiterator_next(t_bytestrieiterator *self); static PyObject *t_bytestrieiterator_getString(t_bytestrieiterator *self); static PyObject *t_bytestrieiterator_getValue(t_bytestrieiterator *self); static PyMethodDef t_bytestrieiterator_methods[] = { DECLARE_METHOD(t_bytestrieiterator, reset, METH_NOARGS), DECLARE_METHOD(t_bytestrieiterator, hasNext, METH_NOARGS), DECLARE_METHOD(t_bytestrieiterator, next, METH_NOARGS), DECLARE_METHOD(t_bytestrieiterator, getString, METH_NOARGS), DECLARE_METHOD(t_bytestrieiterator, getValue, METH_NOARGS), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(BytesTrieIterator, t_bytestrieiterator, UMemory, BytesTrieIterator, t_bytestrieiterator_init, NULL); /* BytesTrieState */ class t_bytestriestate : public _wrapper { public: BytesTrieState *object; }; static PyMethodDef t_bytestriestate_methods[] = { { NULL, NULL, 0, NULL } }; DECLARE_TYPE(BytesTrieState, t_bytestriestate, UMemory, BytesTrieState, abstract_init, NULL); /* BytesTrie */ class t_bytestrie : public _wrapper { public: BytesTrie *object; }; static PyObject *t_bytestrie_reset(t_bytestrie *self); static PyObject *t_bytestrie_saveState(t_bytestrie *self); static PyObject *t_bytestrie_resetToState(t_bytestrie *self, PyObject *arg); static PyObject *t_bytestrie_current(t_bytestrie *self); static PyObject *t_bytestrie_first(t_bytestrie *self, PyObject *arg); static PyObject *t_bytestrie_next(t_bytestrie *self, PyObject *arg); static PyObject *t_bytestrie_hasUniqueValue(t_bytestrie *self); static PyObject *t_bytestrie_getNextBytes(t_bytestrie *self); static PyObject *t_bytestrie_getValue(t_bytestrie *self); static PyMethodDef t_bytestrie_methods[] = { DECLARE_METHOD(t_bytestrie, reset, METH_NOARGS), DECLARE_METHOD(t_bytestrie, saveState, METH_NOARGS), DECLARE_METHOD(t_bytestrie, resetToState, METH_O), DECLARE_METHOD(t_bytestrie, current, METH_NOARGS), DECLARE_METHOD(t_bytestrie, first, METH_O), DECLARE_METHOD(t_bytestrie, next, METH_O), DECLARE_METHOD(t_bytestrie, hasUniqueValue, METH_NOARGS), DECLARE_METHOD(t_bytestrie, getNextBytes, METH_NOARGS), DECLARE_METHOD(t_bytestrie, getValue, METH_NOARGS), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(BytesTrie, t_bytestrie, UMemory, BytesTrie, abstract_init, NULL); /* UCharsTrieBuilder */ class t_ucharstriebuilder : public _wrapper { public: UCharsTrieBuilder *object; }; static int t_ucharstriebuilder_init( t_ucharstriebuilder *self, PyObject *args, PyObject *kwds); static PyObject *t_ucharstriebuilder_add( t_ucharstriebuilder *self, PyObject *args); static PyObject *t_ucharstriebuilder_clear(t_ucharstriebuilder *self); static PyObject *t_ucharstriebuilder_build( t_ucharstriebuilder *self, PyObject *arg); static PyMethodDef t_ucharstriebuilder_methods[] = { DECLARE_METHOD(t_ucharstriebuilder, add, METH_VARARGS), DECLARE_METHOD(t_ucharstriebuilder, clear, METH_NOARGS), DECLARE_METHOD(t_ucharstriebuilder, build, METH_O), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(UCharsTrieBuilder, t_ucharstriebuilder, StringTrieBuilder, UCharsTrieBuilder, t_ucharstriebuilder_init, NULL); /* UCharsTrieIterator */ class t_ucharstrieiterator : public _wrapper { public: UCharsTrieIterator *object; }; int t_ucharstrieiterator_init( t_ucharstrieiterator *self, PyObject *args, PyObject *kwds); static PyObject *t_ucharstrieiterator_reset(t_ucharstrieiterator *self); static PyObject *t_ucharstrieiterator_hasNext(t_ucharstrieiterator *self); static PyObject *t_ucharstrieiterator_next(t_ucharstrieiterator *self); static PyObject *t_ucharstrieiterator_getString(t_ucharstrieiterator *self); static PyObject *t_ucharstrieiterator_getValue(t_ucharstrieiterator *self); static PyMethodDef t_ucharstrieiterator_methods[] = { DECLARE_METHOD(t_ucharstrieiterator, reset, METH_NOARGS), DECLARE_METHOD(t_ucharstrieiterator, hasNext, METH_NOARGS), DECLARE_METHOD(t_ucharstrieiterator, next, METH_NOARGS), DECLARE_METHOD(t_ucharstrieiterator, getString, METH_NOARGS), DECLARE_METHOD(t_ucharstrieiterator, getValue, METH_NOARGS), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(UCharsTrieIterator, t_ucharstrieiterator, UMemory, UCharsTrieIterator, t_ucharstrieiterator_init, NULL); /* UCharsTrieState */ class t_ucharstriestate : public _wrapper { public: UCharsTrieState *object; }; static PyMethodDef t_ucharstriestate_methods[] = { { NULL, NULL, 0, NULL } }; DECLARE_TYPE(UCharsTrieState, t_ucharstriestate, UMemory, UCharsTrieState, abstract_init, NULL); /* UCharsTrie */ class t_ucharstrie : public _wrapper { public: UCharsTrie *object; }; static PyObject *t_ucharstrie_reset(t_ucharstrie *self); static PyObject *t_ucharstrie_saveState(t_ucharstrie *self); static PyObject *t_ucharstrie_resetToState(t_ucharstrie *self, PyObject *arg); static PyObject *t_ucharstrie_current(t_ucharstrie *self); static PyObject *t_ucharstrie_first(t_ucharstrie *self, PyObject *arg); static PyObject *t_ucharstrie_firstForCodePoint(t_ucharstrie *self, PyObject *arg); static PyObject *t_ucharstrie_next(t_ucharstrie *self, PyObject *arg); static PyObject *t_ucharstrie_nextForCodePoint(t_ucharstrie *self, PyObject *arg); static PyObject *t_ucharstrie_hasUniqueValue(t_ucharstrie *self); static PyObject *t_ucharstrie_getNextUChars(t_ucharstrie *self); static PyObject *t_ucharstrie_getValue(t_ucharstrie *self); static PyMethodDef t_ucharstrie_methods[] = { DECLARE_METHOD(t_ucharstrie, reset, METH_NOARGS), DECLARE_METHOD(t_ucharstrie, saveState, METH_NOARGS), DECLARE_METHOD(t_ucharstrie, resetToState, METH_O), DECLARE_METHOD(t_ucharstrie, current, METH_NOARGS), DECLARE_METHOD(t_ucharstrie, first, METH_O), DECLARE_METHOD(t_ucharstrie, firstForCodePoint, METH_O), DECLARE_METHOD(t_ucharstrie, next, METH_O), DECLARE_METHOD(t_ucharstrie, nextForCodePoint, METH_O), DECLARE_METHOD(t_ucharstrie, hasUniqueValue, METH_NOARGS), DECLARE_METHOD(t_ucharstrie, getNextUChars, METH_NOARGS), DECLARE_METHOD(t_ucharstrie, getValue, METH_NOARGS), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(UCharsTrie, t_ucharstrie, UMemory, UCharsTrie, abstract_init, NULL); /* BytesTrieBuilder */ static int t_bytestriebuilder_init(t_bytestriebuilder *self, PyObject *args, PyObject *kwds) { BytesTrieBuilder *builder; switch (PyTuple_Size(args)) { case 0: INT_STATUS_CALL(builder = new BytesTrieBuilder(status)); self->object = builder; self->flags = T_OWNED; break; default: PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; } if (self->object) return 0; return -1; } static PyObject *t_bytestriebuilder_add( t_bytestriebuilder *self, PyObject *args) { charsArg key; int value; if (!parseArgs(args, "ni", &key, &value)) { STATUS_CALL(self->object->add(key.c_str(), value, status)); Py_RETURN_SELF(); } return PyErr_SetArgsError((PyObject *) self, "add", args); } static PyObject *t_bytestriebuilder_clear(t_bytestriebuilder *self) { self->object->clear(); Py_RETURN_SELF(); } static PyObject *t_bytestriebuilder_build( t_bytestriebuilder *self, PyObject *arg) { int option; if (!parseArg(arg, "i", &option)) { BytesTrie *trie; STATUS_CALL(trie = self->object->build( (UStringTrieBuildOption) option, status)); self->object->clear(); // builder data is now owned by trie return wrap_BytesTrie(trie, T_OWNED); } return PyErr_SetArgsError((PyObject *) self, "build", arg); } /* BytesTrie */ static PyObject *t_bytestrie_reset(t_bytestrie *self) { self->object->reset(); Py_RETURN_SELF(); } static PyObject *t_bytestrie_saveState(t_bytestrie *self) { BytesTrieState state; self->object->saveState(state); return wrap_BytesTrieState(new BytesTrieState(state), T_OWNED); } static PyObject *t_bytestrie_resetToState(t_bytestrie *self, PyObject *arg) { PyObject *state; if (!parseArg(arg, "O", &BytesTrieStateType_, &state)) { self->object->resetToState(*((t_bytestriestate *) state)->object); Py_RETURN_SELF(); } return PyErr_SetArgsError((PyObject *) self, "resetToState", arg); } static PyObject *t_bytestrie_iter(t_bytestrie *self) { BytesTrieIterator *iter; STATUS_CALL(iter = new BytesTrieIterator(*self->object, 0, status)); return wrap_BytesTrieIterator(iter, T_OWNED); } static PyObject *t_bytestrie_current(t_bytestrie *self) { return PyInt_FromLong(self->object->current()); } static PyObject *t_bytestrie_first(t_bytestrie *self, PyObject *arg) { int b; charsArg s; if (!parseArg(arg, "i", &b)) return PyInt_FromLong(self->object->first(b)); if (!parseArg(arg, "n", &s) && s.size() == 1) return PyInt_FromLong(self->object->first(s.c_str()[0])); return PyErr_SetArgsError((PyObject *) self, "first", arg); } static PyObject *t_bytestrie_next(t_bytestrie *self, PyObject *arg) { int b; charsArg s; if (!parseArg(arg, "i", &b)) return PyInt_FromLong(self->object->next(b)); if (!parseArg(arg, "n", &s)) return PyInt_FromLong(self->object->next(s.c_str(), s.size())); return PyErr_SetArgsError((PyObject *) self, "next", arg); } static PyObject *t_bytestrie_hasUniqueValue(t_bytestrie *self) { int result; if (self->object->hasUniqueValue(result)) return PyInt_FromLong(result); Py_RETURN_NONE; } static PyObject *t_bytestrie_getNextBytes(t_bytestrie *self) { struct sink { PyObject *bytes = PyBytes_FromStringAndSize("", 0); void append(const char *data, int32_t n) { PyBytes_ConcatAndDel(&bytes, PyBytes_FromStringAndSize(data, n)); } } buffer; StringByteSink sbs(&buffer); self->object->getNextBytes(sbs); return buffer.bytes; } static PyObject *t_bytestrie_getValue(t_bytestrie *self) { if (USTRINGTRIE_HAS_VALUE(self->object->current())) return PyInt_FromLong(self->object->getValue()); Py_RETURN_NONE; } /* BytesTrieIterator */ int t_bytestrieiterator_init(t_bytestrieiterator *self, PyObject *args, PyObject *kwds) { BytesTrieIterator *iterator; PyObject *trie; int len; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "O", &BytesTrieType_, &trie)) { INT_STATUS_CALL(iterator = new BytesTrieIterator( *((t_bytestrie *) trie)->object, 0, status)); self->object = iterator; self->flags = T_OWNED; } else PyErr_SetArgsError((PyObject *) self, "__init__", args); break; case 2: if (!parseArgs(args, "Oi", &BytesTrieType_, &trie, &len)) { INT_STATUS_CALL(iterator = new BytesTrieIterator( *((t_bytestrie *) trie)->object, len, status)); self->object = iterator; self->flags = T_OWNED; } else PyErr_SetArgsError((PyObject *) self, "__init__", args); break; default: PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; } if (self->object) return 0; return -1; } static PyObject *t_bytestrieiterator_reset(t_bytestrieiterator *self) { self->object->reset(); Py_RETURN_SELF(); } static PyObject *t_bytestrieiterator_hasNext(t_bytestrieiterator *self) { if (self->object->hasNext()) Py_RETURN_TRUE; Py_RETURN_FALSE; } static PyObject *t_bytestrieiterator_next(t_bytestrieiterator *self) { UBool result; STATUS_CALL(result = self->object->next(status)); Py_RETURN_BOOL(result); } static PyObject *t_bytestrieiterator_getString(t_bytestrieiterator *self) { StringPiece key = self->object->getString(); return PyString_FromStringAndSize(key.data(), key.size()); } static PyObject *t_bytestrieiterator_getValue(t_bytestrieiterator *self) { return PyInt_FromLong(self->object->getValue()); } static PyObject *t_bytestrieiterator_iter(t_bytestrieiterator *self) { Py_RETURN_SELF(); } static PyObject *t_bytestrieiterator_iter_next(t_bytestrieiterator *self) { UBool found; STATUS_CALL(found = self->object->next(status)); if (!found) { PyErr_SetNone(PyExc_StopIteration); return NULL; } PyObject *result = PyTuple_New(2); StringPiece key = self->object->getString(); PyTuple_SET_ITEM(result, 0, PyString_FromStringAndSize( key.data(), key.size())); PyTuple_SET_ITEM(result, 1, PyInt_FromLong(self->object->getValue())); return result; } /* UCharsTrieBuilder */ static int t_ucharstriebuilder_init(t_ucharstriebuilder *self, PyObject *args, PyObject *kwds) { UCharsTrieBuilder *builder; switch (PyTuple_Size(args)) { case 0: INT_STATUS_CALL(builder = new UCharsTrieBuilder(status)); self->object = builder; self->flags = T_OWNED; break; default: PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; } if (self->object) return 0; return -1; } static PyObject *t_ucharstriebuilder_add( t_ucharstriebuilder *self, PyObject *args) { UnicodeString *u, _u; int value; if (!parseArgs(args, "Si", &u, &_u, &value)) { STATUS_CALL(self->object->add(*u, value, status)); Py_RETURN_SELF(); } return PyErr_SetArgsError((PyObject *) self, "add", args); } static PyObject *t_ucharstriebuilder_clear(t_ucharstriebuilder *self) { self->object->clear(); Py_RETURN_SELF(); } static PyObject *t_ucharstriebuilder_build( t_ucharstriebuilder *self, PyObject *arg) { int option; if (!parseArg(arg, "i", &option)) { UCharsTrie *trie; STATUS_CALL(trie = self->object->build( (UStringTrieBuildOption) option, status)); self->object->clear(); // builder data is now owned by trie return wrap_UCharsTrie(trie, T_OWNED); } return PyErr_SetArgsError((PyObject *) self, "build", arg); } /* UCharsTrie */ static PyObject *t_ucharstrie_reset(t_ucharstrie *self) { self->object->reset(); Py_RETURN_SELF(); } static PyObject *t_ucharstrie_saveState(t_ucharstrie *self) { UCharsTrieState state; self->object->saveState(state); return wrap_UCharsTrieState(new UCharsTrieState(state), T_OWNED); } static PyObject *t_ucharstrie_resetToState(t_ucharstrie *self, PyObject *arg) { PyObject *state; if (!parseArg(arg, "O", &UCharsTrieStateType_, &state)) { self->object->resetToState(*((t_ucharstriestate *) state)->object); Py_RETURN_SELF(); } return PyErr_SetArgsError((PyObject *) self, "resetToState", arg); } static PyObject *t_ucharstrie_iter(t_ucharstrie *self) { UCharsTrieIterator *iter; STATUS_CALL(iter = new UCharsTrieIterator(*self->object, 0, status)); return wrap_UCharsTrieIterator(iter, T_OWNED); } static PyObject *t_ucharstrie_current(t_ucharstrie *self) { return PyInt_FromLong(self->object->current()); } static PyObject *t_ucharstrie_first(t_ucharstrie *self, PyObject *arg) { int b; UnicodeString *u, _u; if (!parseArg(arg, "i", &b)) return PyInt_FromLong(self->object->first(b)); if (!parseArg(arg, "S", &u, &_u) && u->length() == 1) return PyInt_FromLong(self->object->first(u->charAt(0))); return PyErr_SetArgsError((PyObject *) self, "first", arg); } static PyObject *t_ucharstrie_firstForCodePoint( t_ucharstrie *self, PyObject *arg) { int b; UnicodeString *u, _u; if (!parseArg(arg, "i", &b)) return PyInt_FromLong(self->object->firstForCodePoint(b)); if (!parseArg(arg, "S", &u, &_u) && u->countChar32() == 1) return PyInt_FromLong(self->object->firstForCodePoint(u->char32At(0))); return PyErr_SetArgsError((PyObject *) self, "firstForCodePoint", arg); } static PyObject *t_ucharstrie_next(t_ucharstrie *self, PyObject *arg) { int b; UnicodeString *u, _u; if (!parseArg(arg, "i", &b)) return PyInt_FromLong(self->object->next(b)); if (!parseArg(arg, "S", &u, &_u)) return PyInt_FromLong(self->object->next(u->getBuffer(), u->length())); return PyErr_SetArgsError((PyObject *) self, "next", arg); } static PyObject *t_ucharstrie_nextForCodePoint( t_ucharstrie *self, PyObject *arg) { int b; UnicodeString *u, _u; if (!parseArg(arg, "i", &b)) return PyInt_FromLong(self->object->nextForCodePoint(b)); if (!parseArg(arg, "S", &u, &_u) && u->countChar32() == 1) return PyInt_FromLong(self->object->next(u->char32At(0))); return PyErr_SetArgsError((PyObject *) self, "nextForCodePoint", arg); } static PyObject *t_ucharstrie_hasUniqueValue(t_ucharstrie *self) { int result; if (self->object->hasUniqueValue(result)) return PyInt_FromLong(result); Py_RETURN_NONE; } static PyObject *t_ucharstrie_getNextUChars(t_ucharstrie *self) { UnicodeString u; UnicodeStringAppendable a(u); self->object->getNextUChars(a); return PyUnicode_FromUnicodeString(&u); } static PyObject *t_ucharstrie_getValue(t_ucharstrie *self) { if (USTRINGTRIE_HAS_VALUE(self->object->current())) return PyInt_FromLong(self->object->getValue()); Py_RETURN_NONE; } /* UCharsTrieIterator */ int t_ucharstrieiterator_init(t_ucharstrieiterator *self, PyObject *args, PyObject *kwds) { UCharsTrieIterator *iterator; PyObject *trie; int len; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "O", &UCharsTrieType_, &trie)) { INT_STATUS_CALL(iterator = new UCharsTrieIterator( *((t_ucharstrie *) trie)->object, 0, status)); self->object = iterator; self->flags = T_OWNED; } else PyErr_SetArgsError((PyObject *) self, "__init__", args); break; case 2: if (!parseArgs(args, "Oi", &UCharsTrieType_, &trie, &len)) { INT_STATUS_CALL(iterator = new UCharsTrieIterator( *((t_ucharstrie *) trie)->object, len, status)); self->object = iterator; self->flags = T_OWNED; } else PyErr_SetArgsError((PyObject *) self, "__init__", args); break; default: PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; } if (self->object) return 0; return -1; } static PyObject *t_ucharstrieiterator_reset(t_ucharstrieiterator *self) { self->object->reset(); Py_RETURN_SELF(); } static PyObject *t_ucharstrieiterator_hasNext(t_ucharstrieiterator *self) { if (self->object->hasNext()) Py_RETURN_TRUE; Py_RETURN_FALSE; } static PyObject *t_ucharstrieiterator_next(t_ucharstrieiterator *self) { UBool result; STATUS_CALL(result = self->object->next(status)); Py_RETURN_BOOL(result); } static PyObject *t_ucharstrieiterator_getString(t_ucharstrieiterator *self) { const UnicodeString &u = self->object->getString(); return PyUnicode_FromUnicodeString(&u); } static PyObject *t_ucharstrieiterator_getValue(t_ucharstrieiterator *self) { return PyInt_FromLong(self->object->getValue()); } static PyObject *t_ucharstrieiterator_iter(t_ucharstrieiterator *self) { Py_RETURN_SELF(); } static PyObject *t_ucharstrieiterator_iter_next(t_ucharstrieiterator *self) { UBool found; STATUS_CALL(found = self->object->next(status)); if (!found) { PyErr_SetNone(PyExc_StopIteration); return NULL; } PyObject *result = PyTuple_New(2); const UnicodeString &u = self->object->getString(); PyTuple_SET_ITEM(result, 0, PyUnicode_FromUnicodeString(&u)); PyTuple_SET_ITEM(result, 1, PyInt_FromLong(self->object->getValue())); return result; } #endif void _init_tries(PyObject *m) { #if U_ICU_VERSION_HEX >= 0x04080000 BytesTrieType_.tp_iter = (getiterfunc) t_bytestrie_iter; BytesTrieIteratorType_.tp_iter = (getiterfunc) t_bytestrieiterator_iter; BytesTrieIteratorType_.tp_iternext = (iternextfunc) t_bytestrieiterator_iter_next; UCharsTrieType_.tp_iter = (getiterfunc) t_ucharstrie_iter; UCharsTrieIteratorType_.tp_iter = (getiterfunc) t_ucharstrieiterator_iter; UCharsTrieIteratorType_.tp_iternext = (iternextfunc) t_ucharstrieiterator_iter_next; INSTALL_CONSTANTS_TYPE(UStringTrieBuildOption, m); INSTALL_CONSTANTS_TYPE(UStringTrieResult, m); REGISTER_TYPE(StringTrieBuilder, m); REGISTER_TYPE(BytesTrieBuilder, m); INSTALL_STRUCT(BytesTrieIterator, m); INSTALL_STRUCT(BytesTrieState, m); INSTALL_STRUCT(BytesTrie, m); REGISTER_TYPE(UCharsTrieBuilder, m); INSTALL_STRUCT(UCharsTrieIterator, m); INSTALL_STRUCT(UCharsTrieState, m); INSTALL_STRUCT(UCharsTrie, m); PyDict_SetItemString(BytesTrieType_.tp_dict, "Builder", (PyObject *) &BytesTrieBuilderType_); PyDict_SetItemString(BytesTrieType_.tp_dict, "Iterator", (PyObject *) &BytesTrieIteratorType_); PyDict_SetItemString(BytesTrieType_.tp_dict, "State", (PyObject *) &BytesTrieStateType_); PyDict_SetItemString(UCharsTrieType_.tp_dict, "Builder", (PyObject *) &UCharsTrieBuilderType_); PyDict_SetItemString(UCharsTrieType_.tp_dict, "Iterator", (PyObject *) &UCharsTrieIteratorType_); PyDict_SetItemString(UCharsTrieType_.tp_dict, "State", (PyObject *) &UCharsTrieStateType_); INSTALL_ENUM(UStringTrieBuildOption, "FAST", USTRINGTRIE_BUILD_FAST); INSTALL_ENUM(UStringTrieBuildOption, "SMALL", USTRINGTRIE_BUILD_SMALL); INSTALL_ENUM(UStringTrieResult, "NO_MATCH", USTRINGTRIE_NO_MATCH); INSTALL_ENUM(UStringTrieResult, "NO_VALUE", USTRINGTRIE_NO_VALUE); INSTALL_ENUM(UStringTrieResult, "FINAL_VALUE", USTRINGTRIE_FINAL_VALUE); INSTALL_ENUM(UStringTrieResult, "INTERMEDIATE_VALUE", USTRINGTRIE_INTERMEDIATE_VALUE); #endif } ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1569610564.0 PyICU-2.4.2/tries.h0000644000076500000000000000253600000000000014161 0ustar00vajdawheel00000000000000/* ==================================================================== * Copyright (c) 2019 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 _tries_h #define _tries_h void _init_tries(PyObject *m); #endif /* _tries_h */ ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1536104905.0 PyICU-2.4.2/tzinfo.cpp0000644000076500000000000005570300000000000014703 0ustar00vajdawheel00000000000000/* ==================================================================== * Copyright (c) 2007-2014 Open Source Applications Foundation. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. * ==================================================================== */ #include "common.h" #include "structmember.h" #include "datetime.h" #include "bases.h" #include "calendar.h" #include "tzinfo.h" #include "macros.h" #ifdef PYPY_VERSION #if !defined(PYPY_VERSION_NUM) || PYPY_VERSION_NUM < 0x05020000 typedef PyObject PyDateTime_TZInfo; #endif #endif /* A tzinfo extension that wraps an ICU timezone wrapper. * The tz field is supposed to be immutable. */ typedef struct { PyDateTime_TZInfo dt_tzinfo; t_timezone *tz; } t_tzinfo; /* A tzinfo extension that wraps an ICU tzinfo wrapper. * The tzinfo field can be changed and defaults to the default ICU tzinfo * when not set. When this field changes or the default ICU tzinfo is changed, * times expressed with this pseudo-timezone, named "World/Floating", appear * to float. */ typedef struct { PyDateTime_TZInfo dt_tzinfo; t_tzinfo *tzinfo; } t_floatingtz; static void t_tzinfo_dealloc(t_tzinfo *self); static PyObject *t_tzinfo_new(PyTypeObject *type, PyObject *args, PyObject *kwds); static int t_tzinfo_init(t_tzinfo *self, PyObject *args, PyObject *kwds); static PyObject *t_tzinfo_repr(t_tzinfo *self); static PyObject *t_tzinfo_str(t_tzinfo *self); static long t_tzinfo_hash(t_tzinfo *self); static PyObject *t_tzinfo_richcmp(t_tzinfo *self, PyObject *other, int op); static PyObject *t_tzinfo__resetDefault(PyTypeObject *cls); static PyObject *t_tzinfo_getDefault(PyTypeObject *cls); static PyObject *t_tzinfo_setDefault(PyTypeObject *cls, PyObject *tz); static PyObject *t_tzinfo_getFloating(PyTypeObject *cls); static PyObject *t_tzinfo_getInstances(PyTypeObject *cls); static PyObject *t_tzinfo_getInstance(PyTypeObject *cls, PyObject *arg); static PyObject *t_tzinfo_utcoffset(t_tzinfo *self, PyObject *dt); static PyObject *t_tzinfo_dst(t_tzinfo *self, PyObject *dt); static PyObject *t_tzinfo_tzname(t_tzinfo *self, PyObject *dt); static PyObject *t_tzinfo__getTimezone(t_tzinfo *self, void *data); static PyObject *t_tzinfo__getTZID(t_tzinfo *self, void *data); static PyObject *_instances; static t_tzinfo *_default, *_floating; static PyTypeObject *datetime_tzinfoType, *datetime_deltaType; static PyObject *FLOATING_TZNAME; static PyObject *toordinal_NAME; static PyObject *weekday_NAME; static PyMethodDef t_tzinfo_methods[] = { { "_resetDefault", (PyCFunction) t_tzinfo__resetDefault, METH_NOARGS | METH_CLASS, "" }, { "getDefault", (PyCFunction) t_tzinfo_getDefault, METH_NOARGS | METH_CLASS, "" }, { "setDefault", (PyCFunction) t_tzinfo_setDefault, METH_O | METH_CLASS, "" }, { "getFloating", (PyCFunction) t_tzinfo_getFloating, METH_NOARGS | METH_CLASS, "" }, { "getInstances", (PyCFunction) t_tzinfo_getInstances, METH_NOARGS | METH_CLASS, "" }, { "getInstance", (PyCFunction) t_tzinfo_getInstance, METH_O | METH_CLASS, "" }, { "utcoffset", (PyCFunction) t_tzinfo_utcoffset, METH_O, "" }, { "dst", (PyCFunction) t_tzinfo_dst, METH_O, "" }, { "tzname", (PyCFunction) t_tzinfo_tzname, METH_O, "" }, { NULL, NULL, 0, NULL } }; static PyGetSetDef t_tzinfo_properties[] = { { (char *) "timezone", (getter) t_tzinfo__getTimezone, NULL, (char *) "timezone property", NULL }, { (char *) "tzid", (getter) t_tzinfo__getTZID, NULL, (char *) "tzid property", NULL }, { NULL, NULL, NULL, NULL, NULL } }; PyTypeObject TZInfoType_ = { PyVarObject_HEAD_INIT(NULL, 0) "icu.ICUtzinfo", /* tp_name */ sizeof(t_tzinfo), /* tp_basicsize */ 0, /* tp_itemsize */ (destructor) t_tzinfo_dealloc, /* tp_dealloc */ 0, /* tp_print */ 0, /* tp_getattr */ 0, /* tp_setattr */ 0, /* tp_compare */ (reprfunc) t_tzinfo_repr, /* tp_repr */ 0, /* tp_as_number */ 0, /* tp_as_sequence */ 0, /* tp_as_mapping */ (hashfunc) t_tzinfo_hash, /* tp_hash */ 0, /* tp_call */ (reprfunc) t_tzinfo_str, /* tp_str */ 0, /* tp_getattro */ 0, /* tp_setattro */ 0, /* tp_as_buffer */ (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE), /* tp_flags */ "ICUtzinfo objects", /* tp_doc */ 0, /* tp_traverse */ 0, /* tp_clear */ (richcmpfunc) t_tzinfo_richcmp, /* tp_richcompare */ 0, /* tp_weaklistoffset */ 0, /* tp_iter */ 0, /* tp_iternext */ t_tzinfo_methods, /* tp_methods */ 0, /* tp_members */ t_tzinfo_properties, /* tp_getset */ 0, /* tp_base */ 0, /* tp_dict */ 0, /* tp_descr_get */ 0, /* tp_descr_set */ 0, /* tp_dictoffset */ (initproc) t_tzinfo_init, /* tp_init */ 0, /* tp_alloc */ (newfunc) t_tzinfo_new, /* tp_new */ 0, /* tp_free */ }; static void t_floatingtz_dealloc(t_floatingtz *self); static PyObject *t_floatingtz_new(PyTypeObject *type, PyObject *args, PyObject *kwds); static int t_floatingtz_init(t_floatingtz *self, PyObject *args, PyObject *kwds); static PyObject *t_floatingtz_repr(t_floatingtz *self); static PyObject *t_floatingtz_str(t_floatingtz *self); static PyObject *t_floatingtz_richcmp(t_floatingtz *self, PyObject *other, int op); static long t_floatingtz_hash(t_floatingtz *self); static PyObject *t_floatingtz_utcoffset(t_floatingtz *self, PyObject *dt); static PyObject *t_floatingtz_dst(t_floatingtz *self, PyObject *dt); static PyObject *t_floatingtz_tzname(t_floatingtz *self, PyObject *dt); static PyObject *t_floatingtz__getTimezone(t_floatingtz *self, void *data); static PyObject *t_floatingtz__getTZID(t_floatingtz *self, void *data); static PyMemberDef t_floatingtz_members[] = { { (char *) "tzinfo", T_OBJECT, offsetof(t_floatingtz, tzinfo), 0, (char *) "" }, { NULL, 0, 0, 0, NULL } }; static PyMethodDef t_floatingtz_methods[] = { { "utcoffset", (PyCFunction) t_floatingtz_utcoffset, METH_O, "" }, { "dst", (PyCFunction) t_floatingtz_dst, METH_O, "" }, { "tzname", (PyCFunction) t_floatingtz_tzname, METH_O, "" }, { NULL, NULL, 0, NULL } }; static PyGetSetDef t_floatingtz_properties[] = { { (char *) "timezone", (getter) t_floatingtz__getTimezone, NULL, (char *) "timezone property", NULL }, { (char *) "tzid", (getter) t_floatingtz__getTZID, NULL, (char *) "tzid property", NULL }, { NULL, NULL, NULL, NULL, NULL } }; PyTypeObject FloatingTZType_ = { PyVarObject_HEAD_INIT(NULL, 0) "icu.FloatingTZ", /* tp_name */ sizeof(t_floatingtz), /* tp_basicsize */ 0, /* tp_itemsize */ (destructor) t_floatingtz_dealloc, /* tp_dealloc */ 0, /* tp_print */ 0, /* tp_getattr */ 0, /* tp_setattr */ 0, /* tp_compare */ (reprfunc) t_floatingtz_repr, /* tp_repr */ 0, /* tp_as_number */ 0, /* tp_as_sequence */ 0, /* tp_as_mapping */ (hashfunc) t_floatingtz_hash, /* tp_hash */ 0, /* tp_call */ (reprfunc) t_floatingtz_str, /* tp_str */ 0, /* tp_getattro */ 0, /* tp_setattro */ 0, /* tp_as_buffer */ (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE), /* tp_flags */ "FloatingTZ objects", /* tp_doc */ 0, /* tp_traverse */ 0, /* tp_clear */ (richcmpfunc) t_floatingtz_richcmp, /* tp_richcompare */ 0, /* tp_weaklistoffset */ 0, /* tp_iter */ 0, /* tp_iternext */ t_floatingtz_methods, /* tp_methods */ t_floatingtz_members, /* tp_members */ t_floatingtz_properties, /* tp_getset */ 0, /* tp_base */ 0, /* tp_dict */ 0, /* tp_descr_get */ 0, /* tp_descr_set */ 0, /* tp_dictoffset */ (initproc) t_floatingtz_init, /* tp_init */ 0, /* tp_alloc */ (newfunc) t_floatingtz_new, /* tp_new */ 0, /* tp_free */ }; static void t_tzinfo_dealloc(t_tzinfo *self) { Py_CLEAR(self->tz); Py_TYPE(&self->dt_tzinfo)->tp_free((PyObject *) self); } static void t_floatingtz_dealloc(t_floatingtz *self) { Py_CLEAR(self->tzinfo); Py_TYPE(&self->dt_tzinfo)->tp_free((PyObject *) self); } static PyObject *t_tzinfo_new(PyTypeObject *type, PyObject *args, PyObject *kwds) { t_tzinfo *tzinfo = (t_tzinfo *) type->tp_alloc(type, 0); if (tzinfo) tzinfo->tz = NULL; return (PyObject *) tzinfo; } static PyObject *t_floatingtz_new(PyTypeObject *type, PyObject *args, PyObject *kwds) { t_floatingtz *floatingtz = (t_floatingtz *) type->tp_alloc(type, 0); if (floatingtz) floatingtz->tzinfo = NULL; return (PyObject *) floatingtz; } static int t_tzinfo_init(t_tzinfo *self, PyObject *args, PyObject *kwds) { PyObject *tz; if (!PyArg_ParseTuple(args, "O", &tz)) return -1; if (!PyObject_TypeCheck(tz, &TimeZoneType_)) { PyErr_SetObject(PyExc_TypeError, tz); return -1; } Py_INCREF(tz); Py_XDECREF(self->tz); self->tz = (t_timezone *) tz; return 0; } static int t_floatingtz_init(t_floatingtz *self, PyObject *args, PyObject *kwds) { PyObject *tzinfo = NULL; if (!PyArg_ParseTuple(args, "|O", &tzinfo)) return -1; if (tzinfo && !PyObject_TypeCheck(tzinfo, &TZInfoType_)) { PyErr_SetObject(PyExc_TypeError, tzinfo); return -1; } Py_XINCREF(tzinfo); Py_XDECREF((PyObject *) self->tzinfo); self->tzinfo = (t_tzinfo *) tzinfo; return 0; } static PyObject *t_tzinfo_repr(t_tzinfo *self) { PyObject *format = PyString_FromString(""); PyObject *str = PyObject_Str((PyObject *) self->tz); #if PY_VERSION_HEX < 0x02040000 PyObject *args = Py_BuildValue("(O)", str); #else PyObject *args = PyTuple_Pack(1, str); #endif PyObject *repr = PyString_Format(format, args); Py_DECREF(args); Py_DECREF(str); Py_DECREF(format); return repr; } static PyObject *t_tzinfo_str(t_tzinfo *self) { return PyObject_Str((PyObject *) self->tz); } static PyObject *t_floatingtz_repr(t_floatingtz *self) { t_tzinfo *tzinfo = self->tzinfo ? self->tzinfo : _default; PyObject *format = PyString_FromString(""); PyObject *str = PyObject_Str((PyObject *) tzinfo->tz); #if PY_VERSION_HEX < 0x02040000 PyObject *args = Py_BuildValue("(O)", str); #else PyObject *args = PyTuple_Pack(1, str); #endif PyObject *repr = PyString_Format(format, args); Py_DECREF(args); Py_DECREF(str); Py_DECREF(format); return repr; } static PyObject *t_floatingtz_str(t_floatingtz *self) { Py_INCREF(FLOATING_TZNAME); return FLOATING_TZNAME; } static long t_tzinfo_hash(t_tzinfo *self) { PyObject *str = PyObject_Str((PyObject *) self->tz); long hash = PyObject_Hash(str); Py_DECREF(str); return hash; } static long t_floatingtz_hash(t_floatingtz *self) { return PyObject_Hash(FLOATING_TZNAME); } static PyObject *t_tzinfo_richcmp(t_tzinfo *self, PyObject *other, int op) { if (PyObject_TypeCheck(other, &TZInfoType_)) { PyObject *s1 = PyObject_Str((PyObject *) self->tz); PyObject *s2 = PyObject_Str((PyObject *) ((t_tzinfo *) other)->tz); PyObject *result = PyObject_RichCompare(s1, s2, op); Py_DECREF(s1); Py_DECREF(s2); return result; } if (PyObject_TypeCheck(other, &FloatingTZType_)) { PyObject *s1 = PyObject_Str((PyObject *) self->tz); PyObject *result = PyObject_RichCompare(s1, FLOATING_TZNAME, op); Py_DECREF(s1); return result; } Py_INCREF(Py_NotImplemented); return Py_NotImplemented; } static PyObject *t_floatingtz_richcmp(t_floatingtz *self, PyObject *other, int op) { if (PyObject_TypeCheck(other, &FloatingTZType_)) { t_tzinfo *tzi1 = self->tzinfo; t_tzinfo *tzi2 = ((t_floatingtz *) other)->tzinfo; return PyObject_RichCompare((PyObject *) (tzi1 ? tzi1 : _default), (PyObject *) (tzi2 ? tzi2 : _default), op); } if (PyObject_TypeCheck(other, &TZInfoType_)) { PyObject *s2 = PyObject_Str((PyObject *) ((t_tzinfo *) other)->tz); PyObject *result = PyObject_RichCompare(FLOATING_TZNAME, s2, op); Py_DECREF(s2); return result; } Py_INCREF(Py_NotImplemented); return Py_NotImplemented; } static PyObject *t_tzinfo__resetDefault(PyTypeObject *cls) { PyObject *tz = wrap_TimeZone(TimeZone::createDefault()); if (tz) { #if PY_VERSION_HEX < 0x02040000 PyObject *args = Py_BuildValue("(O)", tz); #else PyObject *args = PyTuple_Pack(1, tz); #endif PyObject *tzinfo = PyObject_Call((PyObject *) &TZInfoType_, args, NULL); Py_DECREF(args); Py_DECREF(tz); if (tzinfo) { if (!PyObject_TypeCheck(tzinfo, &TZInfoType_)) { PyErr_SetObject(PyExc_TypeError, tzinfo); return NULL; } Py_XDECREF((PyObject *) _default); _default = (t_tzinfo *) tzinfo; Py_RETURN_NONE; } } return NULL; } static PyObject *t_tzinfo_getFloating(PyTypeObject *cls) { if (_floating) { Py_INCREF((PyObject *) _floating); return (PyObject *) _floating; } Py_RETURN_NONE; } static PyObject *t_tzinfo_getDefault(PyTypeObject *cls) { if (_default) { Py_INCREF((PyObject *) _default); return (PyObject *) _default; } Py_RETURN_NONE; } static PyObject *t_tzinfo_setDefault(PyTypeObject *cls, PyObject *arg) { if (!PyObject_TypeCheck(arg, &TZInfoType_)) { PyErr_SetObject(PyExc_TypeError, arg); return NULL; } PyObject *prev = (PyObject *) _default; Py_INCREF(arg); _default = (t_tzinfo *) arg; if (prev) return prev; Py_RETURN_NONE; } static PyObject *t_tzinfo_getInstances(PyTypeObject *cls) { Py_INCREF(_instances); return _instances; } static PyObject *t_tzinfo_getInstance(PyTypeObject *cls, PyObject *id) { PyObject *instance = PyDict_GetItem(_instances, id); if (instance) { Py_INCREF(instance); return instance; } int cmp = PyObject_RichCompareBool(id, FLOATING_TZNAME, Py_EQ); if (cmp == -1) return NULL; if (cmp) instance = t_tzinfo_getFloating(cls); else { PyObject *tz = t_timezone_createTimeZone(&TimeZoneType_, id); if (!tz) return NULL; #if PY_VERSION_HEX < 0x02040000 PyObject *args = Py_BuildValue("(O)", tz); #else PyObject *args = PyTuple_Pack(1, tz); #endif instance = PyObject_Call((PyObject *) &TZInfoType_, args, NULL); Py_DECREF(args); Py_DECREF(tz); } if (instance) PyDict_SetItem(_instances, id, instance); return instance; } static double _udate(PyObject *dt) { PyObject *result = PyObject_CallMethodObjArgs(dt, toordinal_NAME, NULL); if (!result) return 0.0; #if PY_MAJOR_VERSION >= 3 unsigned long ordinal = PyLong_AsUnsignedLong(result); #else unsigned long ordinal = PyInt_AS_LONG(result); #endif Py_DECREF(result); return ((ordinal - 719163) * 86400.0 + PyDateTime_DATE_GET_HOUR(dt) * 3600.0 + PyDateTime_DATE_GET_MINUTE(dt) * 60.0 + PyDateTime_DATE_GET_SECOND(dt) + PyDateTime_DATE_GET_MICROSECOND(dt) / 1e6) * 1000.0; } static PyObject *t_tzinfo_utcoffset(t_tzinfo *self, PyObject *dt) { PyObject *weekday = PyObject_CallMethodObjArgs(dt, weekday_NAME, NULL); if (!weekday) return NULL; // python's MINYEAR is 1 int era = GregorianCalendar::AD; int year = PyDateTime_GET_YEAR(dt); // python's month is 1-based, 1 is January // ICU's month is 0-based, 0 is January int month = PyDateTime_GET_MONTH(dt) - 1; int day = PyDateTime_GET_DAY(dt); // python's weekday is 0-based, 0 is Monday // ICU's dayofweek is 1-based, 1 is Sunday int dayofweek = ((PyInt_AsLong(weekday) + 1) % 7) + 1; Py_DECREF(weekday); int millis = (int) ((PyDateTime_DATE_GET_HOUR(dt) * 3600.0 + PyDateTime_DATE_GET_MINUTE(dt) * 60.0 + PyDateTime_DATE_GET_SECOND(dt) + PyDateTime_DATE_GET_MICROSECOND(dt) / 1e6) * 1000.0); int offset; STATUS_CALL(offset = self->tz->object->getOffset(era, year, month, day, dayofweek, millis, status)); PyObject *args = PyTuple_New(2); PyObject *result; PyTuple_SET_ITEM(args, 0, PyInt_FromLong(0)); PyTuple_SET_ITEM(args, 1, PyInt_FromLong(offset / 1000)); result = PyObject_Call((PyObject *) datetime_deltaType, args, NULL); Py_DECREF(args); return result; } static PyObject *t_tzinfo_dst(t_tzinfo *self, PyObject *dt) { UDate date = _udate(dt); int raw, dst; if (date == 0.0 && PyErr_Occurred()) return NULL; STATUS_CALL(self->tz->object->getOffset(date, 1, raw, dst, status)); PyObject *args = PyTuple_New(2); PyObject *result; PyTuple_SET_ITEM(args, 0, PyInt_FromLong(0)); PyTuple_SET_ITEM(args, 1, PyInt_FromLong(dst / 1000)); result = PyObject_Call((PyObject *) datetime_deltaType, args, NULL); Py_DECREF(args); return result; } static PyObject *t_tzinfo_tzname(t_tzinfo *self, PyObject *dt) { return PyObject_Str((PyObject *) self->tz); } static PyObject *t_tzinfo__getTimezone(t_tzinfo *self, void *data) { Py_INCREF(self->tz); return (PyObject *) self->tz; } static PyObject *t_tzinfo__getTZID(t_tzinfo *self, void *data) { return PyObject_Str((PyObject *) self); } static PyObject *t_floatingtz_utcoffset(t_floatingtz *self, PyObject *dt) { return t_tzinfo_utcoffset(self->tzinfo ? self->tzinfo : _default, dt); } static PyObject *t_floatingtz_dst(t_floatingtz *self, PyObject *dt) { return t_tzinfo_dst(self->tzinfo ? self->tzinfo : _default, dt); } static PyObject *t_floatingtz_tzname(t_floatingtz *self, PyObject *dt) { Py_INCREF(FLOATING_TZNAME); return FLOATING_TZNAME; } static PyObject *t_floatingtz__getTimezone(t_floatingtz *self, void *data) { t_tzinfo *tzinfo = self->tzinfo ? self->tzinfo : _default; Py_INCREF(tzinfo->tz); return (PyObject *) tzinfo->tz; } static PyObject *t_floatingtz__getTZID(t_floatingtz *self, void *data) { Py_INCREF(FLOATING_TZNAME); return FLOATING_TZNAME; } void _init_tzinfo(PyObject *m) { #if (PY_VERSION_HEX > 0x02040000 && !defined(PYPY_VERSION) || \ defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM >= 0x06000000) 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); } } } ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1321233899.0 PyICU-2.4.2/tzinfo.h0000644000076500000000000000254700000000000014346 0ustar00vajdawheel00000000000000/* ==================================================================== * 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 */ ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1569878543.0 PyICU-2.4.2/unicodeset.cpp0000644000076500000000000011662500000000000015535 0ustar00vajdawheel00000000000000/* ==================================================================== * Copyright (c) 2010-2019 Open Source Applications Foundation. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. * ==================================================================== */ #include "common.h" #include "structmember.h" #include "bases.h" #include "unicodeset.h" #include "macros.h" DECLARE_CONSTANTS_TYPE(UMatchDegree); DECLARE_CONSTANTS_TYPE(USetSpanCondition); /* UnicodeFunctor */ class t_unicodefunctor : public _wrapper { public: UnicodeFunctor *object; }; static PyObject *t_unicodefunctor_toMatcher(t_unicodefunctor *self); static PyMethodDef t_unicodefunctor_methods[] = { DECLARE_METHOD(t_unicodefunctor, toMatcher, METH_NOARGS), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(UnicodeFunctor, t_unicodefunctor, UObject, UnicodeFunctor, abstract_init, NULL); /* UnicodeMatcher */ class t_unicodematcher : public _wrapper { public: UnicodeMatcher *object; }; static PyObject *t_unicodematcher_matches(t_unicodematcher *self, PyObject *args); static PyObject *t_unicodematcher_toPattern(t_unicodematcher *self, PyObject *args); static PyObject *t_unicodematcher_matchesIndexValue(t_unicodematcher *self, PyObject *arg); static PyObject *t_unicodematcher_addMatchSetTo(t_unicodematcher *self, PyObject *arg); static PyMethodDef t_unicodematcher_methods[] = { DECLARE_METHOD(t_unicodematcher, matches, METH_VARARGS), DECLARE_METHOD(t_unicodematcher, toPattern, METH_VARARGS), DECLARE_METHOD(t_unicodematcher, matchesIndexValue, METH_O), DECLARE_METHOD(t_unicodematcher, addMatchSetTo, METH_O), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(UnicodeMatcher, t_unicodematcher, UObject, UnicodeMatcher, abstract_init, NULL); /* UnicodeFilter */ class t_unicodefilter : public _wrapper { public: UnicodeFilter *object; }; static PyObject *t_unicodefilter_toMatcher(t_unicodefilter *self); static PyObject *t_unicodefilter_matches(t_unicodefilter *self, PyObject *args); static PyObject *t_unicodefilter_toPattern(t_unicodefilter *self, PyObject *args); static PyObject *t_unicodefilter_matchesIndexValue(t_unicodefilter *self, PyObject *arg); static PyObject *t_unicodefilter_addMatchSetTo(t_unicodefilter *self, PyObject *arg); static PyObject *t_unicodefilter_contains(t_unicodefilter *self, PyObject *arg); static PyMethodDef t_unicodefilter_methods[] = { DECLARE_METHOD(t_unicodefilter, toMatcher, METH_NOARGS), DECLARE_METHOD(t_unicodefilter, matches, METH_VARARGS), DECLARE_METHOD(t_unicodefilter, toPattern, METH_VARARGS), DECLARE_METHOD(t_unicodefilter, matchesIndexValue, METH_O), DECLARE_METHOD(t_unicodefilter, addMatchSetTo, METH_O), DECLARE_METHOD(t_unicodefilter, contains, METH_O), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(UnicodeFilter, t_unicodefilter, UObject, UnicodeFilter, abstract_init, NULL); /* UnicodeSet */ class t_unicodeset : public _wrapper { public: UnicodeSet *object; }; static int t_unicodeset_init(t_unicodeset *self, PyObject *args, PyObject *kwds); #if U_ICU_VERSION_HEX >= 0x04000000 static PyObject *t_unicodeset_isBogus(t_unicodeset *self); static PyObject *t_unicodeset_setToBogus(t_unicodeset *self); #endif static PyObject *t_unicodeset_isEmpty(t_unicodeset *self); static PyObject *t_unicodeset_isFrozen(t_unicodeset *self); static PyObject *t_unicodeset_freeze(t_unicodeset *self); static PyObject *t_unicodeset_set(t_unicodeset *self, PyObject *args); static PyObject *t_unicodeset_applyPattern(t_unicodeset *self, PyObject *arg); static PyObject *t_unicodeset_applyIntPropertyValue(t_unicodeset *self, PyObject *args); static PyObject *t_unicodeset_applyPropertyAlias(t_unicodeset *self, PyObject *args); static PyObject *t_unicodeset_contains(t_unicodeset *self, PyObject *args); static PyObject *t_unicodeset_containsAll(t_unicodeset *self, PyObject *arg); static PyObject *t_unicodeset_containsNone(t_unicodeset *self, PyObject *args); static PyObject *t_unicodeset_containsSome(t_unicodeset *self, PyObject *args); static PyObject *t_unicodeset_span(t_unicodeset *self, PyObject *args); static PyObject *t_unicodeset_spanBack(t_unicodeset *self, PyObject *args); static PyObject *t_unicodeset_add(t_unicodeset *self, PyObject *args); static PyObject *t_unicodeset_addAll(t_unicodeset *self, PyObject *arg); static PyObject *t_unicodeset_retainAll(t_unicodeset *self, PyObject *arg); static PyObject *t_unicodeset_complementAll(t_unicodeset *self, PyObject *arg); static PyObject *t_unicodeset_removeAll(t_unicodeset *self, PyObject *arg); static PyObject *t_unicodeset_retain(t_unicodeset *self, PyObject *args); static PyObject *t_unicodeset_remove(t_unicodeset *self, PyObject *args); static PyObject *t_unicodeset_complement(t_unicodeset *self, PyObject *args); static PyObject *t_unicodeset_clear(t_unicodeset *self); static PyObject *t_unicodeset_closeOver(t_unicodeset *self, PyObject *arg); #if U_ICU_VERSION_HEX >= 0x04020000 static PyObject *t_unicodeset_removeAllStrings(t_unicodeset *self); #endif static PyObject *t_unicodeset_compact(t_unicodeset *self); static PyObject *t_unicodeset_getRangeCount(t_unicodeset *self); static PyObject *t_unicodeset_getRangeStart(t_unicodeset *self, PyObject *arg); static PyObject *t_unicodeset_getRangeEnd(t_unicodeset *self, PyObject *arg); static PyObject *t_unicodeset_resemblesPattern(PyTypeObject *type, PyObject *args); static PyObject *t_unicodeset_createFrom(PyTypeObject *type, PyObject *arg); static PyObject *t_unicodeset_createFromAll(PyTypeObject *type, PyObject *arg); static PyMethodDef t_unicodeset_methods[] = { #if U_ICU_VERSION_HEX >= 0x04000000 DECLARE_METHOD(t_unicodeset, isBogus, METH_NOARGS), DECLARE_METHOD(t_unicodeset, setToBogus, METH_NOARGS), #endif DECLARE_METHOD(t_unicodeset, isEmpty, METH_NOARGS), DECLARE_METHOD(t_unicodeset, isFrozen, METH_NOARGS), DECLARE_METHOD(t_unicodeset, freeze, METH_NOARGS), DECLARE_METHOD(t_unicodeset, set, METH_VARARGS), DECLARE_METHOD(t_unicodeset, applyPattern, METH_O), DECLARE_METHOD(t_unicodeset, applyIntPropertyValue, METH_VARARGS), DECLARE_METHOD(t_unicodeset, applyPropertyAlias, METH_VARARGS), DECLARE_METHOD(t_unicodeset, contains, METH_VARARGS), DECLARE_METHOD(t_unicodeset, containsAll, METH_O), DECLARE_METHOD(t_unicodeset, containsNone, METH_VARARGS), DECLARE_METHOD(t_unicodeset, containsSome, METH_VARARGS), DECLARE_METHOD(t_unicodeset, span, METH_VARARGS), DECLARE_METHOD(t_unicodeset, spanBack, METH_VARARGS), DECLARE_METHOD(t_unicodeset, add, METH_VARARGS), DECLARE_METHOD(t_unicodeset, addAll, METH_O), DECLARE_METHOD(t_unicodeset, retainAll, METH_O), DECLARE_METHOD(t_unicodeset, complementAll, METH_O), DECLARE_METHOD(t_unicodeset, removeAll, METH_O), DECLARE_METHOD(t_unicodeset, retain, METH_VARARGS), DECLARE_METHOD(t_unicodeset, remove, METH_VARARGS), DECLARE_METHOD(t_unicodeset, complement, METH_VARARGS), DECLARE_METHOD(t_unicodeset, clear, METH_NOARGS), DECLARE_METHOD(t_unicodeset, closeOver, METH_O), #if U_ICU_VERSION_HEX >= 0x04020000 DECLARE_METHOD(t_unicodeset, removeAllStrings, METH_NOARGS), #endif DECLARE_METHOD(t_unicodeset, compact, METH_NOARGS), DECLARE_METHOD(t_unicodeset, getRangeCount, METH_NOARGS), DECLARE_METHOD(t_unicodeset, getRangeStart, METH_O), DECLARE_METHOD(t_unicodeset, getRangeEnd, METH_O), DECLARE_METHOD(t_unicodeset, resemblesPattern, METH_VARARGS | METH_CLASS), DECLARE_METHOD(t_unicodeset, createFrom, METH_O | METH_CLASS), DECLARE_METHOD(t_unicodeset, createFromAll, METH_O | METH_CLASS), { NULL, NULL, 0, NULL } }; DECLARE_TYPE(UnicodeSet, t_unicodeset, UnicodeFilter, UnicodeSet, t_unicodeset_init, NULL); /* UnicodeSetIterator */ class t_unicodesetiterator : public _wrapper { public: UnicodeSetIterator *object; PyObject *set; }; static int t_unicodesetiterator_init(t_unicodesetiterator *self, PyObject *args, PyObject *kwds); static PyObject *t_unicodesetiterator_isString(t_unicodesetiterator *self); static PyObject *t_unicodesetiterator_getCodepoint(t_unicodesetiterator *self); static PyObject *t_unicodesetiterator_getCodepointEnd(t_unicodesetiterator *self); static PyObject *t_unicodesetiterator_getString(t_unicodesetiterator *self); static PyObject *t_unicodesetiterator_next(t_unicodesetiterator *self); static PyObject *t_unicodesetiterator_nextRange(t_unicodesetiterator *self); static PyObject *t_unicodesetiterator_reset(t_unicodesetiterator *self, PyObject *args); static PyMethodDef t_unicodesetiterator_methods[] = { DECLARE_METHOD(t_unicodesetiterator, isString, METH_NOARGS), DECLARE_METHOD(t_unicodesetiterator, getCodepoint, METH_NOARGS), DECLARE_METHOD(t_unicodesetiterator, getCodepointEnd, METH_NOARGS), DECLARE_METHOD(t_unicodesetiterator, getString, METH_NOARGS), DECLARE_METHOD(t_unicodesetiterator, next, METH_NOARGS), DECLARE_METHOD(t_unicodesetiterator, nextRange, METH_NOARGS), DECLARE_METHOD(t_unicodesetiterator, reset, METH_VARARGS), { NULL, NULL, 0, NULL } }; static void t_unicodesetiterator_dealloc(t_unicodesetiterator *self) { if (self->flags & T_OWNED) delete self->object; self->object = NULL; Py_CLEAR(self->set); Py_TYPE(self)->tp_free((PyObject *) self); } DECLARE_TYPE(UnicodeSetIterator, t_unicodesetiterator, UObject, UnicodeSetIterator, t_unicodesetiterator_init, t_unicodesetiterator_dealloc); /* UnicodeFunctor */ static PyObject *t_unicodefunctor_toMatcher(t_unicodefunctor *self) { return wrap_UnicodeMatcher(self->object->clone()->toMatcher(), T_OWNED); } /* UnicodeMatcher */ static PyObject *t_unicodematcher_matches(t_unicodematcher *self, PyObject *args) { UnicodeString *u, _u; int32_t offset, limit, incremental; if (!parseArgs(args, "SiiB", &u, &_u, &offset, &limit, &incremental)) { UMatchDegree degree = self->object->matches(*(Replaceable const *) u, offset, limit, (UBool) incremental); return Py_BuildValue("(ii)", degree, offset); } return PyErr_SetArgsError((PyObject *) self, "matches", args); } static PyObject *t_unicodematcher_toPattern(t_unicodematcher *self, PyObject *args) { UnicodeString u; int escapeUnprintable = 0; switch (PyTuple_Size(args)) { case 0: self->object->toPattern(u); return PyUnicode_FromUnicodeString(&u); case 1: if (!parseArgs(args, "B", &escapeUnprintable)) { self->object->toPattern(u, (UBool) escapeUnprintable); return PyUnicode_FromUnicodeString(&u); } } return PyErr_SetArgsError((PyObject *) self, "toPattern", args); } static PyObject *t_unicodematcher_matchesIndexValue(t_unicodematcher *self, PyObject *arg) { int v; if (!parseArg(arg, "i", &v)) { UBool b = self->object->matchesIndexValue((uint8_t) v); Py_RETURN_BOOL(b); } return PyErr_SetArgsError((PyObject *) self, "matchesIndexValue", arg); } static PyObject *t_unicodematcher_addMatchSetTo(t_unicodematcher *self, PyObject *arg) { UnicodeSet *set; if (!parseArg(arg, "P", TYPE_CLASSID(UnicodeSet), &set)) { self->object->addMatchSetTo(*set); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "addMatchSetTo", arg); } /* UnicodeFilter */ static PyObject *t_unicodefilter_toMatcher(t_unicodefilter *self) { return wrap_UnicodeMatcher(self->object->clone()->toMatcher(), T_OWNED); } static PyObject *t_unicodefilter_matches(t_unicodefilter *self, PyObject *args) { UnicodeString *u; UnicodeString _u; int32_t offset, limit, incremental; if (!parseArgs(args, "SiiB", &u, &_u, &offset, &limit, &incremental)) { UMatchDegree degree = self->object->matches(*(Replaceable const *) u, offset, limit, (UBool) incremental); return Py_BuildValue("(ii)", degree, offset); } return PyErr_SetArgsError((PyObject *) self, "matches", args); } static PyObject *t_unicodefilter_toPattern(t_unicodefilter *self, PyObject *args) { UnicodeString *u, _u; int escapeUnprintable = 0; switch (PyTuple_Size(args)) { case 0: self->object->toPattern(_u); return PyUnicode_FromUnicodeString(&_u); case 1: if (!parseArgs(args, "U", &u)) { self->object->toPattern(*u, (UBool) escapeUnprintable); Py_RETURN_ARG(args, 0); } if (!parseArgs(args, "B", &escapeUnprintable)) { self->object->toPattern(_u, (UBool) escapeUnprintable); return PyUnicode_FromUnicodeString(&_u); } case 2: if (!parseArgs(args, "UB", &u, &escapeUnprintable)) { self->object->toPattern(*u, (UBool) escapeUnprintable); Py_RETURN_ARG(args, 0); } } return PyErr_SetArgsError((PyObject *) self, "toPattern", args); } static PyObject *t_unicodefilter_matchesIndexValue(t_unicodefilter *self, PyObject *arg) { int v; if (!parseArg(arg, "i", &v)) { UBool b = self->object->matchesIndexValue((uint8_t) v); Py_RETURN_BOOL(b); } return PyErr_SetArgsError((PyObject *) self, "matchesIndexValue", arg); } static PyObject *t_unicodefilter_addMatchSetTo(t_unicodefilter *self, PyObject *arg) { UnicodeSet *set; if (!parseArg(arg, "P", TYPE_CLASSID(UnicodeSet), &set)) { self->object->addMatchSetTo(*set); Py_RETURN_NONE; } return PyErr_SetArgsError((PyObject *) self, "addMatchSetTo", arg); } static PyObject *t_unicodefilter_contains(t_unicodefilter *self, PyObject *arg) { UnicodeString *u; UnicodeString _u; if (!parseArg(arg, "S", &u, &_u)) { UChar32 c; int32_t len; STATUS_CALL(len = toUChar32(*u, &c, status)); if (len == 1) { UBool b = self->object->contains(c); Py_RETURN_BOOL(b); } } return PyErr_SetArgsError((PyObject *) self, "contains", arg); } /* UnicodeSet */ static int t_unicodeset_init(t_unicodeset *self, PyObject *args, PyObject *kwds) { UnicodeSet *set; UnicodeString *u0, *u1; UnicodeString _u0, _u1; switch (PyTuple_Size(args)) { case 0: self->object = new UnicodeSet(); self->flags = T_OWNED; break; case 1: if (!parseArgs(args, "S", &u0, &_u0)) { INT_STATUS_CALL(set = new UnicodeSet(*u0, status)); self->object = set; self->flags = T_OWNED; break; } if (!parseArgs(args, "P", TYPE_CLASSID(UnicodeSet), &set)) { self->object = new UnicodeSet(*set); self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; case 2: if (!parseArgs(args, "SS", &u0, &_u0, &u1, &_u1)) { UChar32 c0, c1; int32_t l0, l1; INT_STATUS_CALL(l0 = toUChar32(*u0, &c0, status)); INT_STATUS_CALL(l1 = toUChar32(*u1, &c1, status)); if (l0 == 1 && l1 == 1) { self->object = new UnicodeSet(c0, c1); self->flags = T_OWNED; break; } } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; default: PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; } if (self->object) return 0; return -1; } #if U_ICU_VERSION_HEX >= 0x04000000 static PyObject *t_unicodeset_isBogus(t_unicodeset *self) { UBool b = self->object->isBogus(); Py_RETURN_BOOL(b); } static PyObject *t_unicodeset_setToBogus(t_unicodeset *self) { self->object->setToBogus(); Py_RETURN_NONE; } #endif static PyObject *t_unicodeset_isEmpty(t_unicodeset *self) { UBool b = self->object->isEmpty(); Py_RETURN_BOOL(b); } static PyObject *t_unicodeset_isFrozen(t_unicodeset *self) { UBool b = self->object->isFrozen(); Py_RETURN_BOOL(b); } static PyObject *t_unicodeset_freeze(t_unicodeset *self) { self->object->freeze(); Py_RETURN_NONE; } static PyObject *t_unicodeset_set(t_unicodeset *self, PyObject *args) { UnicodeString *u0, *u1; UnicodeString _u0, _u1; if (!parseArgs(args, "SS", &u0, &_u0, &u1, &_u1)) { UChar32 c0, c1; int32_t l0, l1; STATUS_CALL(l0 = toUChar32(*u0, &c0, status)); STATUS_CALL(l1 = toUChar32(*u1, &c1, status)); if (l0 == 1 && l1 == 1) { self->object->set(c0, c1); Py_RETURN_SELF(); } } PyErr_SetArgsError((PyObject *) self, "set", args); return NULL; } static PyObject *t_unicodeset_add(t_unicodeset *self, PyObject *args) { UnicodeString *u0, *u1; UnicodeString _u0, _u1; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "S", &u0, &_u0)) { UChar32 c0; int32_t l0; if (u0->length() == 1) { STATUS_CALL(l0 = toUChar32(*u0, &c0, status)); if (l0 == 1) { self->object->add(c0); Py_RETURN_SELF(); } } else { self->object->add(*u0); Py_RETURN_SELF(); } } break; case 2: if (!parseArgs(args, "SS", &u0, &_u0, &u1, &_u1)) { UChar32 c0, c1; int32_t l0, l1; STATUS_CALL(l0 = toUChar32(*u0, &c0, status)); STATUS_CALL(l1 = toUChar32(*u1, &c1, status)); if (l0 == 1 && l1 == 1) { self->object->add(c0, c1); Py_RETURN_SELF(); } } break; } PyErr_SetArgsError((PyObject *) self, "add", args); return NULL; } static PyObject *t_unicodeset_addAll(t_unicodeset *self, PyObject *arg) { UnicodeString *u, _u; UnicodeSet *set; if (!parseArg(arg, "S", &u, &_u)) { self->object->addAll(*u); Py_RETURN_SELF(); } if (!parseArg(arg, "P", TYPE_CLASSID(UnicodeSet), &set)) { self->object->addAll(*set); Py_RETURN_SELF(); } PyErr_SetArgsError((PyObject *) self, "addAll", arg); return NULL; } static PyObject *t_unicodeset_retain(t_unicodeset *self, PyObject *args) { UnicodeString *u0, *u1; UnicodeString _u0, _u1; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "S", &u0, &_u0)) { UChar32 c0; int32_t l0; if (u0->length() == 1) { STATUS_CALL(l0 = toUChar32(*u0, &c0, status)); if (l0 == 1) { self->object->retain(c0); Py_RETURN_SELF(); } } } break; case 2: if (!parseArgs(args, "SS", &u0, &_u0, &u1, &_u1)) { UChar32 c0, c1; int32_t l0, l1; STATUS_CALL(l0 = toUChar32(*u0, &c0, status)); STATUS_CALL(l1 = toUChar32(*u1, &c1, status)); if (l0 == 1 && l1 == 1) { self->object->retain(c0, c1); Py_RETURN_SELF(); } } break; } PyErr_SetArgsError((PyObject *) self, "retain", args); return NULL; } static PyObject *t_unicodeset_retainAll(t_unicodeset *self, PyObject *arg) { UnicodeString *u, _u; UnicodeSet *set; if (!parseArg(arg, "S", &u, &_u)) { self->object->retainAll(*u); Py_RETURN_SELF(); } if (!parseArg(arg, "P", TYPE_CLASSID(UnicodeSet), &set)) { self->object->retainAll(*set); Py_RETURN_SELF(); } PyErr_SetArgsError((PyObject *) self, "retainAll", arg); return NULL; } static PyObject *t_unicodeset_complement(t_unicodeset *self, PyObject *args) { UnicodeString *u0, *u1; UnicodeString _u0, _u1; switch (PyTuple_Size(args)) { case 0: self->object->complement(); break; case 1: if (!parseArgs(args, "S", &u0, &_u0)) { UChar32 c0; int32_t l0; if (u0->length() == 1) { STATUS_CALL(l0 = toUChar32(*u0, &c0, status)); if (l0 == 1) { self->object->complement(c0); Py_RETURN_SELF(); } } else { self->object->complement(*u0); Py_RETURN_SELF(); } } break; case 2: if (!parseArgs(args, "SS", &u0, &_u0, &u1, &_u1)) { UChar32 c0, c1; int32_t l0, l1; STATUS_CALL(l0 = toUChar32(*u0, &c0, status)); STATUS_CALL(l1 = toUChar32(*u1, &c1, status)); if (l0 == 1 && l1 == 1) { self->object->complement(c0, c1); Py_RETURN_SELF(); } } break; } PyErr_SetArgsError((PyObject *) self, "complement", args); return NULL; } static PyObject *t_unicodeset_complementAll(t_unicodeset *self, PyObject *arg) { UnicodeString *u, _u; UnicodeSet *set; if (!parseArg(arg, "S", &u, &_u)) { self->object->complementAll(*u); Py_RETURN_SELF(); } if (!parseArg(arg, "P", TYPE_CLASSID(UnicodeSet), &set)) { self->object->complementAll(*set); Py_RETURN_SELF(); } PyErr_SetArgsError((PyObject *) self, "complementAll", arg); return NULL; } static PyObject *t_unicodeset_remove(t_unicodeset *self, PyObject *args) { UnicodeString *u0, *u1; UnicodeString _u0, _u1; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "S", &u0, &_u0)) { UChar32 c0; int32_t l0; if (u0->length() == 1) { STATUS_CALL(l0 = toUChar32(*u0, &c0, status)); if (l0 == 1) { self->object->remove(c0); Py_RETURN_SELF(); } } else { self->object->remove(*u0); Py_RETURN_SELF(); } } break; case 2: if (!parseArgs(args, "SS", &u0, &_u0, &u1, &_u1)) { UChar32 c0, c1; int32_t l0, l1; STATUS_CALL(l0 = toUChar32(*u0, &c0, status)); STATUS_CALL(l1 = toUChar32(*u1, &c1, status)); if (l0 == 1 && l1 == 1) { self->object->remove(c0, c1); Py_RETURN_SELF(); } } break; } PyErr_SetArgsError((PyObject *) self, "remove", args); return NULL; } static PyObject *t_unicodeset_removeAll(t_unicodeset *self, PyObject *arg) { UnicodeString *u, _u; UnicodeSet *set; if (!parseArg(arg, "S", &u, &_u)) { self->object->removeAll(*u); Py_RETURN_SELF(); } if (!parseArg(arg, "P", TYPE_CLASSID(UnicodeSet), &set)) { self->object->removeAll(*set); Py_RETURN_SELF(); } PyErr_SetArgsError((PyObject *) self, "removeAll", arg); return NULL; } static PyObject *t_unicodeset_applyPattern(t_unicodeset *self, PyObject *arg) { UnicodeString *u, _u; if (!parseArg(arg, "S", &u, &_u)) { STATUS_CALL(self->object->applyPattern(*u, status)); Py_RETURN_SELF(); } PyErr_SetArgsError((PyObject *) self, "applyPattern", arg); return NULL; } static PyObject *t_unicodeset_applyIntPropertyValue(t_unicodeset *self, PyObject *args) { UProperty prop; int32_t value; if (!parseArgs(args, "ii", &prop, &value)) { STATUS_CALL(self->object->applyIntPropertyValue(prop, value, status)); Py_RETURN_SELF(); } PyErr_SetArgsError((PyObject *) self, "applyIntPropertyValue", args); return NULL; } static PyObject *t_unicodeset_applyPropertyAlias(t_unicodeset *self, PyObject *args) { UnicodeString *u0, *u1; UnicodeString _u0, _u1; if (!parseArgs(args, "SS", &u0, &_u0, &u1, &_u1)) { STATUS_CALL(self->object->applyPropertyAlias(*u0, *u1, status)); Py_RETURN_SELF(); } PyErr_SetArgsError((PyObject *) self, "applyPropertyAlias", args); return NULL; } static PyObject *t_unicodeset_contains(t_unicodeset *self, PyObject *args) { UnicodeString *u0, *u1; UnicodeString _u0, _u1; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "S", &u0, &_u0)) { UChar32 c0; int32_t l0; if (u0->length() == 1) { STATUS_CALL(l0 = toUChar32(*u0, &c0, status)); if (l0 == 1) { UBool b = self->object->contains(c0); Py_RETURN_BOOL(b); } } else { UBool b = self->object->contains(*u0); Py_RETURN_BOOL(b); } } break; case 2: if (!parseArgs(args, "SS", &u0, &_u0, &u1, &_u1)) { UChar32 c0, c1; int32_t l0, l1; STATUS_CALL(l0 = toUChar32(*u0, &c0, status)); STATUS_CALL(l1 = toUChar32(*u1, &c1, status)); if (l0 == 1 && l1 == 1) { UBool b = self->object->contains(c0, c1); Py_RETURN_BOOL(b); } } break; } return PyErr_SetArgsError((PyObject *) self, "contains", args); } static PyObject *t_unicodeset_containsAll(t_unicodeset *self, PyObject *arg) { UnicodeString *u, _u; UnicodeSet *set; UBool b; if (!parseArg(arg, "S", &u, &_u)) b = self->object->containsAll(*u); else if (!parseArg(arg, "P", TYPE_CLASSID(UnicodeSet), &set)) b = self->object->containsAll(*set); else return PyErr_SetArgsError((PyObject *) self, "containsAll", arg); Py_RETURN_BOOL(b); } static PyObject *t_unicodeset_containsNone(t_unicodeset *self, PyObject *args) { UnicodeString *u0, *u1; UnicodeString _u0, _u1; UnicodeSet *set; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "S", &u0, &_u0)) { UBool b = self->object->containsNone(*u0); Py_RETURN_BOOL(b); } if (!parseArgs(args, "P", TYPE_CLASSID(UnicodeSet), &set)) { UBool b = self->object->containsNone(*u0); Py_RETURN_BOOL(b); } break; case 2: if (!parseArgs(args, "SS", &u0, &_u0, &u1, &_u1)) { UChar32 c0, c1; int32_t l0, l1; STATUS_CALL(l0 = toUChar32(*u0, &c0, status)); STATUS_CALL(l1 = toUChar32(*u1, &c1, status)); if (l0 == 1 && l1 == 1) { UBool b = self->object->containsNone(c0, c1); Py_RETURN_BOOL(b); } } break; } return PyErr_SetArgsError((PyObject *) self, "containsNone", args); } static PyObject *t_unicodeset_containsSome(t_unicodeset *self, PyObject *args) { UnicodeString *u0, *u1; UnicodeString _u0, _u1; UnicodeSet *set; switch (PyTuple_Size(args)) { case 1: if (!parseArgs(args, "S", &u0, &_u0)) { UBool b = self->object->containsSome(*u0); Py_RETURN_BOOL(b); } if (!parseArgs(args, "P", TYPE_CLASSID(UnicodeSet), &set)) { UBool b = self->object->containsSome(*u0); Py_RETURN_BOOL(b); } break; case 2: if (!parseArgs(args, "SS", &u0, &_u0, &u1, &_u1)) { UChar32 c0, c1; int32_t l0, l1; STATUS_CALL(l0 = toUChar32(*u0, &c0, status)); STATUS_CALL(l1 = toUChar32(*u1, &c1, status)); if (l0 == 1 && l1 == 1) { UBool b = self->object->containsSome(c0, c1); Py_RETURN_BOOL(b); } } break; } return PyErr_SetArgsError((PyObject *) self, "containsSome", args); } static PyObject *t_unicodeset_span(t_unicodeset *self, PyObject *args) { UnicodeString *u, _u; USetSpanCondition spanCondition; int32_t length; if (!parseArgs(args, "Si", &u, &_u, &spanCondition)) { length = self->object->span(u->getBuffer(), u->length(), spanCondition); return PyInt_FromLong(length); } return PyErr_SetArgsError((PyObject *) self, "span", args); } static PyObject *t_unicodeset_spanBack(t_unicodeset *self, PyObject *args) { UnicodeString *u, _u; USetSpanCondition spanCondition; int length; if (!parseArgs(args, "Si", &u, &_u, &spanCondition)) { length = self->object->spanBack(u->getBuffer(), u->length(), spanCondition); return PyInt_FromLong(length); } return PyErr_SetArgsError((PyObject *) self, "spanBack", args); } static PyObject *t_unicodeset_clear(t_unicodeset *self) { self->object->clear(); Py_RETURN_SELF(); } #if U_ICU_VERSION_HEX >= 0x04020000 static PyObject *t_unicodeset_removeAllStrings(t_unicodeset *self) { self->object->removeAllStrings(); Py_RETURN_SELF(); } #endif static PyObject *t_unicodeset_closeOver(t_unicodeset *self, PyObject *arg) { int32_t attribute; if (!parseArg(arg, "i", &attribute)) { self->object->closeOver(attribute); Py_RETURN_SELF(); } return PyErr_SetArgsError((PyObject *) self, "closeOver", arg); } static PyObject *t_unicodeset_compact(t_unicodeset *self) { self->object->compact(); Py_RETURN_SELF(); } static PyObject *t_unicodeset_getRangeCount(t_unicodeset *self) { int32_t count = self->object->getRangeCount(); return PyInt_FromLong(count); } static PyObject *t_unicodeset_getRangeStart(t_unicodeset *self, PyObject *arg) { int32_t index; if (!parseArg(arg, "i", &index)) { UnicodeString u = UnicodeString(self->object->getRangeStart(index)); return PyUnicode_FromUnicodeString(&u); } return PyErr_SetArgsError((PyObject *) self, "getRangeStart", arg); } static PyObject *t_unicodeset_getRangeEnd(t_unicodeset *self, PyObject *arg) { int32_t index; if (!parseArg(arg, "i", &index)) { UnicodeString u = UnicodeString(self->object->getRangeEnd(index)); return PyUnicode_FromUnicodeString(&u); } return PyErr_SetArgsError((PyObject *) self, "getRangeEnd", arg); } static PyObject *t_unicodeset_resemblesPattern(PyTypeObject *type, PyObject *args) { UnicodeString *u, _u; int32_t pos; if (!parseArgs(args, "Si", &u, &_u, &pos)) { UBool b = UnicodeSet::resemblesPattern(*u, pos); Py_RETURN_BOOL(b); } return PyErr_SetArgsError(type, "resemblesPattern", args); } static PyObject *t_unicodeset_createFrom(PyTypeObject *type, PyObject *arg) { UnicodeString *u, _u; if (!parseArg(arg, "S", &u, &_u)) return wrap_UnicodeSet(UnicodeSet::createFrom(*u), T_OWNED); return PyErr_SetArgsError(type, "createFrom", arg); } static PyObject *t_unicodeset_createFromAll(PyTypeObject *type, PyObject *arg) { UnicodeString *u, _u; if (!parseArg(arg, "S", &u, &_u)) return wrap_UnicodeSet(UnicodeSet::createFromAll(*u), T_OWNED); return PyErr_SetArgsError(type, "createFromAll", arg); } static PyObject *t_unicodeset_str(t_unicodeset *self) { UnicodeString u; self->object->toPattern(u); return PyUnicode_FromUnicodeString(&u); } DEFINE_RICHCMP(UnicodeSet, t_unicodeset); static PyObject *t_unicodeset_iter(t_unicodeset *self) { return PyObject_CallFunctionObjArgs((PyObject *) &UnicodeSetIteratorType_, (PyObject *) self, NULL); } static long t_unicodeset_hash(t_unicodeset *self) { return (long) self->object->hashCode(); } static Py_ssize_t _t_unicodeset_length(t_unicodeset *self) { return self->object->size(); } static int _t_unicodeset_contains(t_unicodeset *self, PyObject *arg) { UnicodeString *u, _u; if (!parseArg(arg, "S", &u, &_u)) { UChar32 c; int32_t l; if (u->length() == 1) { INT_STATUS_CALL(l = toUChar32(*u, &c, status)); if (l == 1) return self->object->contains(c); } else return self->object->contains(*u); } PyErr_SetArgsError((PyObject *) self, "in", arg); return -1; } static PyObject *_t_unicodeset_item(t_unicodeset *self, int n) { int len = self->object->size(); if (n < 0) n += len; if (n >= 0 && n < len) { UnicodeString u = UnicodeString(self->object->charAt(n)); return PyUnicode_FromUnicodeString(&u); } PyErr_SetNone(PyExc_IndexError); return NULL; } static PySequenceMethods t_unicodeset_as_sequence = { (lenfunc) _t_unicodeset_length, /* sq_length */ NULL, /* sq_concat */ NULL, /* sq_repeat */ (ssizeargfunc) _t_unicodeset_item, /* sq_item */ NULL, /* sq_slice */ NULL, /* sq_ass_item */ NULL, /* sq_ass_slice */ (objobjproc) _t_unicodeset_contains, /* sq_contains */ NULL, /* sq_inplace_concat */ NULL, /* sq_inplace_repeat */ }; /* UnicodeSetIterator */ static int t_unicodesetiterator_init(t_unicodesetiterator *self, PyObject *args, PyObject *kwds) { UnicodeSet *set; switch (PyTuple_Size(args)) { case 0: self->object = new UnicodeSetIterator(); self->flags = T_OWNED; break; case 1: if (!parseArgs(args, "p", TYPE_CLASSID(UnicodeSet), &set, &self->set)) { self->object = new UnicodeSetIterator(*set); self->flags = T_OWNED; break; } PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; default: PyErr_SetArgsError((PyObject *) self, "__init__", args); return -1; } if (self->object) return 0; return -1; } static PyObject *t_unicodesetiterator_isString(t_unicodesetiterator *self) { UBool b = self->object->isString(); Py_RETURN_BOOL(b); } static PyObject *t_unicodesetiterator_getCodepoint(t_unicodesetiterator *self) { UChar32 c = self->object->getCodepoint(); UnicodeString u = fromUChar32(c); return PyUnicode_FromUnicodeString(&u); } static PyObject *t_unicodesetiterator_getCodepointEnd(t_unicodesetiterator *self) { UChar32 c = self->object->getCodepointEnd(); UnicodeString u = fromUChar32(c); return PyUnicode_FromUnicodeString(&u); } static PyObject *t_unicodesetiterator_getString(t_unicodesetiterator *self) { UnicodeString u = self->object->getString(); return PyUnicode_FromUnicodeString(&u); } static PyObject *t_unicodesetiterator_next(t_unicodesetiterator *self) { UBool b = self->object->next(); Py_RETURN_BOOL(b); } static PyObject *t_unicodesetiterator_nextRange(t_unicodesetiterator *self) { UBool b = self->object->nextRange(); Py_RETURN_BOOL(b); } static PyObject *t_unicodesetiterator_reset(t_unicodesetiterator *self, PyObject *args) { UnicodeSet *set; switch (PyTuple_Size(args)) { case 0: self->object->reset(); Py_RETURN_NONE; case 1: if (!parseArgs(args, "P", TYPE_CLASSID(UnicodeSet), &set)) { PyObject *setObject = PyTuple_GetItem(args, 0); Py_INCREF(setObject); Py_XDECREF(self->set); self->set = setObject; self->object->reset(*set); Py_RETURN_NONE; } break; } return PyErr_SetArgsError((PyObject *) self, "reset", args); } static PyObject *t_unicodesetiterator_iter(t_unicodesetiterator *self) { Py_RETURN_SELF(); } static PyObject *t_unicodesetiterator_iter_next(t_unicodesetiterator *self) { if (!self->object->next()) { PyErr_SetNone(PyExc_StopIteration); return NULL; } return t_unicodesetiterator_getString(self); } void _init_unicodeset(PyObject *m) { UnicodeSetType_.tp_str = (reprfunc) t_unicodeset_str; UnicodeSetType_.tp_richcompare = (richcmpfunc) t_unicodeset_richcmp; UnicodeSetType_.tp_hash = (hashfunc) t_unicodeset_hash; UnicodeSetType_.tp_iter = (getiterfunc) t_unicodeset_iter; UnicodeSetType_.tp_as_sequence = &t_unicodeset_as_sequence; UnicodeSetIteratorType_.tp_iter = (getiterfunc) t_unicodesetiterator_iter; UnicodeSetIteratorType_.tp_iternext = (iternextfunc) t_unicodesetiterator_iter_next; INSTALL_CONSTANTS_TYPE(UMatchDegree, m); INSTALL_CONSTANTS_TYPE(USetSpanCondition, m); REGISTER_TYPE(UnicodeFunctor, m); INSTALL_TYPE(UnicodeMatcher, m); REGISTER_TYPE(UnicodeFilter, m); REGISTER_TYPE(UnicodeSet, m); REGISTER_TYPE(UnicodeSetIterator, m); INSTALL_ENUM(UMatchDegree, "MISMATCH", U_MISMATCH); INSTALL_ENUM(UMatchDegree, "PARTIAL_MATCH", U_PARTIAL_MATCH); INSTALL_ENUM(UMatchDegree, "MATCH", U_MATCH); INSTALL_ENUM(USetSpanCondition, "SPAN_NOT_CONTAINED", USET_SPAN_NOT_CONTAINED); INSTALL_ENUM(USetSpanCondition, "SPAN_CONTAINED", USET_SPAN_CONTAINED); INSTALL_ENUM(USetSpanCondition, "SPAN_SIMPLE", USET_SPAN_SIMPLE); } ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1430285598.0 PyICU-2.4.2/unicodeset.h0000644000076500000000000000305100000000000015166 0ustar00vajdawheel00000000000000/* ==================================================================== * 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 */