(assert(_PyUnicode_CHECK(op)), \
(PyUnicode_IS_READY(op) ? \
0 : \
- _PyUnicode_Ready((PyObject *)(op))))
+ _PyUnicode_Ready(op)))
#define _PyUnicode_READY_REPLACE(p_obj) \
(assert(_PyUnicode_CHECK(*p_obj)), \
#ifdef Py_DEBUG
int
-/* FIXME: use PyObject* type for op */
-_PyUnicode_CheckConsistency(void *op, int check_content)
+_PyUnicode_CheckConsistency(PyObject *op, int check_content)
{
PyASCIIObject *ascii;
unsigned int kind;
else
assert(maxchar >= 0x10000);
}
- if (check_content && !unicode_is_singleton((PyObject*)ascii))
+ if (check_content && !unicode_is_singleton(op))
assert(ascii->hash == -1);
return 1;
}
_PyUnicode_LENGTH(unicode) = 0;
_PyUnicode_UTF8(unicode) = NULL;
_PyUnicode_UTF8_LENGTH(unicode) = 0;
- assert(_PyUnicode_CheckConsistency(unicode, 0));
+ assert(_PyUnicode_CheckConsistency((PyObject *)unicode, 0));
return unicode;
onError:
_PyUnicode_WSTR(unicode) = NULL;
}
}
- assert(_PyUnicode_CheckConsistency(unicode, 0));
+ assert(_PyUnicode_CheckConsistency((PyObject*)unicode, 0));
return obj;
}
case SSTATE_INTERNED_MORTAL:
/* revive dead object temporarily for DelItem */
Py_REFCNT(unicode) = 3;
- if (PyDict_DelItem(interned, (PyObject *)unicode) != 0)
+ if (PyDict_DelItem(interned, unicode) != 0)
Py_FatalError(
"deletion of interned string failed");
break;
PyObject_DEL(_PyUnicode_UTF8(unicode));
if (PyUnicode_IS_COMPACT(unicode)) {
- Py_TYPE(unicode)->tp_free((PyObject *)unicode);
+ Py_TYPE(unicode)->tp_free(unicode);
}
else {
if (_PyUnicode_DATA_ANY(unicode))
PyObject_DEL(_PyUnicode_DATA_ANY(unicode));
- Py_TYPE(unicode)->tp_free((PyObject *)unicode);
+ Py_TYPE(unicode)->tp_free(unicode);
}
}
if (numberresults)
PyObject_Free(numberresults);
assert(_PyUnicode_CheckConsistency(string, 1));
- return (PyObject *)string;
+ return string;
fail:
if (callresults) {
PyObject **callresult2 = callresults;
const char *encoding, const char *reason,
const char **input, const char **inend, Py_ssize_t *startinpos,
Py_ssize_t *endinpos, PyObject **exceptionObject, const char **inptr,
- PyUnicodeObject **output, Py_ssize_t *outpos, Py_UNICODE **outptr)
+ PyObject **output, Py_ssize_t *outpos, Py_UNICODE **outptr)
{
static char *argparse = "O!n;decoding error handler must return (str, int) tuple";
if (requiredsize > outsize) {
if (requiredsize<2*outsize)
requiredsize = 2*outsize;
- if (PyUnicode_Resize((PyObject**)output, requiredsize) < 0)
+ if (PyUnicode_Resize(output, requiredsize) < 0)
goto onError;
*outptr = PyUnicode_AS_UNICODE(*output) + *outpos;
}
Py_ssize_t endinpos;
Py_ssize_t outpos;
const char *e;
- PyUnicodeObject *unicode;
+ PyObject *unicode;
Py_UNICODE *p;
const char *errmsg = "";
int inShift = 0;
PyObject *errorHandler = NULL;
PyObject *exc = NULL;
- unicode = _PyUnicode_New(size);
+ unicode = (PyObject*)_PyUnicode_New(size);
if (!unicode)
return NULL;
if (size == 0) {
if (consumed)
*consumed = 0;
- return (PyObject *)unicode;
+ return unicode;
}
p = PyUnicode_AS_UNICODE(unicode);
}
}
- if (PyUnicode_Resize((PyObject**)&unicode, p - PyUnicode_AS_UNICODE(unicode)) < 0)
+ if (PyUnicode_Resize(&unicode, p - PyUnicode_AS_UNICODE(unicode)) < 0)
goto onError;
Py_XDECREF(errorHandler);
}
#endif
assert(_PyUnicode_CheckConsistency(unicode, 1));
- return (PyObject *)unicode;
+ return unicode;
onError:
Py_XDECREF(errorHandler);
Py_ssize_t startinpos;
Py_ssize_t endinpos;
const char *e, *aligned_end;
- PyUnicodeObject *unicode;
+ PyObject *unicode;
const char *errmsg = "";
PyObject *errorHandler = NULL;
PyObject *exc = NULL;
maxchar = utf8_max_char_size_and_has_errors(s, size, &unicode_size,
consumed, &has_errors);
if (has_errors) {
- unicode = _PyUnicode_New(size);
+ unicode = (PyObject*)_PyUnicode_New(size);
if (!unicode)
return NULL;
kind = PyUnicode_WCHAR_KIND;
assert(data != NULL);
}
else {
- unicode = (PyUnicodeObject *)PyUnicode_New(unicode_size, maxchar);
+ unicode = PyUnicode_New(unicode_size, maxchar);
if (!unicode)
return NULL;
/* When the string is ASCII only, just use memcpy and return.
sequence at the end of the ASCII block. */
if (maxchar < 128 && size == unicode_size) {
Py_MEMCPY(PyUnicode_1BYTE_DATA(unicode), s, unicode_size);
- return (PyObject *)unicode;
+ return unicode;
}
kind = PyUnicode_KIND(unicode);
data = PyUnicode_DATA(unicode);
/* If this is not yet a resizable string, make it one.. */
if (kind != PyUnicode_WCHAR_KIND) {
const Py_UNICODE *u;
- PyUnicodeObject *new_unicode = _PyUnicode_New(size);
+ PyObject *new_unicode = (PyObject*)_PyUnicode_New(size);
if (!new_unicode)
goto onError;
- u = PyUnicode_AsUnicode((PyObject *)unicode);
+ u = PyUnicode_AsUnicode(unicode);
if (!u)
goto onError;
#if SIZEOF_WCHAR_T == 2
/* Adjust length and ready string when it contained errors and
is of the old resizable kind. */
if (kind == PyUnicode_WCHAR_KIND) {
- if (PyUnicode_Resize((PyObject**)&unicode, i) < 0)
+ if (PyUnicode_Resize(&unicode, i) < 0)
goto onError;
}
}
#endif
assert(_PyUnicode_CheckConsistency(unicode, 1));
- return (PyObject *)unicode;
+ return unicode;
onError:
Py_XDECREF(errorHandler);
the excess memory at the end.
*/
PyObject *
-_PyUnicode_AsUTF8String(PyObject *obj, const char *errors)
+_PyUnicode_AsUTF8String(PyObject *unicode, const char *errors)
{
#define MAX_SHORT_UNICHARS 300 /* largest size we'll do on the stack */
int kind;
void *data;
Py_ssize_t size;
- PyUnicodeObject *unicode = (PyUnicodeObject *)obj;
#if SIZEOF_WCHAR_T == 2
Py_ssize_t wchar_offset = 0;
#endif
#endif
rep = unicode_encode_call_errorhandler(
errors, &errorHandler, "utf-8", "surrogates not allowed",
- obj, &exc, startpos, startpos+1, &newpos);
+ unicode, &exc, startpos, startpos+1, &newpos);
if (!rep)
goto error;
c = prep[k];
if (0x80 <= c) {
raise_encode_exception_obj(&exc, "utf-8",
- (PyObject*)unicode,
+ unicode,
i-1, i,
"surrogates not allowed");
goto error;
Py_ssize_t startinpos;
Py_ssize_t endinpos;
Py_ssize_t outpos;
- PyUnicodeObject *unicode;
+ PyObject *unicode;
Py_UNICODE *p;
#ifndef Py_UNICODE_WIDE
int pairs = 0;
#endif
/* This might be one to much, because of a BOM */
- unicode = _PyUnicode_New((size+3)/4+pairs);
+ unicode = (PyObject*)_PyUnicode_New((size+3)/4+pairs);
if (!unicode)
return NULL;
if (size == 0)
- return (PyObject *)unicode;
+ return unicode;
/* Unpack UTF-32 encoded data */
p = PyUnicode_AS_UNICODE(unicode);
*consumed = (const char *)q-starts;
/* Adjust length */
- if (PyUnicode_Resize((PyObject**)&unicode, p - PyUnicode_AS_UNICODE(unicode)) < 0)
+ if (PyUnicode_Resize(&unicode, p - PyUnicode_AS_UNICODE(unicode)) < 0)
goto onError;
Py_XDECREF(errorHandler);
}
#endif
assert(_PyUnicode_CheckConsistency(unicode, 1));
- return (PyObject *)unicode;
+ return unicode;
onError:
Py_DECREF(unicode);
Py_ssize_t startinpos;
Py_ssize_t endinpos;
Py_ssize_t outpos;
- PyUnicodeObject *unicode;
+ PyObject *unicode;
Py_UNICODE *p;
const unsigned char *q, *e, *aligned_end;
int bo = 0; /* assume native ordering by default */
/* Note: size will always be longer than the resulting Unicode
character count */
- unicode = _PyUnicode_New(size);
+ unicode = (PyObject*)_PyUnicode_New(size);
if (!unicode)
return NULL;
if (size == 0)
- return (PyObject *)unicode;
+ return unicode;
/* Unpack UTF-16 encoded data */
p = PyUnicode_AS_UNICODE(unicode);
*consumed = (const char *)q-starts;
/* Adjust length */
- if (PyUnicode_Resize((PyObject**)&unicode, p - PyUnicode_AS_UNICODE(unicode)) < 0)
+ if (PyUnicode_Resize(&unicode, p - PyUnicode_AS_UNICODE(unicode)) < 0)
goto onError;
Py_XDECREF(errorHandler);
}
#endif
assert(_PyUnicode_CheckConsistency(unicode, 1));
- return (PyObject *)unicode;
+ return unicode;
onError:
Py_DECREF(unicode);
Py_ssize_t startinpos;
Py_ssize_t endinpos;
int j;
- PyUnicodeObject *v;
+ PyObject *v;
Py_UNICODE *p;
const char *end;
char* message;
or it contains \x, \u, ... escape sequences. then we create a
legacy wchar string and resize it at the end of this function. */
if (ascii_length >= 0) {
- v = (PyUnicodeObject *)PyUnicode_New(ascii_length, 127);
+ v = PyUnicode_New(ascii_length, 127);
if (!v)
goto onError;
assert(PyUnicode_KIND(v) == PyUnicode_1BYTE_KIND);
length after conversion to the true value.
(but if the error callback returns a long replacement string
we'll have to allocate more space) */
- v = _PyUnicode_New(size);
+ v = (PyObject*)_PyUnicode_New(size);
if (!v)
goto onError;
kind = PyUnicode_WCHAR_KIND;
}
if (size == 0)
- return (PyObject *)v;
+ return v;
i = 0;
end = s + size;
if (kind == PyUnicode_WCHAR_KIND)
{
- if (PyUnicode_Resize((PyObject**)&v, i) < 0)
+ if (PyUnicode_Resize(&v, i) < 0)
goto onError;
}
Py_XDECREF(errorHandler);
}
#endif
assert(_PyUnicode_CheckConsistency(v, 1));
- return (PyObject *)v;
+ return v;
ucnhashError:
PyErr_SetString(
Py_ssize_t startinpos;
Py_ssize_t endinpos;
Py_ssize_t outpos;
- PyUnicodeObject *v;
+ PyObject *v;
Py_UNICODE *p;
const char *end;
const char *bs;
Unicode string, so we start with size here and then reduce the
length after conversion to the true value. (But decoding error
handler might have to resize the string) */
- v = _PyUnicode_New(size);
+ v = (PyObject*)_PyUnicode_New(size);
if (v == NULL)
goto onError;
if (size == 0)
- return (PyObject *)v;
+ return v;
p = PyUnicode_AS_UNICODE(v);
end = s + size;
while (s < end) {
nextByte:
;
}
- if (PyUnicode_Resize((PyObject**)&v, p - PyUnicode_AS_UNICODE(v)) < 0)
+ if (PyUnicode_Resize(&v, p - PyUnicode_AS_UNICODE(v)) < 0)
goto onError;
Py_XDECREF(errorHandler);
Py_XDECREF(exc);
}
#endif
assert(_PyUnicode_CheckConsistency(v, 1));
- return (PyObject *)v;
+ return v;
onError:
Py_XDECREF(v);
Py_ssize_t startinpos;
Py_ssize_t endinpos;
Py_ssize_t outpos;
- PyUnicodeObject *v;
+ PyObject *v;
Py_UNICODE *p;
const char *end;
const char *reason;
#endif
/* XXX overflow detection missing */
- v = _PyUnicode_New((size+Py_UNICODE_SIZE-1)/ Py_UNICODE_SIZE);
+ v = (PyObject*)_PyUnicode_New((size+Py_UNICODE_SIZE-1)/ Py_UNICODE_SIZE);
if (v == NULL)
goto onError;
/* Intentionally PyUnicode_GET_SIZE instead of PyUnicode_GET_LENGTH
as string was created with the old API. */
if (PyUnicode_GET_SIZE(v) == 0)
- return (PyObject *)v;
+ return v;
p = PyUnicode_AS_UNICODE(v);
end = s + size;
}
}
- if (PyUnicode_Resize((PyObject**)&v, p - PyUnicode_AS_UNICODE(v)) < 0)
+ if (PyUnicode_Resize(&v, p - PyUnicode_AS_UNICODE(v)) < 0)
goto onError;
Py_XDECREF(errorHandler);
Py_XDECREF(exc);
}
#endif
assert(_PyUnicode_CheckConsistency(v, 1));
- return (PyObject *)v;
+ return v;
onError:
Py_XDECREF(v);
const char *errors)
{
const char *starts = s;
- PyUnicodeObject *v;
+ PyObject *v;
Py_UNICODE *u;
Py_ssize_t startinpos;
Py_ssize_t endinpos;
if (!has_error)
return unicode_fromascii((const unsigned char *)s, size);
- v = _PyUnicode_New(size);
+ v = (PyObject*)_PyUnicode_New(size);
if (v == NULL)
goto onError;
if (size == 0)
- return (PyObject *)v;
+ return v;
u = PyUnicode_AS_UNICODE(v);
e = s + size;
while (s < e) {
}
}
if (u - PyUnicode_AS_UNICODE(v) < PyUnicode_GET_SIZE(v))
- if (PyUnicode_Resize((PyObject**)&v, u - PyUnicode_AS_UNICODE(v)) < 0)
+ if (PyUnicode_Resize(&v, u - PyUnicode_AS_UNICODE(v)) < 0)
goto onError;
Py_XDECREF(errorHandler);
Py_XDECREF(exc);
}
#endif
assert(_PyUnicode_CheckConsistency(v, 1));
- return (PyObject *)v;
+ return v;
onError:
Py_XDECREF(v);
Py_ssize_t endinpos;
Py_ssize_t outpos;
const char *e;
- PyUnicodeObject *v;
+ PyObject *v;
Py_UNICODE *p;
Py_ssize_t extrachars = 0;
PyObject *errorHandler = NULL;
if (mapping == NULL)
return PyUnicode_DecodeLatin1(s, size, errors);
- v = _PyUnicode_New(size);
+ v = (PyObject*)_PyUnicode_New(size);
if (v == NULL)
goto onError;
if (size == 0)
- return (PyObject *)v;
+ return v;
p = PyUnicode_AS_UNICODE(v);
e = s + size;
if (PyUnicode_CheckExact(mapping)) {
(targetsize << 2);
extrachars += needed;
/* XXX overflow detection missing */
- if (PyUnicode_Resize((PyObject**)&v,
- PyUnicode_GET_SIZE(v) + needed) < 0) {
+ if (PyUnicode_Resize(&v,
+ PyUnicode_GET_SIZE(v) + needed) < 0) {
Py_DECREF(x);
goto onError;
}
}
}
if (p - PyUnicode_AS_UNICODE(v) < PyUnicode_GET_SIZE(v))
- if (PyUnicode_Resize((PyObject**)&v, p - PyUnicode_AS_UNICODE(v)) < 0)
+ if (PyUnicode_Resize(&v, p - PyUnicode_AS_UNICODE(v)) < 0)
goto onError;
Py_XDECREF(errorHandler);
Py_XDECREF(exc);
}
#endif
assert(_PyUnicode_CheckConsistency(v, 1));
- return (PyObject *)v;
+ return v;
onError:
Py_XDECREF(errorHandler);
kind = kind1 > kind2 ? kind1 : kind2;
buf1 = PyUnicode_DATA(str_obj);
if (kind1 != kind)
- buf1 = _PyUnicode_AsKind((PyObject*)str_obj, kind);
+ buf1 = _PyUnicode_AsKind(str_obj, kind);
if (!buf1)
goto onError;
buf2 = PyUnicode_DATA(sub_obj);
if (kind2 != kind)
- buf2 = _PyUnicode_AsKind((PyObject*)sub_obj, kind);
+ buf2 = _PyUnicode_AsKind(sub_obj, kind);
if (!buf2)
goto onError;
len1 = PyUnicode_GET_LENGTH(str_obj);
(to save space, not time) */
Py_INCREF(self);
Py_DECREF(u);
- return (PyObject*) self;
+ return self;
}
else if (maxchar_new == maxchar_old) {
return u;
case PyUnicode_1BYTE_KIND:
if (PyUnicode_IS_ASCII(string))
list = asciilib_splitlines(
- (PyObject*) string, PyUnicode_1BYTE_DATA(string),
+ string, PyUnicode_1BYTE_DATA(string),
PyUnicode_GET_LENGTH(string), keepends);
else
list = ucs1lib_splitlines(
- (PyObject*) string, PyUnicode_1BYTE_DATA(string),
+ string, PyUnicode_1BYTE_DATA(string),
PyUnicode_GET_LENGTH(string), keepends);
break;
case PyUnicode_2BYTE_KIND:
list = ucs2lib_splitlines(
- (PyObject*) string, PyUnicode_2BYTE_DATA(string),
+ string, PyUnicode_2BYTE_DATA(string),
PyUnicode_GET_LENGTH(string), keepends);
break;
case PyUnicode_4BYTE_KIND:
list = ucs4lib_splitlines(
- (PyObject*) string, PyUnicode_4BYTE_DATA(string),
+ string, PyUnicode_4BYTE_DATA(string),
PyUnicode_GET_LENGTH(string), keepends);
break;
default:
case PyUnicode_1BYTE_KIND:
if (PyUnicode_IS_ASCII(self))
return asciilib_split_whitespace(
- (PyObject*) self, PyUnicode_1BYTE_DATA(self),
+ self, PyUnicode_1BYTE_DATA(self),
PyUnicode_GET_LENGTH(self), maxcount
);
else
return ucs1lib_split_whitespace(
- (PyObject*) self, PyUnicode_1BYTE_DATA(self),
+ self, PyUnicode_1BYTE_DATA(self),
PyUnicode_GET_LENGTH(self), maxcount
);
case PyUnicode_2BYTE_KIND:
return ucs2lib_split_whitespace(
- (PyObject*) self, PyUnicode_2BYTE_DATA(self),
+ self, PyUnicode_2BYTE_DATA(self),
PyUnicode_GET_LENGTH(self), maxcount
);
case PyUnicode_4BYTE_KIND:
return ucs4lib_split_whitespace(
- (PyObject*) self, PyUnicode_4BYTE_DATA(self),
+ self, PyUnicode_4BYTE_DATA(self),
PyUnicode_GET_LENGTH(self), maxcount
);
default:
buf1 = PyUnicode_DATA(self);
buf2 = PyUnicode_DATA(substring);
if (kind1 != kind)
- buf1 = _PyUnicode_AsKind((PyObject*)self, kind);
+ buf1 = _PyUnicode_AsKind(self, kind);
if (!buf1)
return NULL;
if (kind2 != kind)
- buf2 = _PyUnicode_AsKind((PyObject*)substring, kind);
+ buf2 = _PyUnicode_AsKind(substring, kind);
if (!buf2) {
if (kind1 != kind) PyMem_Free(buf1);
return NULL;
case PyUnicode_1BYTE_KIND:
if (PyUnicode_IS_ASCII(self) && PyUnicode_IS_ASCII(substring))
out = asciilib_split(
- (PyObject*) self, buf1, len1, buf2, len2, maxcount);
+ self, buf1, len1, buf2, len2, maxcount);
else
out = ucs1lib_split(
- (PyObject*) self, buf1, len1, buf2, len2, maxcount);
+ self, buf1, len1, buf2, len2, maxcount);
break;
case PyUnicode_2BYTE_KIND:
out = ucs2lib_split(
- (PyObject*) self, buf1, len1, buf2, len2, maxcount);
+ self, buf1, len1, buf2, len2, maxcount);
break;
case PyUnicode_4BYTE_KIND:
out = ucs4lib_split(
- (PyObject*) self, buf1, len1, buf2, len2, maxcount);
+ self, buf1, len1, buf2, len2, maxcount);
break;
default:
out = NULL;
case PyUnicode_1BYTE_KIND:
if (PyUnicode_IS_ASCII(self))
return asciilib_rsplit_whitespace(
- (PyObject*) self, PyUnicode_1BYTE_DATA(self),
+ self, PyUnicode_1BYTE_DATA(self),
PyUnicode_GET_LENGTH(self), maxcount
);
else
return ucs1lib_rsplit_whitespace(
- (PyObject*) self, PyUnicode_1BYTE_DATA(self),
+ self, PyUnicode_1BYTE_DATA(self),
PyUnicode_GET_LENGTH(self), maxcount
);
case PyUnicode_2BYTE_KIND:
return ucs2lib_rsplit_whitespace(
- (PyObject*) self, PyUnicode_2BYTE_DATA(self),
+ self, PyUnicode_2BYTE_DATA(self),
PyUnicode_GET_LENGTH(self), maxcount
);
case PyUnicode_4BYTE_KIND:
return ucs4lib_rsplit_whitespace(
- (PyObject*) self, PyUnicode_4BYTE_DATA(self),
+ self, PyUnicode_4BYTE_DATA(self),
PyUnicode_GET_LENGTH(self), maxcount
);
default:
buf1 = PyUnicode_DATA(self);
buf2 = PyUnicode_DATA(substring);
if (kind1 != kind)
- buf1 = _PyUnicode_AsKind((PyObject*)self, kind);
+ buf1 = _PyUnicode_AsKind(self, kind);
if (!buf1)
return NULL;
if (kind2 != kind)
- buf2 = _PyUnicode_AsKind((PyObject*)substring, kind);
+ buf2 = _PyUnicode_AsKind(substring, kind);
if (!buf2) {
if (kind1 != kind) PyMem_Free(buf1);
return NULL;
case PyUnicode_1BYTE_KIND:
if (PyUnicode_IS_ASCII(self) && PyUnicode_IS_ASCII(substring))
out = asciilib_rsplit(
- (PyObject*) self, buf1, len1, buf2, len2, maxcount);
+ self, buf1, len1, buf2, len2, maxcount);
else
out = ucs1lib_rsplit(
- (PyObject*) self, buf1, len1, buf2, len2, maxcount);
+ self, buf1, len1, buf2, len2, maxcount);
break;
case PyUnicode_2BYTE_KIND:
out = ucs2lib_rsplit(
- (PyObject*) self, buf1, len1, buf2, len2, maxcount);
+ self, buf1, len1, buf2, len2, maxcount);
break;
case PyUnicode_4BYTE_KIND:
out = ucs4lib_rsplit(
- (PyObject*) self, buf1, len1, buf2, len2, maxcount);
+ self, buf1, len1, buf2, len2, maxcount);
break;
default:
out = NULL;
PyMem_FREE(buf2);
if (PyUnicode_CheckExact(self)) {
Py_INCREF(self);
- return (PyObject *) self;
+ return self;
}
return PyUnicode_Copy(self);
error:
onError:
Py_DECREF(list);
- return (PyObject *)item;
+ return item;
}
#endif
if (_PyUnicode_LENGTH(self) >= width && PyUnicode_CheckExact(self)) {
Py_INCREF(self);
- return (PyObject*) self;
+ return self;
}
marg = width - _PyUnicode_LENGTH(self);
buf1 = PyUnicode_DATA(str);
buf2 = PyUnicode_DATA(sub);
if (kind1 != kind)
- buf1 = _PyUnicode_AsKind((PyObject*)str, kind);
+ buf1 = _PyUnicode_AsKind(str, kind);
if (!buf1) {
Py_DECREF(sub);
return -1;
}
if (kind2 != kind)
- buf2 = _PyUnicode_AsKind((PyObject*)sub, kind);
+ buf2 = _PyUnicode_AsKind(sub, kind);
if (!buf2) {
Py_DECREF(sub);
if (kind1 != kind) PyMem_Free(buf1);
buf1 = PyUnicode_DATA(self);
buf2 = PyUnicode_DATA(substring);
if (kind1 != kind)
- buf1 = _PyUnicode_AsKind((PyObject*)self, kind);
+ buf1 = _PyUnicode_AsKind(self, kind);
if (!buf1) {
Py_DECREF(substring);
return NULL;
}
if (kind2 != kind)
- buf2 = _PyUnicode_AsKind((PyObject*)substring, kind);
+ buf2 = _PyUnicode_AsKind(substring, kind);
if (!buf2) {
Py_DECREF(substring);
if (kind1 != kind) PyMem_Free(buf1);
}
}
if (!found && PyUnicode_CheckExact(self)) {
- Py_INCREF((PyObject *) self);
- return (PyObject *) self;
+ Py_INCREF(self);
+ return self;
}
/* Second pass: create output string and fill it */
}
#endif
assert(_PyUnicode_CheckConsistency(u, 1));
- return (PyObject*) u;
+ return u;
overflow:
PyErr_SetString(PyExc_OverflowError, "new string is too long");
if (PyUnicode_READY(substring) == -1)
return NULL;
- result = any_find_slice(1,
- self, (PyObject*)substring, start, end
- );
+ result = any_find_slice(1, self, substring, start, end);
Py_DECREF(substring);
if (PyUnicode_READY(substring) == -1)
return NULL;
- result = any_find_slice(1,
- self, (PyObject*)substring, start, end
- );
+ result = any_find_slice(1, self, substring, start, end);
Py_DECREF(substring);
if (_PyUnicode_LENGTH(self) >= width && PyUnicode_CheckExact(self)) {
Py_INCREF(self);
- return (PyObject*) self;
+ return self;
}
- return (PyObject*) pad(self, 0, width - _PyUnicode_LENGTH(self), fillchar);
+ return pad(self, 0, width - _PyUnicode_LENGTH(self), fillchar);
}
PyDoc_STRVAR(lower__doc__,
j++;
}
- return PyUnicode_Substring((PyObject*)self, i, j);
+ return PyUnicode_Substring(self, i, j);
}
PyObject*
j++;
}
- return PyUnicode_Substring((PyObject*)self, i, j);
+ return PyUnicode_Substring(self, i, j);
}
if (len == 1 && PyUnicode_CheckExact(str)) {
/* no repeat, return original string */
Py_INCREF(str);
- return (PyObject*) str;
+ return str;
}
if (PyUnicode_READY(str) == -1)
if (PyUnicode_READY(substring) == -1)
return NULL;
- result = any_find_slice(-1,
- self, (PyObject*)substring, start, end
- );
+ result = any_find_slice(-1, self, substring, start, end);
Py_DECREF(substring);
if (PyUnicode_READY(substring) == -1)
return NULL;
- result = any_find_slice(-1,
- self, (PyObject*)substring, start, end
- );
+ result = any_find_slice(-1, self, substring, start, end);
Py_DECREF(substring);
if (_PyUnicode_LENGTH(self) >= width && PyUnicode_CheckExact(self)) {
Py_INCREF(self);
- return (PyObject*) self;
+ return self;
}
- return (PyObject*) pad(self, width - _PyUnicode_LENGTH(self), 0, fillchar);
+ return pad(self, width - _PyUnicode_LENGTH(self), 0, fillchar);
}
PyObject *
else if (PyUnicode_Check(substring))
return split(self, substring, maxcount);
else
- return PyUnicode_Split((PyObject *)self, substring, maxcount);
+ return PyUnicode_Split(self, substring, maxcount);
}
PyObject *
if (PyUnicode_GET_LENGTH(self) >= width) {
if (PyUnicode_CheckExact(self)) {
Py_INCREF(self);
- return (PyObject*) self;
+ return self;
}
else
- return PyUnicode_Copy((PyObject*)self);
+ return PyUnicode_Copy(self);
}
fill = width - _PyUnicode_LENGTH(self);
}
assert(_PyUnicode_CheckConsistency(u, 1));
- return (PyObject*) u;
+ return u;
}
#if 0
fmtpos++;
fmtcnt--;
}
- nonfmt = PyUnicode_Substring((PyObject *) uformat, nonfmtpos, fmtpos);
+ nonfmt = PyUnicode_Substring(uformat, nonfmtpos, fmtpos);
if (nonfmt == NULL)
goto onError;
r = _PyAccu_Accumulate(&acc, nonfmt);
"incomplete format key");
goto onError;
}
- key = PyUnicode_Substring((PyObject*)uformat,
+ key = PyUnicode_Substring(uformat,
keystart, keystart + keylen);
if (key == NULL)
goto onError;
Py_DECREF(uformat);
Py_XDECREF(temp);
Py_XDECREF(second);
- return (PyObject *)result;
+ return result;
onError:
Py_DECREF(uformat);
kwlist, &x, &encoding, &errors))
return NULL;
if (x == NULL)
- return (PyObject *)PyUnicode_New(0, 0);
+ return PyUnicode_New(0, 0);
if (encoding == NULL && errors == NULL)
return PyObject_Str(x);
else
_PyUnicode_HASH(self) = _PyUnicode_HASH(unicode);
#endif
Py_DECREF(unicode);
- return (PyObject *)self;
+ return self;
onError:
Py_DECREF(unicode);
though the key is present in the dictionary,
namely when this happens during a stack overflow. */
Py_ALLOW_RECURSION
- t = PyDict_GetItem(interned, (PyObject *)s);
+ t = PyDict_GetItem(interned, s);
Py_END_ALLOW_RECURSION
if (t) {
}
PyThreadState_GET()->recursion_critical = 1;
- if (PyDict_SetItem(interned, (PyObject *)s, (PyObject *)s) < 0) {
+ if (PyDict_SetItem(interned, s, s) < 0) {
PyErr_Clear();
PyThreadState_GET()->recursion_critical = 0;
return;
projects / python / commitdiff