#ifndef Py_CPYTHON_UNICODEOBJECT_H

# error "this header file must not be included directly"

#endif

#ifdef __cplusplus

extern "C" {

#endif

#define PY_UNICODE_TYPE wchar_t

/* Py_DEPRECATED(3.3) */ typedef wchar_t Py_UNICODE;

#define Py_UNICODE_ISSPACE(ch) \

((Py_UCS4)(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_ISPRINTABLE(ch) _PyUnicode_IsPrintable(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)

#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) \

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)

#define Py_UNICODE_IS_SURROGATE(ch) (0xD800 <= (ch) && (ch) <= 0xDFFF)

#define Py_UNICODE_IS_HIGH_SURROGATE(ch) (0xD800 <= (ch) && (ch) <= 0xDBFF)

#define Py_UNICODE_IS_LOW_SURROGATE(ch) (0xDC00 <= (ch) && (ch) <= 0xDFFF)

#define Py_UNICODE_JOIN_SURROGATES(high, low) \

(((((Py_UCS4)(high) & 0x03FF) << 10) | \

((Py_UCS4)(low) & 0x03FF)) + 0x10000)

#define Py_UNICODE_HIGH_SURROGATE(ch) (0xD800 - (0x10000 >> 10) + ((ch) >> 10))

#define Py_UNICODE_LOW_SURROGATE(ch) (0xDC00 + ((ch) & 0x3FF))

#define Py_UNICODE_MATCH(string, offset, substring) \

((*((string)->wstr + (offset)) == *((substring)->wstr)) && \

((*((string)->wstr + (offset) + (substring)->wstr_length-1) == *((substring)->wstr + (substring)->wstr_length-1))) && \

!memcmp((string)->wstr + (offset), (substring)->wstr, (substring)->wstr_length*sizeof(Py_UNICODE)))

typedef struct {

/* There are 4 forms of Unicode strings:

PyObject_HEAD

Py_ssize_t length; /* Number of code points in the string */

Py_hash_t hash; /* Hash value; -1 if not set */

struct {

/*

unsigned int interned:2;

/* Character size:

unsigned int kind:3;

/* Compact is with respect to the allocation scheme. Compact unicode

unsigned int compact:1;

/* The string only contains characters in the range U+0000-U+007F (ASCII)

unsigned int ascii:1;

/* The ready flag indicates whether the object layout is initialized

unsigned int ready:1;

/* Padding to ensure that PyUnicode_DATA() is always aligned to

unsigned int :24;

} state;

wchar_t *wstr; /* wchar_t representation (null-terminated) */

} PyASCIIObject;

typedef struct {

PyASCIIObject _base;

Py_ssize_t utf8_length; /* Number of bytes in utf8, excluding the

char *utf8; /* UTF-8 representation (null-terminated) */

Py_ssize_t wstr_length; /* Number of code points in wstr, possible

} PyCompactUnicodeObject;

typedef struct {

PyCompactUnicodeObject _base;

union {

void *any;

Py_UCS1 *latin1;

Py_UCS2 *ucs2;

Py_UCS4 *ucs4;

} data; /* Canonical, smallest-form Unicode buffer */

} PyUnicodeObject;

PyAPI_FUNC(int) _PyUnicode_CheckConsistency(

PyObject *op,

int check_content);

#define PyUnicode_WSTR_LENGTH(op) \

(PyUnicode_IS_COMPACT_ASCII(op) ? \

((PyASCIIObject*)op)->length : \

((PyCompactUnicodeObject*)op)->wstr_length)

#define PyUnicode_GET_SIZE(op) \

(assert(PyUnicode_Check(op)), \

(((PyASCIIObject *)(op))->wstr) ? \

PyUnicode_WSTR_LENGTH(op) : \

((void)PyUnicode_AsUnicode(_PyObject_CAST(op)),\

assert(((PyASCIIObject *)(op))->wstr), \

PyUnicode_WSTR_LENGTH(op)))

#define PyUnicode_GET_DATA_SIZE(op) \

(PyUnicode_GET_SIZE(op) * Py_UNICODE_SIZE)

#define PyUnicode_AS_UNICODE(op) \

(assert(PyUnicode_Check(op)), \

(((PyASCIIObject *)(op))->wstr) ? (((PyASCIIObject *)(op))->wstr) : \

PyUnicode_AsUnicode(_PyObject_CAST(op)))

#define PyUnicode_AS_DATA(op) \

((const char *)(PyUnicode_AS_UNICODE(op)))

#define SSTATE_NOT_INTERNED 0

#define SSTATE_INTERNED_MORTAL 1

#define SSTATE_INTERNED_IMMORTAL 2

#define PyUnicode_IS_ASCII(op) \

(assert(PyUnicode_Check(op)), \

assert(PyUnicode_IS_READY(op)), \

((PyASCIIObject*)op)->state.ascii)

#define PyUnicode_IS_COMPACT(op) \

(((PyASCIIObject*)(op))->state.compact)

#define PyUnicode_IS_COMPACT_ASCII(op) \

(((PyASCIIObject*)op)->state.ascii && PyUnicode_IS_COMPACT(op))

enum PyUnicode_Kind {

};

#define PyUnicode_1BYTE_DATA(op) ((Py_UCS1*)PyUnicode_DATA(op))

#define PyUnicode_2BYTE_DATA(op) ((Py_UCS2*)PyUnicode_DATA(op))

#define PyUnicode_4BYTE_DATA(op) ((Py_UCS4*)PyUnicode_DATA(op))

#define PyUnicode_KIND(op) \

(assert(PyUnicode_Check(op)), \

assert(PyUnicode_IS_READY(op)), \

((PyASCIIObject *)(op))->state.kind)

#define _PyUnicode_COMPACT_DATA(op) \

(PyUnicode_IS_ASCII(op) ? \

((void*)((PyASCIIObject*)(op) + 1)) : \

((void*)((PyCompactUnicodeObject*)(op) + 1)))

#define _PyUnicode_NONCOMPACT_DATA(op) \

(assert(((PyUnicodeObject*)(op))->data.any), \

((((PyUnicodeObject *)(op))->data.any)))

#define PyUnicode_DATA(op) \

(assert(PyUnicode_Check(op)), \

PyUnicode_IS_COMPACT(op) ? _PyUnicode_COMPACT_DATA(op) : \

_PyUnicode_NONCOMPACT_DATA(op))

#define PyUnicode_WRITE(kind, data, index, value) \

do { \

switch ((kind)) { \

case PyUnicode_1BYTE_KIND: { \

((Py_UCS1 *)(data))[(index)] = (Py_UCS1)(value); \

break; \

} \

case PyUnicode_2BYTE_KIND: { \

((Py_UCS2 *)(data))[(index)] = (Py_UCS2)(value); \

break; \

} \

default: { \

assert((kind) == PyUnicode_4BYTE_KIND); \

((Py_UCS4 *)(data))[(index)] = (Py_UCS4)(value); \

} \

} \

} while (0)

#define PyUnicode_READ(kind, data, index) \

((Py_UCS4) \

((kind) == PyUnicode_1BYTE_KIND ? \

((const Py_UCS1 *)(data))[(index)] : \

((kind) == PyUnicode_2BYTE_KIND ? \

((const Py_UCS2 *)(data))[(index)] : \

((const Py_UCS4 *)(data))[(index)] \

) \

))

#define PyUnicode_READ_CHAR(unicode, index) \

(assert(PyUnicode_Check(unicode)), \

assert(PyUnicode_IS_READY(unicode)), \

(Py_UCS4) \

(PyUnicode_KIND((unicode)) == PyUnicode_1BYTE_KIND ? \

((const Py_UCS1 *)(PyUnicode_DATA((unicode))))[(index)] : \

(PyUnicode_KIND((unicode)) == PyUnicode_2BYTE_KIND ? \

((const Py_UCS2 *)(PyUnicode_DATA((unicode))))[(index)] : \

((const Py_UCS4 *)(PyUnicode_DATA((unicode))))[(index)] \

) \

))

#define PyUnicode_GET_LENGTH(op) \

(assert(PyUnicode_Check(op)), \

assert(PyUnicode_IS_READY(op)), \

((PyASCIIObject *)(op))->length)

#define PyUnicode_IS_READY(op) (((PyASCIIObject*)op)->state.ready)

#define PyUnicode_READY(op) \

(assert(PyUnicode_Check(op)), \

(PyUnicode_IS_READY(op) ? \

0 : _PyUnicode_Ready(_PyObject_CAST(op))))

#define PyUnicode_MAX_CHAR_VALUE(op) \

(assert(PyUnicode_IS_READY(op)), \

(PyUnicode_IS_ASCII(op) ? \

(0x7f) : \

(PyUnicode_KIND(op) == PyUnicode_1BYTE_KIND ? \

(0xffU) : \

(PyUnicode_KIND(op) == PyUnicode_2BYTE_KIND ? \

(0xffffU) : \

(0x10ffffU)))))

PyAPI_FUNC(PyObject*) PyUnicode_New(

Py_ssize_t size, /* Number of code points in the new string */

Py_UCS4 maxchar /* maximum code point value in the string */

);

PyAPI_FUNC(int) _PyUnicode_Ready(

PyObject *unicode /* Unicode object */

);

PyAPI_FUNC(PyObject*) _PyUnicode_Copy(

PyObject *unicode

);

PyAPI_FUNC(Py_ssize_t) PyUnicode_CopyCharacters(

PyObject *to,

Py_ssize_t to_start,

PyObject *from,

Py_ssize_t from_start,

Py_ssize_t how_many

);

PyAPI_FUNC(void) _PyUnicode_FastCopyCharacters(

PyObject *to,

Py_ssize_t to_start,

PyObject *from,

Py_ssize_t from_start,

Py_ssize_t how_many

);

PyAPI_FUNC(Py_ssize_t) PyUnicode_Fill(

PyObject *unicode,

Py_ssize_t start,

Py_ssize_t length,

Py_UCS4 fill_char

);

PyAPI_FUNC(void) _PyUnicode_FastFill(

PyObject *unicode,

Py_ssize_t start,

Py_ssize_t length,

Py_UCS4 fill_char

);

/* Py_DEPRECATED(3.3) */ PyAPI_FUNC(PyObject*) PyUnicode_FromUnicode(

const Py_UNICODE *u, /* Unicode buffer */

Py_ssize_t size /* size of buffer */

);

PyAPI_FUNC(PyObject*) PyUnicode_FromKindAndData(

int kind,

const void *buffer,

Py_ssize_t size);

PyAPI_FUNC(PyObject*) _PyUnicode_FromASCII(

const char *buffer,

Py_ssize_t size);

PyAPI_FUNC(Py_UCS4) _PyUnicode_FindMaxChar (

PyObject *unicode,

Py_ssize_t start,

Py_ssize_t end);

/* Py_DEPRECATED(3.3) */ PyAPI_FUNC(Py_UNICODE *) PyUnicode_AsUnicode(

PyObject *unicode /* Unicode object */

);

PyAPI_FUNC(const Py_UNICODE *) _PyUnicode_AsUnicode(

PyObject *unicode /* Unicode object */

);

/* Py_DEPRECATED(3.3) */ PyAPI_FUNC(Py_UNICODE *) PyUnicode_AsUnicodeAndSize(

PyObject *unicode, /* Unicode object */

Py_ssize_t *size /* location where to save the length */

);

Py_DEPRECATED(3.3) PyAPI_FUNC(Py_UNICODE) PyUnicode_GetMax(void);

typedef struct {

PyObject *buffer;

void *data;

enum PyUnicode_Kind kind;

Py_UCS4 maxchar;

Py_ssize_t size;

Py_ssize_t pos;

/* minimum number of allocated characters (default: 0) */

Py_ssize_t min_length;

/* minimum character (default: 127, ASCII) */

Py_UCS4 min_char;

/* If non-zero, overallocate the buffer (default: 0). */

unsigned char overallocate;

/* If readonly is 1, buffer is a shared string (cannot be modified)

unsigned char readonly;

} _PyUnicodeWriter ;

PyAPI_FUNC(void)

_PyUnicodeWriter_Init(_PyUnicodeWriter *writer);

#define _PyUnicodeWriter_Prepare(WRITER, LENGTH, MAXCHAR) \

(((MAXCHAR) <= (WRITER)->maxchar \

&& (LENGTH) <= (WRITER)->size - (WRITER)->pos) \

? 0 \

: (((LENGTH) == 0) \

? 0 \

: _PyUnicodeWriter_PrepareInternal((WRITER), (LENGTH), (MAXCHAR))))

PyAPI_FUNC(int)

_PyUnicodeWriter_PrepareInternal(_PyUnicodeWriter *writer,

Py_ssize_t length, Py_UCS4 maxchar);

#define _PyUnicodeWriter_PrepareKind(WRITER, KIND) \

(assert((KIND) != PyUnicode_WCHAR_KIND), \

(KIND) <= (WRITER)->kind \

? 0 \

: _PyUnicodeWriter_PrepareKindInternal((WRITER), (KIND)))

PyAPI_FUNC(int)

_PyUnicodeWriter_PrepareKindInternal(_PyUnicodeWriter *writer,

enum PyUnicode_Kind kind);

PyAPI_FUNC(int)

_PyUnicodeWriter_WriteChar(_PyUnicodeWriter *writer,

Py_UCS4 ch

);

PyAPI_FUNC(int)

_PyUnicodeWriter_WriteStr(_PyUnicodeWriter *writer,

PyObject *str /* Unicode string */

);

PyAPI_FUNC(int)

_PyUnicodeWriter_WriteSubstring(_PyUnicodeWriter *writer,

PyObject *str, /* Unicode string */

Py_ssize_t start,

Py_ssize_t end

);

PyAPI_FUNC(int)

_PyUnicodeWriter_WriteASCIIString(_PyUnicodeWriter *writer,

const char *str, /* ASCII-encoded byte string */

Py_ssize_t len /* number of bytes, or -1 if unknown */

);

PyAPI_FUNC(int)

_PyUnicodeWriter_WriteLatin1String(_PyUnicodeWriter *writer,

const char *str, /* latin1-encoded byte string */

Py_ssize_t len /* length in bytes */

);

PyAPI_FUNC(PyObject *)

_PyUnicodeWriter_Finish(_PyUnicodeWriter *writer);

PyAPI_FUNC(void)

_PyUnicodeWriter_Dealloc(_PyUnicodeWriter *writer);

PyAPI_FUNC(int) _PyUnicode_FormatAdvancedWriter(

_PyUnicodeWriter *writer,

PyObject *obj,

PyObject *format_spec,

Py_ssize_t start,

Py_ssize_t end);

#ifdef HAVE_WCHAR_H

PyAPI_FUNC(void*) _PyUnicode_AsKind(PyObject *s, unsigned int kind);

#endif

PyAPI_FUNC(const char *) PyUnicode_AsUTF8AndSize(

PyObject *unicode,

Py_ssize_t *size);

#define _PyUnicode_AsStringAndSize PyUnicode_AsUTF8AndSize

PyAPI_FUNC(const char *) PyUnicode_AsUTF8(PyObject *unicode);

#define _PyUnicode_AsString PyUnicode_AsUTF8

Py_DEPRECATED(3.3) 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 */

);

Py_DEPRECATED(3.3) PyAPI_FUNC(PyObject*) PyUnicode_EncodeUTF7(

const Py_UNICODE *data, /* Unicode char buffer */

Py_ssize_t length, /* number of Py_UNICODE chars to encode */

int base64SetO, /* Encode RFC2152 Set O characters in base64 */

int base64WhiteSpace, /* Encode whitespace (sp, ht, nl, cr) in base64 */

const char *errors /* error handling */

);

PyAPI_FUNC(PyObject*) _PyUnicode_EncodeUTF7(

PyObject *unicode, /* Unicode object */

int base64SetO, /* Encode RFC2152 Set O characters in base64 */

int base64WhiteSpace, /* Encode whitespace (sp, ht, nl, cr) in base64 */

const char *errors /* error handling */

);

PyAPI_FUNC(PyObject*) _PyUnicode_AsUTF8String(

PyObject *unicode,

const char *errors);

Py_DEPRECATED(3.3) 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 */

);

Py_DEPRECATED(3.3) 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 */

);

