#ifndef Py_CPYTHON_UNICODEOBJECT_H

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

#define PY_UNICODE_TYPE wchar_t

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

static inline int Py_UNICODE_IS_SURROGATE(Py_UCS4 ch) {

return (0xD800 <= ch && ch <= 0xDFFF);

}

static inline int Py_UNICODE_IS_HIGH_SURROGATE(Py_UCS4 ch) {

return (0xD800 <= ch && ch <= 0xDBFF);

}

static inline int Py_UNICODE_IS_LOW_SURROGATE(Py_UCS4 ch) {

return (0xDC00 <= ch && ch <= 0xDFFF);

}

static inline Py_UCS4 Py_UNICODE_JOIN_SURROGATES(Py_UCS4 high, Py_UCS4 low) {

assert(Py_UNICODE_IS_HIGH_SURROGATE(high));

assert(Py_UNICODE_IS_LOW_SURROGATE(low));

return 0x10000 + (((high & 0x03FF) << 10) | (low & 0x03FF));

}

static inline Py_UCS4 Py_UNICODE_HIGH_SURROGATE(Py_UCS4 ch) {

assert(0x10000 <= ch && ch <= 0x10ffff);

return (0xD800 - (0x10000 >> 10) + (ch >> 10));

}

static inline Py_UCS4 Py_UNICODE_LOW_SURROGATE(Py_UCS4 ch) {

assert(0x10000 <= ch && ch <= 0x10ffff);

return (0xDC00 + (ch & 0x3FF));

}

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 {

/* If interned is non-zero, the two references from the

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 object is statically allocated. */

unsigned int statically_allocated:1;

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

unsigned int :24;

} state;

} PyASCIIObject;

typedef struct {

PyASCIIObject _base;

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

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

} 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 _PyASCIIObject_CAST(op) \

(assert(PyUnicode_Check(op)), \

_Py_CAST(PyASCIIObject*, (op)))

#define _PyCompactUnicodeObject_CAST(op) \

(assert(PyUnicode_Check(op)), \

_Py_CAST(PyCompactUnicodeObject*, (op)))

#define _PyUnicodeObject_CAST(op) \

(assert(PyUnicode_Check(op)), \

_Py_CAST(PyUnicodeObject*, (op)))

#define SSTATE_NOT_INTERNED 0

#define SSTATE_INTERNED_MORTAL 1

#define SSTATE_INTERNED_IMMORTAL 2

#define SSTATE_INTERNED_IMMORTAL_STATIC 3

static inline unsigned int PyUnicode_CHECK_INTERNED(PyObject *op) {

return _PyASCIIObject_CAST(op)->state.interned;

}

#define PyUnicode_CHECK_INTERNED(op) PyUnicode_CHECK_INTERNED(_PyObject_CAST(op))

static inline unsigned int PyUnicode_IS_READY(PyObject* Py_UNUSED(op)) {

return 1;

}

#define PyUnicode_IS_READY(op) PyUnicode_IS_READY(_PyObject_CAST(op))

static inline unsigned int PyUnicode_IS_ASCII(PyObject *op) {

return _PyASCIIObject_CAST(op)->state.ascii;

}

#define PyUnicode_IS_ASCII(op) PyUnicode_IS_ASCII(_PyObject_CAST(op))

static inline unsigned int PyUnicode_IS_COMPACT(PyObject *op) {

return _PyASCIIObject_CAST(op)->state.compact;

}

#define PyUnicode_IS_COMPACT(op) PyUnicode_IS_COMPACT(_PyObject_CAST(op))

static inline int PyUnicode_IS_COMPACT_ASCII(PyObject *op) {

return (_PyASCIIObject_CAST(op)->state.ascii && PyUnicode_IS_COMPACT(op));

}

#define PyUnicode_IS_COMPACT_ASCII(op) PyUnicode_IS_COMPACT_ASCII(_PyObject_CAST(op))

enum PyUnicode_Kind {

};

#define PyUnicode_KIND(op) _Py_RVALUE(_PyASCIIObject_CAST(op)->state.kind)

