#ifndef Py_UNICODEOBJECT_H

#define Py_UNICODEOBJECT_H

#include <stdarg.h>

#include <ctype.h>

#define Py_USING_UNICODE

#ifndef SIZEOF_WCHAR_T

#error Must define SIZEOF_WCHAR_T

#endif

#define Py_UNICODE_SIZE SIZEOF_WCHAR_T

#if Py_UNICODE_SIZE >= 4

#define Py_UNICODE_WIDE

#endif

#ifndef Py_LIMITED_API

#define PY_UNICODE_TYPE wchar_t

typedef wchar_t Py_UNICODE;

#endif

#ifdef HAVE_USABLE_WCHAR_T

# ifndef HAVE_WCHAR_H

# define HAVE_WCHAR_H

# endif

#endif

#if defined(MS_WINDOWS)

# define HAVE_MBCS

#endif

#ifdef HAVE_WCHAR_H

# ifdef _HAVE_BSDI

# include <time.h>

# endif

# include <wchar.h>

#endif

#if SIZEOF_INT == 4

typedef unsigned int Py_UCS4;

#elif SIZEOF_LONG == 4

typedef unsigned long Py_UCS4;

#else

#error "Could not find a proper typedef for Py_UCS4"

#endif

#if SIZEOF_SHORT == 2

typedef unsigned short Py_UCS2;

#else

#error "Could not find a proper typedef for Py_UCS2"

#endif

typedef unsigned char Py_UCS1;

#ifndef Py_LIMITED_API

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

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)

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

#endif /* Py_LIMITED_API */

#ifdef __cplusplus

extern "C" {

#endif

#ifndef Py_LIMITED_API

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;

#endif

PyAPI_DATA(PyTypeObject) PyUnicode_Type;

PyAPI_DATA(PyTypeObject) PyUnicodeIter_Type;

#define PyUnicode_Check(op) \

PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_UNICODE_SUBCLASS)

#define PyUnicode_CheckExact(op) (Py_TYPE(op) == &PyUnicode_Type)

#ifndef Py_LIMITED_API

#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 *)(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 *)(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 *)(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)))))

#endif

#define Py_UNICODE_REPLACEMENT_CHARACTER ((Py_UCS4) 0xFFFD)

#ifndef Py_LIMITED_API

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

);

#endif

#ifndef Py_LIMITED_API

PyAPI_FUNC(int) _PyUnicode_Ready(

PyObject *unicode /* Unicode object */

);

#endif

#ifndef Py_LIMITED_API

PyAPI_FUNC(PyObject*) _PyUnicode_Copy(

PyObject *unicode

);

#endif

#ifndef Py_LIMITED_API

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

);

#endif

#ifndef Py_LIMITED_API

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

);

#endif

#ifndef Py_LIMITED_API

PyAPI_FUNC(PyObject*) PyUnicode_FromUnicode(

const Py_UNICODE *u, /* Unicode buffer */

Py_ssize_t size /* size of buffer */

);

#endif

PyAPI_FUNC(PyObject*) PyUnicode_FromStringAndSize(

const char *u, /* UTF-8 encoded string */

Py_ssize_t size /* size of buffer */

);

PyAPI_FUNC(PyObject*) PyUnicode_FromString(

const char *u /* UTF-8 encoded string */

);

#ifndef Py_LIMITED_API

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

#endif

PyAPI_FUNC(PyObject*) PyUnicode_Substring(

PyObject *str,

Py_ssize_t start,

Py_ssize_t end);

#ifndef Py_LIMITED_API

PyAPI_FUNC(Py_UCS4) _PyUnicode_FindMaxChar (

PyObject *unicode,

Py_ssize_t start,

Py_ssize_t end);

#endif

PyAPI_FUNC(Py_UCS4*) PyUnicode_AsUCS4(

PyObject *unicode,

Py_UCS4* buffer,

Py_ssize_t buflen,

int copy_null);

PyAPI_FUNC(Py_UCS4*) PyUnicode_AsUCS4Copy(PyObject *unicode);

#ifndef Py_LIMITED_API

PyAPI_FUNC(Py_UNICODE *) PyUnicode_AsUnicode(

PyObject *unicode /* Unicode object */

);

#endif

#ifndef Py_LIMITED_API

PyAPI_FUNC(Py_UNICODE *) PyUnicode_AsUnicodeAndSize(

PyObject *unicode, /* Unicode object */

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

);

#endif

PyAPI_FUNC(Py_ssize_t) PyUnicode_GetLength(

PyObject *unicode

);

PyAPI_FUNC(Py_ssize_t) PyUnicode_GetSize(

PyObject *unicode /* Unicode object */

);

PyAPI_FUNC(Py_UCS4) PyUnicode_ReadChar(

PyObject *unicode,

Py_ssize_t index

);

PyAPI_FUNC(int) PyUnicode_WriteChar(

PyObject *unicode,

Py_ssize_t index,

Py_UCS4 character

);

#ifndef Py_LIMITED_API

PyAPI_FUNC(Py_UNICODE) PyUnicode_GetMax(void);

#endif

PyAPI_FUNC(int) PyUnicode_Resize(

PyObject **unicode, /* Pointer to the Unicode object */

Py_ssize_t length /* New length */

);

PyAPI_FUNC(PyObject*) PyUnicode_FromEncodedObject(

PyObject *obj, /* Object */

const char *encoding, /* encoding */

const char *errors /* error handling */

);

PyAPI_FUNC(PyObject*) PyUnicode_FromObject(

PyObject *obj /* Object */

);

PyAPI_FUNC(PyObject *) PyUnicode_FromFormatV(

const char *format, /* ASCII-encoded string */

va_list vargs

);

PyAPI_FUNC(PyObject *) PyUnicode_FromFormat(

const char *format, /* ASCII-encoded string */

...

);

#ifndef Py_LIMITED_API

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 by 25% (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);

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

#endif

#ifndef Py_LIMITED_API

PyAPI_FUNC(int) _PyUnicode_FormatAdvancedWriter(

_PyUnicodeWriter *writer,

PyObject *obj,

PyObject *format_spec,

Py_ssize_t start,

Py_ssize_t end);

#endif

PyAPI_FUNC(void) PyUnicode_InternInPlace(PyObject **);

PyAPI_FUNC(void) PyUnicode_InternImmortal(PyObject **);

PyAPI_FUNC(PyObject *) PyUnicode_InternFromString(