PyAPI_FUNC(PyObject*) _PyUnicode_EncodeUTF32(

PyObject *object, /* Unicode object */

const char *errors, /* error handling */

int byteorder /* byteorder to use 0=BOM+native;-1=LE,1=BE */

);

Py_DEPRECATED(3.3) 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 */

);

PyAPI_FUNC(PyObject*) _PyUnicode_EncodeUTF16(

PyObject* unicode, /* Unicode object */

const char *errors, /* error handling */

int byteorder /* byteorder to use 0=BOM+native;-1=LE,1=BE */

);

PyAPI_FUNC(PyObject*) _PyUnicode_DecodeUnicodeEscape(

const char *string, /* Unicode-Escape encoded string */

Py_ssize_t length, /* size of string */

const char *errors, /* error handling */

const char **first_invalid_escape /* on return, points to first

);

Py_DEPRECATED(3.3) PyAPI_FUNC(PyObject*) PyUnicode_EncodeUnicodeEscape(

const Py_UNICODE *data, /* Unicode char buffer */

Py_ssize_t length /* Number of Py_UNICODE chars to encode */

);

Py_DEPRECATED(3.3) PyAPI_FUNC(PyObject*) PyUnicode_EncodeRawUnicodeEscape(

const Py_UNICODE *data, /* Unicode char buffer */

Py_ssize_t length /* Number of Py_UNICODE chars to encode */

);

PyAPI_FUNC(PyObject*) _PyUnicode_AsLatin1String(

PyObject* unicode,

const char* errors);

Py_DEPRECATED(3.3) 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 */

);

PyAPI_FUNC(PyObject*) _PyUnicode_AsASCIIString(

PyObject* unicode,

const char* errors);

Py_DEPRECATED(3.3) 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 */

);

Py_DEPRECATED(3.3) 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, /* encoding mapping */

const char *errors /* error handling */

);

PyAPI_FUNC(PyObject*) _PyUnicode_EncodeCharmap(

PyObject *unicode, /* Unicode object */

PyObject *mapping, /* encoding mapping */

const char *errors /* error handling */

);

Py_DEPRECATED(3.3) 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_WINDOWS

Py_DEPRECATED(3.3) 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

/* Py_DEPRECATED(3.3) */ 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 */

);