static inline void* _PyUnicode_COMPACT_DATA(PyObject *op) {

if (PyUnicode_IS_ASCII(op)) {

return _Py_STATIC_CAST(void*, (_PyASCIIObject_CAST(op) + 1));

}

return _Py_STATIC_CAST(void*, (_PyCompactUnicodeObject_CAST(op) + 1));

}

static inline void* _PyUnicode_NONCOMPACT_DATA(PyObject *op) {

void *data;

assert(!PyUnicode_IS_COMPACT(op));

data = _PyUnicodeObject_CAST(op)->data.any;

assert(data != NULL);

return data;

}

static inline void* PyUnicode_DATA(PyObject *op) {

if (PyUnicode_IS_COMPACT(op)) {

return _PyUnicode_COMPACT_DATA(op);

}

return _PyUnicode_NONCOMPACT_DATA(op);

}

#define PyUnicode_DATA(op) PyUnicode_DATA(_PyObject_CAST(op))

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

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

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

static inline Py_ssize_t PyUnicode_GET_LENGTH(PyObject *op) {

return _PyASCIIObject_CAST(op)->length;

}

#define PyUnicode_GET_LENGTH(op) PyUnicode_GET_LENGTH(_PyObject_CAST(op))

static inline void PyUnicode_WRITE(int kind, void *data,

Py_ssize_t index, Py_UCS4 value)

{

assert(index >= 0);

if (kind == PyUnicode_1BYTE_KIND) {

assert(value <= 0xffU);

_Py_STATIC_CAST(Py_UCS1*, data)[index] = _Py_STATIC_CAST(Py_UCS1, value);

}

else if (kind == PyUnicode_2BYTE_KIND) {

assert(value <= 0xffffU);

_Py_STATIC_CAST(Py_UCS2*, data)[index] = _Py_STATIC_CAST(Py_UCS2, value);

}

else {

assert(kind == PyUnicode_4BYTE_KIND);

assert(value <= 0x10ffffU);

_Py_STATIC_CAST(Py_UCS4*, data)[index] = value;

}

}

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

PyUnicode_WRITE(_Py_STATIC_CAST(int, kind), _Py_CAST(void*, data), \

(index), _Py_STATIC_CAST(Py_UCS4, value))

static inline Py_UCS4 PyUnicode_READ(int kind,

const void *data, Py_ssize_t index)

{

assert(index >= 0);

if (kind == PyUnicode_1BYTE_KIND) {

return _Py_STATIC_CAST(const Py_UCS1*, data)[index];

}

if (kind == PyUnicode_2BYTE_KIND) {

return _Py_STATIC_CAST(const Py_UCS2*, data)[index];

}

assert(kind == PyUnicode_4BYTE_KIND);

return _Py_STATIC_CAST(const Py_UCS4*, data)[index];

}

#define PyUnicode_READ(kind, data, index) \

PyUnicode_READ(_Py_STATIC_CAST(int, kind), \

_Py_STATIC_CAST(const void*, data), \

(index))

static inline Py_UCS4 PyUnicode_READ_CHAR(PyObject *unicode, Py_ssize_t index)

{

int kind;

assert(index >= 0);

// Tolerate reading the NUL character at str[len(str)]

assert(index <= PyUnicode_GET_LENGTH(unicode));

kind = PyUnicode_KIND(unicode);

if (kind == PyUnicode_1BYTE_KIND) {

return PyUnicode_1BYTE_DATA(unicode)[index];

}

if (kind == PyUnicode_2BYTE_KIND) {

return PyUnicode_2BYTE_DATA(unicode)[index];

}

assert(kind == PyUnicode_4BYTE_KIND);

return PyUnicode_4BYTE_DATA(unicode)[index];

}

#define PyUnicode_READ_CHAR(unicode, index) \

PyUnicode_READ_CHAR(_PyObject_CAST(unicode), (index))

static inline Py_UCS4 PyUnicode_MAX_CHAR_VALUE(PyObject *op)

