FCL/sf/adapt/qemu: comparison symbian-qemu-0.9.1-12/python-win32-2.6.1/include/unicodeobject.h

equal deleted inserted replaced

-:ffa851df0825
+:2fb8b9db1c86
+#ifndef Py_UNICODEOBJECT_H
+#define Py_UNICODEOBJECT_H
+#include <stdarg.h>
+/*
+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).
+Copyright (c) Corporation for National Research Initiatives.
+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 -------------------------------------------- */
+#ifndef Py_USING_UNICODE
+#define PyUnicode_Check(op)                 0
+#define PyUnicode_CheckExact(op)            0
+#else
+/* FIXME: MvL's new implementation assumes that Py_UNICODE_SIZE is
+properly set, but the default rules below doesn't set it.  I'll
+sort this out some other day -- fredrik@pythonware.com */
+#ifndef Py_UNICODE_SIZE
+#error Must define Py_UNICODE_SIZE
+#endif
+/* Setting Py_UNICODE_WIDE enables UCS-4 storage.  Otherwise, Unicode
+strings are stored as UCS-2 (with limited support for UTF-16) */
+#if Py_UNICODE_SIZE >= 4
+#define Py_UNICODE_WIDE
+#endif
+/* 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 PY_UNICODE_TYPE
+/* Windows has a usable wchar_t type (unless we're using UCS-4) */
+# if defined(MS_WIN32) && Py_UNICODE_SIZE == 2
+#  define HAVE_USABLE_WCHAR_T
+#  define PY_UNICODE_TYPE wchar_t
+# endif
+# if defined(Py_UNICODE_WIDE)
+#  define PY_UNICODE_TYPE Py_UCS4
+# 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
+# ifndef HAVE_WCHAR_H
+#  define HAVE_WCHAR_H
+# endif
+#endif
+#ifdef HAVE_WCHAR_H
+/* Work around a cosmetic bug in BSDI 4.x wchar.h; thanks to Thomas Wouters */
+# ifdef _HAVE_BSDI
+#  include <time.h>
+# endif
+#  include <wchar.h>
+#endif
+/*
+* Use this typedef when you need to represent a UTF-16 surrogate pair
+* as single unsigned integer.
+*/
+#if SIZEOF_INT >= 4
+typedef unsigned int Py_UCS4;
+#elif SIZEOF_LONG >= 4
+typedef unsigned long Py_UCS4;
+#endif
+typedef PY_UNICODE_TYPE Py_UNICODE;
+/* --- UCS-2/UCS-4 Name Mangling ------------------------------------------ */
+/* Unicode API names are mangled to assure that UCS-2 and UCS-4 builds
+produce different external names and thus cause import errors in
+case Python interpreters and extensions with mixed compiled in
+Unicode width assumptions are combined. */
+#ifndef Py_UNICODE_WIDE
+# define PyUnicode_AsASCIIString PyUnicodeUCS2_AsASCIIString
+# define PyUnicode_AsCharmapString PyUnicodeUCS2_AsCharmapString
+# define PyUnicode_AsEncodedObject PyUnicodeUCS2_AsEncodedObject
+# define PyUnicode_AsEncodedString PyUnicodeUCS2_AsEncodedString
+# define PyUnicode_AsLatin1String PyUnicodeUCS2_AsLatin1String
+# define PyUnicode_AsRawUnicodeEscapeString PyUnicodeUCS2_AsRawUnicodeEscapeString
+# define PyUnicode_AsUTF32String PyUnicodeUCS2_AsUTF32String
+# define PyUnicode_AsUTF16String PyUnicodeUCS2_AsUTF16String
+# define PyUnicode_AsUTF8String PyUnicodeUCS2_AsUTF8String
+# define PyUnicode_AsUnicode PyUnicodeUCS2_AsUnicode
+# define PyUnicode_AsUnicodeEscapeString PyUnicodeUCS2_AsUnicodeEscapeString
+# define PyUnicode_AsWideChar PyUnicodeUCS2_AsWideChar
+# define PyUnicode_Compare PyUnicodeUCS2_Compare
+# define PyUnicode_Concat PyUnicodeUCS2_Concat
+# define PyUnicode_Contains PyUnicodeUCS2_Contains
+# define PyUnicode_Count PyUnicodeUCS2_Count
+# define PyUnicode_Decode PyUnicodeUCS2_Decode
+# define PyUnicode_DecodeASCII PyUnicodeUCS2_DecodeASCII
+# define PyUnicode_DecodeCharmap PyUnicodeUCS2_DecodeCharmap
+# define PyUnicode_DecodeLatin1 PyUnicodeUCS2_DecodeLatin1
+# define PyUnicode_DecodeRawUnicodeEscape PyUnicodeUCS2_DecodeRawUnicodeEscape
+# define PyUnicode_DecodeUTF32 PyUnicodeUCS2_DecodeUTF32
+# define PyUnicode_DecodeUTF32Stateful PyUnicodeUCS2_DecodeUTF32Stateful
+# define PyUnicode_DecodeUTF16 PyUnicodeUCS2_DecodeUTF16
+# define PyUnicode_DecodeUTF16Stateful PyUnicodeUCS2_DecodeUTF16Stateful
+# define PyUnicode_DecodeUTF8 PyUnicodeUCS2_DecodeUTF8
+# define PyUnicode_DecodeUTF8Stateful PyUnicodeUCS2_DecodeUTF8Stateful
+# define PyUnicode_DecodeUnicodeEscape PyUnicodeUCS2_DecodeUnicodeEscape
+# define PyUnicode_Encode PyUnicodeUCS2_Encode
+# define PyUnicode_EncodeASCII PyUnicodeUCS2_EncodeASCII
+# define PyUnicode_EncodeCharmap PyUnicodeUCS2_EncodeCharmap
+# define PyUnicode_EncodeDecimal PyUnicodeUCS2_EncodeDecimal
+# define PyUnicode_EncodeLatin1 PyUnicodeUCS2_EncodeLatin1
+# define PyUnicode_EncodeRawUnicodeEscape PyUnicodeUCS2_EncodeRawUnicodeEscape
+# define PyUnicode_EncodeUTF32 PyUnicodeUCS2_EncodeUTF32
+# define PyUnicode_EncodeUTF16 PyUnicodeUCS2_EncodeUTF16
+# define PyUnicode_EncodeUTF8 PyUnicodeUCS2_EncodeUTF8
+# define PyUnicode_EncodeUnicodeEscape PyUnicodeUCS2_EncodeUnicodeEscape
+# define PyUnicode_Find PyUnicodeUCS2_Find
+# define PyUnicode_Format PyUnicodeUCS2_Format
+# define PyUnicode_FromEncodedObject PyUnicodeUCS2_FromEncodedObject
+# define PyUnicode_FromObject PyUnicodeUCS2_FromObject
+# define PyUnicode_FromOrdinal PyUnicodeUCS2_FromOrdinal
+# define PyUnicode_FromUnicode PyUnicodeUCS2_FromUnicode
+# define PyUnicode_FromString PyUnicodeUCS2_FromString
+# define PyUnicode_FromStringAndSize PyUnicodeUCS2_FromStringAndSize
+# define PyUnicode_FromFormatV PyUnicodeUCS2_FromFormatV
+# define PyUnicode_FromFormat PyUnicodeUCS2_FromFormat
+# define PyUnicode_FromWideChar PyUnicodeUCS2_FromWideChar
+# define PyUnicode_GetDefaultEncoding PyUnicodeUCS2_GetDefaultEncoding
+# define PyUnicode_GetMax PyUnicodeUCS2_GetMax
+# define PyUnicode_GetSize PyUnicodeUCS2_GetSize
+# define PyUnicode_Join PyUnicodeUCS2_Join
+# define PyUnicode_Partition PyUnicodeUCS2_Partition
+# define PyUnicode_RPartition PyUnicodeUCS2_RPartition
+# define PyUnicode_RSplit PyUnicodeUCS2_RSplit
+# define PyUnicode_Replace PyUnicodeUCS2_Replace
+# define PyUnicode_Resize PyUnicodeUCS2_Resize
+# define PyUnicode_RichCompare PyUnicodeUCS2_RichCompare
+# define PyUnicode_SetDefaultEncoding PyUnicodeUCS2_SetDefaultEncoding
+# define PyUnicode_Split PyUnicodeUCS2_Split
+# define PyUnicode_Splitlines PyUnicodeUCS2_Splitlines
+# define PyUnicode_Tailmatch PyUnicodeUCS2_Tailmatch
+# define PyUnicode_Translate PyUnicodeUCS2_Translate
+# define PyUnicode_TranslateCharmap PyUnicodeUCS2_TranslateCharmap
+# define _PyUnicode_AsDefaultEncodedString _PyUnicodeUCS2_AsDefaultEncodedString
+# define _PyUnicode_Fini _PyUnicodeUCS2_Fini
+# define _PyUnicode_Init _PyUnicodeUCS2_Init
+# define PyUnicode_ClearFreeList PyUnicodeUCS2_ClearFreelist
+# define _PyUnicode_IsAlpha _PyUnicodeUCS2_IsAlpha
+# define _PyUnicode_IsDecimalDigit _PyUnicodeUCS2_IsDecimalDigit
+# define _PyUnicode_IsDigit _PyUnicodeUCS2_IsDigit
+# define _PyUnicode_IsLinebreak _PyUnicodeUCS2_IsLinebreak
+# define _PyUnicode_IsLowercase _PyUnicodeUCS2_IsLowercase
+# define _PyUnicode_IsNumeric _PyUnicodeUCS2_IsNumeric
+# define _PyUnicode_IsTitlecase _PyUnicodeUCS2_IsTitlecase
+# define _PyUnicode_IsUppercase _PyUnicodeUCS2_IsUppercase
+# define _PyUnicode_IsWhitespace _PyUnicodeUCS2_IsWhitespace
+# define _PyUnicode_ToDecimalDigit _PyUnicodeUCS2_ToDecimalDigit
+# define _PyUnicode_ToDigit _PyUnicodeUCS2_ToDigit
+# define _PyUnicode_ToLowercase _PyUnicodeUCS2_ToLowercase
+# define _PyUnicode_ToNumeric _PyUnicodeUCS2_ToNumeric
+# define _PyUnicode_ToTitlecase _PyUnicodeUCS2_ToTitlecase
+# define _PyUnicode_ToUppercase _PyUnicodeUCS2_ToUppercase
+#else
+# define PyUnicode_AsASCIIString PyUnicodeUCS4_AsASCIIString
+# define PyUnicode_AsCharmapString PyUnicodeUCS4_AsCharmapString
+# define PyUnicode_AsEncodedObject PyUnicodeUCS4_AsEncodedObject
+# define PyUnicode_AsEncodedString PyUnicodeUCS4_AsEncodedString
+# define PyUnicode_AsLatin1String PyUnicodeUCS4_AsLatin1String
+# define PyUnicode_AsRawUnicodeEscapeString PyUnicodeUCS4_AsRawUnicodeEscapeString
+# define PyUnicode_AsUTF32String PyUnicodeUCS4_AsUTF32String
+# define PyUnicode_AsUTF16String PyUnicodeUCS4_AsUTF16String
+# define PyUnicode_AsUTF8String PyUnicodeUCS4_AsUTF8String
+# define PyUnicode_AsUnicode PyUnicodeUCS4_AsUnicode
+# define PyUnicode_AsUnicodeEscapeString PyUnicodeUCS4_AsUnicodeEscapeString
+# define PyUnicode_AsWideChar PyUnicodeUCS4_AsWideChar
+# define PyUnicode_Compare PyUnicodeUCS4_Compare
+# define PyUnicode_Concat PyUnicodeUCS4_Concat
+# define PyUnicode_Contains PyUnicodeUCS4_Contains
+# define PyUnicode_Count PyUnicodeUCS4_Count
+# define PyUnicode_Decode PyUnicodeUCS4_Decode
+# define PyUnicode_DecodeASCII PyUnicodeUCS4_DecodeASCII
+# define PyUnicode_DecodeCharmap PyUnicodeUCS4_DecodeCharmap
+# define PyUnicode_DecodeLatin1 PyUnicodeUCS4_DecodeLatin1
+# define PyUnicode_DecodeRawUnicodeEscape PyUnicodeUCS4_DecodeRawUnicodeEscape
+# define PyUnicode_DecodeUTF32 PyUnicodeUCS4_DecodeUTF32
+# define PyUnicode_DecodeUTF32Stateful PyUnicodeUCS4_DecodeUTF32Stateful
+# define PyUnicode_DecodeUTF16 PyUnicodeUCS4_DecodeUTF16
+# define PyUnicode_DecodeUTF16Stateful PyUnicodeUCS4_DecodeUTF16Stateful
+# define PyUnicode_DecodeUTF8 PyUnicodeUCS4_DecodeUTF8
+# define PyUnicode_DecodeUTF8Stateful PyUnicodeUCS4_DecodeUTF8Stateful
+# define PyUnicode_DecodeUnicodeEscape PyUnicodeUCS4_DecodeUnicodeEscape
+# define PyUnicode_Encode PyUnicodeUCS4_Encode
+# define PyUnicode_EncodeASCII PyUnicodeUCS4_EncodeASCII
+# define PyUnicode_EncodeCharmap PyUnicodeUCS4_EncodeCharmap
+# define PyUnicode_EncodeDecimal PyUnicodeUCS4_EncodeDecimal
+# define PyUnicode_EncodeLatin1 PyUnicodeUCS4_EncodeLatin1
+# define PyUnicode_EncodeRawUnicodeEscape PyUnicodeUCS4_EncodeRawUnicodeEscape
+# define PyUnicode_EncodeUTF32 PyUnicodeUCS4_EncodeUTF32
+# define PyUnicode_EncodeUTF16 PyUnicodeUCS4_EncodeUTF16
+# define PyUnicode_EncodeUTF8 PyUnicodeUCS4_EncodeUTF8
+# define PyUnicode_EncodeUnicodeEscape PyUnicodeUCS4_EncodeUnicodeEscape
+# define PyUnicode_Find PyUnicodeUCS4_Find
+# define PyUnicode_Format PyUnicodeUCS4_Format
+# define PyUnicode_FromEncodedObject PyUnicodeUCS4_FromEncodedObject
+# define PyUnicode_FromObject PyUnicodeUCS4_FromObject
+# define PyUnicode_FromOrdinal PyUnicodeUCS4_FromOrdinal
+# define PyUnicode_FromUnicode PyUnicodeUCS4_FromUnicode
+# define PyUnicode_FromString PyUnicodeUCS4_FromString
+# define PyUnicode_FromStringAndSize PyUnicodeUCS4_FromStringAndSize
+# define PyUnicode_FromFormatV PyUnicodeUCS4_FromFormatV
+# define PyUnicode_FromFormat PyUnicodeUCS4_FromFormat
+# define PyUnicode_FromWideChar PyUnicodeUCS4_FromWideChar
+# define PyUnicode_GetDefaultEncoding PyUnicodeUCS4_GetDefaultEncoding
+# define PyUnicode_GetMax PyUnicodeUCS4_GetMax
+# define PyUnicode_GetSize PyUnicodeUCS4_GetSize
+# define PyUnicode_Join PyUnicodeUCS4_Join
+# define PyUnicode_Partition PyUnicodeUCS4_Partition
+# define PyUnicode_RPartition PyUnicodeUCS4_RPartition
+# define PyUnicode_RSplit PyUnicodeUCS4_RSplit
+# define PyUnicode_Replace PyUnicodeUCS4_Replace
+# define PyUnicode_Resize PyUnicodeUCS4_Resize
+# define PyUnicode_RichCompare PyUnicodeUCS4_RichCompare
+# define PyUnicode_SetDefaultEncoding PyUnicodeUCS4_SetDefaultEncoding
+# define PyUnicode_Split PyUnicodeUCS4_Split
+# define PyUnicode_Splitlines PyUnicodeUCS4_Splitlines
+# define PyUnicode_Tailmatch PyUnicodeUCS4_Tailmatch
+# define PyUnicode_Translate PyUnicodeUCS4_Translate
+# define PyUnicode_TranslateCharmap PyUnicodeUCS4_TranslateCharmap
+# define _PyUnicode_AsDefaultEncodedString _PyUnicodeUCS4_AsDefaultEncodedString
+# define _PyUnicode_Fini _PyUnicodeUCS4_Fini
+# define _PyUnicode_Init _PyUnicodeUCS4_Init
+# define PyUnicode_ClearFreeList PyUnicodeUCS2_ClearFreelist
+# define _PyUnicode_IsAlpha _PyUnicodeUCS4_IsAlpha
+# define _PyUnicode_IsDecimalDigit _PyUnicodeUCS4_IsDecimalDigit
+# define _PyUnicode_IsDigit _PyUnicodeUCS4_IsDigit
+# define _PyUnicode_IsLinebreak _PyUnicodeUCS4_IsLinebreak
+# define _PyUnicode_IsLowercase _PyUnicodeUCS4_IsLowercase
+# define _PyUnicode_IsNumeric _PyUnicodeUCS4_IsNumeric
+# define _PyUnicode_IsTitlecase _PyUnicodeUCS4_IsTitlecase
+# define _PyUnicode_IsUppercase _PyUnicodeUCS4_IsUppercase
+# define _PyUnicode_IsWhitespace _PyUnicodeUCS4_IsWhitespace
+# define _PyUnicode_ToDecimalDigit _PyUnicodeUCS4_ToDecimalDigit
+# define _PyUnicode_ToDigit _PyUnicodeUCS4_ToDigit
+# define _PyUnicode_ToLowercase _PyUnicodeUCS4_ToLowercase
+# define _PyUnicode_ToNumeric _PyUnicodeUCS4_ToNumeric
+# define _PyUnicode_ToTitlecase _PyUnicodeUCS4_ToTitlecase
+# define _PyUnicode_ToUppercase _PyUnicodeUCS4_ToUppercase
+#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 or
+configure Python using --with-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)
+#define Py_UNICODE_ISALPHA(ch) iswalpha(ch)
+#else
+/* Since splitting on whitespace is an important use case, and whitespace
+in most situations is solely ASCII whitespace, we optimize for the common
+case by using a quick look-up table with an inlined check.
+*/
+PyAPI_DATA(const unsigned char) _Py_ascii_whitespace[];
+#define Py_UNICODE_ISSPACE(ch) \
+	((ch) < 128U ? _Py_ascii_whitespace[(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)
+#define Py_UNICODE_ISALPHA(ch) _PyUnicode_IsAlpha(ch)
+#endif
+#define Py_UNICODE_ISALNUM(ch) \
+(Py_UNICODE_ISALPHA(ch) || \
+Py_UNICODE_ISDECIMAL(ch) || \
+Py_UNICODE_ISDIGIT(ch) || \
+Py_UNICODE_ISNUMERIC(ch))
+#define Py_UNICODE_COPY(target, source, length)				\
+	Py_MEMCPY((target), (source), (length)*sizeof(Py_UNICODE))
+#define Py_UNICODE_FILL(target, value, length) do\
+{Py_ssize_t i_; Py_UNICODE *t_ = (target); Py_UNICODE v_ = (value);\
+for (i_ = 0; i_ < (length); i_++) t_[i_] = v_;\
+} while (0)
+/* check if substring matches at given offset.  the offset must be
+valid, and the substring must not be empty */
+#define Py_UNICODE_MATCH(string, offset, substring) \
+((*((string)->str + (offset)) == *((substring)->str)) && \
+((*((string)->str + (offset) + (substring)->length-1) == *((substring)->str + (substring)->length-1))) && \
+!memcmp((string)->str + (offset), (substring)->str, (substring)->length*sizeof(Py_UNICODE)))
+#ifdef __cplusplus
+extern "C" {
+#endif
+PyAPI_FUNC(int) PyUnicode_ClearFreeList(void);
+/* --- Unicode Type ------------------------------------------------------- */
+typedef struct {
+PyObject_HEAD
+Py_ssize_t length;		/* Length of raw Unicode data in buffer */
+Py_UNICODE *str;		/* Raw Unicode buffer */
+long hash;			/* Hash value; -1 if not set */
+PyObject *defenc;		/* (Default) Encoded version as Python
+				   string, or NULL; this is used for
+				   implementing the buffer protocol */
+} PyUnicodeObject;
+PyAPI_DATA(PyTypeObject) PyUnicode_Type;
+#define PyUnicode_Check(op) \
+PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_UNICODE_SUBCLASS)
+#define PyUnicode_CheckExact(op) (Py_TYPE(op) == &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 afterwards. Note
+that modifying the Unicode object contents after construction is
+only allowed if u was set to NULL.
+The buffer is copied into the new object. */
+PyAPI_FUNC(PyObject*) PyUnicode_FromUnicode(
+const Py_UNICODE *u,        /* Unicode buffer */
+Py_ssize_t size             /* size of buffer */
+);
+/* Similar to PyUnicode_FromUnicode(), but u points to Latin-1 encoded bytes */
+PyAPI_FUNC(PyObject*) PyUnicode_FromStringAndSize(
+const char *u,        /* char buffer */
+Py_ssize_t size       /* size of buffer */
+);
+/* Similar to PyUnicode_FromUnicode(), but u points to null-terminated
+Latin-1 encoded bytes */
+PyAPI_FUNC(PyObject*) PyUnicode_FromString(
+const char *u        /* string */
+);
+/* Return a read-only pointer to the Unicode object's internal
+Py_UNICODE buffer. */
+PyAPI_FUNC(Py_UNICODE *) PyUnicode_AsUnicode(
+PyObject *unicode	 	/* Unicode object */
+);
+/* Get the length of the Unicode object. */
+PyAPI_FUNC(Py_ssize_t) PyUnicode_GetSize(
+PyObject *unicode	 	/* Unicode object */
+);
+/* Get the maximum ordinal for a Unicode character. */
+PyAPI_FUNC(Py_UNICODE) PyUnicode_GetMax(void);
+/* Resize an already allocated Unicode object to the new size length.
+*unicode is modified to point to the new (resized) object and 0
+returned on success.
+This API may only be called by the function which also called the
+Unicode constructor. The refcount on the object must be 1. Otherwise,
+an error is returned.
+Error handling is implemented as follows: an exception is set, -1
+is returned and *unicode left untouched.
+*/
+PyAPI_FUNC(int) PyUnicode_Resize(
+PyObject **unicode,		/* Pointer to the Unicode object */
+Py_ssize_t length		/* New length */
+);
+/* Coerce obj to an Unicode object and return a reference with
+*incremented* refcount.
+Coercion is done in the following way:
+1. String and other char buffer compatible objects are decoded
+under the assumptions that they contain data using the current
+default encoding. Decoding is done in "strict" mode.
+2. All other objects (including Unicode objects) raise an
+exception.
+The API returns NULL in case of an error. The caller is responsible
+for decref'ing the returned objects.
+*/
+PyAPI_FUNC(PyObject*) PyUnicode_FromEncodedObject(
+register PyObject *obj, 	/* Object */
+const char *encoding,       /* encoding */
+const char *errors          /* error handling */
+);
+/* Coerce obj to an Unicode object and return a reference with
+*incremented* refcount.
+Unicode objects are passed back as-is (subclasses are converted to
+true Unicode objects), all other objects are delegated to
+PyUnicode_FromEncodedObject(obj, NULL, "strict") which results in
+using the default encoding as basis for decoding the object.
+The API returns NULL in case of an error. The caller is responsible
+for decref'ing the returned objects.
+*/
+PyAPI_FUNC(PyObject*) PyUnicode_FromObject(
+register PyObject *obj 	/* Object */
+);
+PyAPI_FUNC(PyObject *) PyUnicode_FromFormatV(const char*, va_list);
+PyAPI_FUNC(PyObject *) PyUnicode_FromFormat(const char*, ...);
+/* Format the object based on the format_spec, as defined in PEP 3101
+(Advanced String Formatting). */
+PyAPI_FUNC(PyObject *) _PyUnicode_FormatAdvanced(PyObject *obj,
+						 Py_UNICODE *format_spec,
+						 Py_ssize_t format_spec_len);
+/* --- 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. */
+PyAPI_FUNC(PyObject*) PyUnicode_FromWideChar(
+register const wchar_t *w,  /* wchar_t buffer */
+Py_ssize_t size             /* size of buffer */
+);
+/* Copies the Unicode Object contents into the wchar_t buffer w.  At
+most size wchar_t characters are copied.
+Note that the resulting wchar_t string may or may not be
+0-terminated.  It is the responsibility of the caller to make sure
+that the wchar_t string is 0-terminated in case this is required by
+the application.
+Returns the number of wchar_t characters copied (excluding a
+possibly trailing 0-termination character) or -1 in case of an
+error. */
+PyAPI_FUNC(Py_ssize_t) PyUnicode_AsWideChar(
+PyUnicodeObject *unicode,   /* Unicode object */
+register wchar_t *w,        /* wchar_t buffer */
+Py_ssize_t size             /* size of buffer */
+);
+#endif
+/* --- Unicode ordinals --------------------------------------------------- */
+/* Create a Unicode Object from the given Unicode code point ordinal.
+The ordinal must be in range(0x10000) on narrow Python builds
+(UCS2), and range(0x110000) on wide builds (UCS4). A ValueError is
+raised in case it is not.
+*/
+PyAPI_FUNC(PyObject*) PyUnicode_FromOrdinal(int ordinal);
+/* === 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.
+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.
+*/
+/* --- Manage the default encoding ---------------------------------------- */
+/* Return a Python string holding the default encoded value of the
+Unicode object.
+The resulting string is cached in the Unicode object for subsequent
+usage by this function. The cached version is needed to implement
+the character buffer interface and will live (at least) as long as
+the Unicode object itself.
+The refcount of the string is *not* incremented.
+*** Exported for internal use by the interpreter only !!! ***
+*/
+PyAPI_FUNC(PyObject *) _PyUnicode_AsDefaultEncodedString(
+PyObject *, const char *);
+/* Returns the currently active default encoding.
+The default encoding is currently implemented as run-time settable
+process global.  This may change in future versions of the
+interpreter to become a parameter which is managed on a per-thread
+basis.
+*/
+PyAPI_FUNC(const char*) PyUnicode_GetDefaultEncoding(void);
+/* Sets the currently active default encoding.
+Returns 0 on success, -1 in case of an error.
+*/
+PyAPI_FUNC(int) PyUnicode_SetDefaultEncoding(
+const char *encoding	/* Encoding name in standard form */
+);
+/* --- Generic Codecs ----------------------------------------------------- */
+/* Create a Unicode object by decoding the encoded string s of the
+given size. */
+PyAPI_FUNC(PyObject*) PyUnicode_Decode(
+const char *s,              /* encoded string */
+Py_ssize_t 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. */
+PyAPI_FUNC(PyObject*) PyUnicode_Encode(
+const Py_UNICODE *s,        /* Unicode char buffer */
+Py_ssize_t 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
+object. */
+PyAPI_FUNC(PyObject*) PyUnicode_AsEncodedObject(
+PyObject *unicode,	 	/* Unicode object */
+const char *encoding,	/* encoding */
+const char *errors		/* error handling */
+);
+/* Encodes a Unicode object and returns the result as Python string
+object. */
+PyAPI_FUNC(PyObject*) PyUnicode_AsEncodedString(
+PyObject *unicode,	 	/* Unicode object */
+const char *encoding,	/* encoding */
+const char *errors		/* error handling */
+);
+PyAPI_FUNC(PyObject*) PyUnicode_BuildEncodingMap(
+PyObject* string            /* 256 character map */
+);
+/* --- UTF-7 Codecs ------------------------------------------------------- */
+PyAPI_FUNC(PyObject*) PyUnicode_DecodeUTF7(
+const char *string, 	/* UTF-7 encoded string */
+Py_ssize_t length,	 	/* size of string */
+const char *errors		/* error handling */
+);
+PyAPI_FUNC(PyObject*) PyUnicode_DecodeUTF7Stateful(
+const char *string, 	/* UTF-7 encoded string */
+Py_ssize_t length,	 	/* size of string */
+const char *errors,		/* error handling */
+Py_ssize_t *consumed	/* bytes consumed */
+);
+PyAPI_FUNC(PyObject*) PyUnicode_EncodeUTF7(
+const Py_UNICODE *data, 	/* Unicode char buffer */
+Py_ssize_t length,	 		/* number of Py_UNICODE chars to encode */
+int encodeSetO,             /* force the encoder to encode characters in
+Set O, as described in RFC2152 */
+int encodeWhiteSpace,       /* force the encoder to encode space, tab,
+carriage return and linefeed characters */
+const char *errors		/* error handling */
+);
+/* --- UTF-8 Codecs ------------------------------------------------------- */
+PyAPI_FUNC(PyObject*) PyUnicode_DecodeUTF8(
+const char *string, 	/* UTF-8 encoded string */
+Py_ssize_t length,	 	/* size of string */
+const char *errors		/* error handling */
+);
+PyAPI_FUNC(PyObject*) PyUnicode_DecodeUTF8Stateful(
+const char *string, 	/* UTF-8 encoded string */
+Py_ssize_t length,	 	/* size of string */
+const char *errors,		/* error handling */
+Py_ssize_t *consumed		/* bytes consumed */
+);
+PyAPI_FUNC(PyObject*) PyUnicode_AsUTF8String(
+PyObject *unicode	 	/* Unicode object */
+);
+PyAPI_FUNC(PyObject*) PyUnicode_EncodeUTF8(
+const Py_UNICODE *data, 	/* Unicode char buffer */
+Py_ssize_t length,	 		/* number of Py_UNICODE chars to encode */
+const char *errors		/* error handling */
+);
+/* --- UTF-32 Codecs ------------------------------------------------------ */
+/* Decodes length bytes from a UTF-32 encoded buffer string and returns
+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
+In native mode, the first four bytes of the stream are checked for a
+BOM mark. If found, the BOM mark is analysed, the byte order
+adjusted and the BOM skipped.  In the other modes, no BOM mark
+interpretation is done. 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.
+*/
+PyAPI_FUNC(PyObject*) PyUnicode_DecodeUTF32(
+const char *string, 	/* UTF-32 encoded string */
+Py_ssize_t 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 */
+);
+PyAPI_FUNC(PyObject*) PyUnicode_DecodeUTF32Stateful(
+const char *string, 	/* UTF-32 encoded string */
+Py_ssize_t 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 */
+Py_ssize_t *consumed	/* bytes consumed */
+);
+/* Returns a Python string using the UTF-32 encoding in native byte
+order. The string always starts with a BOM mark.  */
+PyAPI_FUNC(PyObject*) PyUnicode_AsUTF32String(
+PyObject *unicode	 	/* Unicode object */
+);
+/* Returns a Python string object holding the UTF-32 encoded value of
+the Unicode data.
+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.
+*/
+PyAPI_FUNC(PyObject*) PyUnicode_EncodeUTF32(
+const Py_UNICODE *data, 	/* Unicode char buffer */
+Py_ssize_t 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 */
+);
+/* --- UTF-16 Codecs ------------------------------------------------------ */
+/* Decodes length bytes from a UTF-16 encoded buffer string and returns
+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
+In native mode, the first two bytes of the stream are checked for a
+BOM mark. If found, the BOM mark is analysed, the byte order
+adjusted and the BOM skipped.  In the other modes, no BOM mark
+interpretation is done. 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.
+*/
+PyAPI_FUNC(PyObject*) PyUnicode_DecodeUTF16(
+const char *string, 	/* UTF-16 encoded string */
+Py_ssize_t 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 */
+);
+PyAPI_FUNC(PyObject*) PyUnicode_DecodeUTF16Stateful(
+const char *string, 	/* UTF-16 encoded string */
+Py_ssize_t 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 */
+Py_ssize_t *consumed		/* bytes consumed */
+);
+/* Returns a Python string using the UTF-16 encoding in native byte
+order. The string always starts with a BOM mark.  */
+PyAPI_FUNC(PyObject*) PyUnicode_AsUTF16String(
+PyObject *unicode	 	/* Unicode object */
+);
+/* Returns a Python string object holding the UTF-16 encoded value of
+the Unicode data.
+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 compromising the APIs.
+*/
+PyAPI_FUNC(PyObject*) PyUnicode_EncodeUTF16(
+const Py_UNICODE *data, 	/* Unicode char buffer */
+Py_ssize_t 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 ---------------------------------------------- */
+PyAPI_FUNC(PyObject*) PyUnicode_DecodeUnicodeEscape(
+const char *string, 	/* Unicode-Escape encoded string */
+Py_ssize_t length,	 	/* size of string */
+const char *errors		/* error handling */
+);
+PyAPI_FUNC(PyObject*) PyUnicode_AsUnicodeEscapeString(
+PyObject *unicode	 	/* Unicode object */
+);
+PyAPI_FUNC(PyObject*) PyUnicode_EncodeUnicodeEscape(
+const Py_UNICODE *data, 	/* Unicode char buffer */
+Py_ssize_t length	 		/* Number of Py_UNICODE chars to encode */
+);
+/* --- Raw-Unicode-Escape Codecs ------------------------------------------ */
+PyAPI_FUNC(PyObject*) PyUnicode_DecodeRawUnicodeEscape(
+const char *string, 	/* Raw-Unicode-Escape encoded string */
+Py_ssize_t length,	 	/* size of string */
+const char *errors		/* error handling */
+);
+PyAPI_FUNC(PyObject*) PyUnicode_AsRawUnicodeEscapeString(
+PyObject *unicode	 	/* Unicode object */
+);
+PyAPI_FUNC(PyObject*) PyUnicode_EncodeRawUnicodeEscape(
+const Py_UNICODE *data, 	/* Unicode char buffer */
+Py_ssize_t length	 		/* Number of Py_UNICODE chars to encode */
+);
+/* --- Unicode Internal Codec ---------------------------------------------
+Only for internal use in _codecsmodule.c */
+PyObject *_PyUnicode_DecodeUnicodeInternal(
+const char *string,
+Py_ssize_t length,
+const char *errors
+);
+/* --- Latin-1 Codecs -----------------------------------------------------
+Note: Latin-1 corresponds to the first 256 Unicode ordinals.
+*/
+PyAPI_FUNC(PyObject*) PyUnicode_DecodeLatin1(
+const char *string, 	/* Latin-1 encoded string */
+Py_ssize_t length,	 	/* size of string */
+const char *errors		/* error handling */
+);
+PyAPI_FUNC(PyObject*) PyUnicode_AsLatin1String(
+PyObject *unicode	 	/* Unicode object */
+);
+PyAPI_FUNC(PyObject*) PyUnicode_EncodeLatin1(
+const Py_UNICODE *data, 	/* Unicode char buffer */
+Py_ssize_t 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.
+*/
+PyAPI_FUNC(PyObject*) PyUnicode_DecodeASCII(
+const char *string, 	/* ASCII encoded string */
+Py_ssize_t length,	 	/* size of string */
+const char *errors		/* error handling */
+);
+PyAPI_FUNC(PyObject*) PyUnicode_AsASCIIString(
+PyObject *unicode	 	/* Unicode object */
+);
+PyAPI_FUNC(PyObject*) PyUnicode_EncodeASCII(
+const Py_UNICODE *data, 	/* Unicode char buffer */
+Py_ssize_t 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.
+*/
+PyAPI_FUNC(PyObject*) PyUnicode_DecodeCharmap(
+const char *string, 	/* Encoded string */
+Py_ssize_t length,	 	/* size of string */
+PyObject *mapping,		/* character mapping
+				   (char ordinal -> unicode ordinal) */
+const char *errors		/* error handling */
+);
+PyAPI_FUNC(PyObject*) PyUnicode_AsCharmapString(
+PyObject *unicode,	 	/* Unicode object */
+PyObject *mapping		/* character mapping
+				   (unicode ordinal -> char ordinal) */
+);
+PyAPI_FUNC(PyObject*) PyUnicode_EncodeCharmap(
+const Py_UNICODE *data, 	/* Unicode char buffer */
+Py_ssize_t 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.
+*/
+PyAPI_FUNC(PyObject *) PyUnicode_TranslateCharmap(
+const Py_UNICODE *data, 	/* Unicode char buffer */
+Py_ssize_t length,	 		/* Number of Py_UNICODE chars to encode */
+PyObject *table,		/* Translate table */
+const char *errors		/* error handling */
+);
+#ifdef MS_WIN32
+/* --- MBCS codecs for Windows -------------------------------------------- */
+PyAPI_FUNC(PyObject*) PyUnicode_DecodeMBCS(
+const char *string,         /* MBCS encoded string */
+Py_ssize_t length,              /* size of string */
+const char *errors          /* error handling */
+);
+PyAPI_FUNC(PyObject*) PyUnicode_DecodeMBCSStateful(
+const char *string,         /* MBCS encoded string */
+Py_ssize_t length,          /* size of string */
+const char *errors,         /* error handling */
+Py_ssize_t *consumed        /* bytes consumed */
+);
+PyAPI_FUNC(PyObject*) PyUnicode_AsMBCSString(
+PyObject *unicode           /* Unicode object */
+);
+PyAPI_FUNC(PyObject*) PyUnicode_EncodeMBCS(
+const Py_UNICODE *data,     /* Unicode char buffer */
+Py_ssize_t length,              /* Number of Py_UNICODE chars to encode */
+const char *errors          /* error handling */
+);
+#endif /* MS_WIN32 */
+/* --- Decimal Encoder ---------------------------------------------------- */
+/* Takes a Unicode string holding a decimal value and writes it into
+an output buffer using standard ASCII digit codes.
+The output buffer has to provide at least length+1 bytes of storage
+area. The output string is 0-terminated.
+The encoder converts whitespace to ' ', decimal characters to their
+corresponding ASCII digit and all other Latin-1 characters except
+\0 as-is. Characters outside this range (Unicode ordinals 1-256)
+are treated as errors. This includes embedded NULL bytes.
+Error handling is defined by the errors argument:
+NULL or "strict": raise a ValueError
+"ignore": ignore the wrong characters (these are not copied to the
+		output buffer)
+"replace": replaces illegal characters with '?'
+Returns 0 on success, -1 on failure.
+*/
+PyAPI_FUNC(int) PyUnicode_EncodeDecimal(
+Py_UNICODE *s,		/* Unicode buffer */
+Py_ssize_t length,			/* Number of Py_UNICODE chars to encode */
+char *output,		/* Output buffer; must have size >= length */
+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. */
+PyAPI_FUNC(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.
+*/
+PyAPI_FUNC(PyObject*) PyUnicode_Split(
+PyObject *s,		/* String to split */
+PyObject *sep,		/* String separator */
+Py_ssize_t 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. */
+PyAPI_FUNC(PyObject*) PyUnicode_Splitlines(
+PyObject *s,		/* String to split */
+int keepends		/* If true, line end markers are included */
+);
+/* Partition a string using a given separator. */
+PyAPI_FUNC(PyObject*) PyUnicode_Partition(
+PyObject *s,		/* String to partition */
+PyObject *sep		/* String separator */
+);
+/* Partition a string using a given separator, searching from the end of the
+string. */
+PyAPI_FUNC(PyObject*) PyUnicode_RPartition(
+PyObject *s,		/* String to partition */
+PyObject *sep		/* String separator */
+);
+/* 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. But unlike PyUnicode_Split
+PyUnicode_RSplit splits from the end of the string. If negative,
+no limit is set.
+Separators are not included in the resulting list.
+*/
+PyAPI_FUNC(PyObject*) PyUnicode_RSplit(
+PyObject *s,		/* String to split */
+PyObject *sep,		/* String separator */
+Py_ssize_t 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.
+*/
+PyAPI_FUNC(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. */
+PyAPI_FUNC(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. */
+PyAPI_FUNC(Py_ssize_t) PyUnicode_Tailmatch(
+PyObject *str,		/* String */
+PyObject *substr,		/* Prefix or Suffix string */
+Py_ssize_t start,		/* Start index */
+Py_ssize_t 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. -2 is returned in case
+an error occurred and an exception is set. */
+PyAPI_FUNC(Py_ssize_t) PyUnicode_Find(
+PyObject *str,		/* String */
+PyObject *substr,		/* Substring to find */
+Py_ssize_t start,		/* Start index */
+Py_ssize_t end,		/* Stop index */
+int direction		/* Find direction: +1 forward, -1 backward */
+);
+/* Count the number of occurrences of substr in str[start:end]. */
+PyAPI_FUNC(Py_ssize_t) PyUnicode_Count(
+PyObject *str,		/* String */
+PyObject *substr,		/* Substring to count */
+Py_ssize_t start,		/* Start index */
+Py_ssize_t end		/* Stop index */
+);
+/* Replace at most maxcount occurrences of substr in str with replstr
+and return the resulting Unicode object. */
+PyAPI_FUNC(PyObject *) PyUnicode_Replace(
+PyObject *str,		/* String */
+PyObject *substr,		/* Substring to find */
+PyObject *replstr,		/* Substring to replace */
+Py_ssize_t maxcount		/* Max. number of replacements to apply;
+				   -1 = all */
+);
+/* Compare two strings and return -1, 0, 1 for less than, equal,
+greater than resp. */
+PyAPI_FUNC(int) PyUnicode_Compare(
+PyObject *left,		/* Left string */
+PyObject *right		/* Right string */
+);
+/* Rich compare two strings and return one of the following:
+- NULL in case an exception was raised
+- Py_True or Py_False for successfuly comparisons
+- Py_NotImplemented in case the type combination is unknown
+Note that Py_EQ and Py_NE comparisons can cause a UnicodeWarning in
+case the conversion of the arguments to Unicode fails with a
+UnicodeDecodeError.
+Possible values for op:
+Py_GT, Py_GE, Py_EQ, Py_NE, Py_LT, Py_LE
+*/
+PyAPI_FUNC(PyObject *) PyUnicode_RichCompare(
+PyObject *left,		/* Left string */
+PyObject *right,		/* Right string */
+int op			/* Operation: Py_EQ, Py_NE, Py_GT, etc. */
+);
+/* Apply a argument tuple or dictionary to a format string and return
+the resulting Unicode string. */
+PyAPI_FUNC(PyObject *) PyUnicode_Format(
+PyObject *format,		/* Format string */
+PyObject *args		/* Argument tuple or dictionary */
+);
+/* Checks whether element is contained in container and return 1/0
+accordingly.
+element has to coerce to an one element Unicode string. -1 is
+returned in case of an error. */
+PyAPI_FUNC(int) PyUnicode_Contains(
+PyObject *container,	/* Container string */
+PyObject *element		/* Element string */
+);
+/* Externally visible for str.strip(unicode) */
+PyAPI_FUNC(PyObject *) _PyUnicode_XStrip(
+PyUnicodeObject *self,
+int striptype,
+PyObject *sepobj
+);
+/* === 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.
+*/
+PyAPI_FUNC(int) _PyUnicode_IsLowercase(
+Py_UNICODE ch 	/* Unicode character */
+);
+PyAPI_FUNC(int) _PyUnicode_IsUppercase(
+Py_UNICODE ch 	/* Unicode character */
+);
+PyAPI_FUNC(int) _PyUnicode_IsTitlecase(
+Py_UNICODE ch 	/* Unicode character */
+);
+PyAPI_FUNC(int) _PyUnicode_IsWhitespace(
+const Py_UNICODE ch 	/* Unicode character */
+);
+PyAPI_FUNC(int) _PyUnicode_IsLinebreak(
+const Py_UNICODE ch 	/* Unicode character */
+);
+PyAPI_FUNC(Py_UNICODE) _PyUnicode_ToLowercase(
+Py_UNICODE ch 	/* Unicode character */
+);
+PyAPI_FUNC(Py_UNICODE) _PyUnicode_ToUppercase(
+Py_UNICODE ch 	/* Unicode character */
+);
+PyAPI_FUNC(Py_UNICODE) _PyUnicode_ToTitlecase(
+Py_UNICODE ch 	/* Unicode character */
+);
+PyAPI_FUNC(int) _PyUnicode_ToDecimalDigit(
+Py_UNICODE ch 	/* Unicode character */
+);
+PyAPI_FUNC(int) _PyUnicode_ToDigit(
+Py_UNICODE ch 	/* Unicode character */
+);
+PyAPI_FUNC(double) _PyUnicode_ToNumeric(
+Py_UNICODE ch 	/* Unicode character */
+);
+PyAPI_FUNC(int) _PyUnicode_IsDecimalDigit(
+Py_UNICODE ch 	/* Unicode character */
+);
+PyAPI_FUNC(int) _PyUnicode_IsDigit(
+Py_UNICODE ch 	/* Unicode character */
+);
+PyAPI_FUNC(int) _PyUnicode_IsNumeric(
+Py_UNICODE ch 	/* Unicode character */
+);
+PyAPI_FUNC(int) _PyUnicode_IsAlpha(
+Py_UNICODE ch 	/* Unicode character */
+);
+#ifdef __cplusplus
+}
+#endif
+#endif /* Py_USING_UNICODE */
+#endif /* !Py_UNICODEOBJECT_H */