From 9db1a8b69f13f884336556b61252f7ca271f2b76 Mon Sep 17 00:00:00 2001 From: Victor Stinner Date: Sun, 23 Oct 2011 20:04:37 +0200 Subject: Replace PyUnicodeObject* by PyObject* where it was irrevelant A Unicode string can now be a PyASCIIObject, PyCompactUnicodeObject or PyUnicodeObject. Aliasing a PyASCIIObject* or PyCompactUnicodeObject* to PyUnicodeObject* is wrong --- Include/unicodeobject.h | 2 +- Objects/stringlib/find.h | 8 +- Objects/unicodeobject.c | 265 ++++++++++++++++++++++------------------------- 3 files changed, 131 insertions(+), 144 deletions(-) diff --git a/Include/unicodeobject.h b/Include/unicodeobject.h index 4e492dd..592f4dd 100644 --- a/Include/unicodeobject.h +++ b/Include/unicodeobject.h @@ -1828,7 +1828,7 @@ PyAPI_FUNC(int) PyUnicode_IsIdentifier(PyObject *s); #ifndef Py_LIMITED_API /* Externally visible for str.strip(unicode) */ PyAPI_FUNC(PyObject *) _PyUnicode_XStrip( - PyUnicodeObject *self, + PyObject *self, int striptype, PyObject *sepobj ); diff --git a/Objects/stringlib/find.h b/Objects/stringlib/find.h index 00eaf1b..26b6ce4 100644 --- a/Objects/stringlib/find.h +++ b/Objects/stringlib/find.h @@ -95,7 +95,7 @@ This function is a helper for the "find" family (find, rfind, index, rindex) and for count, startswith and endswith, because they all have the same behaviour for the arguments. -It does not touch the variables received until it knows everything +It does not touch the variables received until it knows everything is ok. */ @@ -145,13 +145,13 @@ first argument is a unicode object. Note that we receive a pointer to the pointer of the substring object, so when we create that object in this function we don't DECREF it, -because it continues living in the caller functions (those functions, +because it continues living in the caller functions (those functions, after finishing using the substring, must DECREF it). */ Py_LOCAL_INLINE(int) STRINGLIB(parse_args_finds_unicode)(const char * function_name, PyObject *args, - PyUnicodeObject **substring, + PyObject **substring, Py_ssize_t *start, Py_ssize_t *end) { PyObject *tmp_substring; @@ -161,7 +161,7 @@ STRINGLIB(parse_args_finds_unicode)(const char * function_name, PyObject *args, tmp_substring = PyUnicode_FromObject(tmp_substring); if (!tmp_substring) return 0; - *substring = (PyUnicodeObject *)tmp_substring; + *substring = tmp_substring; return 1; } return 0; diff --git a/Objects/unicodeobject.c b/Objects/unicodeobject.c index 82d532f..43ecd5d 100644 --- a/Objects/unicodeobject.c +++ b/Objects/unicodeobject.c @@ -585,7 +585,7 @@ resize_compact(PyObject *unicode, Py_ssize_t length) } static int -resize_inplace(PyUnicodeObject *unicode, Py_ssize_t length) +resize_inplace(PyObject *unicode, Py_ssize_t length) { wchar_t *wstr; assert(!PyUnicode_IS_COMPACT(unicode)); @@ -675,17 +675,17 @@ resize_copy(PyObject *unicode, Py_ssize_t length) return copy; } else { - PyUnicodeObject *w; + PyObject *w; assert(_PyUnicode_WSTR(unicode) != NULL); assert(_PyUnicode_DATA_ANY(unicode) == NULL); - w = _PyUnicode_New(length); + 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 (PyObject*)w; + return w; } } @@ -983,7 +983,7 @@ PyUnicode_New(Py_ssize_t size, Py_UCS4 maxchar) characters for a terminating null character. */ static void unicode_convert_wchar_to_ucs4(const wchar_t *begin, const wchar_t *end, - PyUnicodeObject *unicode) + PyObject *unicode) { const wchar_t *iter; Py_UCS4 *ucs4_out; @@ -1254,7 +1254,7 @@ static int unicode_ready_calls = 0; static int unicode_ready(PyObject **p_obj, int replace) { - PyUnicodeObject *unicode; + PyObject *unicode; wchar_t *end; Py_UCS4 maxchar = 0; Py_ssize_t num_surrogates; @@ -1263,7 +1263,7 @@ unicode_ready(PyObject **p_obj, int replace) #endif assert(p_obj != NULL); - unicode = (PyUnicodeObject *)*p_obj; + unicode = *p_obj; /* _PyUnicode_Ready() is only intended for old-style API usage where strings were created using _PyObject_New() and where no canonical @@ -1423,7 +1423,7 @@ _PyUnicode_Ready(PyObject *op) } static void -unicode_dealloc(register PyUnicodeObject *unicode) +unicode_dealloc(register PyObject *unicode) { switch (PyUnicode_CHECK_INTERNED(unicode)) { case SSTATE_NOT_INTERNED: @@ -1526,7 +1526,7 @@ unicode_resize(PyObject **p_unicode, Py_ssize_t length) assert(_PyUnicode_CheckConsistency(*p_unicode, 0)); return 0; } - return resize_inplace((PyUnicodeObject*)unicode, length); + return resize_inplace(unicode, length); } int @@ -1566,7 +1566,7 @@ get_latin1_char(unsigned char ch) PyObject * PyUnicode_FromUnicode(const Py_UNICODE *u, Py_ssize_t size) { - PyUnicodeObject *unicode; + PyObject *unicode; Py_UCS4 maxchar = 0; Py_ssize_t num_surrogates; @@ -1593,7 +1593,7 @@ PyUnicode_FromUnicode(const Py_UNICODE *u, Py_ssize_t size) &maxchar, &num_surrogates) == -1) return NULL; - unicode = (PyUnicodeObject *) PyUnicode_New(size - num_surrogates, + unicode = PyUnicode_New(size - num_surrogates, maxchar); if (!unicode) return NULL; @@ -1626,14 +1626,12 @@ PyUnicode_FromUnicode(const Py_UNICODE *u, Py_ssize_t size) } assert(_PyUnicode_CheckConsistency(unicode, 1)); - return (PyObject *)unicode; + return unicode; } PyObject * PyUnicode_FromStringAndSize(const char *u, Py_ssize_t size) { - PyUnicodeObject *unicode; - if (size < 0) { PyErr_SetString(PyExc_SystemError, "Negative size passed to PyUnicode_FromStringAndSize"); @@ -1660,11 +1658,7 @@ PyUnicode_FromStringAndSize(const char *u, Py_ssize_t size) return PyUnicode_DecodeUTF8(u, size, NULL); } - unicode = _PyUnicode_New(size); - if (!unicode) - return NULL; - - return (PyObject *)unicode; + return (PyObject *)_PyUnicode_New(size); } PyObject * @@ -2650,14 +2644,14 @@ PyUnicode_FromFormat(const char *format, ...) character) written into w. Write at most size wide characters (including the null character). */ static Py_ssize_t -unicode_aswidechar(PyUnicodeObject *unicode, +unicode_aswidechar(PyObject *unicode, wchar_t *w, Py_ssize_t size) { Py_ssize_t res; const wchar_t *wstr; - wstr = PyUnicode_AsUnicodeAndSize((PyObject *)unicode, &res); + wstr = PyUnicode_AsUnicodeAndSize(unicode, &res); if (wstr == NULL) return -1; @@ -2682,7 +2676,7 @@ PyUnicode_AsWideChar(PyObject *unicode, PyErr_BadInternalCall(); return -1; } - return unicode_aswidechar((PyUnicodeObject*)unicode, w, size); + return unicode_aswidechar(unicode, w, size); } wchar_t* @@ -2697,7 +2691,7 @@ PyUnicode_AsWideCharString(PyObject *unicode, return NULL; } - buflen = unicode_aswidechar((PyUnicodeObject *)unicode, NULL, 0); + buflen = unicode_aswidechar(unicode, NULL, 0); if (buflen == -1) return NULL; if (PY_SSIZE_T_MAX / sizeof(wchar_t) < buflen) { @@ -2710,7 +2704,7 @@ PyUnicode_AsWideCharString(PyObject *unicode, PyErr_NoMemory(); return NULL; } - buflen = unicode_aswidechar((PyUnicodeObject *)unicode, buffer, buflen); + buflen = unicode_aswidechar(unicode, buffer, buflen); if (buflen == -1) return NULL; if (size != NULL) @@ -3322,13 +3316,12 @@ char* PyUnicode_AsUTF8AndSize(PyObject *unicode, Py_ssize_t *psize) { PyObject *bytes; - PyUnicodeObject *u = (PyUnicodeObject *)unicode; if (!PyUnicode_Check(unicode)) { PyErr_BadArgument(); return NULL; } - if (PyUnicode_READY(u) == -1) + if (PyUnicode_READY(unicode) == -1) return NULL; if (PyUnicode_UTF8(unicode) == NULL) { @@ -3336,13 +3329,15 @@ PyUnicode_AsUTF8AndSize(PyObject *unicode, Py_ssize_t *psize) bytes = _PyUnicode_AsUTF8String(unicode, "strict"); if (bytes == NULL) return NULL; - _PyUnicode_UTF8(u) = PyObject_MALLOC(PyBytes_GET_SIZE(bytes) + 1); - if (_PyUnicode_UTF8(u) == NULL) { + _PyUnicode_UTF8(unicode) = PyObject_MALLOC(PyBytes_GET_SIZE(bytes) + 1); + if (_PyUnicode_UTF8(unicode) == NULL) { Py_DECREF(bytes); return NULL; } - _PyUnicode_UTF8_LENGTH(u) = PyBytes_GET_SIZE(bytes); - Py_MEMCPY(_PyUnicode_UTF8(u), PyBytes_AS_STRING(bytes), _PyUnicode_UTF8_LENGTH(u) + 1); + _PyUnicode_UTF8_LENGTH(unicode) = PyBytes_GET_SIZE(bytes); + Py_MEMCPY(_PyUnicode_UTF8(unicode), + PyBytes_AS_STRING(bytes), + _PyUnicode_UTF8_LENGTH(unicode) + 1); Py_DECREF(bytes); } @@ -3365,7 +3360,6 @@ static int unicode_as_unicode_calls = 0; Py_UNICODE * PyUnicode_AsUnicodeAndSize(PyObject *unicode, Py_ssize_t *size) { - PyUnicodeObject *u; const unsigned char *one_byte; #if SIZEOF_WCHAR_T == 4 const Py_UCS2 *two_bytes; @@ -3381,20 +3375,19 @@ PyUnicode_AsUnicodeAndSize(PyObject *unicode, Py_ssize_t *size) PyErr_BadArgument(); return NULL; } - u = (PyUnicodeObject*)unicode; - if (_PyUnicode_WSTR(u) == NULL) { + if (_PyUnicode_WSTR(unicode) == NULL) { /* Non-ASCII compact unicode object */ - assert(_PyUnicode_KIND(u) != 0); - assert(PyUnicode_IS_READY(u)); + assert(_PyUnicode_KIND(unicode) != 0); + assert(PyUnicode_IS_READY(unicode)); #ifdef Py_DEBUG ++unicode_as_unicode_calls; #endif - if (PyUnicode_KIND(u) == PyUnicode_4BYTE_KIND) { + if (PyUnicode_KIND(unicode) == PyUnicode_4BYTE_KIND) { #if SIZEOF_WCHAR_T == 2 - four_bytes = PyUnicode_4BYTE_DATA(u); - ucs4_end = four_bytes + _PyUnicode_LENGTH(u); + four_bytes = PyUnicode_4BYTE_DATA(unicode); + ucs4_end = four_bytes + _PyUnicode_LENGTH(unicode); num_surrogates = 0; for (; four_bytes < ucs4_end; ++four_bytes) { @@ -3402,17 +3395,17 @@ PyUnicode_AsUnicodeAndSize(PyObject *unicode, Py_ssize_t *size) ++num_surrogates; } - _PyUnicode_WSTR(u) = (wchar_t *) PyObject_MALLOC( - sizeof(wchar_t) * (_PyUnicode_LENGTH(u) + 1 + num_surrogates)); - if (!_PyUnicode_WSTR(u)) { + _PyUnicode_WSTR(unicode) = (wchar_t *) PyObject_MALLOC( + sizeof(wchar_t) * (_PyUnicode_LENGTH(unicode) + 1 + num_surrogates)); + if (!_PyUnicode_WSTR(unicode)) { PyErr_NoMemory(); return NULL; } - _PyUnicode_WSTR_LENGTH(u) = _PyUnicode_LENGTH(u) + num_surrogates; + _PyUnicode_WSTR_LENGTH(unicode) = _PyUnicode_LENGTH(unicode) + num_surrogates; - w = _PyUnicode_WSTR(u); - wchar_end = w + _PyUnicode_WSTR_LENGTH(u); - four_bytes = PyUnicode_4BYTE_DATA(u); + w = _PyUnicode_WSTR(unicode); + wchar_end = w + _PyUnicode_WSTR_LENGTH(unicode); + four_bytes = PyUnicode_4BYTE_DATA(unicode); for (; four_bytes < ucs4_end; ++four_bytes, ++w) { if (*four_bytes > 0xFFFF) { /* encode surrogate pair in this case */ @@ -3435,35 +3428,35 @@ PyUnicode_AsUnicodeAndSize(PyObject *unicode, Py_ssize_t *size) #endif } else { - _PyUnicode_WSTR(u) = (wchar_t *) PyObject_MALLOC(sizeof(wchar_t) * - (_PyUnicode_LENGTH(u) + 1)); - if (!_PyUnicode_WSTR(u)) { + _PyUnicode_WSTR(unicode) = (wchar_t *) PyObject_MALLOC(sizeof(wchar_t) * + (_PyUnicode_LENGTH(unicode) + 1)); + if (!_PyUnicode_WSTR(unicode)) { PyErr_NoMemory(); return NULL; } - if (!PyUnicode_IS_COMPACT_ASCII(u)) - _PyUnicode_WSTR_LENGTH(u) = _PyUnicode_LENGTH(u); - w = _PyUnicode_WSTR(u); - wchar_end = w + _PyUnicode_LENGTH(u); + if (!PyUnicode_IS_COMPACT_ASCII(unicode)) + _PyUnicode_WSTR_LENGTH(unicode) = _PyUnicode_LENGTH(unicode); + w = _PyUnicode_WSTR(unicode); + wchar_end = w + _PyUnicode_LENGTH(unicode); - if (PyUnicode_KIND(u) == PyUnicode_1BYTE_KIND) { - one_byte = PyUnicode_1BYTE_DATA(u); + if (PyUnicode_KIND(unicode) == PyUnicode_1BYTE_KIND) { + one_byte = PyUnicode_1BYTE_DATA(unicode); for (; w < wchar_end; ++one_byte, ++w) *w = *one_byte; /* null-terminate the wstr */ *w = 0; } - else if (PyUnicode_KIND(u) == PyUnicode_2BYTE_KIND) { + else if (PyUnicode_KIND(unicode) == PyUnicode_2BYTE_KIND) { #if SIZEOF_WCHAR_T == 4 - two_bytes = PyUnicode_2BYTE_DATA(u); + two_bytes = PyUnicode_2BYTE_DATA(unicode); for (; w < wchar_end; ++two_bytes, ++w) *w = *two_bytes; /* null-terminate the wstr */ *w = 0; #else /* sizeof(wchar_t) == 2 */ - PyObject_FREE(_PyUnicode_WSTR(u)); - _PyUnicode_WSTR(u) = NULL; + PyObject_FREE(_PyUnicode_WSTR(unicode)); + _PyUnicode_WSTR(unicode) = NULL; Py_FatalError("Impossible unicode object state, wstr " "and str should share memory already."); return NULL; @@ -3475,8 +3468,8 @@ PyUnicode_AsUnicodeAndSize(PyObject *unicode, Py_ssize_t *size) } } if (size != NULL) - *size = PyUnicode_WSTR_LENGTH(u); - return _PyUnicode_WSTR(u); + *size = PyUnicode_WSTR_LENGTH(unicode); + return _PyUnicode_WSTR(unicode); } Py_UNICODE * @@ -9109,16 +9102,16 @@ PyUnicode_Count(PyObject *str, Py_ssize_t end) { Py_ssize_t result; - PyUnicodeObject* str_obj; - PyUnicodeObject* sub_obj; + PyObject* str_obj; + PyObject* sub_obj; int kind1, kind2, kind; void *buf1 = NULL, *buf2 = NULL; Py_ssize_t len1, len2; - str_obj = (PyUnicodeObject*) PyUnicode_FromObject(str); + str_obj = PyUnicode_FromObject(str); if (!str_obj || PyUnicode_READY(str_obj) == -1) return -1; - sub_obj = (PyUnicodeObject*) PyUnicode_FromObject(substr); + sub_obj = PyUnicode_FromObject(substr); if (!sub_obj || PyUnicode_READY(sub_obj) == -1) { Py_DECREF(str_obj); return -1; @@ -9242,8 +9235,8 @@ PyUnicode_FindChar(PyObject *str, Py_UCS4 ch, } static int -tailmatch(PyUnicodeObject *self, - PyUnicodeObject *substring, +tailmatch(PyObject *self, + PyObject *substring, Py_ssize_t start, Py_ssize_t end, int direction) @@ -9327,8 +9320,7 @@ PyUnicode_Tailmatch(PyObject *str, return -1; } - result = tailmatch((PyUnicodeObject *)str, - (PyUnicodeObject *)substr, + result = tailmatch(str, substr, start, end, direction); Py_DECREF(str); Py_DECREF(substr); @@ -10402,7 +10394,7 @@ Apply .capitalize() to all words in S and return the result with\n\ normalized whitespace (all whitespace strings are replaced by ' ')."); static PyObject* -unicode_capwords(PyUnicodeObject *self) +unicode_capwords(PyObject *self) { PyObject *list; PyObject *item; @@ -10415,7 +10407,7 @@ unicode_capwords(PyUnicodeObject *self) /* Capitalize each word */ for (i = 0; i < PyList_GET_SIZE(list); i++) { - item = fixup((PyUnicodeObject *)PyList_GET_ITEM(list, i), + item = fixup(PyList_GET_ITEM(list, i), fixcapitalize); if (item == NULL) goto onError; @@ -10490,7 +10482,7 @@ unicode_center(PyObject *self, PyObject *args) /* This function assumes that str1 and str2 are readied by the caller. */ static int -unicode_compare(PyUnicodeObject *str1, PyUnicodeObject *str2) +unicode_compare(PyObject *str1, PyObject *str2) { int kind1, kind2; void *data1, *data2; @@ -10522,8 +10514,7 @@ PyUnicode_Compare(PyObject *left, PyObject *right) if (PyUnicode_READY(left) == -1 || PyUnicode_READY(right) == -1) return -1; - return unicode_compare((PyUnicodeObject *)left, - (PyUnicodeObject *)right); + return unicode_compare(left, right); } PyErr_Format(PyExc_TypeError, "Can't compare %.100s and %.100s", @@ -10586,8 +10577,7 @@ PyUnicode_RichCompare(PyObject *left, PyObject *right, int op) if (left == right) result = 0; else - result = unicode_compare((PyUnicodeObject *)left, - (PyUnicodeObject *)right); + result = unicode_compare(left, right); /* Convert the return value to a Boolean */ switch (op) { @@ -10849,9 +10839,9 @@ string S[start:end]. Optional arguments start and end are\n\ interpreted as in slice notation."); static PyObject * -unicode_count(PyUnicodeObject *self, PyObject *args) +unicode_count(PyObject *self, PyObject *args) { - PyUnicodeObject *substring; + PyObject *substring; Py_ssize_t start = 0; Py_ssize_t end = PY_SSIZE_T_MAX; PyObject *result; @@ -10931,7 +10921,7 @@ a UnicodeEncodeError. Other possible values are 'ignore', 'replace' and\n\ codecs.register_error that can handle UnicodeEncodeErrors."); static PyObject * -unicode_encode(PyUnicodeObject *self, PyObject *args, PyObject *kwargs) +unicode_encode(PyObject *self, PyObject *args, PyObject *kwargs) { static char *kwlist[] = {"encoding", "errors", 0}; char *encoding = NULL; @@ -10940,7 +10930,7 @@ unicode_encode(PyUnicodeObject *self, PyObject *args, PyObject *kwargs) if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|ss:encode", kwlist, &encoding, &errors)) return NULL; - return PyUnicode_AsEncodedString((PyObject *)self, encoding, errors); + return PyUnicode_AsEncodedString(self, encoding, errors); } PyDoc_STRVAR(expandtabs__doc__, @@ -10950,7 +10940,7 @@ Return a copy of S where all tab characters are expanded using spaces.\n\ If tabsize is not given, a tab size of 8 characters is assumed."); static PyObject* -unicode_expandtabs(PyUnicodeObject *self, PyObject *args) +unicode_expandtabs(PyObject *self, PyObject *args) { Py_ssize_t i, j, line_pos, src_len, incr; Py_UCS4 ch; @@ -11053,7 +11043,7 @@ Return -1 on failure."); static PyObject * unicode_find(PyObject *self, PyObject *args) { - PyUnicodeObject *substring; + PyObject *substring; Py_ssize_t start; Py_ssize_t end; Py_ssize_t result; @@ -11091,7 +11081,7 @@ unicode_getitem(PyObject *self, Py_ssize_t index) /* Believe it or not, this produces the same value for ASCII strings as bytes_hash(). */ static Py_hash_t -unicode_hash(PyUnicodeObject *self) +unicode_hash(PyObject *self) { Py_ssize_t len; Py_uhash_t x; @@ -11146,7 +11136,7 @@ static PyObject * unicode_index(PyObject *self, PyObject *args) { Py_ssize_t result; - PyUnicodeObject *substring; + PyObject *substring; Py_ssize_t start; Py_ssize_t end; @@ -11183,7 +11173,7 @@ Return True if all cased characters in S are lowercase and there is\n\ at least one cased character in S, False otherwise."); static PyObject* -unicode_islower(PyUnicodeObject *self) +unicode_islower(PyObject *self) { Py_ssize_t i, length; int kind; @@ -11224,7 +11214,7 @@ Return True if all cased characters in S are uppercase and there is\n\ at least one cased character in S, False otherwise."); static PyObject* -unicode_isupper(PyUnicodeObject *self) +unicode_isupper(PyObject *self) { Py_ssize_t i, length; int kind; @@ -11267,7 +11257,7 @@ follow uncased characters and lowercase characters only cased ones.\n\ Return False otherwise."); static PyObject* -unicode_istitle(PyUnicodeObject *self) +unicode_istitle(PyObject *self) { Py_ssize_t i, length; int kind; @@ -11321,7 +11311,7 @@ Return True if all characters in S are whitespace\n\ and there is at least one character in S, False otherwise."); static PyObject* -unicode_isspace(PyUnicodeObject *self) +unicode_isspace(PyObject *self) { Py_ssize_t i, length; int kind; @@ -11357,7 +11347,7 @@ Return True if all characters in S are alphabetic\n\ and there is at least one character in S, False otherwise."); static PyObject* -unicode_isalpha(PyUnicodeObject *self) +unicode_isalpha(PyObject *self) { Py_ssize_t i, length; int kind; @@ -11392,7 +11382,7 @@ Return True if all characters in S are alphanumeric\n\ and there is at least one character in S, False otherwise."); static PyObject* -unicode_isalnum(PyUnicodeObject *self) +unicode_isalnum(PyObject *self) { int kind; void *data; @@ -11430,7 +11420,7 @@ Return True if there are only decimal characters in S,\n\ False otherwise."); static PyObject* -unicode_isdecimal(PyUnicodeObject *self) +unicode_isdecimal(PyObject *self) { Py_ssize_t i, length; int kind; @@ -11465,7 +11455,7 @@ Return True if all characters in S are digits\n\ and there is at least one character in S, False otherwise."); static PyObject* -unicode_isdigit(PyUnicodeObject *self) +unicode_isdigit(PyObject *self) { Py_ssize_t i, length; int kind; @@ -11501,7 +11491,7 @@ Return True if there are only numeric characters in S,\n\ False otherwise."); static PyObject* -unicode_isnumeric(PyUnicodeObject *self) +unicode_isnumeric(PyObject *self) { Py_ssize_t i, length; int kind; @@ -11623,7 +11613,7 @@ unicode_join(PyObject *self, PyObject *data) } static Py_ssize_t -unicode_length(PyUnicodeObject *self) +unicode_length(PyObject *self) { if (PyUnicode_READY(self) == -1) return -1; @@ -11678,7 +11668,7 @@ static const char *stripformat[] = {"|O:lstrip", "|O:rstrip", "|O:strip"}; /* externally visible for str.strip(unicode) */ PyObject * -_PyUnicode_XStrip(PyUnicodeObject *self, int striptype, PyObject *sepobj) +_PyUnicode_XStrip(PyObject *self, int striptype, PyObject *sepobj) { void *data; int kind; @@ -11761,7 +11751,7 @@ PyUnicode_Substring(PyObject *self, Py_ssize_t start, Py_ssize_t end) } static PyObject * -do_strip(PyUnicodeObject *self, int striptype) +do_strip(PyObject *self, int striptype) { int kind; void *data; @@ -11794,7 +11784,7 @@ do_strip(PyUnicodeObject *self, int striptype) static PyObject * -do_argstrip(PyUnicodeObject *self, int striptype, PyObject *args) +do_argstrip(PyObject *self, int striptype, PyObject *args) { PyObject *sep = NULL; @@ -11824,7 +11814,7 @@ whitespace removed.\n\ If chars is given and not None, remove characters in chars instead."); static PyObject * -unicode_strip(PyUnicodeObject *self, PyObject *args) +unicode_strip(PyObject *self, PyObject *args) { if (PyTuple_GET_SIZE(args) == 0) return do_strip(self, BOTHSTRIP); /* Common case */ @@ -11840,7 +11830,7 @@ Return a copy of the string S with leading whitespace removed.\n\ If chars is given and not None, remove characters in chars instead."); static PyObject * -unicode_lstrip(PyUnicodeObject *self, PyObject *args) +unicode_lstrip(PyObject *self, PyObject *args) { if (PyTuple_GET_SIZE(args) == 0) return do_strip(self, LEFTSTRIP); /* Common case */ @@ -11856,7 +11846,7 @@ Return a copy of the string S with trailing whitespace removed.\n\ If chars is given and not None, remove characters in chars instead."); static PyObject * -unicode_rstrip(PyUnicodeObject *self, PyObject *args) +unicode_rstrip(PyObject *self, PyObject *args) { if (PyTuple_GET_SIZE(args) == 0) return do_strip(self, RIGHTSTRIP); /* Common case */ @@ -11866,9 +11856,9 @@ unicode_rstrip(PyUnicodeObject *self, PyObject *args) static PyObject* -unicode_repeat(PyUnicodeObject *str, Py_ssize_t len) +unicode_repeat(PyObject *str, Py_ssize_t len) { - PyUnicodeObject *u; + PyObject *u; Py_ssize_t nchars, n; if (len < 1) { @@ -11892,7 +11882,7 @@ unicode_repeat(PyUnicodeObject *str, Py_ssize_t len) } nchars = len * PyUnicode_GET_LENGTH(str); - u = (PyUnicodeObject *)PyUnicode_New(nchars, PyUnicode_MAX_CHAR_VALUE(str)); + u = PyUnicode_New(nchars, PyUnicode_MAX_CHAR_VALUE(str)); if (!u) return NULL; assert(PyUnicode_KIND(u) == PyUnicode_KIND(str)); @@ -11923,7 +11913,7 @@ unicode_repeat(PyUnicodeObject *str, Py_ssize_t len) } assert(_PyUnicode_CheckConsistency(u, 1)); - return (PyObject*) u; + return u; } PyObject * @@ -12156,7 +12146,7 @@ Return -1 on failure."); static PyObject * unicode_rfind(PyObject *self, PyObject *args) { - PyUnicodeObject *substring; + PyObject *substring; Py_ssize_t start; Py_ssize_t end; Py_ssize_t result; @@ -12190,7 +12180,7 @@ Like S.rfind() but raise ValueError when the substring is not found."); static PyObject * unicode_rindex(PyObject *self, PyObject *args) { - PyUnicodeObject *substring; + PyObject *substring; Py_ssize_t start; Py_ssize_t end; Py_ssize_t result; @@ -12522,7 +12512,7 @@ Line breaks are not included in the resulting list unless keepends\n\ is given and true."); static PyObject* -unicode_splitlines(PyUnicodeObject *self, PyObject *args, PyObject *kwds) +unicode_splitlines(PyObject *self, PyObject *args, PyObject *kwds) { static char *kwlist[] = {"keepends", 0}; int keepends = 0; @@ -12531,7 +12521,7 @@ unicode_splitlines(PyUnicodeObject *self, PyObject *args, PyObject *kwds) kwlist, &keepends)) return NULL; - return PyUnicode_Splitlines((PyObject *)self, keepends); + return PyUnicode_Splitlines(self, keepends); } static @@ -12570,7 +12560,7 @@ character at the same position in y. If there is a third argument, it\n\ must be a string, whose characters will be mapped to None in the result."); static PyObject* -unicode_maketrans(PyUnicodeObject *null, PyObject *args) +unicode_maketrans(PyObject *null, PyObject *args) { PyObject *x, *y = NULL, *z = NULL; PyObject *new = NULL, *key, *value; @@ -12768,11 +12758,11 @@ With optional end, stop comparing S at that position.\n\ prefix can also be a tuple of strings to try."); static PyObject * -unicode_startswith(PyUnicodeObject *self, +unicode_startswith(PyObject *self, PyObject *args) { PyObject *subobj; - PyUnicodeObject *substring; + PyObject *substring; Py_ssize_t start = 0; Py_ssize_t end = PY_SSIZE_T_MAX; int result; @@ -12782,8 +12772,7 @@ unicode_startswith(PyUnicodeObject *self, if (PyTuple_Check(subobj)) { Py_ssize_t i; for (i = 0; i < PyTuple_GET_SIZE(subobj); i++) { - substring = (PyUnicodeObject *)PyUnicode_FromObject( - PyTuple_GET_ITEM(subobj, i)); + substring = PyUnicode_FromObject(PyTuple_GET_ITEM(subobj, i)); if (substring == NULL) return NULL; result = tailmatch(self, substring, start, end, -1); @@ -12795,7 +12784,7 @@ unicode_startswith(PyUnicodeObject *self, /* nothing matched */ Py_RETURN_FALSE; } - substring = (PyUnicodeObject *)PyUnicode_FromObject(subobj); + substring = PyUnicode_FromObject(subobj); if (substring == NULL) { if (PyErr_ExceptionMatches(PyExc_TypeError)) PyErr_Format(PyExc_TypeError, "startswith first arg must be str or " @@ -12817,11 +12806,11 @@ With optional end, stop comparing S at that position.\n\ suffix can also be a tuple of strings to try."); static PyObject * -unicode_endswith(PyUnicodeObject *self, +unicode_endswith(PyObject *self, PyObject *args) { PyObject *subobj; - PyUnicodeObject *substring; + PyObject *substring; Py_ssize_t start = 0; Py_ssize_t end = PY_SSIZE_T_MAX; int result; @@ -12831,7 +12820,7 @@ unicode_endswith(PyUnicodeObject *self, if (PyTuple_Check(subobj)) { Py_ssize_t i; for (i = 0; i < PyTuple_GET_SIZE(subobj); i++) { - substring = (PyUnicodeObject *)PyUnicode_FromObject( + substring = PyUnicode_FromObject( PyTuple_GET_ITEM(subobj, i)); if (substring == NULL) return NULL; @@ -12843,7 +12832,7 @@ unicode_endswith(PyUnicodeObject *self, } Py_RETURN_FALSE; } - substring = (PyUnicodeObject *)PyUnicode_FromObject(subobj); + substring = PyUnicode_FromObject(subobj); if (substring == NULL) { if (PyErr_ExceptionMatches(PyExc_TypeError)) PyErr_Format(PyExc_TypeError, "endswith first arg must be str or " @@ -12888,7 +12877,7 @@ PyDoc_STRVAR(p_format__doc__, Return a formatted version of S as described by format_spec."); static PyObject * -unicode__sizeof__(PyUnicodeObject *v) +unicode__sizeof__(PyObject *v) { Py_ssize_t size; @@ -13020,7 +13009,7 @@ static PySequenceMethods unicode_as_sequence = { }; static PyObject* -unicode_subscript(PyUnicodeObject* self, PyObject* item) +unicode_subscript(PyObject* self, PyObject* item) { if (PyUnicode_READY(self) == -1) return NULL; @@ -13031,7 +13020,7 @@ unicode_subscript(PyUnicodeObject* self, PyObject* item) return NULL; if (i < 0) i += PyUnicode_GET_LENGTH(self); - return unicode_getitem((PyObject*)self, i); + return unicode_getitem(self, i); } else if (PySlice_Check(item)) { Py_ssize_t start, stop, step, slicelength, cur, i; PyObject *result; @@ -13050,9 +13039,9 @@ unicode_subscript(PyUnicodeObject* self, PyObject* item) slicelength == PyUnicode_GET_LENGTH(self) && PyUnicode_CheckExact(self)) { Py_INCREF(self); - return (PyObject *)self; + return self; } else if (step == 1) { - return PyUnicode_Substring((PyObject*)self, + return PyUnicode_Substring(self, start, start + slicelength); } /* General case */ @@ -13195,7 +13184,7 @@ repeat_accumulate(_PyAccu *acc, PyObject *obj, Py_ssize_t count) assert(count > 0); assert(PyUnicode_Check(obj)); if (count > 5) { - PyObject *repeated = unicode_repeat((PyUnicodeObject *) obj, count); + PyObject *repeated = unicode_repeat(obj, count); if (repeated == NULL) return -1; r = _PyAccu_Accumulate(acc, repeated); @@ -13224,7 +13213,7 @@ PyUnicode_Format(PyObject *format, PyObject *args) PyObject *dict = NULL; PyObject *temp = NULL; PyObject *second = NULL; - PyUnicodeObject *uformat; + PyObject *uformat; _PyAccu acc; static PyObject *plus, *minus, *blank, *zero, *percent; @@ -13243,7 +13232,7 @@ PyUnicode_Format(PyObject *format, PyObject *args) PyErr_BadInternalCall(); return NULL; } - uformat = (PyUnicodeObject*)PyUnicode_FromObject(format); + uformat = PyUnicode_FromObject(format); if (uformat == NULL || PyUnicode_READY(uformat) == -1) return NULL; if (_PyAccu_Init(&acc)) @@ -13732,7 +13721,7 @@ unicode_new(PyTypeObject *type, PyObject *args, PyObject *kwds) static PyObject * unicode_subtype_new(PyTypeObject *type, PyObject *args, PyObject *kwds) { - PyUnicodeObject *unicode, *self; + PyObject *unicode, *self; Py_ssize_t length, char_size; int share_wstr, share_utf8; unsigned int kind; @@ -13740,14 +13729,14 @@ unicode_subtype_new(PyTypeObject *type, PyObject *args, PyObject *kwds) assert(PyType_IsSubtype(type, &PyUnicode_Type)); - unicode = (PyUnicodeObject *)unicode_new(&PyUnicode_Type, args, kwds); + unicode = unicode_new(&PyUnicode_Type, args, kwds); if (unicode == NULL) return NULL; assert(_PyUnicode_CHECK(unicode)); if (PyUnicode_READY(unicode)) return NULL; - self = (PyUnicodeObject *) type->tp_alloc(type, 0); + self = type->tp_alloc(type, 0); if (self == NULL) { Py_DECREF(unicode); return NULL; @@ -13955,7 +13944,7 @@ _PyUnicode_Fini(void) void PyUnicode_InternInPlace(PyObject **p) { - register PyUnicodeObject *s = (PyUnicodeObject *)(*p); + register PyObject *s = *p; PyObject *t; #ifdef Py_DEBUG assert(s != NULL); @@ -13974,7 +13963,7 @@ PyUnicode_InternInPlace(PyObject **p) assert(0 && "_PyUnicode_READY_REPLACE fail in PyUnicode_InternInPlace"); return; } - s = (PyUnicodeObject *)(*p); + s = *p; if (interned == NULL) { interned = PyDict_New(); if (interned == NULL) { @@ -14035,7 +14024,7 @@ void _Py_ReleaseInternedUnicodeStrings(void) { PyObject *keys; - PyUnicodeObject *s; + PyObject *s; Py_ssize_t i, n; Py_ssize_t immortal_size = 0, mortal_size = 0; @@ -14056,7 +14045,7 @@ _Py_ReleaseInternedUnicodeStrings(void) fprintf(stderr, "releasing %" PY_FORMAT_SIZE_T "d interned strings\n", n); for (i = 0; i < n; i++) { - s = (PyUnicodeObject *) PyList_GET_ITEM(keys, i); + s = PyList_GET_ITEM(keys, i); if (PyUnicode_READY(s) == -1) { assert(0 && "could not ready string"); fprintf(stderr, "could not ready string\n"); @@ -14093,7 +14082,7 @@ _Py_ReleaseInternedUnicodeStrings(void) typedef struct { PyObject_HEAD Py_ssize_t it_index; - PyUnicodeObject *it_seq; /* Set to NULL when iterator is exhausted */ + PyObject *it_seq; /* Set to NULL when iterator is exhausted */ } unicodeiterobject; static void @@ -14114,8 +14103,7 @@ unicodeiter_traverse(unicodeiterobject *it, visitproc visit, void *arg) static PyObject * unicodeiter_next(unicodeiterobject *it) { - PyUnicodeObject *seq; - PyObject *item; + PyObject *seq, *item; assert(it != NULL); seq = it->it_seq; @@ -14204,7 +14192,7 @@ unicode_iter(PyObject *seq) return NULL; it->it_index = 0; Py_INCREF(seq); - it->it_seq = (PyUnicodeObject *)seq; + it->it_seq = seq; _PyObject_GC_TRACK(it); return (PyObject *)it; } @@ -14221,9 +14209,8 @@ unicode_iter(PyObject *seq) #undef UNIOP_t Py_UNICODE* -PyUnicode_AsUnicodeCopy(PyObject *object) +PyUnicode_AsUnicodeCopy(PyObject *unicode) { - PyUnicodeObject *unicode = (PyUnicodeObject *)object; Py_UNICODE *u, *copy; Py_ssize_t size; @@ -14231,7 +14218,7 @@ PyUnicode_AsUnicodeCopy(PyObject *object) PyErr_BadArgument(); return NULL; } - u = PyUnicode_AsUnicode(object); + u = PyUnicode_AsUnicode(unicode); if (u == NULL) return NULL; /* Ensure we won't overflow the size. */ -- cgit v0.12