{

int kind;

if (PyUnicode_IS_ASCII(op)) {

return 0x7fU;

}

kind = PyUnicode_KIND(op);

if (kind == PyUnicode_1BYTE_KIND) {

return 0xffU;

}

if (kind == PyUnicode_2BYTE_KIND) {

return 0xffffU;

}

assert(kind == PyUnicode_4BYTE_KIND);

return 0x10ffffU;

}

#define PyUnicode_MAX_CHAR_VALUE(op) \

PyUnicode_MAX_CHAR_VALUE(_PyObject_CAST(op))

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 */

);

static inline int PyUnicode_READY(PyObject* Py_UNUSED(op))

{

return 0;

}

#define PyUnicode_READY(op) PyUnicode_READY(_PyObject_CAST(op))

PyAPI_FUNC(PyObject*) _PyUnicode_Copy(

PyObject *unicode

);

PyAPI_FUNC(Py_ssize_t) PyUnicode_CopyCharacters(

);

PyAPI_FUNC(void) _PyUnicode_FastCopyCharacters(

);

PyAPI_FUNC(Py_ssize_t) PyUnicode_Fill(

);

PyAPI_FUNC(void) _PyUnicode_FastFill(

);

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);

typedef struct {

PyObject *buffer;

void *data;

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

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

? 0 \

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

PyAPI_FUNC(int)

_PyUnicodeWriter_PrepareKindInternal(_PyUnicodeWriter *writer,

int 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,

);

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(

Py_ssize_t end);

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

#define _PyUnicode_AsString PyUnicode_AsUTF8

PyAPI_FUNC(PyObject*) _PyUnicode_EncodeUTF7(

);

PyAPI_FUNC(PyObject*) _PyUnicode_AsUTF8String(

PyObject *unicode,

const char *errors);

PyAPI_FUNC(PyObject*) _PyUnicode_EncodeUTF32(

);

PyAPI_FUNC(PyObject*) _PyUnicode_EncodeUTF16(

);

PyAPI_FUNC(PyObject*) _PyUnicode_DecodeUnicodeEscapeStateful(

);

PyAPI_FUNC(PyObject*) _PyUnicode_DecodeUnicodeEscapeInternal2(

const char **first_invalid_escape_ptr); /* on return, if not NULL, may

PyAPI_FUNC(PyObject*) _PyUnicode_DecodeUnicodeEscapeInternal(

);

PyAPI_FUNC(PyObject*) _PyUnicode_DecodeRawUnicodeEscapeStateful(

);

PyAPI_FUNC(PyObject*) _PyUnicode_AsLatin1String(

PyObject* unicode,

const char* errors);

PyAPI_FUNC(PyObject*) _PyUnicode_AsASCIIString(

PyObject* unicode,

const char* errors);

PyAPI_FUNC(PyObject*) _PyUnicode_EncodeCharmap(

);

PyAPI_FUNC(PyObject*) _PyUnicode_TransformDecimalAndSpaceToASCII(

PyObject *unicode /* Unicode object */

);

PyAPI_FUNC(PyObject *) _PyUnicode_JoinArray(

);

PyAPI_FUNC(int) _PyUnicode_EqualToASCIIId(

PyObject *left, /* Left string */

_Py_Identifier *right /* Right identifier */

);

PyAPI_FUNC(int) _PyUnicode_EqualToASCIIString(

PyObject *left,

const char *right /* ASCII-encoded string */

);

PyAPI_FUNC(PyObject *) _PyUnicode_XStrip(

);

PyAPI_FUNC(Py_ssize_t) _PyUnicode_InsertThousandsGrouping(

Py_UCS4 *maxchar);

PyAPI_FUNC(int) _PyUnicode_IsLowercase(

Py_UCS4 ch /* Unicode character */

);

PyAPI_FUNC(int) _PyUnicode_IsUppercase(

Py_UCS4 ch /* Unicode character */

);

PyAPI_FUNC(int) _PyUnicode_IsTitlecase(

Py_UCS4 ch /* Unicode character */

);

PyAPI_FUNC(int) _PyUnicode_IsXidStart(

Py_UCS4 ch /* Unicode character */

);

PyAPI_FUNC(int) _PyUnicode_IsXidContinue(

Py_UCS4 ch /* Unicode character */

);

