--- /dev/null
+#ifndef Py_UNICODEOBJECT_H
+#define Py_UNICODEOBJECT_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+
+Unicode implementation based on original code by Fredrik Lundh,
+modified by Marc-Andre Lemburg (mal@lemburg.com) according to the
+Unicode Integration Proposal (see file Misc/unicode.txt).
+
+(c) Copyright CNRI, All Rights Reserved. NO WARRANTY.
+
+
+ Original header:
+ --------------------------------------------------------------------
+
+ * Yet another Unicode string type for Python. This type supports the
+ * 16-bit Basic Multilingual Plane (BMP) only.
+ *
+ * Written by Fredrik Lundh, January 1999.
+ *
+ * Copyright (c) 1999 by Secret Labs AB.
+ * Copyright (c) 1999 by Fredrik Lundh.
+ *
+ * fredrik@pythonware.com
+ * http://www.pythonware.com
+ *
+ * --------------------------------------------------------------------
+ * This Unicode String Type is
+ *
+ * Copyright (c) 1999 by Secret Labs AB
+ * Copyright (c) 1999 by Fredrik Lundh
+ *
+ * By obtaining, using, and/or copying this software and/or its
+ * associated documentation, you agree that you have read, understood,
+ * and will comply with the following terms and conditions:
+ *
+ * Permission to use, copy, modify, and distribute this software and its
+ * associated documentation for any purpose and without fee is hereby
+ * granted, provided that the above copyright notice appears in all
+ * copies, and that both that copyright notice and this permission notice
+ * appear in supporting documentation, and that the name of Secret Labs
+ * AB or the author not be used in advertising or publicity pertaining to
+ * distribution of the software without specific, written prior
+ * permission.
+ *
+ * SECRET LABS AB AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO
+ * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS. IN NO EVENT SHALL SECRET LABS AB OR THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
+ * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ * -------------------------------------------------------------------- */
+
+#include "ctype.h"
+
+/* === Internal API ======================================================= */
+
+/* --- Internal Unicode Format -------------------------------------------- */
+
+/* Set these flags if the platform has "wchar.h", "wctype.h" and the
+ wchar_t type is a 16-bit unsigned type */
+/* #define HAVE_WCHAR_H */
+/* #define HAVE_USABLE_WCHAR_T */
+
+/* Defaults for various platforms */
+#ifndef HAVE_USABLE_WCHAR_T
+
+/* Windows has a usable wchar_t type */
+# if defined(MS_WIN32)
+# define HAVE_USABLE_WCHAR_T
+# endif
+
+#endif
+
+/* If the compiler provides a wchar_t type we try to support it
+ through the interface functions PyUnicode_FromWideChar() and
+ PyUnicode_AsWideChar(). */
+
+#ifdef HAVE_USABLE_WCHAR_T
+# define HAVE_WCHAR_H
+#endif
+
+#ifdef HAVE_WCHAR_H
+# include "wchar.h"
+#endif
+
+#ifdef HAVE_USABLE_WCHAR_T
+
+/* If the compiler defines whcar_t as a 16-bit unsigned type we can
+ use the compiler type directly. Works fine with all modern Windows
+ platforms. */
+
+typedef wchar_t Py_UNICODE;
+
+#else
+
+/* Use if you have a standard ANSI compiler, without wchar_t support.
+ If a short is not 16 bits on your platform, you have to fix the
+ typedef below, or the module initialization code will complain. */
+
+typedef unsigned short Py_UNICODE;
+
+#endif
+
+/* --- Internal Unicode Operations ---------------------------------------- */
+
+/* If you want Python to use the compiler's wctype.h functions instead
+ of the ones supplied with Python, define WANT_WCTYPE_FUNCTIONS.
+ This reduces the interpreter's code size. */
+
+#if defined(HAVE_USABLE_WCHAR_T) && defined(WANT_WCTYPE_FUNCTIONS)
+
+#include "wctype.h"
+
+#define Py_UNICODE_ISSPACE(ch) iswspace(ch)
+
+#define Py_UNICODE_ISLOWER(ch) iswlower(ch)
+#define Py_UNICODE_ISUPPER(ch) iswupper(ch)
+#define Py_UNICODE_ISTITLE(ch) _PyUnicode_IsTitlecase(ch)
+#define Py_UNICODE_ISLINEBREAK(ch) _PyUnicode_IsLinebreak(ch)
+
+#define Py_UNICODE_TOLOWER(ch) towlower(ch)
+#define Py_UNICODE_TOUPPER(ch) towupper(ch)
+#define Py_UNICODE_TOTITLE(ch) _PyUnicode_ToTitlecase(ch)
+
+#define Py_UNICODE_ISDECIMAL(ch) _PyUnicode_IsDecimalDigit(ch)
+#define Py_UNICODE_ISDIGIT(ch) _PyUnicode_IsDigit(ch)
+#define Py_UNICODE_ISNUMERIC(ch) _PyUnicode_IsNumeric(ch)
+
+#define Py_UNICODE_TODECIMAL(ch) _PyUnicode_ToDecimalDigit(ch)
+#define Py_UNICODE_TODIGIT(ch) _PyUnicode_ToDigit(ch)
+#define Py_UNICODE_TONUMERIC(ch) _PyUnicode_ToNumeric(ch)
+
+#else
+
+#define Py_UNICODE_ISSPACE(ch) _PyUnicode_IsWhitespace(ch)
+
+#define Py_UNICODE_ISLOWER(ch) _PyUnicode_IsLowercase(ch)
+#define Py_UNICODE_ISUPPER(ch) _PyUnicode_IsUppercase(ch)
+#define Py_UNICODE_ISTITLE(ch) _PyUnicode_IsTitlecase(ch)
+#define Py_UNICODE_ISLINEBREAK(ch) _PyUnicode_IsLinebreak(ch)
+
+#define Py_UNICODE_TOLOWER(ch) _PyUnicode_ToLowercase(ch)
+#define Py_UNICODE_TOUPPER(ch) _PyUnicode_ToUppercase(ch)
+#define Py_UNICODE_TOTITLE(ch) _PyUnicode_ToTitlecase(ch)
+
+#define Py_UNICODE_ISDECIMAL(ch) _PyUnicode_IsDecimalDigit(ch)
+#define Py_UNICODE_ISDIGIT(ch) _PyUnicode_IsDigit(ch)
+#define Py_UNICODE_ISNUMERIC(ch) _PyUnicode_IsNumeric(ch)
+
+#define Py_UNICODE_TODECIMAL(ch) _PyUnicode_ToDecimalDigit(ch)
+#define Py_UNICODE_TODIGIT(ch) _PyUnicode_ToDigit(ch)
+#define Py_UNICODE_TONUMERIC(ch) _PyUnicode_ToNumeric(ch)
+
+#endif
+
+#define Py_UNICODE_COPY(target, source, length)\
+ (memcpy((target), (source), (length)*sizeof(Py_UNICODE)))
+
+#define Py_UNICODE_FILL(target, value, length) do\
+ {int i; for (i = 0; i < (length); i++) (target)[i] = (value);}\
+ while (0)
+
+#define Py_UNICODE_MATCH(string, offset, substring)\
+ (!memcmp((string)->str + (offset), (substring)->str,\
+ (substring)->length*sizeof(Py_UNICODE)))
+
+/* --- Unicode Type ------------------------------------------------------- */
+
+typedef struct {
+ PyObject_HEAD
+ int length; /* Length of raw Unicode data in buffer */
+ Py_UNICODE *str; /* Raw Unicode buffer */
+ long hash; /* Hash value; -1 if not set */
+ PyObject *utf8str; /* UTF-8 encoded version as Python string,
+ or NULL */
+} PyUnicodeObject;
+
+extern DL_IMPORT(PyTypeObject) PyUnicode_Type;
+
+#define PyUnicode_Check(op) (((op)->ob_type == &PyUnicode_Type))
+
+/* Fast access macros */
+#define PyUnicode_GET_SIZE(op) \
+ (((PyUnicodeObject *)(op))->length)
+#define PyUnicode_GET_DATA_SIZE(op) \
+ (((PyUnicodeObject *)(op))->length * sizeof(Py_UNICODE))
+#define PyUnicode_AS_UNICODE(op) \
+ (((PyUnicodeObject *)(op))->str)
+#define PyUnicode_AS_DATA(op) \
+ ((const char *)((PyUnicodeObject *)(op))->str)
+
+/* --- Constants ---------------------------------------------------------- */
+
+/* This Unicode character will be used as replacement character during
+ decoding if the errors argument is set to "replace". Note: the
+ Unicode character U+FFFD is the official REPLACEMENT CHARACTER in
+ Unicode 3.0. */
+
+#define Py_UNICODE_REPLACEMENT_CHARACTER ((Py_UNICODE) 0xFFFD)
+
+/* === Public API ========================================================= */
+
+/* --- Plain Py_UNICODE --------------------------------------------------- */
+
+/* Create a Unicode Object from the Py_UNICODE buffer u of the given
+ size. u may be NULL which causes the contents to be undefined. It
+ is the user's responsibility to fill in the needed data.
+
+ The buffer is copied into the new object. */
+
+extern DL_IMPORT(PyObject*) PyUnicode_FromUnicode(
+ const Py_UNICODE *u, /* Unicode buffer */
+ int size /* size of buffer */
+ );
+
+/* Return a read-only pointer to the Unicode object's internal
+ Py_UNICODE buffer. */
+
+extern DL_IMPORT(Py_UNICODE *) PyUnicode_AsUnicode(
+ PyObject *unicode /* Unicode object */
+ );
+
+/* Get the length of the Unicode object. */
+
+extern DL_IMPORT(int) PyUnicode_GetSize(
+ PyObject *unicode /* Unicode object */
+ );
+
+/* Coerce obj to an Unicode object and return a reference with
+ *incremented* refcount.
+
+ Coercion is done in the following way:
+
+ 1. Unicode objects are passed back as-is with incremented
+ refcount.
+
+ 2. String and other char buffer compatible objects are decoded
+ under the assumptions that they contain UTF-8 data. Decoding
+ is done in "strict" mode.
+
+ 3. All other objects raise an exception.
+
+ The API returns NULL in case of an error. The caller is responsible
+ for decref'ing the returned objects.
+
+*/
+
+extern DL_IMPORT(PyObject*) PyUnicode_FromObject(
+ register PyObject *obj /* Object */
+ );
+
+/* --- wchar_t support for platforms which support it --------------------- */
+
+#ifdef HAVE_WCHAR_H
+
+/* Create a Unicode Object from the whcar_t buffer w of the given
+ size.
+
+ The buffer is copied into the new object. */
+
+extern DL_IMPORT(PyObject*) PyUnicode_FromWideChar(
+ register const wchar_t *w, /* wchar_t buffer */
+ int size /* size of buffer */
+ );
+
+/* Copies the Unicode Object contents into the whcar_t buffer w. At
+ most size wchar_t characters are copied.
+
+ Returns the number of wchar_t characters copied or -1 in case of an
+ error. */
+
+extern DL_IMPORT(int) PyUnicode_AsWideChar(
+ PyUnicodeObject *unicode, /* Unicode object */
+ register wchar_t *w, /* wchar_t buffer */
+ int size /* size of buffer */
+ );
+
+#endif
+
+/* === Builtin Codecs =====================================================
+
+ Many of these APIs take two arguments encoding and errors. These
+ parameters encoding and errors have the same semantics as the ones
+ of the builtin unicode() API.
+
+ Setting encoding to NULL causes the default encoding to be used
+ which is UTF-8.
+
+ Error handling is set by errors which may also be set to NULL
+ meaning to use the default handling defined for the codec. Default
+ error handling for all builtin codecs is "strict" (ValueErrors are
+ raised).
+
+ The codecs all use a similar interface. Only deviation from the
+ generic ones are documented.
+
+*/
+
+/* --- Generic Codecs ----------------------------------------------------- */
+
+/* Create a Unicode object by decoding the encoded string s of the
+ given size. */
+
+extern DL_IMPORT(PyObject*) PyUnicode_Decode(
+ const char *s, /* encoded string */
+ int size, /* size of buffer */
+ const char *encoding, /* encoding */
+ const char *errors /* error handling */
+ );
+
+/* Encodes a Py_UNICODE buffer of the given size and returns a
+ Python string object. */
+
+extern DL_IMPORT(PyObject*) PyUnicode_Encode(
+ const Py_UNICODE *s, /* Unicode char buffer */
+ int size, /* number of Py_UNICODE chars to encode */
+ const char *encoding, /* encoding */
+ const char *errors /* error handling */
+ );
+
+/* Encodes a Unicode object and returns the result as Python string
+ object. */
+
+extern DL_IMPORT(PyObject*) PyUnicode_AsEncodedString(
+ PyObject *unicode, /* Unicode object */
+ const char *encoding, /* encoding */
+ const char *errors /* error handling */
+ );
+
+/* --- UTF-8 Codecs ------------------------------------------------------- */
+
+extern DL_IMPORT(PyObject*) PyUnicode_DecodeUTF8(
+ const char *string, /* UTF-8 encoded string */
+ int length, /* size of string */
+ const char *errors /* error handling */
+ );
+
+extern DL_IMPORT(PyObject*) PyUnicode_AsUTF8String(
+ PyObject *unicode /* Unicode object */
+ );
+
+extern DL_IMPORT(PyObject*) PyUnicode_EncodeUTF8(
+ const Py_UNICODE *data, /* Unicode char buffer */
+ int length, /* number of Py_UNICODE chars to encode */
+ const char *errors /* error handling */
+ );
+
+/* --- UTF-16 Codecs ------------------------------------------------------ */
+
+/* Decodes length bytes from a UTF-16 encoded buffer string and return
+ the corresponding Unicode object.
+
+ errors (if non-NULL) defines the error handling. It defaults
+ to "strict".
+
+ If byteorder is non-NULL, the decoder starts decoding using the
+ given byte order:
+
+ *byteorder == -1: little endian
+ *byteorder == 0: native order
+ *byteorder == 1: big endian
+
+ and then switches according to all BOM marks it finds in the input
+ data. BOM marks are not copied into the resulting Unicode string.
+ After completion, *byteorder is set to the current byte order at
+ the end of input data.
+
+ If byteorder is NULL, the codec starts in native order mode.
+
+*/
+
+extern DL_IMPORT(PyObject*) PyUnicode_DecodeUTF16(
+ const char *string, /* UTF-16 encoded string */
+ int length, /* size of string */
+ const char *errors, /* error handling */
+ int *byteorder /* pointer to byteorder to use
+ 0=native;-1=LE,1=BE; updated on
+ exit */
+ );
+
+/* Returns a Python string using the UTF-16 encoding in native byte
+ order. The string always starts with a BOM mark. */
+
+extern DL_IMPORT(PyObject*) PyUnicode_AsUTF16String(
+ PyObject *unicode /* Unicode object */
+ );
+
+/* Returns a Python string object holding the UTF-16 encoded value of
+ the Unicode data in s.
+
+ If byteorder is not 0, output is written according to the following
+ byte order:
+
+ byteorder == -1: little endian
+ byteorder == 0: native byte order (writes a BOM mark)
+ byteorder == 1: big endian
+
+ If byteorder is 0, the output string will always start with the
+ Unicode BOM mark (U+FEFF). In the other two modes, no BOM mark is
+ prepended.
+
+ Note that Py_UNICODE data is being interpreted as UTF-16 reduced to
+ UCS-2. This trick makes it possible to add full UTF-16 capabilities
+ at a later point without comprimising the APIs.
+
+*/
+
+extern DL_IMPORT(PyObject*) PyUnicode_EncodeUTF16(
+ const Py_UNICODE *data, /* Unicode char buffer */
+ int length, /* number of Py_UNICODE chars to encode */
+ const char *errors, /* error handling */
+ int byteorder /* byteorder to use 0=BOM+native;-1=LE,1=BE */
+ );
+
+/* --- Unicode-Escape Codecs ---------------------------------------------- */
+
+extern DL_IMPORT(PyObject*) PyUnicode_DecodeUnicodeEscape(
+ const char *string, /* Unicode-Escape encoded string */
+ int length, /* size of string */
+ const char *errors /* error handling */
+ );
+
+extern DL_IMPORT(PyObject*) PyUnicode_AsUnicodeEscapeString(
+ PyObject *unicode /* Unicode object */
+ );
+
+extern DL_IMPORT(PyObject*) PyUnicode_EncodeUnicodeEscape(
+ const Py_UNICODE *data, /* Unicode char buffer */
+ int length /* Number of Py_UNICODE chars to encode */
+ );
+
+/* --- Raw-Unicode-Escape Codecs ------------------------------------------ */
+
+extern DL_IMPORT(PyObject*) PyUnicode_DecodeRawUnicodeEscape(
+ const char *string, /* Raw-Unicode-Escape encoded string */
+ int length, /* size of string */
+ const char *errors /* error handling */
+ );
+
+extern DL_IMPORT(PyObject*) PyUnicode_AsRawUnicodeEscapeString(
+ PyObject *unicode /* Unicode object */
+ );
+
+extern DL_IMPORT(PyObject*) PyUnicode_EncodeRawUnicodeEscape(
+ const Py_UNICODE *data, /* Unicode char buffer */
+ int length /* Number of Py_UNICODE chars to encode */
+ );
+
+/* --- Latin-1 Codecs -----------------------------------------------------
+
+ Note: Latin-1 corresponds to the first 256 Unicode ordinals.
+
+*/
+
+extern DL_IMPORT(PyObject*) PyUnicode_DecodeLatin1(
+ const char *string, /* Latin-1 encoded string */
+ int length, /* size of string */
+ const char *errors /* error handling */
+ );
+
+extern DL_IMPORT(PyObject*) PyUnicode_AsLatin1String(
+ PyObject *unicode /* Unicode object */
+ );
+
+extern DL_IMPORT(PyObject*) PyUnicode_EncodeLatin1(
+ const Py_UNICODE *data, /* Unicode char buffer */
+ int length, /* Number of Py_UNICODE chars to encode */
+ const char *errors /* error handling */
+ );
+
+/* --- ASCII Codecs -------------------------------------------------------
+
+ Only 7-bit ASCII data is excepted. All other codes generate errors.
+
+*/
+
+extern DL_IMPORT(PyObject*) PyUnicode_DecodeASCII(
+ const char *string, /* ASCII encoded string */
+ int length, /* size of string */
+ const char *errors /* error handling */
+ );
+
+extern DL_IMPORT(PyObject*) PyUnicode_AsASCIIString(
+ PyObject *unicode /* Unicode object */
+ );
+
+extern DL_IMPORT(PyObject*) PyUnicode_EncodeASCII(
+ const Py_UNICODE *data, /* Unicode char buffer */
+ int length, /* Number of Py_UNICODE chars to encode */
+ const char *errors /* error handling */
+ );
+
+/* --- Character Map Codecs -----------------------------------------------
+
+ This codec uses mappings to encode and decode characters.
+
+ Decoding mappings must map single string characters to single
+ Unicode characters, integers (which are then interpreted as Unicode
+ ordinals) or None (meaning "undefined mapping" and causing an
+ error).
+
+ Encoding mappings must map single Unicode characters to single
+ string characters, integers (which are then interpreted as Latin-1
+ ordinals) or None (meaning "undefined mapping" and causing an
+ error).
+
+ If a character lookup fails with a LookupError, the character is
+ copied as-is meaning that its ordinal value will be interpreted as
+ Unicode or Latin-1 ordinal resp. Because of this mappings only need
+ to contain those mappings which map characters to different code
+ points.
+
+*/
+
+extern DL_IMPORT(PyObject*) PyUnicode_DecodeCharmap(
+ const char *string, /* Encoded string */
+ int length, /* size of string */
+ PyObject *mapping, /* character mapping
+ (char ordinal -> unicode ordinal) */
+ const char *errors /* error handling */
+ );
+
+extern DL_IMPORT(PyObject*) PyUnicode_AsCharmapString(
+ PyObject *unicode, /* Unicode object */
+ PyObject *mapping /* character mapping
+ (unicode ordinal -> char ordinal) */
+ );
+
+extern DL_IMPORT(PyObject*) PyUnicode_EncodeCharmap(
+ const Py_UNICODE *data, /* Unicode char buffer */
+ int length, /* Number of Py_UNICODE chars to encode */
+ PyObject *mapping, /* character mapping
+ (unicode ordinal -> char ordinal) */
+ const char *errors /* error handling */
+ );
+
+/* Translate a Py_UNICODE buffer of the given length by applying a
+ character mapping table to it and return the resulting Unicode
+ object.
+
+ The mapping table must map Unicode ordinal integers to Unicode
+ ordinal integers or None (causing deletion of the character).
+
+ Mapping tables may be dictionaries or sequences. Unmapped character
+ ordinals (ones which cause a LookupError) are left untouched and
+ are copied as-is.
+
+*/
+
+extern DL_IMPORT(PyObject *) PyUnicode_TranslateCharmap(
+ const Py_UNICODE *data, /* Unicode char buffer */
+ int length, /* Number of Py_UNICODE chars to encode */
+ PyObject *table, /* Translate table */
+ const char *errors /* error handling */
+ );
+
+/* --- Methods & Slots ----------------------------------------------------
+
+ These are capable of handling Unicode objects and strings on input
+ (we refer to them as strings in the descriptions) and return
+ Unicode objects or integers as apporpriate. */
+
+/* Concat two strings giving a new Unicode string. */
+
+extern DL_IMPORT(PyObject*) PyUnicode_Concat(
+ PyObject *left, /* Left string */
+ PyObject *right /* Right string */
+ );
+
+/* Split a string giving a list of Unicode strings.
+
+ If sep is NULL, splitting will be done at all whitespace
+ substrings. Otherwise, splits occur at the given separator.
+
+ At most maxsplit splits will be done. If negative, no limit is set.
+
+ Separators are not included in the resulting list.
+
+*/
+
+extern DL_IMPORT(PyObject*) PyUnicode_Split(
+ PyObject *s, /* String to split */
+ PyObject *sep, /* String separator */
+ int maxsplit /* Maxsplit count */
+ );
+
+/* Dito, but split at line breaks.
+
+ CRLF is considered to be one line break. Line breaks are not
+ included in the resulting list. */
+
+extern DL_IMPORT(PyObject*) PyUnicode_Splitlines(
+ PyObject *s, /* String to split */
+ int maxsplit /* Maxsplit count */
+ );
+
+/* Translate a string by applying a character mapping table to it and
+ return the resulting Unicode object.
+
+ The mapping table must map Unicode ordinal integers to Unicode
+ ordinal integers or None (causing deletion of the character).
+
+ Mapping tables may be dictionaries or sequences. Unmapped character
+ ordinals (ones which cause a LookupError) are left untouched and
+ are copied as-is.
+
+*/
+
+extern DL_IMPORT(PyObject *) PyUnicode_Translate(
+ PyObject *str, /* String */
+ PyObject *table, /* Translate table */
+ const char *errors /* error handling */
+ );
+
+/* Join a sequence of strings using the given separator and return
+ the resulting Unicode string. */
+
+extern DL_IMPORT(PyObject*) PyUnicode_Join(
+ PyObject *separator, /* Separator string */
+ PyObject *seq /* Sequence object */
+ );
+
+/* Return 1 if substr matches str[start:end] at the given tail end, 0
+ otherwise. */
+
+extern DL_IMPORT(int) PyUnicode_Tailmatch(
+ PyObject *str, /* String */
+ PyObject *substr, /* Prefix or Suffix string */
+ int start, /* Start index */
+ int end, /* Stop index */
+ int direction /* Tail end: -1 prefix, +1 suffix */
+ );
+
+/* Return the first position of substr in str[start:end] using the
+ given search direction or -1 if not found. */
+
+extern DL_IMPORT(int) PyUnicode_Find(
+ PyObject *str, /* String */
+ PyObject *substr, /* Substring to find */
+ int start, /* Start index */
+ int end, /* Stop index */
+ int direction /* Find direction: +1 forward, -1 backward */
+ );
+
+/* Count the number of occurances of substr in str[start:end]. */
+
+extern DL_IMPORT(int) PyUnicode_Count(
+ PyObject *str, /* String */
+ PyObject *substr, /* Substring to count */
+ int start, /* Start index */
+ int end /* Stop index */
+ );
+
+/* Replace at most maxcount occurances of substr in str with replstr
+ and return the resulting Unicode object. */
+
+extern DL_IMPORT(PyObject *) PyUnicode_Replace(
+ PyObject *str, /* String */
+ PyObject *substr, /* Substring to find */
+ PyObject *replstr, /* Substring to replace */
+ int maxcount /* Max. number of replacements to apply;
+ -1 = all */
+ );
+
+/* Compare two strings and return -1, 0, 1 for less than, equal,
+ greater than resp. */
+
+extern DL_IMPORT(int) PyUnicode_Compare(
+ PyObject *left, /* Left string */
+ PyObject *right /* Right string */
+ );
+
+/* Apply a argument tuple or dictionar to a format string and return
+ the resulting Unicode string. */
+
+extern DL_IMPORT(PyObject *) PyUnicode_Format(
+ PyObject *format, /* Format string */
+ PyObject *args /* Argument tuple or dictionary */
+ );
+
+/* === Characters Type APIs =============================================== */
+
+/* These should not be used directly. Use the Py_UNICODE_IS* and
+ Py_UNICODE_TO* macros instead.
+
+ These APIs are implemented in Objects/unicodectype.c.
+
+*/
+
+extern DL_IMPORT(int) _PyUnicode_IsLowercase(
+ register const Py_UNICODE ch /* Unicode character */
+ );
+
+extern DL_IMPORT(int) _PyUnicode_IsUppercase(
+ register const Py_UNICODE ch /* Unicode character */
+ );
+
+extern DL_IMPORT(int) _PyUnicode_IsTitlecase(
+ register const Py_UNICODE ch /* Unicode character */
+ );
+
+extern DL_IMPORT(int) _PyUnicode_IsWhitespace(
+ register const Py_UNICODE ch /* Unicode character */
+ );
+
+extern DL_IMPORT(int) _PyUnicode_IsLinebreak(
+ register const Py_UNICODE ch /* Unicode character */
+ );
+
+extern DL_IMPORT(Py_UNICODE) _PyUnicode_ToLowercase(
+ register const Py_UNICODE ch /* Unicode character */
+ );
+
+extern DL_IMPORT(Py_UNICODE) _PyUnicode_ToUppercase(
+ register const Py_UNICODE ch /* Unicode character */
+ );
+
+extern DL_IMPORT(Py_UNICODE) _PyUnicode_ToTitlecase(
+ register const Py_UNICODE ch /* Unicode character */
+ );
+
+extern DL_IMPORT(int) _PyUnicode_ToDecimalDigit(
+ register const Py_UNICODE ch /* Unicode character */
+ );
+
+extern DL_IMPORT(int) _PyUnicode_ToDigit(
+ register const Py_UNICODE ch /* Unicode character */
+ );
+
+extern DL_IMPORT(double) _PyUnicode_ToNumeric(
+ register const Py_UNICODE ch /* Unicode character */
+ );
+
+extern DL_IMPORT(int) _PyUnicode_IsDecimalDigit(
+ register const Py_UNICODE ch /* Unicode character */
+ );
+
+extern DL_IMPORT(int) _PyUnicode_IsDigit(
+ register const Py_UNICODE ch /* Unicode character */
+ );
+
+extern DL_IMPORT(int) _PyUnicode_IsNumeric(
+ register const Py_UNICODE ch /* Unicode character */
+ );
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_UNICODEOBJECT_H */
projects / python / commitdiff