/*

Unicode implementation based on original code by Fredrik Lundh,

modified by Marc-Andre Lemburg <mal@lemburg.com>.

Major speed upgrades to the method implementations at the Reykjavik

NeedForSpeed sprint, by Fredrik Lundh and Andrew Dalke.

Copyright (c) Corporation for National Research Initiatives.

--------------------------------------------------------------------

The original string type implementation 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.

--------------------------------------------------------------------

*/

#define PY_SSIZE_T_CLEAN

#include "Python.h"

#include "ucnhash.h"

#include "bytes_methods.h"

#ifdef MS_WINDOWS

#include <windows.h>

#endif

/* Endianness switches; defaults to little endian */

#ifdef WORDS_BIGENDIAN

# define BYTEORDER_IS_BIG_ENDIAN

#else

# define BYTEORDER_IS_LITTLE_ENDIAN

#endif

/* --- Globals ------------------------------------------------------------

NOTE: In the interpreter's initialization phase, some globals are currently

initialized dynamically as needed. In the process Unicode objects may

be created before the Unicode type is ready.

*/

#ifdef __cplusplus

extern "C" {

#endif

/* Maximum code point of Unicode 6.0: 0x10ffff (1,114,111) */

#define MAX_UNICODE 0x10ffff

#ifdef Py_DEBUG

# define _PyUnicode_CHECK(op) _PyUnicode_CheckConsistency(op, 0)

#else

# define _PyUnicode_CHECK(op) PyUnicode_Check(op)

#endif

#define _PyUnicode_UTF8(op) \

(((PyCompactUnicodeObject*)(op))->utf8)

#define PyUnicode_UTF8(op) \

(assert(_PyUnicode_CHECK(op)), \

assert(PyUnicode_IS_READY(op)), \

PyUnicode_IS_COMPACT_ASCII(op) ? \

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

_PyUnicode_UTF8(op))

#define _PyUnicode_UTF8_LENGTH(op) \

(((PyCompactUnicodeObject*)(op))->utf8_length)

#define PyUnicode_UTF8_LENGTH(op) \

(assert(_PyUnicode_CHECK(op)), \

assert(PyUnicode_IS_READY(op)), \

PyUnicode_IS_COMPACT_ASCII(op) ? \

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

_PyUnicode_UTF8_LENGTH(op))

#define _PyUnicode_WSTR(op) \

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

#define _PyUnicode_WSTR_LENGTH(op) \

(((PyCompactUnicodeObject*)(op))->wstr_length)

#define _PyUnicode_LENGTH(op) \

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

#define _PyUnicode_STATE(op) \

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

#define _PyUnicode_HASH(op) \

(((PyASCIIObject *)(op))->hash)

#define _PyUnicode_KIND(op) \

(assert(_PyUnicode_CHECK(op)), \

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

#define _PyUnicode_GET_LENGTH(op) \

(assert(_PyUnicode_CHECK(op)), \

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

#define _PyUnicode_DATA_ANY(op) \

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

#undef PyUnicode_READY

#define PyUnicode_READY(op) \

(assert(_PyUnicode_CHECK(op)), \

(PyUnicode_IS_READY(op) ? \

0 : \

_PyUnicode_Ready(op)))

#define _PyUnicode_SHARE_UTF8(op) \

(assert(_PyUnicode_CHECK(op)), \

assert(!PyUnicode_IS_COMPACT_ASCII(op)), \

(_PyUnicode_UTF8(op) == PyUnicode_DATA(op)))

#define _PyUnicode_SHARE_WSTR(op) \

(assert(_PyUnicode_CHECK(op)), \

(_PyUnicode_WSTR(unicode) == PyUnicode_DATA(op)))

/* true if the Unicode object has an allocated UTF-8 memory block

(not shared with other data) */

#define _PyUnicode_HAS_UTF8_MEMORY(op) \

(assert(_PyUnicode_CHECK(op)), \

(!PyUnicode_IS_COMPACT_ASCII(op) \

&& _PyUnicode_UTF8(op) \

&& _PyUnicode_UTF8(op) != PyUnicode_DATA(op)))

/* true if the Unicode object has an allocated wstr memory block

(not shared with other data) */

#define _PyUnicode_HAS_WSTR_MEMORY(op) \

(assert(_PyUnicode_CHECK(op)), \

(_PyUnicode_WSTR(op) && \

(!PyUnicode_IS_READY(op) || \

_PyUnicode_WSTR(op) != PyUnicode_DATA(op))))

/* Generic helper macro to convert characters of different types.

from_type and to_type have to be valid type names, begin and end

are pointers to the source characters which should be of type

"from_type *". to is a pointer of type "to_type *" and points to the

buffer where the result characters are written to. */

#define _PyUnicode_CONVERT_BYTES(from_type, to_type, begin, end, to) \

do { \

to_type *_to = (to_type *) to; \

const from_type *_iter = (begin); \

const from_type *_end = (end); \

Py_ssize_t n = (_end) - (_iter); \

const from_type *_unrolled_end = \

_iter + _Py_SIZE_ROUND_DOWN(n, 4); \

while (_iter < (_unrolled_end)) { \

_to[0] = (to_type) _iter[0]; \

_to[1] = (to_type) _iter[1]; \

_to[2] = (to_type) _iter[2]; \

_to[3] = (to_type) _iter[3]; \

_iter += 4; _to += 4; \

} \

while (_iter < (_end)) \

*_to++ = (to_type) *_iter++; \

} while (0)

/* This dictionary holds all interned unicode strings. Note that references

to strings in this dictionary are *not* counted in the string's ob_refcnt.

When the interned string reaches a refcnt of 0 the string deallocation

function will delete the reference from this dictionary.

Another way to look at this is that to say that the actual reference

count of a string is: s->ob_refcnt + (s->state ? 2 : 0)

*/

static PyObject *interned = NULL;

/* The empty Unicode object is shared to improve performance. */

static PyObject *unicode_empty = NULL;

#define _Py_INCREF_UNICODE_EMPTY() \

do { \

if (unicode_empty != NULL) \

Py_INCREF(unicode_empty); \

else { \

unicode_empty = PyUnicode_New(0, 0); \

if (unicode_empty != NULL) { \

Py_INCREF(unicode_empty); \

assert(_PyUnicode_CheckConsistency(unicode_empty, 1)); \

} \

} \

} while (0)

#define _Py_RETURN_UNICODE_EMPTY() \

do { \

_Py_INCREF_UNICODE_EMPTY(); \

return unicode_empty; \

} while (0)

/* List of static strings. */

static _Py_Identifier *static_strings = NULL;

/* Single character Unicode strings in the Latin-1 range are being

shared as well. */

static PyObject *unicode_latin1[256] = {NULL};

/* Fast detection of the most frequent whitespace characters */

const unsigned char _Py_ascii_whitespace[] = {

0, 0, 0, 0, 0, 0, 0, 0,

/* case 0x0009: * CHARACTER TABULATION */

/* case 0x000A: * LINE FEED */

/* case 0x000B: * LINE TABULATION */

/* case 0x000C: * FORM FEED */

/* case 0x000D: * CARRIAGE RETURN */

0, 1, 1, 1, 1, 1, 0, 0,

0, 0, 0, 0, 0, 0, 0, 0,

/* case 0x001C: * FILE SEPARATOR */

/* case 0x001D: * GROUP SEPARATOR */

/* case 0x001E: * RECORD SEPARATOR */

/* case 0x001F: * UNIT SEPARATOR */

0, 0, 0, 0, 1, 1, 1, 1,

/* case 0x0020: * SPACE */

1, 0, 0, 0, 0, 0, 0, 0,

0, 0, 0, 0, 0, 0, 0, 0,

0, 0, 0, 0, 0, 0, 0, 0,

0, 0, 0, 0, 0, 0, 0, 0,

0, 0, 0, 0, 0, 0, 0, 0,

0, 0, 0, 0, 0, 0, 0, 0,

0, 0, 0, 0, 0, 0, 0, 0,

0, 0, 0, 0, 0, 0, 0, 0,

0, 0, 0, 0, 0, 0, 0, 0,

0, 0, 0, 0, 0, 0, 0, 0,

0, 0, 0, 0, 0, 0, 0, 0,

0, 0, 0, 0, 0, 0, 0, 0

};

/* forward */

static PyUnicodeObject *_PyUnicode_New(Py_ssize_t length);

static PyObject* get_latin1_char(unsigned char ch);

static int unicode_modifiable(PyObject *unicode);

static PyObject *

_PyUnicode_FromUCS1(const Py_UCS1 *s, Py_ssize_t size);

static PyObject *

_PyUnicode_FromUCS2(const Py_UCS2 *s, Py_ssize_t size);

static PyObject *

_PyUnicode_FromUCS4(const Py_UCS4 *s, Py_ssize_t size);

static PyObject *

unicode_encode_call_errorhandler(const char *errors,

PyObject **errorHandler,const char *encoding, const char *reason,

PyObject *unicode, PyObject **exceptionObject,

Py_ssize_t startpos, Py_ssize_t endpos, Py_ssize_t *newpos);

static void

raise_encode_exception(PyObject **exceptionObject,

const char *encoding,

PyObject *unicode,

Py_ssize_t startpos, Py_ssize_t endpos,

const char *reason);

/* Same for linebreaks */

static unsigned char ascii_linebreak[] = {

0, 0, 0, 0, 0, 0, 0, 0,

/* 0x000A, * LINE FEED */

/* 0x000B, * LINE TABULATION */

/* 0x000C, * FORM FEED */

/* 0x000D, * CARRIAGE RETURN */

0, 0, 1, 1, 1, 1, 0, 0,

0, 0, 0, 0, 0, 0, 0, 0,

/* 0x001C, * FILE SEPARATOR */

/* 0x001D, * GROUP SEPARATOR */

/* 0x001E, * RECORD SEPARATOR */

0, 0, 0, 0, 1, 1, 1, 0,

0, 0, 0, 0, 0, 0, 0, 0,

0, 0, 0, 0, 0, 0, 0, 0,

0, 0, 0, 0, 0, 0, 0, 0,

0, 0, 0, 0, 0, 0, 0, 0,

0, 0, 0, 0, 0, 0, 0, 0,

0, 0, 0, 0, 0, 0, 0, 0,

0, 0, 0, 0, 0, 0, 0, 0,

0, 0, 0, 0, 0, 0, 0, 0,

0, 0, 0, 0, 0, 0, 0, 0,

0, 0, 0, 0, 0, 0, 0, 0,

0, 0, 0, 0, 0, 0, 0, 0,

0, 0, 0, 0, 0, 0, 0, 0

};

/* The max unicode value is always 0x10FFFF while using the PEP-393 API.

This function is kept for backward compatibility with the old API. */

Py_UNICODE

PyUnicode_GetMax(void)

{

#ifdef Py_UNICODE_WIDE

return 0x10FFFF;

#else

/* This is actually an illegal character, so it should

not be passed to unichr. */

return 0xFFFF;

#endif

}

#ifdef Py_DEBUG

int

_PyUnicode_CheckConsistency(PyObject *op, int check_content)

{

PyASCIIObject *ascii;

unsigned int kind;

assert(PyUnicode_Check(op));

ascii = (PyASCIIObject *)op;

kind = ascii->state.kind;

if (ascii->state.ascii == 1 && ascii->state.compact == 1) {

assert(kind == PyUnicode_1BYTE_KIND);

assert(ascii->state.ready == 1);

}

else {

PyCompactUnicodeObject *compact = (PyCompactUnicodeObject *)op;

void *data;

if (ascii->state.compact == 1) {

data = compact + 1;

assert(kind == PyUnicode_1BYTE_KIND

|| kind == PyUnicode_2BYTE_KIND

|| kind == PyUnicode_4BYTE_KIND);

assert(ascii->state.ascii == 0);

assert(ascii->state.ready == 1);

assert (compact->utf8 != data);

}

else {

PyUnicodeObject *unicode = (PyUnicodeObject *)op;

data = unicode->data.any;

if (kind == PyUnicode_WCHAR_KIND) {

assert(ascii->length == 0);

assert(ascii->hash == -1);

assert(ascii->state.compact == 0);

assert(ascii->state.ascii == 0);

assert(ascii->state.ready == 0);

assert(ascii->state.interned == SSTATE_NOT_INTERNED);

assert(ascii->wstr != NULL);

assert(data == NULL);

assert(compact->utf8 == NULL);

}

else {

assert(kind == PyUnicode_1BYTE_KIND

|| kind == PyUnicode_2BYTE_KIND

|| kind == PyUnicode_4BYTE_KIND);

assert(ascii->state.compact == 0);

assert(ascii->state.ready == 1);

assert(data != NULL);

if (ascii->state.ascii) {

assert (compact->utf8 == data);

assert (compact->utf8_length == ascii->length);

}

else

assert (compact->utf8 != data);

}

}

if (kind != PyUnicode_WCHAR_KIND) {

if (

#if SIZEOF_WCHAR_T == 2

kind == PyUnicode_2BYTE_KIND

#else

kind == PyUnicode_4BYTE_KIND

#endif

)

{

assert(ascii->wstr == data);

assert(compact->wstr_length == ascii->length);

} else

assert(ascii->wstr != data);

}

if (compact->utf8 == NULL)

assert(compact->utf8_length == 0);

if (ascii->wstr == NULL)

assert(compact->wstr_length == 0);

}

/* check that the best kind is used */

if (check_content && kind != PyUnicode_WCHAR_KIND)

{

Py_ssize_t i;

Py_UCS4 maxchar = 0;

void *data;

Py_UCS4 ch;

data = PyUnicode_DATA(ascii);

for (i=0; i < ascii->length; i++)

{

ch = PyUnicode_READ(kind, data, i);

if (ch > maxchar)

maxchar = ch;

}

if (kind == PyUnicode_1BYTE_KIND) {

if (ascii->state.ascii == 0) {

assert(maxchar >= 128);

assert(maxchar <= 255);

}

else

assert(maxchar < 128);

}

else if (kind == PyUnicode_2BYTE_KIND) {

assert(maxchar >= 0x100);

assert(maxchar <= 0xFFFF);

}

else {

assert(maxchar >= 0x10000);

assert(maxchar <= MAX_UNICODE);

}

assert(PyUnicode_READ(kind, data, ascii->length) == 0);

}

return 1;

}

#endif

static PyObject*

unicode_result_wchar(PyObject *unicode)

{

#ifndef Py_DEBUG

Py_ssize_t len;

assert(Py_REFCNT(unicode) == 1);

len = _PyUnicode_WSTR_LENGTH(unicode);

if (len == 0) {

Py_DECREF(unicode);

_Py_RETURN_UNICODE_EMPTY();

}

if (len == 1) {

wchar_t ch = _PyUnicode_WSTR(unicode)[0];

if ((Py_UCS4)ch < 256) {

PyObject *latin1_char = get_latin1_char((unsigned char)ch);

Py_DECREF(unicode);

return latin1_char;

}

}

if (_PyUnicode_Ready(unicode) < 0) {

Py_XDECREF(unicode);

return NULL;

}

#else

/* don't make the result ready in debug mode to ensure that the caller

makes the string ready before using it */

assert(_PyUnicode_CheckConsistency(unicode, 1));

#endif

return unicode;

}

static PyObject*

unicode_result_ready(PyObject *unicode)

{

Py_ssize_t length;

length = PyUnicode_GET_LENGTH(unicode);

if (length == 0) {

if (unicode != unicode_empty) {

Py_DECREF(unicode);

_Py_RETURN_UNICODE_EMPTY();

}

return unicode_empty;

}

if (length == 1) {

Py_UCS4 ch = PyUnicode_READ_CHAR(unicode, 0);

if (ch < 256) {

PyObject *latin1_char = unicode_latin1[ch];

if (latin1_char != NULL) {

if (unicode != latin1_char) {

Py_INCREF(latin1_char);

Py_DECREF(unicode);

}

return latin1_char;

}

else {

assert(_PyUnicode_CheckConsistency(unicode, 1));

Py_INCREF(unicode);

unicode_latin1[ch] = unicode;

return unicode;

}

}

}

assert(_PyUnicode_CheckConsistency(unicode, 1));

return unicode;

}

static PyObject*

unicode_result(PyObject *unicode)

{

assert(_PyUnicode_CHECK(unicode));

if (PyUnicode_IS_READY(unicode))

return unicode_result_ready(unicode);

else

return unicode_result_wchar(unicode);

}

static PyObject*

unicode_result_unchanged(PyObject *unicode)

{

if (PyUnicode_CheckExact(unicode)) {

if (PyUnicode_READY(unicode) == -1)

return NULL;

Py_INCREF(unicode);

return unicode;

}

else

/* Subtype -- return genuine unicode string with the same value. */

return _PyUnicode_Copy(unicode);

}

#ifdef HAVE_MBCS

static OSVERSIONINFOEX winver;

#endif

/* --- Bloom Filters ----------------------------------------------------- */

/* stuff to implement simple "bloom filters" for Unicode characters.

to keep things simple, we use a single bitmask, using the least 5

bits from each unicode characters as the bit index. */

/* the linebreak mask is set up by Unicode_Init below */

#if LONG_BIT >= 128

#define BLOOM_WIDTH 128

#elif LONG_BIT >= 64

#define BLOOM_WIDTH 64

#elif LONG_BIT >= 32

#define BLOOM_WIDTH 32

#else

#error "LONG_BIT is smaller than 32"

#endif

#define BLOOM_MASK unsigned long

static BLOOM_MASK bloom_linebreak = ~(BLOOM_MASK)0;

#define BLOOM_ADD(mask, ch) ((mask |= (1UL << ((ch) & (BLOOM_WIDTH - 1)))))

#define BLOOM(mask, ch) ((mask & (1UL << ((ch) & (BLOOM_WIDTH - 1)))))

#define BLOOM_LINEBREAK(ch) \

((ch) < 128U ? ascii_linebreak[(ch)] : \

(BLOOM(bloom_linebreak, (ch)) && Py_UNICODE_ISLINEBREAK(ch)))

Py_LOCAL_INLINE(BLOOM_MASK)

make_bloom_mask(int kind, void* ptr, Py_ssize_t len)

{

/* calculate simple bloom-style bitmask for a given unicode string */

BLOOM_MASK mask;

Py_ssize_t i;

mask = 0;

for (i = 0; i < len; i++)

BLOOM_ADD(mask, PyUnicode_READ(kind, ptr, i));

return mask;

}

#define BLOOM_MEMBER(mask, chr, str) \

(BLOOM(mask, chr) \

&& (PyUnicode_FindChar(str, chr, 0, PyUnicode_GET_LENGTH(str), 1) >= 0))

/* Compilation of templated routines */

#include "stringlib/asciilib.h"

#include "stringlib/fastsearch.h"

#include "stringlib/partition.h"

#include "stringlib/split.h"

#include "stringlib/count.h"

#include "stringlib/find.h"

#include "stringlib/find_max_char.h"

#include "stringlib/localeutil.h"

#include "stringlib/undef.h"

#include "stringlib/ucs1lib.h"

#include "stringlib/fastsearch.h"

#include "stringlib/partition.h"

#include "stringlib/split.h"

#include "stringlib/count.h"

#include "stringlib/find.h"

#include "stringlib/find_max_char.h"

#include "stringlib/localeutil.h"

#include "stringlib/undef.h"

#include "stringlib/ucs2lib.h"

#include "stringlib/fastsearch.h"

#include "stringlib/partition.h"

#include "stringlib/split.h"

#include "stringlib/count.h"

#include "stringlib/find.h"

#include "stringlib/find_max_char.h"

#include "stringlib/localeutil.h"

#include "stringlib/undef.h"

#include "stringlib/ucs4lib.h"

#include "stringlib/fastsearch.h"

#include "stringlib/partition.h"

#include "stringlib/split.h"

#include "stringlib/count.h"

#include "stringlib/find.h"

#include "stringlib/find_max_char.h"

#include "stringlib/localeutil.h"

#include "stringlib/undef.h"

#include "stringlib/unicodedefs.h"

#include "stringlib/fastsearch.h"

#include "stringlib/count.h"

#include "stringlib/find.h"

#include "stringlib/undef.h"

/* --- Unicode Object ----------------------------------------------------- */

static PyObject *

fixup(PyObject *self, Py_UCS4 (*fixfct)(PyObject *s));

Py_LOCAL_INLINE(Py_ssize_t) findchar(void *s, int kind,

Py_ssize_t size, Py_UCS4 ch,

int direction)

{

int mode = (direction == 1) ? FAST_SEARCH : FAST_RSEARCH;

switch (kind) {

case PyUnicode_1BYTE_KIND:

{

Py_UCS1 ch1 = (Py_UCS1) ch;

if (ch1 == ch)

return ucs1lib_fastsearch((Py_UCS1 *) s, size, &ch1, 1, 0, mode);

else

return -1;

}

case PyUnicode_2BYTE_KIND:

{

Py_UCS2 ch2 = (Py_UCS2) ch;

if (ch2 == ch)

return ucs2lib_fastsearch((Py_UCS2 *) s, size, &ch2, 1, 0, mode);

else

return -1;

}

case PyUnicode_4BYTE_KIND:

return ucs4lib_fastsearch((Py_UCS4 *) s, size, &ch, 1, 0, mode);

default:

assert(0);

return -1;

}

}

static PyObject*

resize_compact(PyObject *unicode, Py_ssize_t length)

{

Py_ssize_t char_size;

Py_ssize_t struct_size;

Py_ssize_t new_size;

int share_wstr;

PyObject *new_unicode;

assert(unicode_modifiable(unicode));

assert(PyUnicode_IS_READY(unicode));

assert(PyUnicode_IS_COMPACT(unicode));

char_size = PyUnicode_KIND(unicode);

if (PyUnicode_IS_ASCII(unicode))

struct_size = sizeof(PyASCIIObject);

else

struct_size = sizeof(PyCompactUnicodeObject);

share_wstr = _PyUnicode_SHARE_WSTR(unicode);

if (length > ((PY_SSIZE_T_MAX - struct_size) / char_size - 1)) {

PyErr_NoMemory();

return NULL;

}

new_size = (struct_size + (length + 1) * char_size);

if (_PyUnicode_HAS_UTF8_MEMORY(unicode)) {

PyObject_DEL(_PyUnicode_UTF8(unicode));

_PyUnicode_UTF8(unicode) = NULL;

_PyUnicode_UTF8_LENGTH(unicode) = 0;

}

_Py_DEC_REFTOTAL;

_Py_ForgetReference(unicode);

new_unicode = (PyObject *)PyObject_REALLOC((char *)unicode, new_size);

if (new_unicode == NULL) {

_Py_NewReference(unicode);

PyErr_NoMemory();

return NULL;

}

unicode = new_unicode;

_Py_NewReference(unicode);

_PyUnicode_LENGTH(unicode) = length;

if (share_wstr) {

_PyUnicode_WSTR(unicode) = PyUnicode_DATA(unicode);

if (!PyUnicode_IS_ASCII(unicode))

_PyUnicode_WSTR_LENGTH(unicode) = length;

}

else if (_PyUnicode_HAS_WSTR_MEMORY(unicode)) {

PyObject_DEL(_PyUnicode_WSTR(unicode));

_PyUnicode_WSTR(unicode) = NULL;

}

PyUnicode_WRITE(PyUnicode_KIND(unicode), PyUnicode_DATA(unicode),

length, 0);

assert(_PyUnicode_CheckConsistency(unicode, 0));

return unicode;

}

static int

resize_inplace(PyObject *unicode, Py_ssize_t length)

{

wchar_t *wstr;

Py_ssize_t new_size;

assert(!PyUnicode_IS_COMPACT(unicode));

assert(Py_REFCNT(unicode) == 1);

if (PyUnicode_IS_READY(unicode)) {

Py_ssize_t char_size;

int share_wstr, share_utf8;

void *data;

data = _PyUnicode_DATA_ANY(unicode);

char_size = PyUnicode_KIND(unicode);

share_wstr = _PyUnicode_SHARE_WSTR(unicode);

share_utf8 = _PyUnicode_SHARE_UTF8(unicode);

if (length > (PY_SSIZE_T_MAX / char_size - 1)) {

PyErr_NoMemory();

return -1;

}

new_size = (length + 1) * char_size;

if (!share_utf8 && _PyUnicode_HAS_UTF8_MEMORY(unicode))

{

PyObject_DEL(_PyUnicode_UTF8(unicode));

_PyUnicode_UTF8(unicode) = NULL;

_PyUnicode_UTF8_LENGTH(unicode) = 0;

}

data = (PyObject *)PyObject_REALLOC(data, new_size);

if (data == NULL) {

PyErr_NoMemory();

return -1;

}

_PyUnicode_DATA_ANY(unicode) = data;

if (share_wstr) {

_PyUnicode_WSTR(unicode) = data;

_PyUnicode_WSTR_LENGTH(unicode) = length;

}

if (share_utf8) {

_PyUnicode_UTF8(unicode) = data;

_PyUnicode_UTF8_LENGTH(unicode) = length;

}

_PyUnicode_LENGTH(unicode) = length;

PyUnicode_WRITE(PyUnicode_KIND(unicode), data, length, 0);

if (share_wstr || _PyUnicode_WSTR(unicode) == NULL) {

assert(_PyUnicode_CheckConsistency(unicode, 0));

return 0;

}

}

assert(_PyUnicode_WSTR(unicode) != NULL);

/* check for integer overflow */

if (length > PY_SSIZE_T_MAX / sizeof(wchar_t) - 1) {

PyErr_NoMemory();

return -1;

}

new_size = sizeof(wchar_t) * (length + 1);

wstr = _PyUnicode_WSTR(unicode);

wstr = PyObject_REALLOC(wstr, new_size);

if (!wstr) {

PyErr_NoMemory();

return -1;

}

_PyUnicode_WSTR(unicode) = wstr;

_PyUnicode_WSTR(unicode)[length] = 0;

_PyUnicode_WSTR_LENGTH(unicode) = length;

assert(_PyUnicode_CheckConsistency(unicode, 0));

return 0;

}

static PyObject*

resize_copy(PyObject *unicode, Py_ssize_t length)

{

Py_ssize_t copy_length;

if (_PyUnicode_KIND(unicode) != PyUnicode_WCHAR_KIND) {

PyObject *copy;

if (PyUnicode_READY(unicode) == -1)

return NULL;

copy = PyUnicode_New(length, PyUnicode_MAX_CHAR_VALUE(unicode));

if (copy == NULL)

return NULL;

copy_length = Py_MIN(length, PyUnicode_GET_LENGTH(unicode));

_PyUnicode_FastCopyCharacters(copy, 0, unicode, 0, copy_length);

return copy;

}

else {

PyObject *w;

w = (PyObject*)_PyUnicode_New(length);

if (w == NULL)

return NULL;

copy_length = _PyUnicode_WSTR_LENGTH(unicode);

copy_length = Py_MIN(copy_length, length);

Py_UNICODE_COPY(_PyUnicode_WSTR(w), _PyUnicode_WSTR(unicode),

copy_length);

return w;

}

}

/* We allocate one more byte to make sure the string is

Ux0000 terminated; some code (e.g. new_identifier)

relies on that.

XXX This allocator could further be enhanced by assuring that the

free list never reduces its size below 1.

*/

static PyUnicodeObject *

_PyUnicode_New(Py_ssize_t length)

{

register PyUnicodeObject *unicode;

size_t new_size;

/* Optimization for empty strings */

if (length == 0 && unicode_empty != NULL) {

Py_INCREF(unicode_empty);

return (PyUnicodeObject*)unicode_empty;

}

/* Ensure we won't overflow the size. */

if (length > ((PY_SSIZE_T_MAX / sizeof(Py_UNICODE)) - 1)) {

return (PyUnicodeObject *)PyErr_NoMemory();

}

if (length < 0) {

PyErr_SetString(PyExc_SystemError,

"Negative size passed to _PyUnicode_New");

return NULL;

}

unicode = PyObject_New(PyUnicodeObject, &PyUnicode_Type);

if (unicode == NULL)

return NULL;

new_size = sizeof(Py_UNICODE) * ((size_t)length + 1);

_PyUnicode_WSTR(unicode) = (Py_UNICODE*) PyObject_MALLOC(new_size);

if (!_PyUnicode_WSTR(unicode)) {

Py_DECREF(unicode);

PyErr_NoMemory();

return NULL;

}

/* Initialize the first element to guard against cases where

* the caller fails before initializing str -- unicode_resize()

* reads str[0], and the Keep-Alive optimization can keep memory

* allocated for str alive across a call to unicode_dealloc(unicode).

* We don't want unicode_resize to read uninitialized memory in

* that case.

*/

_PyUnicode_WSTR(unicode)[0] = 0;

_PyUnicode_WSTR(unicode)[length] = 0;

_PyUnicode_WSTR_LENGTH(unicode) = length;

_PyUnicode_HASH(unicode) = -1;

_PyUnicode_STATE(unicode).interned = 0;

_PyUnicode_STATE(unicode).kind = 0;

_PyUnicode_STATE(unicode).compact = 0;

_PyUnicode_STATE(unicode).ready = 0;

_PyUnicode_STATE(unicode).ascii = 0;

_PyUnicode_DATA_ANY(unicode) = NULL;

_PyUnicode_LENGTH(unicode) = 0;

_PyUnicode_UTF8(unicode) = NULL;

_PyUnicode_UTF8_LENGTH(unicode) = 0;

assert(_PyUnicode_CheckConsistency((PyObject *)unicode, 0));

return unicode;

}

static const char*

unicode_kind_name(PyObject *unicode)

{

/* don't check consistency: unicode_kind_name() is called from

_PyUnicode_Dump() */

if (!PyUnicode_IS_COMPACT(unicode))

{

if (!PyUnicode_IS_READY(unicode))

return "wstr";

switch (PyUnicode_KIND(unicode))

{

case PyUnicode_1BYTE_KIND:

if (PyUnicode_IS_ASCII(unicode))

return "legacy ascii";

else

return "legacy latin1";

case PyUnicode_2BYTE_KIND:

return "legacy UCS2";

case PyUnicode_4BYTE_KIND:

return "legacy UCS4";

default:

return "<legacy invalid kind>";

}

}

assert(PyUnicode_IS_READY(unicode));

switch (PyUnicode_KIND(unicode)) {

case PyUnicode_1BYTE_KIND:

if (PyUnicode_IS_ASCII(unicode))

return "ascii";

else

return "latin1";

case PyUnicode_2BYTE_KIND:

return "UCS2";

case PyUnicode_4BYTE_KIND:

return "UCS4";

default:

return "<invalid compact kind>";

}

}

#ifdef Py_DEBUG

/* Functions wrapping macros for use in debugger */

char *_PyUnicode_utf8(void *unicode){

return PyUnicode_UTF8(unicode);

}

void *_PyUnicode_compact_data(void *unicode) {

return _PyUnicode_COMPACT_DATA(unicode);

}

void *_PyUnicode_data(void *unicode){

printf("obj %p\n", unicode);

printf("compact %d\n", PyUnicode_IS_COMPACT(unicode));

printf("compact ascii %d\n", PyUnicode_IS_COMPACT_ASCII(unicode));

printf("ascii op %p\n", ((void*)((PyASCIIObject*)(unicode) + 1)));

printf("compact op %p\n", ((void*)((PyCompactUnicodeObject*)(unicode) + 1)));

printf("compact data %p\n", _PyUnicode_COMPACT_DATA(unicode));

return PyUnicode_DATA(unicode);

}

void

_PyUnicode_Dump(PyObject *op)

{

PyASCIIObject *ascii = (PyASCIIObject *)op;

PyCompactUnicodeObject *compact = (PyCompactUnicodeObject *)op;

PyUnicodeObject *unicode = (PyUnicodeObject *)op;

void *data;

if (ascii->state.compact)

{

if (ascii->state.ascii)

data = (ascii + 1);

else

data = (compact + 1);

}

else

data = unicode->data.any;

printf("%s: len=%zu, ",unicode_kind_name(op), ascii->length);

if (ascii->wstr == data)

printf("shared ");

printf("wstr=%p", ascii->wstr);

if (!(ascii->state.ascii == 1 && ascii->state.compact == 1)) {

printf(" (%zu), ", compact->wstr_length);

if (!ascii->state.compact && compact->utf8 == unicode->data.any)

printf("shared ");

printf("utf8=%p (%zu)", compact->utf8, compact->utf8_length);

}

printf(", data=%p\n", data);

}

#endif

PyObject *

PyUnicode_New(Py_ssize_t size, Py_UCS4 maxchar)

{

PyObject *obj;

PyCompactUnicodeObject *unicode;

void *data;

enum PyUnicode_Kind kind;

int is_sharing, is_ascii;

Py_ssize_t char_size;

Py_ssize_t struct_size;

/* Optimization for empty strings */

if (size == 0 && unicode_empty != NULL) {

Py_INCREF(unicode_empty);

return unicode_empty;

}

is_ascii = 0;

is_sharing = 0;

struct_size = sizeof(PyCompactUnicodeObject);

if (maxchar < 128) {

kind = PyUnicode_1BYTE_KIND;

char_size = 1;