PyAPI_FUNC(int) _PyUnicode_IsWhitespace(

const Py_UCS4 ch /* Unicode character */

);

PyAPI_FUNC(int) _PyUnicode_IsLinebreak(

const Py_UCS4 ch /* Unicode character */

);

/* Py_DEPRECATED(3.3) */ PyAPI_FUNC(Py_UCS4) _PyUnicode_ToLowercase(

Py_UCS4 ch /* Unicode character */

);

/* Py_DEPRECATED(3.3) */ PyAPI_FUNC(Py_UCS4) _PyUnicode_ToUppercase(

Py_UCS4 ch /* Unicode character */

);

Py_DEPRECATED(3.3) PyAPI_FUNC(Py_UCS4) _PyUnicode_ToTitlecase(

Py_UCS4 ch /* Unicode character */

);

PyAPI_FUNC(int) _PyUnicode_ToLowerFull(

Py_UCS4 ch, /* Unicode character */

Py_UCS4 *res

);

PyAPI_FUNC(int) _PyUnicode_ToTitleFull(

Py_UCS4 ch, /* Unicode character */

Py_UCS4 *res

);

PyAPI_FUNC(int) _PyUnicode_ToUpperFull(

Py_UCS4 ch, /* Unicode character */

Py_UCS4 *res

);

PyAPI_FUNC(int) _PyUnicode_ToFoldedFull(

Py_UCS4 ch, /* Unicode character */

Py_UCS4 *res

);

PyAPI_FUNC(int) _PyUnicode_IsCaseIgnorable(

Py_UCS4 ch /* Unicode character */

);

PyAPI_FUNC(int) _PyUnicode_IsCased(

Py_UCS4 ch /* Unicode character */

);

PyAPI_FUNC(int) _PyUnicode_ToDecimalDigit(

Py_UCS4 ch /* Unicode character */

);

PyAPI_FUNC(int) _PyUnicode_ToDigit(

Py_UCS4 ch /* Unicode character */

);

PyAPI_FUNC(double) _PyUnicode_ToNumeric(

Py_UCS4 ch /* Unicode character */

);

PyAPI_FUNC(int) _PyUnicode_IsDecimalDigit(

Py_UCS4 ch /* Unicode character */

);

PyAPI_FUNC(int) _PyUnicode_IsDigit(

Py_UCS4 ch /* Unicode character */

);

PyAPI_FUNC(int) _PyUnicode_IsNumeric(

Py_UCS4 ch /* Unicode character */

);

PyAPI_FUNC(int) _PyUnicode_IsPrintable(

Py_UCS4 ch /* Unicode character */

);

PyAPI_FUNC(int) _PyUnicode_IsAlpha(

Py_UCS4 ch /* Unicode character */

);

PyAPI_DATA(const unsigned char) _Py_ascii_whitespace[];

static inline int Py_UNICODE_ISSPACE(Py_UCS4 ch) {

if (ch < 128) {

return _Py_ascii_whitespace[ch];

}

return _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)

static inline int Py_UNICODE_ISALNUM(Py_UCS4 ch) {

return (Py_UNICODE_ISALPHA(ch)

|| Py_UNICODE_ISDECIMAL(ch)

|| Py_UNICODE_ISDIGIT(ch)

|| Py_UNICODE_ISNUMERIC(ch));

}

PyAPI_FUNC(PyObject*) _PyUnicode_FormatLong(PyObject *, int, int, int);

PyAPI_FUNC(PyObject*) _PyUnicode_FromId(_Py_Identifier*);

PyAPI_FUNC(int) _PyUnicode_EQ(PyObject *, PyObject *);

PyAPI_FUNC(int) _PyUnicode_Equal(PyObject *, PyObject *);

PyAPI_FUNC(int) _PyUnicode_WideCharString_Converter(PyObject *, void *);

PyAPI_FUNC(int) _PyUnicode_WideCharString_Opt_Converter(PyObject *, void *);

PyAPI_FUNC(Py_ssize_t) _PyUnicode_ScanIdentifier(PyObject *);